pastebin - collaborative debugging

pastebin is a collaborative debugging tool allowing you to share and modify code snippets while chatting on IRC, IM or a message board.

This site is developed to XHTML and CSS2 W3C standards. If you see this paragraph, your browser does not support those standards and you need to upgrade. Visit WaSP for a variety of options.

Diff pastebin - collaborative debugging tool View Help


Posted by Dark Shikari on Mon 31 Mar 07:05
report abuse | download | new post

  1. diff --git a/common/common.c b/common/common.c
  2. index 44d9113..5b9b2c4 100644
  3. --- a/common/common.c
  4. +++ b/common/common.c
  5.  -123,6 +123,9 @@ void    x264_param_default( x264_param_t *param )
  6.      param->analyse.i_chroma_qp_offset = 0;
  7.      param->analyse.b_fast_pskip = 1;
  8.      param->analyse.b_dct_decimate = 1;
  9. +    param->analyse.f_aq_strength = 1.0;
  10. +    param->analyse.i_aq_mode = 2;
  11. +    param->analyse.i_aq_metric = 3;
  12.      param->analyse.i_luma_deadzone[0] = 21;
  13.      param->analyse.i_luma_deadzone[1] = 11;
  14.      param->analyse.b_psnr = 1;
  15.  -455,6 +458,12 @@ int x264_param_parse( x264_param_t *p, const char *name, const char *value )
  16.          p->analyse.b_fast_pskip = atobool(value);
  17.      OPT("dct-decimate")
  18.          p->analyse.b_dct_decimate = atobool(value);
  19. +    OPT("aq-strength")
  20. +        p->analyse.f_aq_strength = atof(value);
  21. +    OPT("aq-mode")
  22. +        p->analyse.i_aq_mode = atoi(value);
  23. +    OPT("aq-metric")
  24. +        p->analyse.i_aq_metric = atoi(value);
  25.      OPT("deadzone-inter")
  26.          p->analyse.i_luma_deadzone[0] = atoi(value);
  27.      OPT("deadzone-intra")
  28.  -883,6 +892,10 @@ char *x264_param2string( x264_param_t *p, int b_res )
  29.          s += sprintf( s, " ip_ratio=%.2f", p->rc.f_ip_factor );
  30.          if( p->i_bframe )
  31.              s += sprintf( s, " pb_ratio=%.2f", p->rc.f_pb_factor );
  32. +        if( p->analyse.i_aq_mode )
  33. +            s += sprintf( s, " aq=%d:%.1f", p->analyse.i_aq_mode, p->analyse.f_aq_strength );
  34. +        else
  35. +            s += sprintf( s, " aq=0" );
  36.          if( p->rc.psz_zones )
  37.              s += sprintf( s, " zones=%s", p->rc.psz_zones );
  38.          else if( p->rc.i_zones )
  39. diff --git a/common/pixel.c b/common/pixel.c
  40. index 1d5567b..a86932a 100644
  41. --- a/common/pixel.c
  42. +++ b/common/pixel.c
  43.  -95,6 +95,39 @@ PIXEL_SSD_C( x264_pixel_ssd_8x4,    8,  4 )
  44.  PIXEL_SSD_C( x264_pixel_ssd_4x8,    4,  8 )
  45.  PIXEL_SSD_C( x264_pixel_ssd_4x4,    4,  4 )
  46.  
  47. +#define PIXEL_NSSD_C( name, lx, ly) \
  48. +static int name( uint8_t *pix1, int i_stride_pix1,  \
  49. +                 uint8_t *pix2, int i_stride_pix2 ) \
  50. +{\
  51. +    int score1=0;\
  52. +    int score2=0;\
  53. +    int x,y;\
  54. +    for(y=0; y<ly; y++){\
  55. +        for(x=0; x<lx; x++){\
  56. +            score1 += abs(pix1[x] - pix2[x]);\
  57. +        }\
  58. +        if(y+1<ly){\
  59. +            for(x=0; x<lx-1; x++){\
  60. +                score2 += abs(  pix1[x] - pix1[x+i_stride_pix1]\
  61. +                             - pix1[x+1] + pix1[x+1+i_stride_pix1])\
  62. +                        -abs(  pix2[x] - pix2[x+i_stride_pix2]\
  63. +                             - pix2[x+1] + pix2[x+1+i_stride_pix2]);\
  64. +            }\
  65. +        }\
  66. +        pix1 += i_stride_pix1;\
  67. +        pix2 += i_stride_pix2;\
  68. +    }\
  69. +    return score1 + abs(score2)*8;\
  70. +}
  71. +
  72. +PIXEL_NSSD_C( x264_pixel_nssd_16x16, 16, 16 )
  73. +PIXEL_NSSD_C( x264_pixel_nssd_16x8,  16,  8 )
  74. +PIXEL_NSSD_C( x264_pixel_nssd_8x16,   8, 16 )
  75. +PIXEL_NSSD_C( x264_pixel_nssd_8x8,    8,  8 )
  76. +PIXEL_NSSD_C( x264_pixel_nssd_8x4,    8,  4 )
  77. +PIXEL_NSSD_C( x264_pixel_nssd_4x8,    4,  8 )
  78. +PIXEL_NSSD_C( x264_pixel_nssd_4x4,    4,  4 )
  79. +
  80.  int64_t x264_pixel_ssd_wxh( x264_pixel_function_t *pf, uint8_t *pix1, int i_pix1, uint8_t *pix2, int i_pix2, int i_width, int i_height )
  81.  {
  82.      int64_t i_ssd = 0;
  83.  -530,6 +563,7 @@ void x264_pixel_init( int cpu, x264_pixel_function_t *pixf )
  84.      INIT7( satd, );
  85.      INIT7( satd_x3, );
  86.      INIT7( satd_x4, );
  87. +    INIT7( nssd, );
  88.      INIT4( sa8d, );
  89.      INIT_ADS( );
  90.  
  91. diff --git a/common/pixel.h b/common/pixel.h
  92. index d533620..5a5ddec 100644
  93. --- a/common/pixel.h
  94. +++ b/common/pixel.h
  95.  -74,6 +74,7 @@ typedef struct
  96.      x264_pixel_cmp_t fpelcmp[7]; /* either satd or sad for fullpel motion search */
  97.      x264_pixel_cmp_x3_t fpelcmp_x3[7];
  98.      x264_pixel_cmp_x4_t fpelcmp_x4[7];
  99. +    x264_pixel_cmp_t nssd[7];
  100.  
  101.      void (*ssim_4x4x2_core)( const uint8_t *pix1, int stride1,
  102.                               const uint8_t *pix2, int stride2, int sums[2][4] );
  103. diff --git a/encoder/analyse.c b/encoder/analyse.c
  104. index 0264621..b89724d 100644
  105. --- a/encoder/analyse.c
  106. +++ b/encoder/analyse.c
  107.  -218,7 +218,7 @@ static void x264_mb_analyse_init( x264_t *h, x264_mb_analysis_t *a, int i_qp )
  108.      h->mb.i_subpel_refine = h->param.analyse.i_subpel_refine;
  109.      h->mb.b_chroma_me = h->param.analyse.b_chroma_me && h->sh.i_type == SLICE_TYPE_P
  110.                          && h->mb.i_subpel_refine >= 5;
  111. -    h->mb.b_trellis = h->param.analyse.i_trellis > 1 && a->b_mbrd;
  112. +    h->mb.b_trellis = (h->param.analyse.i_trellis > 1 && a->b_mbrd);
  113.      h->mb.b_transform_8x8 = 0;
  114.      h->mb.b_noise_reduction = 0;
  115.  
  116.  -2064,8 +2064,13 @@ void x264_macroblock_analyse( x264_t *h )
  117.      int i_cost = COST_MAX;
  118.      int i;
  119.  
  120. -    /* init analysis */
  121. -    x264_mb_analyse_init( h, &analysis, x264_ratecontrol_qp( h ) );
  122. +    h->mb.i_qp = x264_ratecontrol_qp( h );
  123. +    
  124. +    if( h->param.analyse.i_aq_mode )
  125. +        x264_adaptive_quant( h );
  126. +
  127. +     /* init analysis */
  128. +    x264_mb_analyse_init( h, &analysis, h->mb.i_qp );
  129.  
  130.      /*--------------------------- Do the analysis ---------------------------*/
  131.      if( h->sh.i_type == SLICE_TYPE_I )
  132. diff --git a/encoder/encoder.c b/encoder/encoder.c
  133. index 3dadb02..73f289c 100644
  134. --- a/encoder/encoder.c
  135. +++ b/encoder/encoder.c
  136.  -401,6 +401,7 @@ static int x264_validate_parameters( x264_t *h )
  137.          h->param.analyse.b_fast_pskip = 0;
  138.          h->param.analyse.i_noise_reduction = 0;
  139.          h->param.analyse.i_subpel_refine = x264_clip3( h->param.analyse.i_subpel_refine, 1, 6 );
  140. +        h->param.analyse.i_aq_mode = 0;
  141.      }
  142.      if( h->param.rc.i_rc_method == X264_RC_CQP )
  143.      {
  144.  -475,6 +476,17 @@ static int x264_validate_parameters( x264_t *h )
  145.      if( !h->param.b_cabac )
  146.          h->param.analyse.i_trellis = 0;
  147.      h->param.analyse.i_trellis = x264_clip3( h->param.analyse.i_trellis, 0, 2 );
  148. +    h->param.analyse.i_aq_mode = x264_clip3(h->param.analyse.i_aq_mode, 0, 2);
  149. +    if(h->param.analyse.f_aq_strength <= 0) h->param.analyse.i_aq_mode = 0;
  150. +    /* VAQ on mode 1 effectively replaces qcomp, so qcomp is raised towards 1 to compensate. */
  151. +    if(h->param.analyse.i_aq_mode == 2)
  152. +        h->param.rc.f_qcompress = x264_clip3f(h->param.rc.f_qcompress + h->param.analyse.f_aq_strength * 0.4 / 0.28, 0, 1);
  153. +    h->param.analyse.i_aq_metric = x264_clip3(h->param.analyse.i_aq_metric, 0, 3);
  154. +    if(h->param.analyse.i_aq_metric > 0)
  155. +    {
  156. +        x264_log( h, X264_LOG_WARNING, "AQ METRIC %d IS AN EXPERIMENTAL ADAPTIVE QUANTIZATION MODE.\n", h->param.analyse.i_aq_metric );
  157. +        x264_log( h, X264_LOG_WARNING, "USE IT AT YOUR OWN RISK!\n" );
  158. +    }
  159.      h->param.analyse.i_noise_reduction = x264_clip3( h->param.analyse.i_noise_reduction, 0, 1<<16 );
  160.  
  161.      {
  162. diff --git a/encoder/ratecontrol.c b/encoder/ratecontrol.c
  163. index 0c8a6d7..ea9aafc 100644
  164. --- a/encoder/ratecontrol.c
  165. +++ b/encoder/ratecontrol.c
  166.  -127,6 +127,10 @@ struct x264_ratecontrol_t
  167.      predictor_t *pred_b_from_p; /* predict B-frame size from P-frame satd */
  168.      int bframes;                /* # consecutive B-frames before this P-frame */
  169.      int bframe_bits;            /* total cost of those frames */
  170. +    
  171. +    /* AQ stuff */
  172. +    float aq_threshold;
  173. +    int *ac_energy;
  174.  
  175.      int i_zones;
  176.      x264_zone_t *zones;
  177.  -169,6 +173,247 @@ static inline double qscale2bits(ratecontrol_entry_t *rce, double qscale)
  178.             + rce->misc_bits;
  179.  }
  180.  
  181. +static const int window_weights[7][7] =
  182. +{{41,68,94,104,94,68,41},
  183. +{68,115,155,171,155,115,68},
  184. +{94,155,209,230,209,155,94},
  185. +{104,171,230,256,230,171,104},
  186. +{94,155,209,230,209,155,94},
  187. +{68,115,155,171,155,115,68},
  188. +{41,68,94,104,94,68,41}};
  189. +
  190. +static inline int windowed_variance( x264_t *h, uint8_t *plane, int stride, int window_x, int window_y, int blocksize, int mb_x, int mb_y, int step )
  191. +{
  192. +    int x,y,locx,locy,n=0;
  193. +    uint64_t total = 0;
  194. +    int shiftx = (window_x - 1) / 2; int shifty = (window_y - 1) / 2;
  195. +    int startx = shiftx; int starty = shifty;
  196. +    int endx = blocksize - shiftx; int endy = blocksize - shifty;
  197. +    plane -= (shiftx + shifty * stride);
  198. +    if(mb_x == 0) startx += shiftx;
  199. +    if(mb_y == 0) starty += shifty;
  200. +    if(mb_x == h->sps->i_mb_width - 1) endx -= shiftx;
  201. +    if(mb_y == h->sps->i_mb_height - 1) endy -= shifty;
  202. +    plane += starty * stride;
  203. +    for(locy = starty; locy < endy; locy+=step)
  204. +    {
  205. +        for(locx = startx; locx < endx; locx+=step)
  206. +        {
  207. +            int sum = 0;
  208. +            for(y = 0; y < window_y; y++)
  209. +                for(x = 0; x < window_x; x++)
  210. +                    sum += window_weights[y][x] * plane[x+y*stride+locx];
  211. +            sum = (sum + 64) >> 7;
  212. +            sum = (sum + (window_x*window_y+1)/2)/(window_x*window_y);
  213. +            int ssd = 0;
  214. +            for(y = 0; y < window_y; y++)
  215. +                for(x = 0; x < window_x; x++)
  216. +                {
  217. +                    int val = plane[x+y*stride+locx] - sum;
  218. +                    ssd += (window_weights[y][x] * val * val + 64) >> 7;
  219. +                }
  220. +            total += ssd;
  221. +            n++;
  222. +        }
  223. +        plane += stride*step;
  224. +    }
  225. +    return (total * 256) / n;
  226. +}
  227. +
  228. +static inline int fast_windowed_variance( x264_t *h, uint8_t *plane, int stride, int blocksize, int mb_x, int mb_y, int step )
  229. +{
  230. +    DECLARE_ALIGNED( static uint8_t, zero[8], 16 ) = {0,0,0,0,0,0,0,0};
  231. +    int locx,locy,n=0;
  232. +    uint64_t total = 0;
  233. +    int shiftx = 4; int shifty = 4;
  234. +    int startx = shiftx; int starty = shifty;
  235. +    int endx = blocksize - shiftx; int endy = blocksize - shifty;
  236. +    plane -= (shiftx + shifty * stride);
  237. +    if(mb_x == 0) startx += shiftx;
  238. +    if(mb_y == 0) starty += shifty;
  239. +    if(mb_x == h->sps->i_mb_width - 1) endx -= shiftx;
  240. +    if(mb_y == h->sps->i_mb_height - 1) endy -= shifty;
  241. +    plane += starty * stride;
  242. +    for(locy = starty; locy < endy; locy+=step)
  243. +    {
  244. +        for(locx = startx; locx < endx; locx+=step)
  245. +        {
  246. +            int sad = h->pixf.sad[PIXEL_8x8](plane+locx,stride,zero,0);
  247. +            int ssd = h->pixf.ssd[PIXEL_8x8](plane+locx,stride,zero,0);
  248. +            total += ssd - ((sad * sad) >> 6);
  249. +            n++;
  250. +        }
  251. +        plane += stride*step;
  252. +    }
  253. +    return (total * 196) / n;
  254. +}
  255. +
  256. +// Find the total AC energy of the block in all planes.
  257. +static int aq_metric_3( x264_t *h, int mb_x, int mb_y, int *satd )
  258. +{
  259. +    DECLARE_ALIGNED( static uint8_t, zero[16], 16 ) = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  260. +    unsigned int var=0, i;
  261. +    for( i=0; i<1; i++ )
  262. +    {
  263. +        int w = i ? 8 : 16;
  264. +        int stride = h->fenc->i_stride[i];
  265. +        int pix = i ? PIXEL_8x8 : PIXEL_16x16;
  266. +        int offset = h->mb.b_interlaced
  267. +            ? w * (mb_x + (mb_y&~1) * stride) + (mb_y&1) * stride
  268. +            : w * (mb_x + mb_y * stride);
  269. +        stride <<= h->mb.b_interlaced;
  270. +        var += windowed_variance(h, h->fenc->plane[i]+offset, stride, 7, 7, w, mb_x, mb_y, 1);
  271. +        if( var && satd )
  272. +            *satd += h->pixf.satd[pix](zero, 0, h->fenc->plane[i]+offset, stride);
  273. +    }
  274. +    return (var+16) >> 5;
  275. +}
  276. +
  277. +static int aq_metric_2( x264_t *h, int mb_x, int mb_y, int *satd )
  278. +{
  279. +    DECLARE_ALIGNED( static uint8_t, zero[16], 16 ) = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  280. +    unsigned int var=0, i;
  281. +    for( i=0; i<1; i++ )
  282. +    {
  283. +        int w = i ? 8 : 16;
  284. +        int stride = h->fenc->i_stride[i];
  285. +        int pix = i ? PIXEL_8x8 : PIXEL_16x16;
  286. +        int offset = h->mb.b_interlaced
  287. +            ? w * (mb_x + (mb_y&~1) * stride) + (mb_y&1) * stride
  288. +            : w * (mb_x + mb_y * stride);
  289. +        stride <<= h->mb.b_interlaced;
  290. +        var += windowed_variance(h, h->fenc->plane[i]+offset, stride, 7, 7, w, mb_x, mb_y, 2);
  291. +        if( var && satd )
  292. +            *satd += h->pixf.satd[pix](zero, 0, h->fenc->plane[i]+offset, stride);
  293. +    }
  294. +    return (var+16) >> 5;
  295. +}
  296. +
  297. +static int aq_metric_1( x264_t *h, int mb_x, int mb_y, int *satd )
  298. +{
  299. +    DECLARE_ALIGNED( static uint8_t, zero[16], 16 ) = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  300. +    unsigned int var=0, i;
  301. +    for( i=0; i<1; i++ )
  302. +    {
  303. +        int w = i ? 8 : 16;
  304. +        int stride = h->fenc->i_stride[i];
  305. +        int pix = i ? PIXEL_8x8 : PIXEL_16x16;
  306. +        int offset = h->mb.b_interlaced
  307. +            ? w * (mb_x + (mb_y&~1) * stride) + (mb_y&1) * stride
  308. +            : w * (mb_x + mb_y * stride);
  309. +        stride <<= h->mb.b_interlaced;
  310. +        var += fast_windowed_variance(h, h->fenc->plane[i]+offset, stride, w, mb_x, mb_y, 2);
  311. +        if( var && satd )
  312. +            *satd += h->pixf.satd[pix](zero, 0, h->fenc->plane[i]+offset, stride);
  313. +    }
  314. +    return (var+16) >> 5;
  315. +}
  316. +
  317. +static int aq_metric_0( x264_t *h, int mb_x, int mb_y, int *satd )
  318. +{
  319. +    DECLARE_ALIGNED( static uint8_t, flat[16], 16 ) = {128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128};
  320. +    unsigned int var=0, sad, ssd, i;
  321. +    for( i=0; i<3; i++ )
  322. +    {
  323. +        int w = i ? 8 : 16;
  324. +        int stride = h->fenc->i_stride[i];
  325. +        int offset = h->mb.b_interlaced
  326. +            ? w * (mb_x + (mb_y&~1) * stride) + (mb_y&1) * stride
  327. +            : w * (mb_x + mb_y * stride);
  328. +        int pix = i ? PIXEL_8x8 : PIXEL_16x16;
  329. +        stride <<= h->mb.b_interlaced;
  330. +        sad = h->pixf.sad[pix](flat, 0, h->fenc->plane[i]+offset, stride);
  331. +        ssd = h->pixf.ssd[pix](flat, 0, h->fenc->plane[i]+offset, stride);
  332. +        var += ssd - (sad * sad >> (i?6:8));
  333. +        // SATD to represent the block's overall complexity (bit cost) for intra encoding.
  334. +        // exclude the DC coef, because nothing short of an actual intra prediction will estimate DC cost.
  335. +        if( var && satd )
  336. +            *satd += h->pixf.satd[pix](flat, 0, h->fenc->plane[i]+offset, stride) - sad/2;
  337. +    }
  338. +    return var;
  339. +}
  340. +
  341. +void x264_autosense_aq( x264_t *h )
  342. +{
  343. +    double total = 0;
  344. +    double n = 0;
  345. +    int mb_x, mb_y;
  346. +    /* FIXME: Some of the SATDs might be already calculated elsewhere (ratecontrol?).  Can we reuse them? */
  347. +    /* FIXME: Is chroma SATD necessary? */
  348. +    for( mb_y=0; mb_y<h->sps->i_mb_height; mb_y++ )
  349. +        for( mb_x=0; mb_x<h->sps->i_mb_width; mb_x++ )
  350. +        {
  351. +            int energy, satd=0;
  352. +            if(h->param.analyse.i_aq_metric == 0)
  353. +                energy = aq_metric_0( h, h->mb.i_mb_x, h->mb.i_mb_y, &satd );
  354. +            else if(h->param.analyse.i_aq_metric == 1)
  355. +                energy = aq_metric_1( h, h->mb.i_mb_x, h->mb.i_mb_y, &satd );
  356. +            else if(h->param.analyse.i_aq_metric == 2)
  357. +                energy = aq_metric_2( h, h->mb.i_mb_x, h->mb.i_mb_y, &satd );
  358. +            else
  359. +                energy = aq_metric_3( h, h->mb.i_mb_x, h->mb.i_mb_y, &satd );
  360. +            h->rc->ac_energy[mb_x + mb_y * h->sps->i_mb_width] = energy;
  361. +            /* Weight the energy value by the SATD value of the MB.  This represents the fact that
  362. +            the more complex blocks in a frame should be weighted more when calculating the optimal threshold.
  363. +            This also helps diminish the negative effect of large numbers of simple blocks in a frame, such as in the case
  364. +            of a letterboxed film. */
  365. +            if( energy )
  366. +            {
  367. +                x264_cpu_restore(h->param.cpu);
  368. +                total += logf(energy) * satd;
  369. +                n += satd;
  370. +            }
  371. +        }
  372. +    x264_cpu_restore(h->param.cpu);
  373. +    /* Calculate and store the threshold. */
  374. +    h->rc->aq_threshold = n ? total/n : 15;
  375. +}
  376. +
  377. +/*****************************************************************************
  378. +* x264_adaptive_quant:
  379. + * adjust macroblock QP based on variance (AC energy) of the MB.
  380. + * high variance  = higher QP
  381. + * low variance = lower QP
  382. + * This generally increases SSIM and lowers PSNR.
  383. +*****************************************************************************/
  384. +void x264_adaptive_quant( x264_t *h )
  385. +{
  386. +    int qp = h->mb.i_qp;
  387. +    int energy;
  388. +    if(h->param.analyse.i_aq_mode == 2)
  389. +    {
  390. +        if(h->param.analyse.i_aq_metric == 0)
  391. +            energy = aq_metric_0( h, h->mb.i_mb_x, h->mb.i_mb_y, NULL );
  392. +            //printf("%d ",energy);
  393. +        else if(h->param.analyse.i_aq_metric == 1)
  394. +            energy = aq_metric_1( h, h->mb.i_mb_x, h->mb.i_mb_y, NULL );
  395. +            //printf("%d ",energy);
  396. +        else if(h->param.analyse.i_aq_metric == 2)
  397. +            energy = aq_metric_2( h, h->mb.i_mb_x, h->mb.i_mb_y, NULL );
  398. +            //printf("%d ",energy);
  399. +        else
  400. +            energy = aq_metric_3( h, h->mb.i_mb_x, h->mb.i_mb_y, NULL );
  401. +            //printf("%d\n",energy);
  402. +    }
  403. +    else
  404. +        energy = h->rc->ac_energy[h->mb.i_mb_xy];
  405. +    if(energy == 0)
  406. +        h->mb.i_qp = h->mb.i_last_qp;
  407. +    else
  408. +    {
  409. +        x264_cpu_restore(h->param.cpu);
  410. +        float result = energy;
  411. +        /* Adjust the QP based on the AC energy of the macroblock. */
  412. +        float qp_adj = 1.5 * (logf(result) - h->rc->aq_threshold);
  413. +        if(h->param.analyse.i_aq_mode == 1) qp_adj = x264_clip3f(qp_adj, -5, 5);
  414. +        int new_qp = x264_clip3(qp + qp_adj * h->param.analyse.f_aq_strength + .5, h->param.rc.i_qp_min, h->param.rc.i_qp_max);
  415. +        /* If the QP of this MB is within 1 of the previous MB, code the same QP as the previous MB,
  416. +         * to lower the bit cost of the qp_delta. */
  417. +        //if(abs(new_qp - h->mb.i_last_qp) == 1) new_qp = h->mb.i_last_qp;
  418. +        h->mb.i_qp = new_qp;
  419. +    }
  420. +    h->mb.i_chroma_qp = i_chroma_qp_table[x264_clip3( h->mb.i_qp + h->pps->i_chroma_qp_index_offset, 0, 51 )];
  421. +}
  422.  
  423.  int x264_ratecontrol_new( x264_t *h )
  424.  {
  425.  -244,7 +489,7 @@ int x264_ratecontrol_new( x264_t *h )
  426.          rc->rate_tolerance = 0.01;
  427.      }
  428.  
  429. -    h->mb.b_variable_qp = rc->b_vbv && !rc->b_2pass;
  430. +    h->mb.b_variable_qp = (rc->b_vbv && !rc->b_2pass) || h->param.analyse.i_aq_mode;
  431.  
  432.      if( rc->b_abr )
  433.      {
  434.  -458,10 +703,13 @@ int x264_ratecontrol_new( x264_t *h )
  435.          x264_free( p );
  436.      }
  437.  
  438. -    for( i=1; i<h->param.i_threads; i++ )
  439. +    for( i=0; i<h->param.i_threads; i++ )
  440.      {
  441.          h->thread[i]->rc = rc+i;
  442. -        rc[i] = rc[0];
  443. +        if( i )
  444. +            rc[i] = rc[0];
  445. +        if( h->param.analyse.i_aq_mode == 1 )
  446. +            rc[i].ac_energy = x264_malloc( h->mb.i_mb_count * sizeof(int) );
  447.      }
  448.  
  449.      return 0;
  450.  -623,6 +871,8 @@ void x264_ratecontrol_delete( x264_t *h )
  451.                      x264_free( rc->zones[i].param );
  452.          x264_free( rc->zones );
  453.      }
  454. +    for( i=0; i<h->param.i_threads; i++ )
  455. +        x264_free( rc[i].ac_energy );
  456.      x264_free( rc );
  457.  }
  458.  
  459.  -729,6 +979,12 @@ void x264_ratecontrol_start( x264_t *h, int i_force_qp )
  460.  
  461.      if( h->sh.i_type != SLICE_TYPE_B )
  462.          rc->last_non_b_pict_type = h->sh.i_type;
  463. +        
  464. +    /* Adaptive AQ thresholding algorithm. */
  465. +    if( h->param.analyse.i_aq_mode == 2 )
  466. +        h->rc->aq_threshold = logf(5000.0); /* Arbitrary value for "center" of AQ curve. */
  467. +    else if( h->param.analyse.i_aq_mode == 1 )
  468. +        x264_autosense_aq(h);
  469.  }
  470.  
  471.  double predict_row_size( x264_t *h, int y, int qp )
  472. diff --git a/encoder/ratecontrol.h b/encoder/ratecontrol.h
  473. index d4af2c0..e8b2ea1 100644
  474. --- a/encoder/ratecontrol.h
  475. +++ b/encoder/ratecontrol.h
  476.  -34,6 +34,7 @@ void x264_ratecontrol_mb( x264_t *, int bits );
  477.  int  x264_ratecontrol_qp( x264_t * );
  478.  void x264_ratecontrol_end( x264_t *, int bits );
  479.  void x264_ratecontrol_summary( x264_t * );
  480. +void x264_adaptive_quant    ( x264_t * );
  481.  
  482.  #endif
  483.  
  484. diff --git a/x264.c b/x264.c
  485. index f68755d..37618fe 100644
  486. --- a/x264.c
  487. +++ b/x264.c
  488.  -244,6 +244,19 @@ static void Help( x264_param_t *defaults, int b_longhelp )
  489.          "                                  - 2: enabled on all mode decisions\n", defaults->analyse.i_trellis );
  490.      H0( "      --no-fast-pskip         Disables early SKIP detection on P-frames\n" );
  491.      H0( "      --no-dct-decimate       Disables coefficient thresholding on P-frames\n" );
  492. +    H0( "      --aq-strength <float>   Reduces blocking and blurring in flat and\n"
  493. +        "                              textured areas. [%.1f]\n"
  494. +        "                                  - 0.2: weak AQ\n"
  495. +        "                                  - 1.0: very strong AQ\n", defaults->analyse.f_aq_strength );
  496. +    H0( "      --aq-mode <integer>     How AQ distributes bits [%d]\n"
  497. +        "                                  - 0: Disabled\n"
  498. +        "                                  - 1: Avoid moving bits between frames\n"
  499. +        "                                  - 2: Move bits between frames\n", defaults->analyse.i_aq_mode );
  500. +    H0( "      --aq-metric <integer>     The metric used for AQ [%d]\n"
  501. +        "                                  - 0: Whole-macroblock variance (fastest)\n"
  502. +        "                                  - 1: Partial overlapped block variance\n"
  503. +        "                                  - 2: Partial overlapped gaussian variance\n"
  504. +        "                                  - 3: Full overlapped gaussian variance (slowest)", defaults->analyse.i_aq_metric );
  505.      H0( "      --nr <integer>          Noise reduction [%d]\n", defaults->analyse.i_noise_reduction );
  506.      H1( "\n" );
  507.      H1( "      --deadzone-inter <int>  Set the size of the inter luma quantization deadzone [%d]\n", defaults->analyse.i_luma_deadzone[0] );
  508.  -407,6 +420,9 @@ static int  Parse( int argc, char **argv,
  509.              { "trellis", required_argument, NULL, 't' },
  510.              { "no-fast-pskip", no_argument, NULL, 0 },
  511.              { "no-dct-decimate", no_argument, NULL, 0 },
  512. +            { "aq-strength", required_argument, NULL, 0 },
  513. +            { "aq-mode", required_argument, NULL, 0 },
  514. +            { "aq-metric", required_argument, NULL, 0 },
  515.              { "deadzone-inter", required_argument, NULL, '0' },
  516.              { "deadzone-intra", required_argument, NULL, '0' },
  517.              { "level",   required_argument, NULL, 0 },
  518. diff --git a/x264.h b/x264.h
  519. index 70c9eaf..63712d4 100644
  520. --- a/x264.h
  521. +++ b/x264.h
  522.  -232,6 +232,10 @@ typedef struct x264_param_t
  523.          int          i_trellis;  /* trellis RD quantization */
  524.          int          b_fast_pskip; /* early SKIP detection on P-frames */
  525.          int          b_dct_decimate; /* transform coefficient thresholding on P-frames */
  526. +        float        f_aq_strength; /* psy adaptive QP */
  527. +        int          i_aq_mode; /* 0 = off, 1 = auto, 2 = static sensitivity */
  528. +        int          i_aq_metric; /* 0 = macroblock variance, 1 = partial overlapped 8x8 block variance */
  529. +        /* 2 = partial overlapped 7x7 gaussian window variance, 3 = full overlapped 7x7 gaussian window variance. */
  530.          int          i_noise_reduction; /* adaptive pseudo-deadzone */
  531.  
  532.          /* the deadzone size that will be used in luma quantization */

Submit a correction or amendment below (click here to make a fresh posting)
After submitting an amendment, you'll be able to view the differences between the old and new posts easily.

Syntax highlighting:

To highlight particular lines, prefix each line with @@