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 "packet_internal.h"
37 #include "profiles.h"
38 #include "dnxhdenc.h"
39 
40 // The largest value that will not lead to overflow for 10-bit samples.
41 #define DNX10BIT_QMAT_SHIFT 18
42 #define RC_VARIANCE 1 // use variance or ssd for fast rc
43 #define LAMBDA_FRAC_BITS 10
44 
45 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
46 static const AVOption options[] = {
47  { "nitris_compat", "encode with Avid Nitris compatibility",
48  offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
49  { "ibias", "intra quant bias",
50  offsetof(DNXHDEncContext, intra_quant_bias), AV_OPT_TYPE_INT,
51  { .i64 = 0 }, INT_MIN, INT_MAX, VE },
52  { "profile", NULL, offsetof(DNXHDEncContext, profile), AV_OPT_TYPE_INT,
53  { .i64 = FF_PROFILE_DNXHD },
55  { "dnxhd", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHD },
56  0, 0, VE, "profile" },
57  { "dnxhr_444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_444 },
58  0, 0, VE, "profile" },
59  { "dnxhr_hqx", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_HQX },
60  0, 0, VE, "profile" },
61  { "dnxhr_hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_HQ },
62  0, 0, VE, "profile" },
63  { "dnxhr_sq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_SQ },
64  0, 0, VE, "profile" },
65  { "dnxhr_lb", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = FF_PROFILE_DNXHR_LB },
66  0, 0, VE, "profile" },
67  { NULL }
68 };
69 
70 static const AVClass dnxhd_class = {
71  .class_name = "dnxhd",
72  .item_name = av_default_item_name,
73  .option = options,
74  .version = LIBAVUTIL_VERSION_INT,
75 };
76 
77 static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block,
78  const uint8_t *pixels,
79  ptrdiff_t line_size)
80 {
81  int i;
82  for (i = 0; i < 4; i++) {
83  block[0] = pixels[0];
84  block[1] = pixels[1];
85  block[2] = pixels[2];
86  block[3] = pixels[3];
87  block[4] = pixels[4];
88  block[5] = pixels[5];
89  block[6] = pixels[6];
90  block[7] = pixels[7];
91  pixels += line_size;
92  block += 8;
93  }
94  memcpy(block, block - 8, sizeof(*block) * 8);
95  memcpy(block + 8, block - 16, sizeof(*block) * 8);
96  memcpy(block + 16, block - 24, sizeof(*block) * 8);
97  memcpy(block + 24, block - 32, sizeof(*block) * 8);
98 }
99 
100 static av_always_inline
101 void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block,
102  const uint8_t *pixels,
103  ptrdiff_t line_size)
104 {
105  memcpy(block + 0 * 8, pixels + 0 * line_size, 8 * sizeof(*block));
106  memcpy(block + 7 * 8, pixels + 0 * line_size, 8 * sizeof(*block));
107  memcpy(block + 1 * 8, pixels + 1 * line_size, 8 * sizeof(*block));
108  memcpy(block + 6 * 8, pixels + 1 * line_size, 8 * sizeof(*block));
109  memcpy(block + 2 * 8, pixels + 2 * line_size, 8 * sizeof(*block));
110  memcpy(block + 5 * 8, pixels + 2 * line_size, 8 * sizeof(*block));
111  memcpy(block + 3 * 8, pixels + 3 * line_size, 8 * sizeof(*block));
112  memcpy(block + 4 * 8, pixels + 3 * line_size, 8 * sizeof(*block));
113 }
114 
116  int n, int qscale, int *overflow)
117 {
118  int i, j, level, last_non_zero, start_i;
119  const int *qmat;
121  int bias;
122  int max = 0;
123  unsigned int threshold1, threshold2;
124 
125  ctx->fdsp.fdct(block);
126 
127  block[0] = (block[0] + 2) >> 2;
128  start_i = 1;
129  last_non_zero = 0;
130  qmat = n < 4 ? ctx->q_intra_matrix[qscale] : ctx->q_chroma_intra_matrix[qscale];
131  bias= ctx->intra_quant_bias * (1 << (16 - 8));
132  threshold1 = (1 << 16) - bias - 1;
133  threshold2 = (threshold1 << 1);
134 
135  for (i = 63; i >= start_i; i--) {
136  j = scantable[i];
137  level = block[j] * qmat[j];
138 
139  if (((unsigned)(level + threshold1)) > threshold2) {
140  last_non_zero = i;
141  break;
142  } else{
143  block[j]=0;
144  }
145  }
146 
147  for (i = start_i; i <= last_non_zero; i++) {
148  j = scantable[i];
149  level = block[j] * qmat[j];
150 
151  if (((unsigned)(level + threshold1)) > threshold2) {
152  if (level > 0) {
153  level = (bias + level) >> 16;
154  block[j] = level;
155  } else{
156  level = (bias - level) >> 16;
157  block[j] = -level;
158  }
159  max |= level;
160  } else {
161  block[j] = 0;
162  }
163  }
164  *overflow = ctx->max_qcoeff < max; //overflow might have happened
165 
166  /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
167  if (ctx->idsp.perm_type != FF_IDCT_PERM_NONE)
169  scantable, last_non_zero);
170 
171  return last_non_zero;
172 }
173 
175  int n, int qscale, int *overflow)
176 {
178  const int *qmat = n<4 ? ctx->q_intra_matrix[qscale] : ctx->q_chroma_intra_matrix[qscale];
179  int last_non_zero = 0;
180  int i;
181 
182  ctx->fdsp.fdct(block);
183 
184  // Divide by 4 with rounding, to compensate scaling of DCT coefficients
185  block[0] = (block[0] + 2) >> 2;
186 
187  for (i = 1; i < 64; ++i) {
188  int j = scantable[i];
189  int sign = FF_SIGNBIT(block[j]);
190  int level = (block[j] ^ sign) - sign;
191  level = level * qmat[j] >> DNX10BIT_QMAT_SHIFT;
192  block[j] = (level ^ sign) - sign;
193  if (level)
194  last_non_zero = i;
195  }
196 
197  /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
198  if (ctx->idsp.perm_type != FF_IDCT_PERM_NONE)
200  scantable, last_non_zero);
201 
202  return last_non_zero;
203 }
204 
206 {
207  int i, j, level, run;
208  int max_level = 1 << (ctx->bit_depth + 2);
209 
210  if (!FF_ALLOCZ_TYPED_ARRAY(ctx->orig_vlc_codes, max_level * 4) ||
211  !FF_ALLOCZ_TYPED_ARRAY(ctx->orig_vlc_bits, max_level * 4) ||
212  !(ctx->run_codes = av_mallocz(63 * 2)) ||
213  !(ctx->run_bits = av_mallocz(63)))
214  return AVERROR(ENOMEM);
215  ctx->vlc_codes = ctx->orig_vlc_codes + max_level * 2;
216  ctx->vlc_bits = ctx->orig_vlc_bits + max_level * 2;
217  for (level = -max_level; level < max_level; level++) {
218  for (run = 0; run < 2; run++) {
219  int index = level * (1 << 1) | run;
220  int sign, offset = 0, alevel = level;
221 
222  MASK_ABS(sign, alevel);
223  if (alevel > 64) {
224  offset = (alevel - 1) >> 6;
225  alevel -= offset << 6;
226  }
227  for (j = 0; j < 257; j++) {
228  if (ctx->cid_table->ac_info[2*j+0] >> 1 == alevel &&
229  (!offset || (ctx->cid_table->ac_info[2*j+1] & 1) && offset) &&
230  (!run || (ctx->cid_table->ac_info[2*j+1] & 2) && run)) {
231  av_assert1(!ctx->vlc_codes[index]);
232  if (alevel) {
233  ctx->vlc_codes[index] =
234  (ctx->cid_table->ac_codes[j] << 1) | (sign & 1);
235  ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j] + 1;
236  } else {
237  ctx->vlc_codes[index] = ctx->cid_table->ac_codes[j];
238  ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j];
239  }
240  break;
241  }
242  }
243  av_assert0(!alevel || j < 257);
244  if (offset) {
245  ctx->vlc_codes[index] =
246  (ctx->vlc_codes[index] << ctx->cid_table->index_bits) | offset;
247  ctx->vlc_bits[index] += ctx->cid_table->index_bits;
248  }
249  }
250  }
251  for (i = 0; i < 62; i++) {
252  int run = ctx->cid_table->run[i];
253  av_assert0(run < 63);
254  ctx->run_codes[run] = ctx->cid_table->run_codes[i];
255  ctx->run_bits[run] = ctx->cid_table->run_bits[i];
256  }
257  return 0;
258 }
259 
260 static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
261 {
262  // init first elem to 1 to avoid div by 0 in convert_matrix
263  uint16_t weight_matrix[64] = { 1, }; // convert_matrix needs uint16_t*
264  int qscale, i;
265  const uint8_t *luma_weight_table = ctx->cid_table->luma_weight;
266  const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight;
267 
268  if (!FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_l, ctx->m.avctx->qmax + 1) ||
269  !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_c, ctx->m.avctx->qmax + 1) ||
270  !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_l16, ctx->m.avctx->qmax + 1) ||
271  !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_c16, ctx->m.avctx->qmax + 1))
272  return AVERROR(ENOMEM);
273 
274  if (ctx->bit_depth == 8) {
275  for (i = 1; i < 64; i++) {
276  int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
277  weight_matrix[j] = ctx->cid_table->luma_weight[i];
278  }
279  ff_convert_matrix(&ctx->m, ctx->qmatrix_l, ctx->qmatrix_l16,
280  weight_matrix, ctx->intra_quant_bias, 1,
281  ctx->m.avctx->qmax, 1);
282  for (i = 1; i < 64; i++) {
283  int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
284  weight_matrix[j] = ctx->cid_table->chroma_weight[i];
285  }
286  ff_convert_matrix(&ctx->m, ctx->qmatrix_c, ctx->qmatrix_c16,
287  weight_matrix, ctx->intra_quant_bias, 1,
288  ctx->m.avctx->qmax, 1);
289 
290  for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
291  for (i = 0; i < 64; i++) {
292  ctx->qmatrix_l[qscale][i] <<= 2;
293  ctx->qmatrix_c[qscale][i] <<= 2;
294  ctx->qmatrix_l16[qscale][0][i] <<= 2;
295  ctx->qmatrix_l16[qscale][1][i] <<= 2;
296  ctx->qmatrix_c16[qscale][0][i] <<= 2;
297  ctx->qmatrix_c16[qscale][1][i] <<= 2;
298  }
299  }
300  } else {
301  // 10-bit
302  for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
303  for (i = 1; i < 64; i++) {
304  int j = ff_zigzag_direct[i];
305 
306  /* The quantization formula from the VC-3 standard is:
307  * quantized = sign(block[i]) * floor(abs(block[i]/s) * p /
308  * (qscale * weight_table[i]))
309  * Where p is 32 for 8-bit samples and 8 for 10-bit ones.
310  * The s factor compensates scaling of DCT coefficients done by
311  * the DCT routines, and therefore is not present in standard.
312  * It's 8 for 8-bit samples and 4 for 10-bit ones.
313  * We want values of ctx->qtmatrix_l and ctx->qtmatrix_r to be:
314  * ((1 << DNX10BIT_QMAT_SHIFT) * (p / s)) /
315  * (qscale * weight_table[i])
316  * For 10-bit samples, p / s == 2 */
317  ctx->qmatrix_l[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
318  (qscale * luma_weight_table[i]);
319  ctx->qmatrix_c[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
320  (qscale * chroma_weight_table[i]);
321  }
322  }
323  }
324 
326  ctx->m.q_chroma_intra_matrix = ctx->qmatrix_c;
327  ctx->m.q_intra_matrix16 = ctx->qmatrix_l16;
328  ctx->m.q_intra_matrix = ctx->qmatrix_l;
329 
330  return 0;
331 }
332 
334 {
335  if (!FF_ALLOCZ_TYPED_ARRAY(ctx->mb_rc, (ctx->m.avctx->qmax + 1) * ctx->m.mb_num))
336  return AVERROR(ENOMEM);
337 
338  if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) {
339  if (!FF_ALLOCZ_TYPED_ARRAY(ctx->mb_cmp, ctx->m.mb_num) ||
341  return AVERROR(ENOMEM);
342  }
343  ctx->frame_bits = (ctx->coding_unit_size -
344  ctx->data_offset - 4 - ctx->min_padding) * 8;
345  ctx->qscale = 1;
346  ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2
347  return 0;
348 }
349 
351 {
352  DNXHDEncContext *ctx = avctx->priv_data;
353  int i, index, ret;
354 
355  switch (avctx->pix_fmt) {
356  case AV_PIX_FMT_YUV422P:
357  ctx->bit_depth = 8;
358  break;
361  case AV_PIX_FMT_GBRP10:
362  ctx->bit_depth = 10;
363  break;
364  default:
365  av_log(avctx, AV_LOG_ERROR,
366  "pixel format is incompatible with DNxHD\n");
367  return AVERROR(EINVAL);
368  }
369 
370  if ((ctx->profile == FF_PROFILE_DNXHR_444 && (avctx->pix_fmt != AV_PIX_FMT_YUV444P10 &&
371  avctx->pix_fmt != AV_PIX_FMT_GBRP10)) ||
372  (ctx->profile != FF_PROFILE_DNXHR_444 && (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 ||
373  avctx->pix_fmt == AV_PIX_FMT_GBRP10))) {
374  av_log(avctx, AV_LOG_ERROR,
375  "pixel format is incompatible with DNxHD profile\n");
376  return AVERROR(EINVAL);
377  }
378 
379  if (ctx->profile == FF_PROFILE_DNXHR_HQX && avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
380  av_log(avctx, AV_LOG_ERROR,
381  "pixel format is incompatible with DNxHR HQX profile\n");
382  return AVERROR(EINVAL);
383  }
384 
385  if ((ctx->profile == FF_PROFILE_DNXHR_LB ||
386  ctx->profile == FF_PROFILE_DNXHR_SQ ||
387  ctx->profile == FF_PROFILE_DNXHR_HQ) && avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
388  av_log(avctx, AV_LOG_ERROR,
389  "pixel format is incompatible with DNxHR LB/SQ/HQ profile\n");
390  return AVERROR(EINVAL);
391  }
392 
393  ctx->is_444 = ctx->profile == FF_PROFILE_DNXHR_444;
394  avctx->profile = ctx->profile;
395  ctx->cid = ff_dnxhd_find_cid(avctx, ctx->bit_depth);
396  if (!ctx->cid) {
397  av_log(avctx, AV_LOG_ERROR,
398  "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n");
400  return AVERROR(EINVAL);
401  }
402  av_log(avctx, AV_LOG_DEBUG, "cid %d\n", ctx->cid);
403 
404  if (ctx->cid >= 1270 && ctx->cid <= 1274)
405  avctx->codec_tag = MKTAG('A','V','d','h');
406 
407  if (avctx->width < 256 || avctx->height < 120) {
408  av_log(avctx, AV_LOG_ERROR,
409  "Input dimensions too small, input must be at least 256x120\n");
410  return AVERROR(EINVAL);
411  }
412 
413  index = ff_dnxhd_get_cid_table(ctx->cid);
414  av_assert0(index >= 0);
415 
417 
418  ctx->m.avctx = avctx;
419  ctx->m.mb_intra = 1;
420  ctx->m.h263_aic = 1;
421 
422  avctx->bits_per_raw_sample = ctx->bit_depth;
423 
424  ff_blockdsp_init(&ctx->bdsp, avctx);
425  ff_fdctdsp_init(&ctx->m.fdsp, avctx);
426  ff_mpv_idct_init(&ctx->m);
427  ff_mpegvideoencdsp_init(&ctx->m.mpvencdsp, avctx);
428  ff_pixblockdsp_init(&ctx->m.pdsp, avctx);
429  ff_dct_encode_init(&ctx->m);
430 
431  if (ctx->profile != FF_PROFILE_DNXHD)
432  ff_videodsp_init(&ctx->m.vdsp, ctx->bit_depth);
433 
434  if (!ctx->m.dct_quantize)
436 
437  if (ctx->is_444 || ctx->profile == FF_PROFILE_DNXHR_HQX) {
440  ctx->block_width_l2 = 4;
441  } else if (ctx->bit_depth == 10) {
444  ctx->block_width_l2 = 4;
445  } else {
447  ctx->block_width_l2 = 3;
448  }
449 
450  if (ARCH_X86)
452 
453  ctx->m.mb_height = (avctx->height + 15) / 16;
454  ctx->m.mb_width = (avctx->width + 15) / 16;
455 
456  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
457  ctx->interlaced = 1;
458  ctx->m.mb_height /= 2;
459  }
460 
461  if (ctx->interlaced && ctx->profile != FF_PROFILE_DNXHD) {
462  av_log(avctx, AV_LOG_ERROR,
463  "Interlaced encoding is not supported for DNxHR profiles.\n");
464  return AVERROR(EINVAL);
465  }
466 
467  ctx->m.mb_num = ctx->m.mb_height * ctx->m.mb_width;
468 
469  if (ctx->cid_table->frame_size == DNXHD_VARIABLE) {
471  avctx->width, avctx->height);
472  av_assert0(ctx->frame_size >= 0);
473  ctx->coding_unit_size = ctx->frame_size;
474  } else {
475  ctx->frame_size = ctx->cid_table->frame_size;
477  }
478 
479  if (ctx->m.mb_height > 68)
480  ctx->data_offset = 0x170 + (ctx->m.mb_height << 2);
481  else
482  ctx->data_offset = 0x280;
483 
484  // XXX tune lbias/cbias
485  if ((ret = dnxhd_init_qmat(ctx, ctx->intra_quant_bias, 0)) < 0)
486  return ret;
487 
488  /* Avid Nitris hardware decoder requires a minimum amount of padding
489  * in the coding unit payload */
490  if (ctx->nitris_compat)
491  ctx->min_padding = 1600;
492 
493  if ((ret = dnxhd_init_vlc(ctx)) < 0)
494  return ret;
495  if ((ret = dnxhd_init_rc(ctx)) < 0)
496  return ret;
497 
498  if (!FF_ALLOCZ_TYPED_ARRAY(ctx->slice_size, ctx->m.mb_height) ||
500  !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_bits, ctx->m.mb_num) ||
502  return AVERROR(ENOMEM);
503 #if FF_API_CODED_FRAME
505  avctx->coded_frame->key_frame = 1;
508 #endif
509 
510  if (avctx->active_thread_type == FF_THREAD_SLICE) {
511  if (avctx->thread_count > MAX_THREADS) {
512  av_log(avctx, AV_LOG_ERROR, "too many threads\n");
513  return AVERROR(EINVAL);
514  }
515  }
516 
517  if (avctx->qmax <= 1) {
518  av_log(avctx, AV_LOG_ERROR, "qmax must be at least 2\n");
519  return AVERROR(EINVAL);
520  }
521 
522  ctx->thread[0] = ctx;
523  if (avctx->active_thread_type == FF_THREAD_SLICE) {
524  for (i = 1; i < avctx->thread_count; i++) {
525  ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext));
526  if (!ctx->thread[i])
527  return AVERROR(ENOMEM);
528  memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext));
529  }
530  }
531 
532  return 0;
533 }
534 
536 {
537  DNXHDEncContext *ctx = avctx->priv_data;
538 
539  memset(buf, 0, ctx->data_offset);
540 
541  // * write prefix */
542  AV_WB16(buf + 0x02, ctx->data_offset);
543  if (ctx->cid >= 1270 && ctx->cid <= 1274)
544  buf[4] = 0x03;
545  else
546  buf[4] = 0x01;
547 
548  buf[5] = ctx->interlaced ? ctx->cur_field + 2 : 0x01;
549  buf[6] = 0x80; // crc flag off
550  buf[7] = 0xa0; // reserved
551  AV_WB16(buf + 0x18, avctx->height >> ctx->interlaced); // ALPF
552  AV_WB16(buf + 0x1a, avctx->width); // SPL
553  AV_WB16(buf + 0x1d, avctx->height >> ctx->interlaced); // NAL
554 
555  buf[0x21] = ctx->bit_depth == 10 ? 0x58 : 0x38;
556  buf[0x22] = 0x88 + (ctx->interlaced << 2);
557  AV_WB32(buf + 0x28, ctx->cid); // CID
558  buf[0x2c] = (!ctx->interlaced << 7) | (ctx->is_444 << 6) | (avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
559 
560  buf[0x5f] = 0x01; // UDL
561 
562  buf[0x167] = 0x02; // reserved
563  AV_WB16(buf + 0x16a, ctx->m.mb_height * 4 + 4); // MSIPS
564  AV_WB16(buf + 0x16c, ctx->m.mb_height); // Ns
565  buf[0x16f] = 0x10; // reserved
566 
567  ctx->msip = buf + 0x170;
568  return 0;
569 }
570 
572 {
573  int nbits;
574  if (diff < 0) {
575  nbits = av_log2_16bit(-2 * diff);
576  diff--;
577  } else {
578  nbits = av_log2_16bit(2 * diff);
579  }
580  put_bits(&ctx->m.pb, ctx->cid_table->dc_bits[nbits] + nbits,
581  (ctx->cid_table->dc_codes[nbits] << nbits) +
582  av_mod_uintp2(diff, nbits));
583 }
584 
585 static av_always_inline
587  int last_index, int n)
588 {
589  int last_non_zero = 0;
590  int slevel, i, j;
591 
592  dnxhd_encode_dc(ctx, block[0] - ctx->m.last_dc[n]);
593  ctx->m.last_dc[n] = block[0];
594 
595  for (i = 1; i <= last_index; i++) {
596  j = ctx->m.intra_scantable.permutated[i];
597  slevel = block[j];
598  if (slevel) {
599  int run_level = i - last_non_zero - 1;
600  int rlevel = slevel * (1 << 1) | !!run_level;
601  put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
602  if (run_level)
603  put_bits(&ctx->m.pb, ctx->run_bits[run_level],
604  ctx->run_codes[run_level]);
605  last_non_zero = i;
606  }
607  }
608  put_bits(&ctx->m.pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB
609 }
610 
611 static av_always_inline
613  int qscale, int last_index)
614 {
615  const uint8_t *weight_matrix;
616  int level;
617  int i;
618 
619  if (ctx->is_444) {
620  weight_matrix = ((n % 6) < 2) ? ctx->cid_table->luma_weight
621  : ctx->cid_table->chroma_weight;
622  } else {
623  weight_matrix = (n & 2) ? ctx->cid_table->chroma_weight
624  : ctx->cid_table->luma_weight;
625  }
626 
627  for (i = 1; i <= last_index; i++) {
628  int j = ctx->m.intra_scantable.permutated[i];
629  level = block[j];
630  if (level) {
631  if (level < 0) {
632  level = (1 - 2 * level) * qscale * weight_matrix[i];
633  if (ctx->bit_depth == 10) {
634  if (weight_matrix[i] != 8)
635  level += 8;
636  level >>= 4;
637  } else {
638  if (weight_matrix[i] != 32)
639  level += 32;
640  level >>= 6;
641  }
642  level = -level;
643  } else {
644  level = (2 * level + 1) * qscale * weight_matrix[i];
645  if (ctx->bit_depth == 10) {
646  if (weight_matrix[i] != 8)
647  level += 8;
648  level >>= 4;
649  } else {
650  if (weight_matrix[i] != 32)
651  level += 32;
652  level >>= 6;
653  }
654  }
655  block[j] = level;
656  }
657  }
658 }
659 
660 static av_always_inline int dnxhd_ssd_block(int16_t *qblock, int16_t *block)
661 {
662  int score = 0;
663  int i;
664  for (i = 0; i < 64; i++)
665  score += (block[i] - qblock[i]) * (block[i] - qblock[i]);
666  return score;
667 }
668 
669 static av_always_inline
670 int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
671 {
672  int last_non_zero = 0;
673  int bits = 0;
674  int i, j, level;
675  for (i = 1; i <= last_index; i++) {
676  j = ctx->m.intra_scantable.permutated[i];
677  level = block[j];
678  if (level) {
679  int run_level = i - last_non_zero - 1;
680  bits += ctx->vlc_bits[level * (1 << 1) |
681  !!run_level] + ctx->run_bits[run_level];
682  last_non_zero = i;
683  }
684  }
685  return bits;
686 }
687 
688 static av_always_inline
689 void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
690 {
691  const int bs = ctx->block_width_l2;
692  const int bw = 1 << bs;
693  int dct_y_offset = ctx->dct_y_offset;
694  int dct_uv_offset = ctx->dct_uv_offset;
695  int linesize = ctx->m.linesize;
696  int uvlinesize = ctx->m.uvlinesize;
697  const uint8_t *ptr_y = ctx->thread[0]->src[0] +
698  ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs + 1);
699  const uint8_t *ptr_u = ctx->thread[0]->src[1] +
700  ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
701  const uint8_t *ptr_v = ctx->thread[0]->src[2] +
702  ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
703  PixblockDSPContext *pdsp = &ctx->m.pdsp;
704  VideoDSPContext *vdsp = &ctx->m.vdsp;
705 
706  if (ctx->bit_depth != 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
707  (mb_y << 4) + 16 > ctx->m.avctx->height)) {
708  int y_w = ctx->m.avctx->width - (mb_x << 4);
709  int y_h = ctx->m.avctx->height - (mb_y << 4);
710  int uv_w = (y_w + 1) / 2;
711  int uv_h = y_h;
712  linesize = 16;
713  uvlinesize = 8;
714 
715  vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
716  linesize, ctx->m.linesize,
717  linesize, 16,
718  0, 0, y_w, y_h);
719  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
720  uvlinesize, ctx->m.uvlinesize,
721  uvlinesize, 16,
722  0, 0, uv_w, uv_h);
723  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
724  uvlinesize, ctx->m.uvlinesize,
725  uvlinesize, 16,
726  0, 0, uv_w, uv_h);
727 
728  dct_y_offset = bw * linesize;
729  dct_uv_offset = bw * uvlinesize;
730  ptr_y = &ctx->edge_buf_y[0];
731  ptr_u = &ctx->edge_buf_uv[0][0];
732  ptr_v = &ctx->edge_buf_uv[1][0];
733  } else if (ctx->bit_depth == 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
734  (mb_y << 4) + 16 > ctx->m.avctx->height)) {
735  int y_w = ctx->m.avctx->width - (mb_x << 4);
736  int y_h = ctx->m.avctx->height - (mb_y << 4);
737  int uv_w = ctx->is_444 ? y_w : (y_w + 1) / 2;
738  int uv_h = y_h;
739  linesize = 32;
740  uvlinesize = 16 + 16 * ctx->is_444;
741 
742  vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
743  linesize, ctx->m.linesize,
744  linesize / 2, 16,
745  0, 0, y_w, y_h);
746  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
747  uvlinesize, ctx->m.uvlinesize,
748  uvlinesize / 2, 16,
749  0, 0, uv_w, uv_h);
750  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
751  uvlinesize, ctx->m.uvlinesize,
752  uvlinesize / 2, 16,
753  0, 0, uv_w, uv_h);
754 
755  dct_y_offset = bw * linesize / 2;
756  dct_uv_offset = bw * uvlinesize / 2;
757  ptr_y = &ctx->edge_buf_y[0];
758  ptr_u = &ctx->edge_buf_uv[0][0];
759  ptr_v = &ctx->edge_buf_uv[1][0];
760  }
761 
762  if (!ctx->is_444) {
763  pdsp->get_pixels(ctx->blocks[0], ptr_y, linesize);
764  pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
765  pdsp->get_pixels(ctx->blocks[2], ptr_u, uvlinesize);
766  pdsp->get_pixels(ctx->blocks[3], ptr_v, uvlinesize);
767 
768  if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
769  if (ctx->interlaced) {
770  ctx->get_pixels_8x4_sym(ctx->blocks[4],
771  ptr_y + dct_y_offset,
772  linesize);
773  ctx->get_pixels_8x4_sym(ctx->blocks[5],
774  ptr_y + dct_y_offset + bw,
775  linesize);
776  ctx->get_pixels_8x4_sym(ctx->blocks[6],
777  ptr_u + dct_uv_offset,
778  uvlinesize);
779  ctx->get_pixels_8x4_sym(ctx->blocks[7],
780  ptr_v + dct_uv_offset,
781  uvlinesize);
782  } else {
783  ctx->bdsp.clear_block(ctx->blocks[4]);
784  ctx->bdsp.clear_block(ctx->blocks[5]);
785  ctx->bdsp.clear_block(ctx->blocks[6]);
786  ctx->bdsp.clear_block(ctx->blocks[7]);
787  }
788  } else {
789  pdsp->get_pixels(ctx->blocks[4],
790  ptr_y + dct_y_offset, linesize);
791  pdsp->get_pixels(ctx->blocks[5],
792  ptr_y + dct_y_offset + bw, linesize);
793  pdsp->get_pixels(ctx->blocks[6],
794  ptr_u + dct_uv_offset, uvlinesize);
795  pdsp->get_pixels(ctx->blocks[7],
796  ptr_v + dct_uv_offset, uvlinesize);
797  }
798  } else {
799  pdsp->get_pixels(ctx->blocks[0], ptr_y, linesize);
800  pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
801  pdsp->get_pixels(ctx->blocks[6], ptr_y + dct_y_offset, linesize);
802  pdsp->get_pixels(ctx->blocks[7], ptr_y + dct_y_offset + bw, linesize);
803 
804  pdsp->get_pixels(ctx->blocks[2], ptr_u, uvlinesize);
805  pdsp->get_pixels(ctx->blocks[3], ptr_u + bw, uvlinesize);
806  pdsp->get_pixels(ctx->blocks[8], ptr_u + dct_uv_offset, uvlinesize);
807  pdsp->get_pixels(ctx->blocks[9], ptr_u + dct_uv_offset + bw, uvlinesize);
808 
809  pdsp->get_pixels(ctx->blocks[4], ptr_v, uvlinesize);
810  pdsp->get_pixels(ctx->blocks[5], ptr_v + bw, uvlinesize);
811  pdsp->get_pixels(ctx->blocks[10], ptr_v + dct_uv_offset, uvlinesize);
812  pdsp->get_pixels(ctx->blocks[11], ptr_v + dct_uv_offset + bw, uvlinesize);
813  }
814 }
815 
816 static av_always_inline
818 {
819  int x;
820 
821  if (ctx->is_444) {
822  x = (i >> 1) % 3;
823  } else {
824  const static uint8_t component[8]={0,0,1,2,0,0,1,2};
825  x = component[i];
826  }
827  return x;
828 }
829 
831  int jobnr, int threadnr)
832 {
833  DNXHDEncContext *ctx = avctx->priv_data;
834  int mb_y = jobnr, mb_x;
835  int qscale = ctx->qscale;
836  LOCAL_ALIGNED_16(int16_t, block, [64]);
837  ctx = ctx->thread[threadnr];
838 
839  ctx->m.last_dc[0] =
840  ctx->m.last_dc[1] =
841  ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
842 
843  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
844  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
845  int ssd = 0;
846  int ac_bits = 0;
847  int dc_bits = 0;
848  int i;
849 
850  dnxhd_get_blocks(ctx, mb_x, mb_y);
851 
852  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
853  int16_t *src_block = ctx->blocks[i];
854  int overflow, nbits, diff, last_index;
855  int n = dnxhd_switch_matrix(ctx, i);
856 
857  memcpy(block, src_block, 64 * sizeof(*block));
858  last_index = ctx->m.dct_quantize(&ctx->m, block,
859  ctx->is_444 ? 4 * (n > 0): 4 & (2*i),
860  qscale, &overflow);
861  ac_bits += dnxhd_calc_ac_bits(ctx, block, last_index);
862 
863  diff = block[0] - ctx->m.last_dc[n];
864  if (diff < 0)
865  nbits = av_log2_16bit(-2 * diff);
866  else
867  nbits = av_log2_16bit(2 * diff);
868 
869  av_assert1(nbits < ctx->bit_depth + 4);
870  dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
871 
872  ctx->m.last_dc[n] = block[0];
873 
874  if (avctx->mb_decision == FF_MB_DECISION_RD || !RC_VARIANCE) {
875  dnxhd_unquantize_c(ctx, block, i, qscale, last_index);
876  ctx->m.idsp.idct(block);
877  ssd += dnxhd_ssd_block(block, src_block);
878  }
879  }
880  ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].ssd = ssd;
881  ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].bits = ac_bits + dc_bits + 12 +
882  (1 + ctx->is_444) * 8 * ctx->vlc_bits[0];
883  }
884  return 0;
885 }
886 
888  int jobnr, int threadnr)
889 {
890  DNXHDEncContext *ctx = avctx->priv_data;
891  int mb_y = jobnr, mb_x;
892  ctx = ctx->thread[threadnr];
893  init_put_bits(&ctx->m.pb, (uint8_t *)arg + ctx->data_offset + ctx->slice_offs[jobnr],
894  ctx->slice_size[jobnr]);
895 
896  ctx->m.last_dc[0] =
897  ctx->m.last_dc[1] =
898  ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
899  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
900  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
901  int qscale = ctx->mb_qscale[mb];
902  int i;
903 
904  put_bits(&ctx->m.pb, 11, qscale);
905  put_bits(&ctx->m.pb, 1, avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
906 
907  dnxhd_get_blocks(ctx, mb_x, mb_y);
908 
909  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
910  int16_t *block = ctx->blocks[i];
911  int overflow, n = dnxhd_switch_matrix(ctx, i);
912  int last_index = ctx->m.dct_quantize(&ctx->m, block,
913  ctx->is_444 ? (((i >> 1) % 3) < 1 ? 0 : 4): 4 & (2*i),
914  qscale, &overflow);
915 
916  dnxhd_encode_block(ctx, block, last_index, n);
917  }
918  }
919  if (put_bits_count(&ctx->m.pb) & 31)
920  put_bits(&ctx->m.pb, 32 - (put_bits_count(&ctx->m.pb) & 31), 0);
921  flush_put_bits(&ctx->m.pb);
922  return 0;
923 }
924 
926 {
927  int mb_y, mb_x;
928  int offset = 0;
929  for (mb_y = 0; mb_y < ctx->m.mb_height; mb_y++) {
930  int thread_size;
931  ctx->slice_offs[mb_y] = offset;
932  ctx->slice_size[mb_y] = 0;
933  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
934  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
935  ctx->slice_size[mb_y] += ctx->mb_bits[mb];
936  }
937  ctx->slice_size[mb_y] = (ctx->slice_size[mb_y] + 31) & ~31;
938  ctx->slice_size[mb_y] >>= 3;
939  thread_size = ctx->slice_size[mb_y];
940  offset += thread_size;
941  }
942 }
943 
945  int jobnr, int threadnr)
946 {
947  DNXHDEncContext *ctx = avctx->priv_data;
948  int mb_y = jobnr, mb_x, x, y;
949  int partial_last_row = (mb_y == ctx->m.mb_height - 1) &&
950  ((avctx->height >> ctx->interlaced) & 0xF);
951 
952  ctx = ctx->thread[threadnr];
953  if (ctx->bit_depth == 8) {
954  uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y << 4) * ctx->m.linesize);
955  for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x, pix += 16) {
956  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
957  int sum;
958  int varc;
959 
960  if (!partial_last_row && mb_x * 16 <= avctx->width - 16 && (avctx->width % 16) == 0) {
961  sum = ctx->m.mpvencdsp.pix_sum(pix, ctx->m.linesize);
962  varc = ctx->m.mpvencdsp.pix_norm1(pix, ctx->m.linesize);
963  } else {
964  int bw = FFMIN(avctx->width - 16 * mb_x, 16);
965  int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16);
966  sum = varc = 0;
967  for (y = 0; y < bh; y++) {
968  for (x = 0; x < bw; x++) {
969  uint8_t val = pix[x + y * ctx->m.linesize];
970  sum += val;
971  varc += val * val;
972  }
973  }
974  }
975  varc = (varc - (((unsigned) sum * sum) >> 8) + 128) >> 8;
976 
977  ctx->mb_cmp[mb].value = varc;
978  ctx->mb_cmp[mb].mb = mb;
979  }
980  } else { // 10-bit
981  const int linesize = ctx->m.linesize >> 1;
982  for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) {
983  uint16_t *pix = (uint16_t *)ctx->thread[0]->src[0] +
984  ((mb_y << 4) * linesize) + (mb_x << 4);
985  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
986  int sum = 0;
987  int sqsum = 0;
988  int bw = FFMIN(avctx->width - 16 * mb_x, 16);
989  int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16);
990  int mean, sqmean;
991  int i, j;
992  // Macroblocks are 16x16 pixels, unlike DCT blocks which are 8x8.
993  for (i = 0; i < bh; ++i) {
994  for (j = 0; j < bw; ++j) {
995  // Turn 16-bit pixels into 10-bit ones.
996  const int sample = (unsigned) pix[j] >> 6;
997  sum += sample;
998  sqsum += sample * sample;
999  // 2^10 * 2^10 * 16 * 16 = 2^28, which is less than INT_MAX
1000  }
1001  pix += linesize;
1002  }
1003  mean = sum >> 8; // 16*16 == 2^8
1004  sqmean = sqsum >> 8;
1005  ctx->mb_cmp[mb].value = sqmean - mean * mean;
1006  ctx->mb_cmp[mb].mb = mb;
1007  }
1008  }
1009  return 0;
1010 }
1011 
1013 {
1014  int lambda, up_step, down_step;
1015  int last_lower = INT_MAX, last_higher = 0;
1016  int x, y, q;
1017 
1018  for (q = 1; q < avctx->qmax; q++) {
1019  ctx->qscale = q;
1020  avctx->execute2(avctx, dnxhd_calc_bits_thread,
1021  NULL, NULL, ctx->m.mb_height);
1022  }
1023  up_step = down_step = 2 << LAMBDA_FRAC_BITS;
1024  lambda = ctx->lambda;
1025 
1026  for (;;) {
1027  int bits = 0;
1028  int end = 0;
1029  if (lambda == last_higher) {
1030  lambda++;
1031  end = 1; // need to set final qscales/bits
1032  }
1033  for (y = 0; y < ctx->m.mb_height; y++) {
1034  for (x = 0; x < ctx->m.mb_width; x++) {
1035  unsigned min = UINT_MAX;
1036  int qscale = 1;
1037  int mb = y * ctx->m.mb_width + x;
1038  int rc = 0;
1039  for (q = 1; q < avctx->qmax; q++) {
1040  int i = (q*ctx->m.mb_num) + mb;
1041  unsigned score = ctx->mb_rc[i].bits * lambda +
1042  ((unsigned) ctx->mb_rc[i].ssd << LAMBDA_FRAC_BITS);
1043  if (score < min) {
1044  min = score;
1045  qscale = q;
1046  rc = i;
1047  }
1048  }
1049  bits += ctx->mb_rc[rc].bits;
1050  ctx->mb_qscale[mb] = qscale;
1051  ctx->mb_bits[mb] = ctx->mb_rc[rc].bits;
1052  }
1053  bits = (bits + 31) & ~31; // padding
1054  if (bits > ctx->frame_bits)
1055  break;
1056  }
1057  if (end) {
1058  if (bits > ctx->frame_bits)
1059  return AVERROR(EINVAL);
1060  break;
1061  }
1062  if (bits < ctx->frame_bits) {
1063  last_lower = FFMIN(lambda, last_lower);
1064  if (last_higher != 0)
1065  lambda = (lambda+last_higher)>>1;
1066  else
1067  lambda -= down_step;
1068  down_step = FFMIN((int64_t)down_step*5, INT_MAX);
1069  up_step = 1<<LAMBDA_FRAC_BITS;
1070  lambda = FFMAX(1, lambda);
1071  if (lambda == last_lower)
1072  break;
1073  } else {
1074  last_higher = FFMAX(lambda, last_higher);
1075  if (last_lower != INT_MAX)
1076  lambda = (lambda+last_lower)>>1;
1077  else if ((int64_t)lambda + up_step > INT_MAX)
1078  return AVERROR(EINVAL);
1079  else
1080  lambda += up_step;
1081  up_step = FFMIN((int64_t)up_step*5, INT_MAX);
1082  down_step = 1<<LAMBDA_FRAC_BITS;
1083  }
1084  }
1085  ctx->lambda = lambda;
1086  return 0;
1087 }
1088 
1090 {
1091  int bits = 0;
1092  int up_step = 1;
1093  int down_step = 1;
1094  int last_higher = 0;
1095  int last_lower = INT_MAX;
1096  int qscale;
1097  int x, y;
1098 
1099  qscale = ctx->qscale;
1100  for (;;) {
1101  bits = 0;
1102  ctx->qscale = qscale;
1103  // XXX avoid recalculating bits
1105  NULL, NULL, ctx->m.mb_height);
1106  for (y = 0; y < ctx->m.mb_height; y++) {
1107  for (x = 0; x < ctx->m.mb_width; x++)
1108  bits += ctx->mb_rc[(qscale*ctx->m.mb_num) + (y*ctx->m.mb_width+x)].bits;
1109  bits = (bits+31)&~31; // padding
1110  if (bits > ctx->frame_bits)
1111  break;
1112  }
1113  if (bits < ctx->frame_bits) {
1114  if (qscale == 1)
1115  return 1;
1116  if (last_higher == qscale - 1) {
1117  qscale = last_higher;
1118  break;
1119  }
1120  last_lower = FFMIN(qscale, last_lower);
1121  if (last_higher != 0)
1122  qscale = (qscale + last_higher) >> 1;
1123  else
1124  qscale -= down_step++;
1125  if (qscale < 1)
1126  qscale = 1;
1127  up_step = 1;
1128  } else {
1129  if (last_lower == qscale + 1)
1130  break;
1131  last_higher = FFMAX(qscale, last_higher);
1132  if (last_lower != INT_MAX)
1133  qscale = (qscale + last_lower) >> 1;
1134  else
1135  qscale += up_step++;
1136  down_step = 1;
1137  if (qscale >= ctx->m.avctx->qmax)
1138  return AVERROR(EINVAL);
1139  }
1140  }
1141  ctx->qscale = qscale;
1142  return 0;
1143 }
1144 
1145 #define BUCKET_BITS 8
1146 #define RADIX_PASSES 4
1147 #define NBUCKETS (1 << BUCKET_BITS)
1148 
1149 static inline int get_bucket(int value, int shift)
1150 {
1151  value >>= shift;
1152  value &= NBUCKETS - 1;
1153  return NBUCKETS - 1 - value;
1154 }
1155 
1156 static void radix_count(const RCCMPEntry *data, int size,
1157  int buckets[RADIX_PASSES][NBUCKETS])
1158 {
1159  int i, j;
1160  memset(buckets, 0, sizeof(buckets[0][0]) * RADIX_PASSES * NBUCKETS);
1161  for (i = 0; i < size; i++) {
1162  int v = data[i].value;
1163  for (j = 0; j < RADIX_PASSES; j++) {
1164  buckets[j][get_bucket(v, 0)]++;
1165  v >>= BUCKET_BITS;
1166  }
1167  av_assert1(!v);
1168  }
1169  for (j = 0; j < RADIX_PASSES; j++) {
1170  int offset = size;
1171  for (i = NBUCKETS - 1; i >= 0; i--)
1172  buckets[j][i] = offset -= buckets[j][i];
1173  av_assert1(!buckets[j][0]);
1174  }
1175 }
1176 
1177 static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data,
1178  int size, int buckets[NBUCKETS], int pass)
1179 {
1180  int shift = pass * BUCKET_BITS;
1181  int i;
1182  for (i = 0; i < size; i++) {
1183  int v = get_bucket(data[i].value, shift);
1184  int pos = buckets[v]++;
1185  dst[pos] = data[i];
1186  }
1187 }
1188 
1190 {
1191  int buckets[RADIX_PASSES][NBUCKETS];
1192  radix_count(data, size, buckets);
1193  radix_sort_pass(tmp, data, size, buckets[0], 0);
1194  radix_sort_pass(data, tmp, size, buckets[1], 1);
1195  if (buckets[2][NBUCKETS - 1] || buckets[3][NBUCKETS - 1]) {
1196  radix_sort_pass(tmp, data, size, buckets[2], 2);
1197  radix_sort_pass(data, tmp, size, buckets[3], 3);
1198  }
1199 }
1200 
1202 {
1203  int max_bits = 0;
1204  int ret, x, y;
1205  if ((ret = dnxhd_find_qscale(ctx)) < 0)
1206  return ret;
1207  for (y = 0; y < ctx->m.mb_height; y++) {
1208  for (x = 0; x < ctx->m.mb_width; x++) {
1209  int mb = y * ctx->m.mb_width + x;
1210  int rc = (ctx->qscale * ctx->m.mb_num ) + mb;
1211  int delta_bits;
1212  ctx->mb_qscale[mb] = ctx->qscale;
1213  ctx->mb_bits[mb] = ctx->mb_rc[rc].bits;
1214  max_bits += ctx->mb_rc[rc].bits;
1215  if (!RC_VARIANCE) {
1216  delta_bits = ctx->mb_rc[rc].bits -
1217  ctx->mb_rc[rc + ctx->m.mb_num].bits;
1218  ctx->mb_cmp[mb].mb = mb;
1219  ctx->mb_cmp[mb].value =
1220  delta_bits ? ((ctx->mb_rc[rc].ssd -
1221  ctx->mb_rc[rc + ctx->m.mb_num].ssd) * 100) /
1222  delta_bits
1223  : INT_MIN; // avoid increasing qscale
1224  }
1225  }
1226  max_bits += 31; // worst padding
1227  }
1228  if (!ret) {
1229  if (RC_VARIANCE)
1230  avctx->execute2(avctx, dnxhd_mb_var_thread,
1231  NULL, NULL, ctx->m.mb_height);
1232  radix_sort(ctx->mb_cmp, ctx->mb_cmp_tmp, ctx->m.mb_num);
1233  for (x = 0; x < ctx->m.mb_num && max_bits > ctx->frame_bits; x++) {
1234  int mb = ctx->mb_cmp[x].mb;
1235  int rc = (ctx->qscale * ctx->m.mb_num ) + mb;
1236  max_bits -= ctx->mb_rc[rc].bits -
1237  ctx->mb_rc[rc + ctx->m.mb_num].bits;
1238  ctx->mb_qscale[mb] = ctx->qscale + 1;
1239  ctx->mb_bits[mb] = ctx->mb_rc[rc + ctx->m.mb_num].bits;
1240  }
1241  }
1242  return 0;
1243 }
1244 
1246 {
1247  int i;
1248 
1249  for (i = 0; i < ctx->m.avctx->thread_count; i++) {
1250  ctx->thread[i]->m.linesize = frame->linesize[0] << ctx->interlaced;
1251  ctx->thread[i]->m.uvlinesize = frame->linesize[1] << ctx->interlaced;
1252  ctx->thread[i]->dct_y_offset = ctx->m.linesize *8;
1253  ctx->thread[i]->dct_uv_offset = ctx->m.uvlinesize*8;
1254  }
1255 
1256 #if FF_API_CODED_FRAME
1260 #endif
1261  ctx->cur_field = frame->interlaced_frame && !frame->top_field_first;
1262 }
1263 
1265  const AVFrame *frame, int *got_packet)
1266 {
1267  DNXHDEncContext *ctx = avctx->priv_data;
1268  int first_field = 1;
1269  int offset, i, ret;
1270  uint8_t *buf;
1271 
1272  if ((ret = ff_alloc_packet2(avctx, pkt, ctx->frame_size, 0)) < 0)
1273  return ret;
1274  buf = pkt->data;
1275 
1276  dnxhd_load_picture(ctx, frame);
1277 
1278 encode_coding_unit:
1279  for (i = 0; i < 3; i++) {
1280  ctx->src[i] = frame->data[i];
1281  if (ctx->interlaced && ctx->cur_field)
1282  ctx->src[i] += frame->linesize[i];
1283  }
1284 
1285  dnxhd_write_header(avctx, buf);
1286 
1287  if (avctx->mb_decision == FF_MB_DECISION_RD)
1288  ret = dnxhd_encode_rdo(avctx, ctx);
1289  else
1290  ret = dnxhd_encode_fast(avctx, ctx);
1291  if (ret < 0) {
1292  av_log(avctx, AV_LOG_ERROR,
1293  "picture could not fit ratecontrol constraints, increase qmax\n");
1294  return ret;
1295  }
1296 
1298 
1299  offset = 0;
1300  for (i = 0; i < ctx->m.mb_height; i++) {
1301  AV_WB32(ctx->msip + i * 4, offset);
1302  offset += ctx->slice_size[i];
1303  av_assert1(!(ctx->slice_size[i] & 3));
1304  }
1305 
1306  avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height);
1307 
1308  av_assert1(ctx->data_offset + offset + 4 <= ctx->coding_unit_size);
1309  memset(buf + ctx->data_offset + offset, 0,
1310  ctx->coding_unit_size - 4 - offset - ctx->data_offset);
1311 
1312  AV_WB32(buf + ctx->coding_unit_size - 4, 0x600DC0DE); // EOF
1313 
1314  if (ctx->interlaced && first_field) {
1315  first_field = 0;
1316  ctx->cur_field ^= 1;
1317  buf += ctx->coding_unit_size;
1318  goto encode_coding_unit;
1319  }
1320 
1321 #if FF_API_CODED_FRAME
1323  avctx->coded_frame->quality = ctx->qscale * FF_QP2LAMBDA;
1325 #endif
1326 
1328 
1329  pkt->flags |= AV_PKT_FLAG_KEY;
1330  *got_packet = 1;
1331  return 0;
1332 }
1333 
1335 {
1336  DNXHDEncContext *ctx = avctx->priv_data;
1337  int i;
1338 
1339  av_freep(&ctx->orig_vlc_codes);
1340  av_freep(&ctx->orig_vlc_bits);
1341  av_freep(&ctx->run_codes);
1342  av_freep(&ctx->run_bits);
1343 
1344  av_freep(&ctx->mb_bits);
1345  av_freep(&ctx->mb_qscale);
1346  av_freep(&ctx->mb_rc);
1347  av_freep(&ctx->mb_cmp);
1348  av_freep(&ctx->mb_cmp_tmp);
1349  av_freep(&ctx->slice_size);
1350  av_freep(&ctx->slice_offs);
1351 
1352  av_freep(&ctx->qmatrix_c);
1353  av_freep(&ctx->qmatrix_l);
1354  av_freep(&ctx->qmatrix_c16);
1355  av_freep(&ctx->qmatrix_l16);
1356 
1357  if (avctx->active_thread_type == FF_THREAD_SLICE) {
1358  for (i = 1; i < avctx->thread_count; i++)
1359  av_freep(&ctx->thread[i]);
1360  }
1361 
1362  return 0;
1363 }
1364 
1365 static const AVCodecDefault dnxhd_defaults[] = {
1366  { "qmax", "1024" }, /* Maximum quantization scale factor allowed for VC-3 */
1367  { NULL },
1368 };
1369 
1371  .name = "dnxhd",
1372  .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
1373  .type = AVMEDIA_TYPE_VIDEO,
1374  .id = AV_CODEC_ID_DNXHD,
1375  .priv_data_size = sizeof(DNXHDEncContext),
1377  .encode2 = dnxhd_encode_picture,
1378  .close = dnxhd_encode_end,
1380  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1381  .pix_fmts = (const enum AVPixelFormat[]) {
1387  },
1388  .priv_class = &dnxhd_class,
1389  .defaults = dnxhd_defaults,
1391 };
#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:1874
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:660
#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:1156
#define NULL
Definition: coverity.c:32
static av_always_inline void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
Definition: dnxhdenc.c:689
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:308
const uint8_t * dc_bits
Definition: dnxhddata.h:52
AVOption.
Definition: opt.h:248
int ff_side_data_set_encoder_stats(AVPacket *pkt, int quality, int64_t *error, int error_count, int pict_type)
Definition: avpacket.c:796
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:321
#define LAMBDA_FRAC_BITS
Definition: dnxhdenc.c:43
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
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:415
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:70
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:90
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
unsigned dct_uv_offset
Definition: dnxhdenc.h:63
static av_always_inline void dnxhd_encode_dc(DNXHDEncContext *ctx, int diff)
Definition: dnxhdenc.c:571
static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
Definition: dnxhdenc.c:205
mpegvideo header.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
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:204
static AVPacket pkt
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1757
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:1859
#define sample
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
AVCodec.
Definition: codec.h:190
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:670
int h263_aic
Advanced INTRA Coding (AIC)
Definition: mpegvideo.h:87
Macro definitions for various function/variable attributes.
const uint8_t * buf
Definition: dnxhddec.c:54
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:33
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:88
#define av_malloc(s)
#define mb
AVOptions.
static int get_bucket(int value, int shift)
Definition: dnxhdenc.c:1149
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:92
static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx)
Definition: dnxhdenc.c:1201
uint32_t * slice_size
Definition: dnxhdenc.h:55
int(* qmatrix_c)[64]
Definition: dnxhdenc.h:81
#define RADIX_PASSES
Definition: dnxhdenc.c:1146
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: packet.h:363
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:1177
const uint8_t * run_bits
Definition: dnxhddata.h:56
#define BUCKET_BITS
Definition: dnxhdenc.c:1145
const uint8_t * scantable
Definition: idctdsp.h:32
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:455
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:260
#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:1334
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
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:817
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:830
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:1089
#define FF_SIGNBIT(x)
Definition: internal.h:99
#define RC_VARIANCE
Definition: dnxhdenc.c:42
int qmax
maximum quantizer
Definition: avcodec.h:1375
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1804
AVCodec ff_dnxhd_encoder
Definition: dnxhdenc.c:1370
static av_always_inline void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n, int qscale, int last_index)
Definition: dnxhdenc.c:612
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
PixblockDSPContext pdsp
Definition: mpegvideo.h:234
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
Definition: dnxhdenc.c:535
const uint8_t * dc_codes
Definition: dnxhddata.h:52
MpegvideoEncDSPContext mpvencdsp
Definition: mpegvideo.h:233
const char * name
Name of the codec implementation.
Definition: codec.h:197
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
uint8_t bits
Definition: vp3data.h:202
#define FF_PROFILE_DNXHR_LB
Definition: avcodec.h:1875
#define FFMAX(a, b)
Definition: common.h:94
av_cold void ff_pixblockdsp_init(PixblockDSPContext *c, AVCodecContext *avctx)
Definition: pixblockdsp.c:81
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
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: packet.h:369
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:81
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:46
static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block, const uint8_t *pixels, ptrdiff_t line_size)
Definition: dnxhdenc.c:77
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
#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:1365
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:586
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:699
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:254
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:101
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:1797
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:431
ScanTable scantable
Definition: dnxhddec.c:65
uint8_t * msip
Macroblock Scan Indexes Payload.
Definition: dnxhdenc.h:54
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:1014
void ff_dnxhd_print_profiles(AVCodecContext *avctx, int loglevel)
Definition: dnxhddata.c:1163
#define FF_PROFILE_DNXHR_HQ
Definition: avcodec.h:1877
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:1785
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:1012
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:110
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:1845
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:174
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:339
static int dnxhd_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: dnxhdenc.c:1264
main external API structure.
Definition: avcodec.h:526
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:333
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:551
unsigned lambda
Definition: dnxhdenc.h:99
FDCTDSPContext fdsp
Definition: mpegvideo.h:227
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:1017
#define NBUCKETS
Definition: dnxhdenc.c:1147
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:925
#define FF_PROFILE_DNXHR_SQ
Definition: avcodec.h:1876
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:300
unsigned min_padding
Definition: dnxhdenc.h:74
mfxU16 profile
Definition: qsvenc.c:45
static void dnxhd_load_picture(DNXHDEncContext *ctx, const AVFrame *frame)
Definition: dnxhdenc.c:1245
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:400
#define DNX10BIT_QMAT_SHIFT
Definition: dnxhdenc.c:41
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
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:205
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:944
#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:1878
static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: dnxhdenc.c:887
static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
Definition: dnxhdenc.c:350
#define VE
Definition: dnxhdenc.c:45
#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:115
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:1776
static int dnxhd_10bit_dct_quantize_444(MpegEncContext *ctx, int16_t *block, int n, int qscale, int *overflow)
Definition: dnxhdenc.c:115
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
#define FF_PROFILE_DNXHR_444
Definition: avcodec.h:1879
void * priv_data
Definition: avcodec.h:553
static av_always_inline int diff(const uint32_t a, const uint32_t b)
RCCMPEntry * mb_cmp
Definition: dnxhdenc.h:104
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:1189
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:460
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:386
#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:45
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:141
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:406
float min
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
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
int i
Definition: input.c:407
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