FFmpeg
dnxhdenc.c
Go to the documentation of this file.
1 /*
2  * VC3/DNxHD encoder
3  * Copyright (c) 2007 Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  * Copyright (c) 2011 MirriAd Ltd
5  *
6  * VC-3 encoder funded by the British Broadcasting Corporation
7  * 10 bit support added by MirriAd Ltd, Joseph Artsimovich <joseph@mirriad.com>
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
26 #include "libavutil/attributes.h"
27 #include "libavutil/internal.h"
28 #include "libavutil/opt.h"
29 
30 #include "avcodec.h"
31 #include "blockdsp.h"
32 #include "fdctdsp.h"
33 #include "internal.h"
34 #include "mpegvideo.h"
35 #include "pixblockdsp.h"
36 #include "profiles.h"
37 #include "dnxhdenc.h"
38 
39 // The largest value that will not lead to overflow for 10-bit samples.
40 #define DNX10BIT_QMAT_SHIFT 18
41 #define RC_VARIANCE 1 // use variance or ssd for fast rc
42 #define LAMBDA_FRAC_BITS 10
43 
44 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
45 static const AVOption options[] = {
46  { "nitris_compat", "encode with Avid Nitris compatibility",
47  offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
48  { "ibias", "intra quant bias",
49  offsetof(DNXHDEncContext, intra_quant_bias), AV_OPT_TYPE_INT,
50  { .i64 = 0 }, INT_MIN, INT_MAX, VE },
51  { "profile", NULL, offsetof(DNXHDEncContext, profile), AV_OPT_TYPE_INT,
52  { .i64 = FF_PROFILE_DNXHD },
54  { "dnxhd", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHD },
55  0, 0, VE, "profile" },
56  { "dnxhr_444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_444 },
57  0, 0, VE, "profile" },
58  { "dnxhr_hqx", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_HQX },
59  0, 0, VE, "profile" },
60  { "dnxhr_hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_HQ },
61  0, 0, VE, "profile" },
62  { "dnxhr_sq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_SQ },
63  0, 0, VE, "profile" },
64  { "dnxhr_lb", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_LB },
65  0, 0, VE, "profile" },
66  { NULL }
67 };
68 
69 static const AVClass dnxhd_class = {
70  .class_name = "dnxhd",
71  .item_name = av_default_item_name,
72  .option = options,
73  .version = LIBAVUTIL_VERSION_INT,
74 };
75 
76 static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block,
77  const uint8_t *pixels,
78  ptrdiff_t line_size)
79 {
80  int i;
81  for (i = 0; i < 4; i++) {
82  block[0] = pixels[0];
83  block[1] = pixels[1];
84  block[2] = pixels[2];
85  block[3] = pixels[3];
86  block[4] = pixels[4];
87  block[5] = pixels[5];
88  block[6] = pixels[6];
89  block[7] = pixels[7];
90  pixels += line_size;
91  block += 8;
92  }
93  memcpy(block, block - 8, sizeof(*block) * 8);
94  memcpy(block + 8, block - 16, sizeof(*block) * 8);
95  memcpy(block + 16, block - 24, sizeof(*block) * 8);
96  memcpy(block + 24, block - 32, sizeof(*block) * 8);
97 }
98 
99 static av_always_inline
100 void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block,
101  const uint8_t *pixels,
102  ptrdiff_t line_size)
103 {
104  memcpy(block + 0 * 8, pixels + 0 * line_size, 8 * sizeof(*block));
105  memcpy(block + 7 * 8, pixels + 0 * line_size, 8 * sizeof(*block));
106  memcpy(block + 1 * 8, pixels + 1 * line_size, 8 * sizeof(*block));
107  memcpy(block + 6 * 8, pixels + 1 * line_size, 8 * sizeof(*block));
108  memcpy(block + 2 * 8, pixels + 2 * line_size, 8 * sizeof(*block));
109  memcpy(block + 5 * 8, pixels + 2 * line_size, 8 * sizeof(*block));
110  memcpy(block + 3 * 8, pixels + 3 * line_size, 8 * sizeof(*block));
111  memcpy(block + 4 * 8, pixels + 3 * line_size, 8 * sizeof(*block));
112 }
113 
115  int n, int qscale, int *overflow)
116 {
117  int i, j, level, last_non_zero, start_i;
118  const int *qmat;
120  int bias;
121  int max = 0;
122  unsigned int threshold1, threshold2;
123 
124  ctx->fdsp.fdct(block);
125 
126  block[0] = (block[0] + 2) >> 2;
127  start_i = 1;
128  last_non_zero = 0;
129  qmat = n < 4 ? ctx->q_intra_matrix[qscale] : ctx->q_chroma_intra_matrix[qscale];
130  bias= ctx->intra_quant_bias * (1 << (16 - 8));
131  threshold1 = (1 << 16) - bias - 1;
132  threshold2 = (threshold1 << 1);
133 
134  for (i = 63; i >= start_i; i--) {
135  j = scantable[i];
136  level = block[j] * qmat[j];
137 
138  if (((unsigned)(level + threshold1)) > threshold2) {
139  last_non_zero = i;
140  break;
141  } else{
142  block[j]=0;
143  }
144  }
145 
146  for (i = start_i; i <= last_non_zero; i++) {
147  j = scantable[i];
148  level = block[j] * qmat[j];
149 
150  if (((unsigned)(level + threshold1)) > threshold2) {
151  if (level > 0) {
152  level = (bias + level) >> 16;
153  block[j] = level;
154  } else{
155  level = (bias - level) >> 16;
156  block[j] = -level;
157  }
158  max |= level;
159  } else {
160  block[j] = 0;
161  }
162  }
163  *overflow = ctx->max_qcoeff < max; //overflow might have happened
164 
165  /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
166  if (ctx->idsp.perm_type != FF_IDCT_PERM_NONE)
168  scantable, last_non_zero);
169 
170  return last_non_zero;
171 }
172 
174  int n, int qscale, int *overflow)
175 {
177  const int *qmat = n<4 ? ctx->q_intra_matrix[qscale] : ctx->q_chroma_intra_matrix[qscale];
178  int last_non_zero = 0;
179  int i;
180 
181  ctx->fdsp.fdct(block);
182 
183  // Divide by 4 with rounding, to compensate scaling of DCT coefficients
184  block[0] = (block[0] + 2) >> 2;
185 
186  for (i = 1; i < 64; ++i) {
187  int j = scantable[i];
188  int sign = FF_SIGNBIT(block[j]);
189  int level = (block[j] ^ sign) - sign;
190  level = level * qmat[j] >> DNX10BIT_QMAT_SHIFT;
191  block[j] = (level ^ sign) - sign;
192  if (level)
193  last_non_zero = i;
194  }
195 
196  /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
197  if (ctx->idsp.perm_type != FF_IDCT_PERM_NONE)
199  scantable, last_non_zero);
200 
201  return last_non_zero;
202 }
203 
205 {
206  int i, j, level, run;
207  int max_level = 1 << (ctx->bit_depth + 2);
208 
210  max_level, 4 * sizeof(*ctx->orig_vlc_codes), fail);
212  max_level, 4 * sizeof(*ctx->orig_vlc_bits), fail);
213  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes,
214  63 * 2, fail);
215  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits,
216  63, fail);
217 
218  ctx->vlc_codes = ctx->orig_vlc_codes + max_level * 2;
219  ctx->vlc_bits = ctx->orig_vlc_bits + max_level * 2;
220  for (level = -max_level; level < max_level; level++) {
221  for (run = 0; run < 2; run++) {
222  int index = level * (1 << 1) | run;
223  int sign, offset = 0, alevel = level;
224 
225  MASK_ABS(sign, alevel);
226  if (alevel > 64) {
227  offset = (alevel - 1) >> 6;
228  alevel -= offset << 6;
229  }
230  for (j = 0; j < 257; j++) {
231  if (ctx->cid_table->ac_info[2*j+0] >> 1 == alevel &&
232  (!offset || (ctx->cid_table->ac_info[2*j+1] & 1) && offset) &&
233  (!run || (ctx->cid_table->ac_info[2*j+1] & 2) && run)) {
234  av_assert1(!ctx->vlc_codes[index]);
235  if (alevel) {
236  ctx->vlc_codes[index] =
237  (ctx->cid_table->ac_codes[j] << 1) | (sign & 1);
238  ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j] + 1;
239  } else {
240  ctx->vlc_codes[index] = ctx->cid_table->ac_codes[j];
241  ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j];
242  }
243  break;
244  }
245  }
246  av_assert0(!alevel || j < 257);
247  if (offset) {
248  ctx->vlc_codes[index] =
249  (ctx->vlc_codes[index] << ctx->cid_table->index_bits) | offset;
250  ctx->vlc_bits[index] += ctx->cid_table->index_bits;
251  }
252  }
253  }
254  for (i = 0; i < 62; i++) {
255  int run = ctx->cid_table->run[i];
256  av_assert0(run < 63);
257  ctx->run_codes[run] = ctx->cid_table->run_codes[i];
258  ctx->run_bits[run] = ctx->cid_table->run_bits[i];
259  }
260  return 0;
261 fail:
262  return AVERROR(ENOMEM);
263 }
264 
265 static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
266 {
267  // init first elem to 1 to avoid div by 0 in convert_matrix
268  uint16_t weight_matrix[64] = { 1, }; // convert_matrix needs uint16_t*
269  int qscale, i;
270  const uint8_t *luma_weight_table = ctx->cid_table->luma_weight;
271  const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight;
272 
274  (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail);
276  (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail);
278  (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t),
279  fail);
281  (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t),
282  fail);
283 
284  if (ctx->bit_depth == 8) {
285  for (i = 1; i < 64; i++) {
286  int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
287  weight_matrix[j] = ctx->cid_table->luma_weight[i];
288  }
289  ff_convert_matrix(&ctx->m, ctx->qmatrix_l, ctx->qmatrix_l16,
290  weight_matrix, ctx->intra_quant_bias, 1,
291  ctx->m.avctx->qmax, 1);
292  for (i = 1; i < 64; i++) {
293  int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
294  weight_matrix[j] = ctx->cid_table->chroma_weight[i];
295  }
296  ff_convert_matrix(&ctx->m, ctx->qmatrix_c, ctx->qmatrix_c16,
297  weight_matrix, ctx->intra_quant_bias, 1,
298  ctx->m.avctx->qmax, 1);
299 
300  for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
301  for (i = 0; i < 64; i++) {
302  ctx->qmatrix_l[qscale][i] <<= 2;
303  ctx->qmatrix_c[qscale][i] <<= 2;
304  ctx->qmatrix_l16[qscale][0][i] <<= 2;
305  ctx->qmatrix_l16[qscale][1][i] <<= 2;
306  ctx->qmatrix_c16[qscale][0][i] <<= 2;
307  ctx->qmatrix_c16[qscale][1][i] <<= 2;
308  }
309  }
310  } else {
311  // 10-bit
312  for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
313  for (i = 1; i < 64; i++) {
314  int j = ff_zigzag_direct[i];
315 
316  /* The quantization formula from the VC-3 standard is:
317  * quantized = sign(block[i]) * floor(abs(block[i]/s) * p /
318  * (qscale * weight_table[i]))
319  * Where p is 32 for 8-bit samples and 8 for 10-bit ones.
320  * The s factor compensates scaling of DCT coefficients done by
321  * the DCT routines, and therefore is not present in standard.
322  * It's 8 for 8-bit samples and 4 for 10-bit ones.
323  * We want values of ctx->qtmatrix_l and ctx->qtmatrix_r to be:
324  * ((1 << DNX10BIT_QMAT_SHIFT) * (p / s)) /
325  * (qscale * weight_table[i])
326  * For 10-bit samples, p / s == 2 */
327  ctx->qmatrix_l[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
328  (qscale * luma_weight_table[i]);
329  ctx->qmatrix_c[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
330  (qscale * chroma_weight_table[i]);
331  }
332  }
333  }
334 
336  ctx->m.q_chroma_intra_matrix = ctx->qmatrix_c;
337  ctx->m.q_intra_matrix16 = ctx->qmatrix_l16;
338  ctx->m.q_intra_matrix = ctx->qmatrix_l;
339 
340  return 0;
341 fail:
342  return AVERROR(ENOMEM);
343 }
344 
346 {
347  FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_rc, (ctx->m.avctx->qmax + 1),
348  ctx->m.mb_num * sizeof(RCEntry), fail);
349  if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) {
351  ctx->m.mb_num, sizeof(RCCMPEntry), fail);
353  ctx->m.mb_num, sizeof(RCCMPEntry), fail);
354  }
355  ctx->frame_bits = (ctx->coding_unit_size -
356  ctx->data_offset - 4 - ctx->min_padding) * 8;
357  ctx->qscale = 1;
358  ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2
359  return 0;
360 fail:
361  return AVERROR(ENOMEM);
362 }
363 
365 {
366  DNXHDEncContext *ctx = avctx->priv_data;
367  int i, index, ret;
368 
369  switch (avctx->pix_fmt) {
370  case AV_PIX_FMT_YUV422P:
371  ctx->bit_depth = 8;
372  break;
375  case AV_PIX_FMT_GBRP10:
376  ctx->bit_depth = 10;
377  break;
378  default:
379  av_log(avctx, AV_LOG_ERROR,
380  "pixel format is incompatible with DNxHD\n");
381  return AVERROR(EINVAL);
382  }
383 
384  if ((ctx->profile == FF_PROFILE_DNXHR_444 && (avctx->pix_fmt != AV_PIX_FMT_YUV444P10 &&
385  avctx->pix_fmt != AV_PIX_FMT_GBRP10)) ||
386  (ctx->profile != FF_PROFILE_DNXHR_444 && (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 ||
387  avctx->pix_fmt == AV_PIX_FMT_GBRP10))) {
388  av_log(avctx, AV_LOG_ERROR,
389  "pixel format is incompatible with DNxHD profile\n");
390  return AVERROR(EINVAL);
391  }
392 
393  if (ctx->profile == FF_PROFILE_DNXHR_HQX && avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
394  av_log(avctx, AV_LOG_ERROR,
395  "pixel format is incompatible with DNxHR HQX profile\n");
396  return AVERROR(EINVAL);
397  }
398 
399  if ((ctx->profile == FF_PROFILE_DNXHR_LB ||
400  ctx->profile == FF_PROFILE_DNXHR_SQ ||
401  ctx->profile == FF_PROFILE_DNXHR_HQ) && avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
402  av_log(avctx, AV_LOG_ERROR,
403  "pixel format is incompatible with DNxHR LB/SQ/HQ profile\n");
404  return AVERROR(EINVAL);
405  }
406 
407  ctx->is_444 = ctx->profile == FF_PROFILE_DNXHR_444;
408  avctx->profile = ctx->profile;
409  ctx->cid = ff_dnxhd_find_cid(avctx, ctx->bit_depth);
410  if (!ctx->cid) {
411  av_log(avctx, AV_LOG_ERROR,
412  "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n");
414  return AVERROR(EINVAL);
415  }
416  av_log(avctx, AV_LOG_DEBUG, "cid %d\n", ctx->cid);
417 
418  if (ctx->cid >= 1270 && ctx->cid <= 1274)
419  avctx->codec_tag = MKTAG('A','V','d','h');
420 
421  if (avctx->width < 256 || avctx->height < 120) {
422  av_log(avctx, AV_LOG_ERROR,
423  "Input dimensions too small, input must be at least 256x120\n");
424  return AVERROR(EINVAL);
425  }
426 
427  index = ff_dnxhd_get_cid_table(ctx->cid);
428  av_assert0(index >= 0);
429 
431 
432  ctx->m.avctx = avctx;
433  ctx->m.mb_intra = 1;
434  ctx->m.h263_aic = 1;
435 
436  avctx->bits_per_raw_sample = ctx->bit_depth;
437 
438  ff_blockdsp_init(&ctx->bdsp, avctx);
439  ff_fdctdsp_init(&ctx->m.fdsp, avctx);
440  ff_mpv_idct_init(&ctx->m);
441  ff_mpegvideoencdsp_init(&ctx->m.mpvencdsp, avctx);
442  ff_pixblockdsp_init(&ctx->m.pdsp, avctx);
443  ff_dct_encode_init(&ctx->m);
444 
445  if (ctx->profile != FF_PROFILE_DNXHD)
446  ff_videodsp_init(&ctx->m.vdsp, ctx->bit_depth);
447 
448  if (!ctx->m.dct_quantize)
450 
451  if (ctx->is_444 || ctx->profile == FF_PROFILE_DNXHR_HQX) {
454  ctx->block_width_l2 = 4;
455  } else if (ctx->bit_depth == 10) {
458  ctx->block_width_l2 = 4;
459  } else {
461  ctx->block_width_l2 = 3;
462  }
463 
464  if (ARCH_X86)
466 
467  ctx->m.mb_height = (avctx->height + 15) / 16;
468  ctx->m.mb_width = (avctx->width + 15) / 16;
469 
470  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
471  ctx->interlaced = 1;
472  ctx->m.mb_height /= 2;
473  }
474 
475  if (ctx->interlaced && ctx->profile != FF_PROFILE_DNXHD) {
476  av_log(avctx, AV_LOG_ERROR,
477  "Interlaced encoding is not supported for DNxHR profiles.\n");
478  return AVERROR(EINVAL);
479  }
480 
481  ctx->m.mb_num = ctx->m.mb_height * ctx->m.mb_width;
482 
483  if (ctx->cid_table->frame_size == DNXHD_VARIABLE) {
485  avctx->width, avctx->height);
486  av_assert0(ctx->frame_size >= 0);
487  ctx->coding_unit_size = ctx->frame_size;
488  } else {
489  ctx->frame_size = ctx->cid_table->frame_size;
491  }
492 
493  if (ctx->m.mb_height > 68)
494  ctx->data_offset = 0x170 + (ctx->m.mb_height << 2);
495  else
496  ctx->data_offset = 0x280;
497 
498  // XXX tune lbias/cbias
499  if ((ret = dnxhd_init_qmat(ctx, ctx->intra_quant_bias, 0)) < 0)
500  return ret;
501 
502  /* Avid Nitris hardware decoder requires a minimum amount of padding
503  * in the coding unit payload */
504  if (ctx->nitris_compat)
505  ctx->min_padding = 1600;
506 
507  if ((ret = dnxhd_init_vlc(ctx)) < 0)
508  return ret;
509  if ((ret = dnxhd_init_rc(ctx)) < 0)
510  return ret;
511 
512  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size,
513  ctx->m.mb_height * sizeof(uint32_t), fail);
514  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs,
515  ctx->m.mb_height * sizeof(uint32_t), fail);
516  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits,
517  ctx->m.mb_num * sizeof(uint16_t), fail);
518  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale,
519  ctx->m.mb_num * sizeof(uint8_t), fail);
520 
521 #if FF_API_CODED_FRAME
523  avctx->coded_frame->key_frame = 1;
526 #endif
527 
528  if (avctx->active_thread_type == FF_THREAD_SLICE) {
529  if (avctx->thread_count > MAX_THREADS) {
530  av_log(avctx, AV_LOG_ERROR, "too many threads\n");
531  return AVERROR(EINVAL);
532  }
533  }
534 
535  if (avctx->qmax <= 1) {
536  av_log(avctx, AV_LOG_ERROR, "qmax must be at least 2\n");
537  return AVERROR(EINVAL);
538  }
539 
540  ctx->thread[0] = ctx;
541  if (avctx->active_thread_type == FF_THREAD_SLICE) {
542  for (i = 1; i < avctx->thread_count; i++) {
543  ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext));
544  if (!ctx->thread[i])
545  goto fail;
546  memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext));
547  }
548  }
549 
550  return 0;
551 fail: // for FF_ALLOCZ_OR_GOTO
552  return AVERROR(ENOMEM);
553 }
554 
556 {
557  DNXHDEncContext *ctx = avctx->priv_data;
558 
559  memset(buf, 0, ctx->data_offset);
560 
561  // * write prefix */
562  AV_WB16(buf + 0x02, ctx->data_offset);
563  if (ctx->cid >= 1270 && ctx->cid <= 1274)
564  buf[4] = 0x03;
565  else
566  buf[4] = 0x01;
567 
568  buf[5] = ctx->interlaced ? ctx->cur_field + 2 : 0x01;
569  buf[6] = 0x80; // crc flag off
570  buf[7] = 0xa0; // reserved
571  AV_WB16(buf + 0x18, avctx->height >> ctx->interlaced); // ALPF
572  AV_WB16(buf + 0x1a, avctx->width); // SPL
573  AV_WB16(buf + 0x1d, avctx->height >> ctx->interlaced); // NAL
574 
575  buf[0x21] = ctx->bit_depth == 10 ? 0x58 : 0x38;
576  buf[0x22] = 0x88 + (ctx->interlaced << 2);
577  AV_WB32(buf + 0x28, ctx->cid); // CID
578  buf[0x2c] = (!ctx->interlaced << 7) | (ctx->is_444 << 6) | (avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
579 
580  buf[0x5f] = 0x01; // UDL
581 
582  buf[0x167] = 0x02; // reserved
583  AV_WB16(buf + 0x16a, ctx->m.mb_height * 4 + 4); // MSIPS
584  AV_WB16(buf + 0x16c, ctx->m.mb_height); // Ns
585  buf[0x16f] = 0x10; // reserved
586 
587  ctx->msip = buf + 0x170;
588  return 0;
589 }
590 
592 {
593  int nbits;
594  if (diff < 0) {
595  nbits = av_log2_16bit(-2 * diff);
596  diff--;
597  } else {
598  nbits = av_log2_16bit(2 * diff);
599  }
600  put_bits(&ctx->m.pb, ctx->cid_table->dc_bits[nbits] + nbits,
601  (ctx->cid_table->dc_codes[nbits] << nbits) +
602  av_mod_uintp2(diff, nbits));
603 }
604 
605 static av_always_inline
607  int last_index, int n)
608 {
609  int last_non_zero = 0;
610  int slevel, i, j;
611 
612  dnxhd_encode_dc(ctx, block[0] - ctx->m.last_dc[n]);
613  ctx->m.last_dc[n] = block[0];
614 
615  for (i = 1; i <= last_index; i++) {
616  j = ctx->m.intra_scantable.permutated[i];
617  slevel = block[j];
618  if (slevel) {
619  int run_level = i - last_non_zero - 1;
620  int rlevel = slevel * (1 << 1) | !!run_level;
621  put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
622  if (run_level)
623  put_bits(&ctx->m.pb, ctx->run_bits[run_level],
624  ctx->run_codes[run_level]);
625  last_non_zero = i;
626  }
627  }
628  put_bits(&ctx->m.pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB
629 }
630 
631 static av_always_inline
633  int qscale, int last_index)
634 {
635  const uint8_t *weight_matrix;
636  int level;
637  int i;
638 
639  if (ctx->is_444) {
640  weight_matrix = ((n % 6) < 2) ? ctx->cid_table->luma_weight
641  : ctx->cid_table->chroma_weight;
642  } else {
643  weight_matrix = (n & 2) ? ctx->cid_table->chroma_weight
644  : ctx->cid_table->luma_weight;
645  }
646 
647  for (i = 1; i <= last_index; i++) {
648  int j = ctx->m.intra_scantable.permutated[i];
649  level = block[j];
650  if (level) {
651  if (level < 0) {
652  level = (1 - 2 * level) * qscale * weight_matrix[i];
653  if (ctx->bit_depth == 10) {
654  if (weight_matrix[i] != 8)
655  level += 8;
656  level >>= 4;
657  } else {
658  if (weight_matrix[i] != 32)
659  level += 32;
660  level >>= 6;
661  }
662  level = -level;
663  } else {
664  level = (2 * level + 1) * qscale * weight_matrix[i];
665  if (ctx->bit_depth == 10) {
666  if (weight_matrix[i] != 8)
667  level += 8;
668  level >>= 4;
669  } else {
670  if (weight_matrix[i] != 32)
671  level += 32;
672  level >>= 6;
673  }
674  }
675  block[j] = level;
676  }
677  }
678 }
679 
680 static av_always_inline int dnxhd_ssd_block(int16_t *qblock, int16_t *block)
681 {
682  int score = 0;
683  int i;
684  for (i = 0; i < 64; i++)
685  score += (block[i] - qblock[i]) * (block[i] - qblock[i]);
686  return score;
687 }
688 
689 static av_always_inline
690 int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
691 {
692  int last_non_zero = 0;
693  int bits = 0;
694  int i, j, level;
695  for (i = 1; i <= last_index; i++) {
696  j = ctx->m.intra_scantable.permutated[i];
697  level = block[j];
698  if (level) {
699  int run_level = i - last_non_zero - 1;
700  bits += ctx->vlc_bits[level * (1 << 1) |
701  !!run_level] + ctx->run_bits[run_level];
702  last_non_zero = i;
703  }
704  }
705  return bits;
706 }
707 
708 static av_always_inline
709 void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
710 {
711  const int bs = ctx->block_width_l2;
712  const int bw = 1 << bs;
713  int dct_y_offset = ctx->dct_y_offset;
714  int dct_uv_offset = ctx->dct_uv_offset;
715  int linesize = ctx->m.linesize;
716  int uvlinesize = ctx->m.uvlinesize;
717  const uint8_t *ptr_y = ctx->thread[0]->src[0] +
718  ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs + 1);
719  const uint8_t *ptr_u = ctx->thread[0]->src[1] +
720  ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
721  const uint8_t *ptr_v = ctx->thread[0]->src[2] +
722  ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
723  PixblockDSPContext *pdsp = &ctx->m.pdsp;
724  VideoDSPContext *vdsp = &ctx->m.vdsp;
725 
726  if (ctx->bit_depth != 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
727  (mb_y << 4) + 16 > ctx->m.avctx->height)) {
728  int y_w = ctx->m.avctx->width - (mb_x << 4);
729  int y_h = ctx->m.avctx->height - (mb_y << 4);
730  int uv_w = (y_w + 1) / 2;
731  int uv_h = y_h;
732  linesize = 16;
733  uvlinesize = 8;
734 
735  vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
736  linesize, ctx->m.linesize,
737  linesize, 16,
738  0, 0, y_w, y_h);
739  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
740  uvlinesize, ctx->m.uvlinesize,
741  uvlinesize, 16,
742  0, 0, uv_w, uv_h);
743  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
744  uvlinesize, ctx->m.uvlinesize,
745  uvlinesize, 16,
746  0, 0, uv_w, uv_h);
747 
748  dct_y_offset = bw * linesize;
749  dct_uv_offset = bw * uvlinesize;
750  ptr_y = &ctx->edge_buf_y[0];
751  ptr_u = &ctx->edge_buf_uv[0][0];
752  ptr_v = &ctx->edge_buf_uv[1][0];
753  } else if (ctx->bit_depth == 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
754  (mb_y << 4) + 16 > ctx->m.avctx->height)) {
755  int y_w = ctx->m.avctx->width - (mb_x << 4);
756  int y_h = ctx->m.avctx->height - (mb_y << 4);
757  int uv_w = ctx->is_444 ? y_w : (y_w + 1) / 2;
758  int uv_h = y_h;
759  linesize = 32;
760  uvlinesize = 16 + 16 * ctx->is_444;
761 
762  vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
763  linesize, ctx->m.linesize,
764  linesize / 2, 16,
765  0, 0, y_w, y_h);
766  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
767  uvlinesize, ctx->m.uvlinesize,
768  uvlinesize / 2, 16,
769  0, 0, uv_w, uv_h);
770  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
771  uvlinesize, ctx->m.uvlinesize,
772  uvlinesize / 2, 16,
773  0, 0, uv_w, uv_h);
774 
775  dct_y_offset = bw * linesize / 2;
776  dct_uv_offset = bw * uvlinesize / 2;
777  ptr_y = &ctx->edge_buf_y[0];
778  ptr_u = &ctx->edge_buf_uv[0][0];
779  ptr_v = &ctx->edge_buf_uv[1][0];
780  }
781 
782  if (!ctx->is_444) {
783  pdsp->get_pixels(ctx->blocks[0], ptr_y, linesize);
784  pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
785  pdsp->get_pixels(ctx->blocks[2], ptr_u, uvlinesize);
786  pdsp->get_pixels(ctx->blocks[3], ptr_v, uvlinesize);
787 
788  if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
789  if (ctx->interlaced) {
790  ctx->get_pixels_8x4_sym(ctx->blocks[4],
791  ptr_y + dct_y_offset,
792  linesize);
793  ctx->get_pixels_8x4_sym(ctx->blocks[5],
794  ptr_y + dct_y_offset + bw,
795  linesize);
796  ctx->get_pixels_8x4_sym(ctx->blocks[6],
797  ptr_u + dct_uv_offset,
798  uvlinesize);
799  ctx->get_pixels_8x4_sym(ctx->blocks[7],
800  ptr_v + dct_uv_offset,
801  uvlinesize);
802  } else {
803  ctx->bdsp.clear_block(ctx->blocks[4]);
804  ctx->bdsp.clear_block(ctx->blocks[5]);
805  ctx->bdsp.clear_block(ctx->blocks[6]);
806  ctx->bdsp.clear_block(ctx->blocks[7]);
807  }
808  } else {
809  pdsp->get_pixels(ctx->blocks[4],
810  ptr_y + dct_y_offset, linesize);
811  pdsp->get_pixels(ctx->blocks[5],
812  ptr_y + dct_y_offset + bw, linesize);
813  pdsp->get_pixels(ctx->blocks[6],
814  ptr_u + dct_uv_offset, uvlinesize);
815  pdsp->get_pixels(ctx->blocks[7],
816  ptr_v + dct_uv_offset, uvlinesize);
817  }
818  } else {
819  pdsp->get_pixels(ctx->blocks[0], ptr_y, linesize);
820  pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
821  pdsp->get_pixels(ctx->blocks[6], ptr_y + dct_y_offset, linesize);
822  pdsp->get_pixels(ctx->blocks[7], ptr_y + dct_y_offset + bw, linesize);
823 
824  pdsp->get_pixels(ctx->blocks[2], ptr_u, uvlinesize);
825  pdsp->get_pixels(ctx->blocks[3], ptr_u + bw, uvlinesize);
826  pdsp->get_pixels(ctx->blocks[8], ptr_u + dct_uv_offset, uvlinesize);
827  pdsp->get_pixels(ctx->blocks[9], ptr_u + dct_uv_offset + bw, uvlinesize);
828 
829  pdsp->get_pixels(ctx->blocks[4], ptr_v, uvlinesize);
830  pdsp->get_pixels(ctx->blocks[5], ptr_v + bw, uvlinesize);
831  pdsp->get_pixels(ctx->blocks[10], ptr_v + dct_uv_offset, uvlinesize);
832  pdsp->get_pixels(ctx->blocks[11], ptr_v + dct_uv_offset + bw, uvlinesize);
833  }
834 }
835 
836 static av_always_inline
838 {
839  int x;
840 
841  if (ctx->is_444) {
842  x = (i >> 1) % 3;
843  } else {
844  const static uint8_t component[8]={0,0,1,2,0,0,1,2};
845  x = component[i];
846  }
847  return x;
848 }
849 
851  int jobnr, int threadnr)
852 {
853  DNXHDEncContext *ctx = avctx->priv_data;
854  int mb_y = jobnr, mb_x;
855  int qscale = ctx->qscale;
856  LOCAL_ALIGNED_16(int16_t, block, [64]);
857  ctx = ctx->thread[threadnr];
858 
859  ctx->m.last_dc[0] =
860  ctx->m.last_dc[1] =
861  ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
862 
863  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
864  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
865  int ssd = 0;
866  int ac_bits = 0;
867  int dc_bits = 0;
868  int i;
869 
870  dnxhd_get_blocks(ctx, mb_x, mb_y);
871 
872  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
873  int16_t *src_block = ctx->blocks[i];
874  int overflow, nbits, diff, last_index;
875  int n = dnxhd_switch_matrix(ctx, i);
876 
877  memcpy(block, src_block, 64 * sizeof(*block));
878  last_index = ctx->m.dct_quantize(&ctx->m, block,
879  ctx->is_444 ? 4 * (n > 0): 4 & (2*i),
880  qscale, &overflow);
881  ac_bits += dnxhd_calc_ac_bits(ctx, block, last_index);
882 
883  diff = block[0] - ctx->m.last_dc[n];
884  if (diff < 0)
885  nbits = av_log2_16bit(-2 * diff);
886  else
887  nbits = av_log2_16bit(2 * diff);
888 
889  av_assert1(nbits < ctx->bit_depth + 4);
890  dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
891 
892  ctx->m.last_dc[n] = block[0];
893 
894  if (avctx->mb_decision == FF_MB_DECISION_RD || !RC_VARIANCE) {
895  dnxhd_unquantize_c(ctx, block, i, qscale, last_index);
896  ctx->m.idsp.idct(block);
897  ssd += dnxhd_ssd_block(block, src_block);
898  }
899  }
900  ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].ssd = ssd;
901  ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].bits = ac_bits + dc_bits + 12 +
902  (1 + ctx->is_444) * 8 * ctx->vlc_bits[0];
903  }
904  return 0;
905 }
906 
908  int jobnr, int threadnr)
909 {
910  DNXHDEncContext *ctx = avctx->priv_data;
911  int mb_y = jobnr, mb_x;
912  ctx = ctx->thread[threadnr];
913  init_put_bits(&ctx->m.pb, (uint8_t *)arg + ctx->data_offset + ctx->slice_offs[jobnr],
914  ctx->slice_size[jobnr]);
915 
916  ctx->m.last_dc[0] =
917  ctx->m.last_dc[1] =
918  ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
919  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
920  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
921  int qscale = ctx->mb_qscale[mb];
922  int i;
923 
924  put_bits(&ctx->m.pb, 11, qscale);
925  put_bits(&ctx->m.pb, 1, avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
926 
927  dnxhd_get_blocks(ctx, mb_x, mb_y);
928 
929  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
930  int16_t *block = ctx->blocks[i];
931  int overflow, n = dnxhd_switch_matrix(ctx, i);
932  int last_index = ctx->m.dct_quantize(&ctx->m, block,
933  ctx->is_444 ? (((i >> 1) % 3) < 1 ? 0 : 4): 4 & (2*i),
934  qscale, &overflow);
935 
936  dnxhd_encode_block(ctx, block, last_index, n);
937  }
938  }
939  if (put_bits_count(&ctx->m.pb) & 31)
940  put_bits(&ctx->m.pb, 32 - (put_bits_count(&ctx->m.pb) & 31), 0);
941  flush_put_bits(&ctx->m.pb);
942  return 0;
943 }
944 
946 {
947  int mb_y, mb_x;
948  int offset = 0;
949  for (mb_y = 0; mb_y < ctx->m.mb_height; mb_y++) {
950  int thread_size;
951  ctx->slice_offs[mb_y] = offset;
952  ctx->slice_size[mb_y] = 0;
953  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
954  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
955  ctx->slice_size[mb_y] += ctx->mb_bits[mb];
956  }
957  ctx->slice_size[mb_y] = (ctx->slice_size[mb_y] + 31) & ~31;
958  ctx->slice_size[mb_y] >>= 3;
959  thread_size = ctx->slice_size[mb_y];
960  offset += thread_size;
961  }
962 }
963 
965  int jobnr, int threadnr)
966 {
967  DNXHDEncContext *ctx = avctx->priv_data;
968  int mb_y = jobnr, mb_x, x, y;
969  int partial_last_row = (mb_y == ctx->m.mb_height - 1) &&
970  ((avctx->height >> ctx->interlaced) & 0xF);
971 
972  ctx = ctx->thread[threadnr];
973  if (ctx->bit_depth == 8) {
974  uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y << 4) * ctx->m.linesize);
975  for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x, pix += 16) {
976  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
977  int sum;
978  int varc;
979 
980  if (!partial_last_row && mb_x * 16 <= avctx->width - 16 && (avctx->width % 16) == 0) {
981  sum = ctx->m.mpvencdsp.pix_sum(pix, ctx->m.linesize);
982  varc = ctx->m.mpvencdsp.pix_norm1(pix, ctx->m.linesize);
983  } else {
984  int bw = FFMIN(avctx->width - 16 * mb_x, 16);
985  int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16);
986  sum = varc = 0;
987  for (y = 0; y < bh; y++) {
988  for (x = 0; x < bw; x++) {
989  uint8_t val = pix[x + y * ctx->m.linesize];
990  sum += val;
991  varc += val * val;
992  }
993  }
994  }
995  varc = (varc - (((unsigned) sum * sum) >> 8) + 128) >> 8;
996 
997  ctx->mb_cmp[mb].value = varc;
998  ctx->mb_cmp[mb].mb = mb;
999  }
1000  } else { // 10-bit
1001  const int linesize = ctx->m.linesize >> 1;
1002  for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) {
1003  uint16_t *pix = (uint16_t *)ctx->thread[0]->src[0] +
1004  ((mb_y << 4) * linesize) + (mb_x << 4);
1005  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
1006  int sum = 0;
1007  int sqsum = 0;
1008  int bw = FFMIN(avctx->width - 16 * mb_x, 16);
1009  int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16);
1010  int mean, sqmean;
1011  int i, j;
1012  // Macroblocks are 16x16 pixels, unlike DCT blocks which are 8x8.
1013  for (i = 0; i < bh; ++i) {
1014  for (j = 0; j < bw; ++j) {
1015  // Turn 16-bit pixels into 10-bit ones.
1016  const int sample = (unsigned) pix[j] >> 6;
1017  sum += sample;
1018  sqsum += sample * sample;
1019  // 2^10 * 2^10 * 16 * 16 = 2^28, which is less than INT_MAX
1020  }
1021  pix += linesize;
1022  }
1023  mean = sum >> 8; // 16*16 == 2^8
1024  sqmean = sqsum >> 8;
1025  ctx->mb_cmp[mb].value = sqmean - mean * mean;
1026  ctx->mb_cmp[mb].mb = mb;
1027  }
1028  }
1029  return 0;
1030 }
1031 
1033 {
1034  int lambda, up_step, down_step;
1035  int last_lower = INT_MAX, last_higher = 0;
1036  int x, y, q;
1037 
1038  for (q = 1; q < avctx->qmax; q++) {
1039  ctx->qscale = q;
1040  avctx->execute2(avctx, dnxhd_calc_bits_thread,
1041  NULL, NULL, ctx->m.mb_height);
1042  }
1043  up_step = down_step = 2 << LAMBDA_FRAC_BITS;
1044  lambda = ctx->lambda;
1045 
1046  for (;;) {
1047  int bits = 0;
1048  int end = 0;
1049  if (lambda == last_higher) {
1050  lambda++;
1051  end = 1; // need to set final qscales/bits
1052  }
1053  for (y = 0; y < ctx->m.mb_height; y++) {
1054  for (x = 0; x < ctx->m.mb_width; x++) {
1055  unsigned min = UINT_MAX;
1056  int qscale = 1;
1057  int mb = y * ctx->m.mb_width + x;
1058  int rc = 0;
1059  for (q = 1; q < avctx->qmax; q++) {
1060  int i = (q*ctx->m.mb_num) + mb;
1061  unsigned score = ctx->mb_rc[i].bits * lambda +
1062  ((unsigned) ctx->mb_rc[i].ssd << LAMBDA_FRAC_BITS);
1063  if (score < min) {
1064  min = score;
1065  qscale = q;
1066  rc = i;
1067  }
1068  }
1069  bits += ctx->mb_rc[rc].bits;
1070  ctx->mb_qscale[mb] = qscale;
1071  ctx->mb_bits[mb] = ctx->mb_rc[rc].bits;
1072  }
1073  bits = (bits + 31) & ~31; // padding
1074  if (bits > ctx->frame_bits)
1075  break;
1076  }
1077  if (end) {
1078  if (bits > ctx->frame_bits)
1079  return AVERROR(EINVAL);
1080  break;
1081  }
1082  if (bits < ctx->frame_bits) {
1083  last_lower = FFMIN(lambda, last_lower);
1084  if (last_higher != 0)
1085  lambda = (lambda+last_higher)>>1;
1086  else
1087  lambda -= down_step;
1088  down_step = FFMIN((int64_t)down_step*5, INT_MAX);
1089  up_step = 1<<LAMBDA_FRAC_BITS;
1090  lambda = FFMAX(1, lambda);
1091  if (lambda == last_lower)
1092  break;
1093  } else {
1094  last_higher = FFMAX(lambda, last_higher);
1095  if (last_lower != INT_MAX)
1096  lambda = (lambda+last_lower)>>1;
1097  else if ((int64_t)lambda + up_step > INT_MAX)
1098  return AVERROR(EINVAL);
1099  else
1100  lambda += up_step;
1101  up_step = FFMIN((int64_t)up_step*5, INT_MAX);
1102  down_step = 1<<LAMBDA_FRAC_BITS;
1103  }
1104  }
1105  ctx->lambda = lambda;
1106  return 0;
1107 }
1108 
1110 {
1111  int bits = 0;
1112  int up_step = 1;
1113  int down_step = 1;
1114  int last_higher = 0;
1115  int last_lower = INT_MAX;
1116  int qscale;
1117  int x, y;
1118 
1119  qscale = ctx->qscale;
1120  for (;;) {
1121  bits = 0;
1122  ctx->qscale = qscale;
1123  // XXX avoid recalculating bits
1125  NULL, NULL, ctx->m.mb_height);
1126  for (y = 0; y < ctx->m.mb_height; y++) {
1127  for (x = 0; x < ctx->m.mb_width; x++)
1128  bits += ctx->mb_rc[(qscale*ctx->m.mb_num) + (y*ctx->m.mb_width+x)].bits;
1129  bits = (bits+31)&~31; // padding
1130  if (bits > ctx->frame_bits)
1131  break;
1132  }
1133  if (bits < ctx->frame_bits) {
1134  if (qscale == 1)
1135  return 1;
1136  if (last_higher == qscale - 1) {
1137  qscale = last_higher;
1138  break;
1139  }
1140  last_lower = FFMIN(qscale, last_lower);
1141  if (last_higher != 0)
1142  qscale = (qscale + last_higher) >> 1;
1143  else
1144  qscale -= down_step++;
1145  if (qscale < 1)
1146  qscale = 1;
1147  up_step = 1;
1148  } else {
1149  if (last_lower == qscale + 1)
1150  break;
1151  last_higher = FFMAX(qscale, last_higher);
1152  if (last_lower != INT_MAX)
1153  qscale = (qscale + last_lower) >> 1;
1154  else
1155  qscale += up_step++;
1156  down_step = 1;
1157  if (qscale >= ctx->m.avctx->qmax)
1158  return AVERROR(EINVAL);
1159  }
1160  }
1161  ctx->qscale = qscale;
1162  return 0;
1163 }
1164 
1165 #define BUCKET_BITS 8
1166 #define RADIX_PASSES 4
1167 #define NBUCKETS (1 << BUCKET_BITS)
1168 
1169 static inline int get_bucket(int value, int shift)
1170 {
1171  value >>= shift;
1172  value &= NBUCKETS - 1;
1173  return NBUCKETS - 1 - value;
1174 }
1175 
1176 static void radix_count(const RCCMPEntry *data, int size,
1177  int buckets[RADIX_PASSES][NBUCKETS])
1178 {
1179  int i, j;
1180  memset(buckets, 0, sizeof(buckets[0][0]) * RADIX_PASSES * NBUCKETS);
1181  for (i = 0; i < size; i++) {
1182  int v = data[i].value;
1183  for (j = 0; j < RADIX_PASSES; j++) {
1184  buckets[j][get_bucket(v, 0)]++;
1185  v >>= BUCKET_BITS;
1186  }
1187  av_assert1(!v);
1188  }
1189  for (j = 0; j < RADIX_PASSES; j++) {
1190  int offset = size;
1191  for (i = NBUCKETS - 1; i >= 0; i--)
1192  buckets[j][i] = offset -= buckets[j][i];
1193  av_assert1(!buckets[j][0]);
1194  }
1195 }
1196 
1197 static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data,
1198  int size, int buckets[NBUCKETS], int pass)
1199 {
1200  int shift = pass * BUCKET_BITS;
1201  int i;
1202  for (i = 0; i < size; i++) {
1203  int v = get_bucket(data[i].value, shift);
1204  int pos = buckets[v]++;
1205  dst[pos] = data[i];
1206  }
1207 }
1208 
1210 {
1211  int buckets[RADIX_PASSES][NBUCKETS];
1212  radix_count(data, size, buckets);
1213  radix_sort_pass(tmp, data, size, buckets[0], 0);
1214  radix_sort_pass(data, tmp, size, buckets[1], 1);
1215  if (buckets[2][NBUCKETS - 1] || buckets[3][NBUCKETS - 1]) {
1216  radix_sort_pass(tmp, data, size, buckets[2], 2);
1217  radix_sort_pass(data, tmp, size, buckets[3], 3);
1218  }
1219 }
1220 
1222 {
1223  int max_bits = 0;
1224  int ret, x, y;
1225  if ((ret = dnxhd_find_qscale(ctx)) < 0)
1226  return ret;
1227  for (y = 0; y < ctx->m.mb_height; y++) {
1228  for (x = 0; x < ctx->m.mb_width; x++) {
1229  int mb = y * ctx->m.mb_width + x;
1230  int rc = (ctx->qscale * ctx->m.mb_num ) + mb;
1231  int delta_bits;
1232  ctx->mb_qscale[mb] = ctx->qscale;
1233  ctx->mb_bits[mb] = ctx->mb_rc[rc].bits;
1234  max_bits += ctx->mb_rc[rc].bits;
1235  if (!RC_VARIANCE) {
1236  delta_bits = ctx->mb_rc[rc].bits -
1237  ctx->mb_rc[rc + ctx->m.mb_num].bits;
1238  ctx->mb_cmp[mb].mb = mb;
1239  ctx->mb_cmp[mb].value =
1240  delta_bits ? ((ctx->mb_rc[rc].ssd -
1241  ctx->mb_rc[rc + ctx->m.mb_num].ssd) * 100) /
1242  delta_bits
1243  : INT_MIN; // avoid increasing qscale
1244  }
1245  }
1246  max_bits += 31; // worst padding
1247  }
1248  if (!ret) {
1249  if (RC_VARIANCE)
1250  avctx->execute2(avctx, dnxhd_mb_var_thread,
1251  NULL, NULL, ctx->m.mb_height);
1252  radix_sort(ctx->mb_cmp, ctx->mb_cmp_tmp, ctx->m.mb_num);
1253  for (x = 0; x < ctx->m.mb_num && max_bits > ctx->frame_bits; x++) {
1254  int mb = ctx->mb_cmp[x].mb;
1255  int rc = (ctx->qscale * ctx->m.mb_num ) + mb;
1256  max_bits -= ctx->mb_rc[rc].bits -
1257  ctx->mb_rc[rc + ctx->m.mb_num].bits;
1258  ctx->mb_qscale[mb] = ctx->qscale + 1;
1259  ctx->mb_bits[mb] = ctx->mb_rc[rc + ctx->m.mb_num].bits;
1260  }
1261  }
1262  return 0;
1263 }
1264 
1266 {
1267  int i;
1268 
1269  for (i = 0; i < ctx->m.avctx->thread_count; i++) {
1270  ctx->thread[i]->m.linesize = frame->linesize[0] << ctx->interlaced;
1271  ctx->thread[i]->m.uvlinesize = frame->linesize[1] << ctx->interlaced;
1272  ctx->thread[i]->dct_y_offset = ctx->m.linesize *8;
1273  ctx->thread[i]->dct_uv_offset = ctx->m.uvlinesize*8;
1274  }
1275 
1276 #if FF_API_CODED_FRAME
1280 #endif
1281  ctx->cur_field = frame->interlaced_frame && !frame->top_field_first;
1282 }
1283 
1285  const AVFrame *frame, int *got_packet)
1286 {
1287  DNXHDEncContext *ctx = avctx->priv_data;
1288  int first_field = 1;
1289  int offset, i, ret;
1290  uint8_t *buf;
1291 
1292  if ((ret = ff_alloc_packet2(avctx, pkt, ctx->frame_size, 0)) < 0)
1293  return ret;
1294  buf = pkt->data;
1295 
1296  dnxhd_load_picture(ctx, frame);
1297 
1298 encode_coding_unit:
1299  for (i = 0; i < 3; i++) {
1300  ctx->src[i] = frame->data[i];
1301  if (ctx->interlaced && ctx->cur_field)
1302  ctx->src[i] += frame->linesize[i];
1303  }
1304 
1305  dnxhd_write_header(avctx, buf);
1306 
1307  if (avctx->mb_decision == FF_MB_DECISION_RD)
1308  ret = dnxhd_encode_rdo(avctx, ctx);
1309  else
1310  ret = dnxhd_encode_fast(avctx, ctx);
1311  if (ret < 0) {
1312  av_log(avctx, AV_LOG_ERROR,
1313  "picture could not fit ratecontrol constraints, increase qmax\n");
1314  return ret;
1315  }
1316 
1318 
1319  offset = 0;
1320  for (i = 0; i < ctx->m.mb_height; i++) {
1321  AV_WB32(ctx->msip + i * 4, offset);
1322  offset += ctx->slice_size[i];
1323  av_assert1(!(ctx->slice_size[i] & 3));
1324  }
1325 
1326  avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height);
1327 
1328  av_assert1(ctx->data_offset + offset + 4 <= ctx->coding_unit_size);
1329  memset(buf + ctx->data_offset + offset, 0,
1330  ctx->coding_unit_size - 4 - offset - ctx->data_offset);
1331 
1332  AV_WB32(buf + ctx->coding_unit_size - 4, 0x600DC0DE); // EOF
1333 
1334  if (ctx->interlaced && first_field) {
1335  first_field = 0;
1336  ctx->cur_field ^= 1;
1337  buf += ctx->coding_unit_size;
1338  goto encode_coding_unit;
1339  }
1340 
1341 #if FF_API_CODED_FRAME
1343  avctx->coded_frame->quality = ctx->qscale * FF_QP2LAMBDA;
1345 #endif
1346 
1348 
1349  pkt->flags |= AV_PKT_FLAG_KEY;
1350  *got_packet = 1;
1351  return 0;
1352 }
1353 
1355 {
1356  DNXHDEncContext *ctx = avctx->priv_data;
1357  int i;
1358 
1359  av_freep(&ctx->orig_vlc_codes);
1360  av_freep(&ctx->orig_vlc_bits);
1361  av_freep(&ctx->run_codes);
1362  av_freep(&ctx->run_bits);
1363 
1364  av_freep(&ctx->mb_bits);
1365  av_freep(&ctx->mb_qscale);
1366  av_freep(&ctx->mb_rc);
1367  av_freep(&ctx->mb_cmp);
1368  av_freep(&ctx->mb_cmp_tmp);
1369  av_freep(&ctx->slice_size);
1370  av_freep(&ctx->slice_offs);
1371 
1372  av_freep(&ctx->qmatrix_c);
1373  av_freep(&ctx->qmatrix_l);
1374  av_freep(&ctx->qmatrix_c16);
1375  av_freep(&ctx->qmatrix_l16);
1376 
1377  if (avctx->active_thread_type == FF_THREAD_SLICE) {
1378  for (i = 1; i < avctx->thread_count; i++)
1379  av_freep(&ctx->thread[i]);
1380  }
1381 
1382  return 0;
1383 }
1384 
1385 static const AVCodecDefault dnxhd_defaults[] = {
1386  { "qmax", "1024" }, /* Maximum quantization scale factor allowed for VC-3 */
1387  { NULL },
1388 };
1389 
1391  .name = "dnxhd",
1392  .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
1393  .type = AVMEDIA_TYPE_VIDEO,
1394  .id = AV_CODEC_ID_DNXHD,
1395  .priv_data_size = sizeof(DNXHDEncContext),
1397  .encode2 = dnxhd_encode_picture,
1398  .close = dnxhd_encode_end,
1400  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1401  .pix_fmts = (const enum AVPixelFormat[]) {
1407  },
1408  .priv_class = &dnxhd_class,
1409  .defaults = dnxhd_defaults,
1411 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define FF_PROFILE_DNXHD
Definition: avcodec.h:2969
int16_t blocks[12][64]
Definition: dnxhdenc.h:77
static av_always_inline int dnxhd_ssd_block(int16_t *qblock, int16_t *block)
Definition: dnxhdenc.c:680
#define MASK_ABS(mask, level)
Definition: mathops.h:155
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
IDCTDSPContext idsp
Definition: mpegvideo.h:230
static void radix_count(const RCCMPEntry *data, int size, int buckets[RADIX_PASSES][NBUCKETS])
Definition: dnxhdenc.c:1176
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:863
static av_always_inline void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
Definition: dnxhdenc.c:709
RCCMPEntry * mb_cmp_tmp
Definition: dnxhdenc.h:105
static int shift(int a, int b)
Definition: sonic.c:82
RCEntry * mb_rc
Definition: dnxhdenc.h:106
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
#define FF_ALLOCZ_ARRAY_OR_GOTO(ctx, p, nelem, elsize, label)
Definition: internal.h:167
const uint8_t * dc_bits
Definition: dnxhddata.h:52
AVOption.
Definition: opt.h:246
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:723
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:914
#define LAMBDA_FRAC_BITS
Definition: dnxhdenc.c:42
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
const uint8_t * luma_weight
Definition: dnxhddata.h:51
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint16_t(* q_chroma_intra_matrix16)[2][64]
Definition: mpegvideo.h:328
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:36
int(* qmatrix_l)[64]
Definition: dnxhdenc.h:82
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:413
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
const CIDEntry ff_dnxhd_cid_table[]
Definition: dnxhddata.c:935
const uint16_t * run_codes
Definition: dnxhddata.h:55
static const AVClass dnxhd_class
Definition: dnxhdenc.c:69
void ff_convert_matrix(MpegEncContext *s, int(*qmat)[64], uint16_t(*qmat16)[2][64], const uint16_t *quant_matrix, int bias, int qmin, int qmax, int intra)
Definition: mpegvideo_enc.c:89
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1831
unsigned dct_uv_offset
Definition: dnxhdenc.h:63
static av_always_inline void dnxhd_encode_dc(DNXHDEncContext *ctx, int diff)
Definition: dnxhdenc.c:591
static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
Definition: dnxhdenc.c:204
mpegvideo header.
uint8_t permutated[64]
Definition: idctdsp.h:33
int ff_dnxhd_find_cid(AVCodecContext *avctx, int bit_depth)
Definition: dnxhddata.c:1133
uint8_t run
Definition: svq3.c:208
static AVPacket pkt
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2852
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:133
av_cold void ff_fdctdsp_init(FDCTDSPContext *c, AVCodecContext *avctx)
Definition: fdctdsp.c:26
struct DNXHDEncContext * thread[MAX_THREADS]
Definition: dnxhdenc.h:58
int profile
profile
Definition: avcodec.h:2954
#define sample
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
AVCodec.
Definition: avcodec.h:3555
Undefined Behavior In the C some operations are like signed integer overflow
Definition: undefined.txt:3
static av_always_inline int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
Definition: dnxhdenc.c:690
int h263_aic
Advanced INTRA Coding (AIC)
Definition: mpegvideo.h:87
Macro definitions for various function/variable attributes.
#define AV_CODEC_CAP_INTRA_ONLY
Codec is intra only.
Definition: avcodec.h:1085
int coding_unit_size
Definition: dnxhdenc.h:67
int intra_quant_bias
Definition: dnxhdenc.h:75
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
void(* emulated_edge_mc)(uint8_t *dst, const uint8_t *src, ptrdiff_t dst_linesize, ptrdiff_t src_linesize, int block_w, int block_h, int src_x, int src_y, int w, int h)
Copy a rectangular area of samples to a temporary buffer and replicate the border samples...
Definition: videodsp.h:63
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
Permute an 8x8 block according to permutation.
av_cold void ff_mpegvideoencdsp_init(MpegvideoEncDSPContext *c, AVCodecContext *avctx)
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
#define mb
AVOptions.
static int get_bucket(int value, int shift)
Definition: dnxhdenc.c:1169
const AVProfile ff_dnxhd_profiles[]
Definition: profiles.c:48
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx)
Definition: dnxhdenc.c:1221
uint32_t * slice_size
Definition: dnxhdenc.h:55
int(* qmatrix_c)[64]
Definition: dnxhdenc.h:81
#define RADIX_PASSES
Definition: dnxhdenc.c:1166
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
uint32_t * slice_offs
Definition: dnxhdenc.h:56
int(* q_chroma_intra_matrix)[64]
Definition: mpegvideo.h:324
unsigned qscale
Definition: dnxhdenc.h:98
uint8_t * data
Definition: avcodec.h:1533
uint8_t * orig_vlc_bits
Definition: dnxhdenc.h:90
static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data, int size, int buckets[NBUCKETS], int pass)
Definition: dnxhdenc.c:1197
const uint8_t * run_bits
Definition: dnxhddata.h:56
#define BUCKET_BITS
Definition: dnxhdenc.c:1165
const uint8_t * scantable
Definition: idctdsp.h:32
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:442
av_cold void ff_mpv_idct_init(MpegEncContext *s)
Definition: mpegvideo.c:329
int mb_height
number of MBs horizontally & vertically
Definition: mpegvideo.h:129
static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
Definition: dnxhdenc.c:265
#define max(a, b)
Definition: cuda_runtime.h:33
unsigned int coding_unit_size
Definition: dnxhddata.h:46
ptrdiff_t size
Definition: opengl_enc.c:100
int max_qcoeff
maximum encodable coefficient
Definition: mpegvideo.h:309
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
BlockDSPContext bdsp
Definition: dnxhdenc.h:46
#define av_log(a,...)
static int first_field(const struct video_data *s)
Definition: v4l2.c:234
static av_cold int dnxhd_encode_end(AVCodecContext *avctx)
Definition: dnxhdenc.c:1354
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1565
const uint8_t * ac_bits
Definition: dnxhddata.h:54
const uint8_t * ac_info
Definition: dnxhddata.h:54
int(* q_intra_matrix)[64]
precomputed matrix (combine qscale and DCT renorm)
Definition: mpegvideo.h:323
static av_always_inline int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i)
Definition: dnxhdenc.c:837
const uint16_t * ac_codes
Definition: dnxhddata.h:53
static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: dnxhdenc.c:850
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int ff_dnxhd_get_cid_table(int cid)
Definition: dnxhddata.c:1078
int last_dc[3]
last DC values for MPEG-1
Definition: mpegvideo.h:185
static int dnxhd_find_qscale(DNXHDEncContext *ctx)
Definition: dnxhdenc.c:1109
#define FF_SIGNBIT(x)
Definition: internal.h:94
#define RC_VARIANCE
Definition: dnxhdenc.c:41
int qmax
maximum quantizer
Definition: avcodec.h:2470
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2899
AVCodec ff_dnxhd_encoder
Definition: dnxhdenc.c:1390
static av_always_inline void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n, int qscale, int last_index)
Definition: dnxhdenc.c:632
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
PixblockDSPContext pdsp
Definition: mpegvideo.h:234
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1701
static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
Definition: dnxhdenc.c:555
const uint8_t * dc_codes
Definition: dnxhddata.h:52
MpegvideoEncDSPContext mpvencdsp
Definition: mpegvideo.h:233
const char * name
Name of the codec implementation.
Definition: avcodec.h:3562
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
uint8_t bits
Definition: vp3data.h:202
#define FF_PROFILE_DNXHR_LB
Definition: avcodec.h:2970
#define FFMAX(a, b)
Definition: common.h:94
av_cold void ff_pixblockdsp_init(PixblockDSPContext *c, AVCodecContext *avctx)
Definition: pixblockdsp.c:81
#define fail()
Definition: checkasm.h:122
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1055
int(* pix_norm1)(uint8_t *pix, int line_size)
int(* pix_sum)(uint8_t *pix, int line_size)
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1539
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:67
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define pass
Definition: fft_template.c:619
const uint8_t * chroma_weight
Definition: dnxhddata.h:51
uint8_t edge_buf_y[512]
Definition: dnxhdenc.h:78
uint16_t * run_codes
Definition: dnxhdenc.h:93
common internal API header
#define MAX_THREADS
static const AVOption options[]
Definition: dnxhdenc.c:45
static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t line_size)
Definition: dnxhdenc.c:76
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
static const AVCodecDefault dnxhd_defaults[]
Definition: dnxhdenc.c:1385
MpegEncContext m
Used for quantization dsp functions.
Definition: dnxhdenc.h:47
#define FFMIN(a, b)
Definition: common.h:96
static av_always_inline void dnxhd_encode_block(DNXHDEncContext *ctx, int16_t *block, int last_index, int n)
Definition: dnxhdenc.c:606
uint8_t * run_bits
Definition: dnxhdenc.h:94
int intra_quant_bias
bias for the quantizer
Definition: mpegvideo.h:306
int width
picture width / height.
Definition: avcodec.h:1794
const uint8_t * run
Definition: dnxhddata.h:56
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:226
unsigned frame_bits
Definition: dnxhdenc.h:86
AVFormatContext * ctx
Definition: movenc.c:48
static av_always_inline void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t line_size)
Definition: dnxhdenc.c:100
uint16_t(* q_intra_matrix16)[2][64]
identical to the above but for MMX & these are not permutated, second 64 entries are bias ...
Definition: mpegvideo.h:327
uint16_t(* qmatrix_l16)[2][64]
Definition: dnxhdenc.h:83
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:2892
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:418
ScanTable scantable
Definition: dnxhddec.c:65
uint8_t * msip
Macroblock Scan Indexes Payload.
Definition: dnxhdenc.h:54
int n
Definition: avisynth_c.h:760
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:96
void(* fdct)(int16_t *block)
Definition: fdctdsp.h:27
int value
Definition: dnxhdenc.h:36
int mb_decision
macroblock decision mode
Definition: avcodec.h:2109
void ff_dnxhd_print_profiles(AVCodecContext *avctx, int loglevel)
Definition: dnxhddata.c:1163
#define FF_PROFILE_DNXHR_HQ
Definition: avcodec.h:2972
uint8_t * vlc_bits
Definition: dnxhdenc.h:92
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2880
int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
Definition: dnxhdenc.c:1032
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1059
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:2940
int index_bits
Definition: dnxhddata.h:48
Libavcodec external API header.
static int dnxhd_10bit_dct_quantize(MpegEncContext *ctx, int16_t *block, int n, int qscale, int *overflow)
Definition: dnxhdenc.c:173
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:134
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
static int dnxhd_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: dnxhdenc.c:1284
main external API structure.
Definition: avcodec.h:1621
unsigned block_width_l2
Definition: dnxhdenc.h:64
ScanTable intra_scantable
Definition: mpegvideo.h:91
int ff_dct_encode_init(MpegEncContext *s)
static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
Definition: dnxhdenc.c:345
uint32_t * orig_vlc_codes
Definition: dnxhdenc.h:89
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1646
unsigned lambda
Definition: dnxhdenc.h:99
FDCTDSPContext fdsp
Definition: mpegvideo.h:227
void * buf
Definition: avisynth_c.h:766
void ff_dnxhdenc_init_x86(DNXHDEncContext *ctx)
Definition: dnxhdenc_init.c:31
Describe the class of an AVClass context structure.
Definition: log.h:67
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
int index
Definition: gxfenc.c:89
#define FF_MB_DECISION_RD
rate distortion
Definition: avcodec.h:2112
#define NBUCKETS
Definition: dnxhdenc.c:1167
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
ptrdiff_t uvlinesize
line size, for chroma in bytes, may be different from width
Definition: mpegvideo.h:135
int ssd
Definition: dnxhdenc.h:40
static void dnxhd_setup_threads_slices(DNXHDEncContext *ctx)
Definition: dnxhdenc.c:945
#define FF_PROFILE_DNXHR_SQ
Definition: avcodec.h:2971
const CIDEntry * cid_table
Definition: dnxhdenc.h:53
int(* dct_quantize)(struct MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
Definition: mpegvideo.h:537
uint16_t(* qmatrix_c16)[2][64]
Definition: dnxhdenc.h:84
unsigned dct_y_offset
Definition: dnxhdenc.h:62
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
unsigned min_padding
Definition: dnxhdenc.h:74
mfxU16 profile
Definition: qsvenc.c:44
static void dnxhd_load_picture(DNXHDEncContext *ctx, const AVFrame *frame)
Definition: dnxhdenc.c:1265
void(* get_pixels)(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t stride)
Definition: pixblockdsp.h:29
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
#define DNX10BIT_QMAT_SHIFT
Definition: dnxhdenc.c:40
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
uint8_t edge_buf_uv[2][512]
Definition: dnxhdenc.h:79
unsigned int frame_size
Definition: dnxhddata.h:45
uint8_t level
Definition: svq3.c:209
uint16_t * mb_bits
Definition: dnxhdenc.h:101
MpegEncContext.
Definition: mpegvideo.h:81
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
PutBitContext pb
bit output
Definition: mpegvideo.h:151
static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: dnxhdenc.c:964
#define DNXHD_VARIABLE
Indicate that a CIDEntry value must be read in the bitstream.
Definition: dnxhddata.h:40
#define FF_PROFILE_DNXHR_HQX
Definition: avcodec.h:2973
static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: dnxhdenc.c:907
static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
Definition: dnxhdenc.c:364
#define VE
Definition: dnxhdenc.c:44
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
void(* get_pixels_8x4_sym)(int16_t *av_restrictblock, const uint8_t *pixels, ptrdiff_t line_size)
Definition: dnxhdenc.h:108
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2871
static int dnxhd_10bit_dct_quantize_444(MpegEncContext *ctx, int16_t *block, int n, int qscale, int *overflow)
Definition: dnxhdenc.c:114
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
#define FF_PROFILE_DNXHR_444
Definition: avcodec.h:2974
void * priv_data
Definition: avcodec.h:1648
static av_always_inline int diff(const uint32_t a, const uint32_t b)
RCCMPEntry * mb_cmp
Definition: dnxhdenc.h:104
int pixels
Definition: avisynth_c.h:390
VideoDSPContext vdsp
Definition: mpegvideo.h:236
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
static void radix_sort(RCCMPEntry *data, RCCMPEntry *tmp, int size)
Definition: dnxhdenc.c:1209
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:447
int nitris_compat
Definition: dnxhdenc.h:73
int bits
Definition: dnxhdenc.h:41
AVCodecContext * avctx
Definition: dnxhddec.c:51
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
#define LOCAL_ALIGNED_16(t, v,...)
Definition: internal.h:131
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:39
void(* idct)(int16_t *block)
Definition: idctdsp.h:65
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint16_t mb
Definition: dnxhdenc.h:35
#define MKTAG(a, b, c, d)
Definition: common.h:366
float min
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1510
uint32_t * vlc_codes
Definition: dnxhdenc.h:91
int avpriv_dnxhd_get_hr_frame_size(int cid, int w, int h)
Definition: dnxhddata.c:1095
#define FF_ALLOCZ_OR_GOTO(ctx, p, size, label)
Definition: internal.h:149
uint8_t * src[3]
Definition: dnxhdenc.h:87
uint8_t * mb_qscale
Definition: dnxhdenc.h:102
enum idct_permutation_type perm_type
Definition: idctdsp.h:97
static uint8_t tmp[11]
Definition: aes_ctr.c:26