API tools faq
paste
Advertisement
Guest User

Dark Shikari

a guest
Mar 31st, 2008
427
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.63 KB | None | 0 0
raw download clone embed print report
  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 */
  533.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!