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 #include "libavutil/timer.h"
30 
31 #include "avcodec.h"
32 #include "blockdsp.h"
33 #include "fdctdsp.h"
34 #include "internal.h"
35 #include "mpegvideo.h"
36 #include "pixblockdsp.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 
211  max_level, 4 * sizeof(*ctx->orig_vlc_codes), fail);
213  max_level, 4 * sizeof(*ctx->orig_vlc_bits), fail);
214  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes,
215  63 * 2, fail);
216  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits,
217  63, fail);
218 
219  ctx->vlc_codes = ctx->orig_vlc_codes + max_level * 2;
220  ctx->vlc_bits = ctx->orig_vlc_bits + max_level * 2;
221  for (level = -max_level; level < max_level; level++) {
222  for (run = 0; run < 2; run++) {
223  int index = (level << 1) | run;
224  int sign, offset = 0, alevel = level;
225 
226  MASK_ABS(sign, alevel);
227  if (alevel > 64) {
228  offset = (alevel - 1) >> 6;
229  alevel -= offset << 6;
230  }
231  for (j = 0; j < 257; j++) {
232  if (ctx->cid_table->ac_info[2*j+0] >> 1 == alevel &&
233  (!offset || (ctx->cid_table->ac_info[2*j+1] & 1) && offset) &&
234  (!run || (ctx->cid_table->ac_info[2*j+1] & 2) && run)) {
235  av_assert1(!ctx->vlc_codes[index]);
236  if (alevel) {
237  ctx->vlc_codes[index] =
238  (ctx->cid_table->ac_codes[j] << 1) | (sign & 1);
239  ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j] + 1;
240  } else {
241  ctx->vlc_codes[index] = ctx->cid_table->ac_codes[j];
242  ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j];
243  }
244  break;
245  }
246  }
247  av_assert0(!alevel || j < 257);
248  if (offset) {
249  ctx->vlc_codes[index] =
250  (ctx->vlc_codes[index] << ctx->cid_table->index_bits) | offset;
251  ctx->vlc_bits[index] += ctx->cid_table->index_bits;
252  }
253  }
254  }
255  for (i = 0; i < 62; i++) {
256  int run = ctx->cid_table->run[i];
257  av_assert0(run < 63);
258  ctx->run_codes[run] = ctx->cid_table->run_codes[i];
259  ctx->run_bits[run] = ctx->cid_table->run_bits[i];
260  }
261  return 0;
262 fail:
263  return AVERROR(ENOMEM);
264 }
265 
266 static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
267 {
268  // init first elem to 1 to avoid div by 0 in convert_matrix
269  uint16_t weight_matrix[64] = { 1, }; // convert_matrix needs uint16_t*
270  int qscale, i;
271  const uint8_t *luma_weight_table = ctx->cid_table->luma_weight;
272  const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight;
273 
275  (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail);
277  (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail);
279  (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t),
280  fail);
282  (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t),
283  fail);
284 
285  if (ctx->bit_depth == 8) {
286  for (i = 1; i < 64; i++) {
287  int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
288  weight_matrix[j] = ctx->cid_table->luma_weight[i];
289  }
290  ff_convert_matrix(&ctx->m, ctx->qmatrix_l, ctx->qmatrix_l16,
291  weight_matrix, ctx->intra_quant_bias, 1,
292  ctx->m.avctx->qmax, 1);
293  for (i = 1; i < 64; i++) {
294  int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
295  weight_matrix[j] = ctx->cid_table->chroma_weight[i];
296  }
297  ff_convert_matrix(&ctx->m, ctx->qmatrix_c, ctx->qmatrix_c16,
298  weight_matrix, ctx->intra_quant_bias, 1,
299  ctx->m.avctx->qmax, 1);
300 
301  for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
302  for (i = 0; i < 64; i++) {
303  ctx->qmatrix_l[qscale][i] <<= 2;
304  ctx->qmatrix_c[qscale][i] <<= 2;
305  ctx->qmatrix_l16[qscale][0][i] <<= 2;
306  ctx->qmatrix_l16[qscale][1][i] <<= 2;
307  ctx->qmatrix_c16[qscale][0][i] <<= 2;
308  ctx->qmatrix_c16[qscale][1][i] <<= 2;
309  }
310  }
311  } else {
312  // 10-bit
313  for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
314  for (i = 1; i < 64; i++) {
315  int j = ff_zigzag_direct[i];
316 
317  /* The quantization formula from the VC-3 standard is:
318  * quantized = sign(block[i]) * floor(abs(block[i]/s) * p /
319  * (qscale * weight_table[i]))
320  * Where p is 32 for 8-bit samples and 8 for 10-bit ones.
321  * The s factor compensates scaling of DCT coefficients done by
322  * the DCT routines, and therefore is not present in standard.
323  * It's 8 for 8-bit samples and 4 for 10-bit ones.
324  * We want values of ctx->qtmatrix_l and ctx->qtmatrix_r to be:
325  * ((1 << DNX10BIT_QMAT_SHIFT) * (p / s)) /
326  * (qscale * weight_table[i])
327  * For 10-bit samples, p / s == 2 */
328  ctx->qmatrix_l[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
329  (qscale * luma_weight_table[i]);
330  ctx->qmatrix_c[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
331  (qscale * chroma_weight_table[i]);
332  }
333  }
334  }
335 
337  ctx->m.q_chroma_intra_matrix = ctx->qmatrix_c;
338  ctx->m.q_intra_matrix16 = ctx->qmatrix_l16;
339  ctx->m.q_intra_matrix = ctx->qmatrix_l;
340 
341  return 0;
342 fail:
343  return AVERROR(ENOMEM);
344 }
345 
347 {
348  FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_rc, (ctx->m.avctx->qmax + 1),
349  ctx->m.mb_num * sizeof(RCEntry), fail);
350  if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) {
352  ctx->m.mb_num, sizeof(RCCMPEntry), fail);
354  ctx->m.mb_num, sizeof(RCCMPEntry), fail);
355  }
356  ctx->frame_bits = (ctx->coding_unit_size -
357  ctx->data_offset - 4 - ctx->min_padding) * 8;
358  ctx->qscale = 1;
359  ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2
360  return 0;
361 fail:
362  return AVERROR(ENOMEM);
363 }
364 
366 {
367  DNXHDEncContext *ctx = avctx->priv_data;
368  int i, index, ret;
369 
370  switch (avctx->pix_fmt) {
371  case AV_PIX_FMT_YUV422P:
372  ctx->bit_depth = 8;
373  break;
376  case AV_PIX_FMT_GBRP10:
377  ctx->bit_depth = 10;
378  break;
379  default:
380  av_log(avctx, AV_LOG_ERROR,
381  "pixel format is incompatible with DNxHD\n");
382  return AVERROR(EINVAL);
383  }
384 
385  if ((ctx->profile == FF_PROFILE_DNXHR_444 && (avctx->pix_fmt != AV_PIX_FMT_YUV444P10 &&
386  avctx->pix_fmt != AV_PIX_FMT_GBRP10)) ||
387  (ctx->profile != FF_PROFILE_DNXHR_444 && (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 ||
388  avctx->pix_fmt == AV_PIX_FMT_GBRP10))) {
389  av_log(avctx, AV_LOG_ERROR,
390  "pixel format is incompatible with DNxHD profile\n");
391  return AVERROR(EINVAL);
392  }
393 
394  if (ctx->profile == FF_PROFILE_DNXHR_HQX && avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
395  av_log(avctx, AV_LOG_ERROR,
396  "pixel format is incompatible with DNxHR HQX profile\n");
397  return AVERROR(EINVAL);
398  }
399 
400  if ((ctx->profile == FF_PROFILE_DNXHR_LB ||
401  ctx->profile == FF_PROFILE_DNXHR_SQ ||
402  ctx->profile == FF_PROFILE_DNXHR_HQ) && avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
403  av_log(avctx, AV_LOG_ERROR,
404  "pixel format is incompatible with DNxHR LB/SQ/HQ profile\n");
405  return AVERROR(EINVAL);
406  }
407 
408  ctx->is_444 = ctx->profile == FF_PROFILE_DNXHR_444;
409  avctx->profile = ctx->profile;
410  ctx->cid = ff_dnxhd_find_cid(avctx, ctx->bit_depth);
411  if (!ctx->cid) {
412  av_log(avctx, AV_LOG_ERROR,
413  "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n");
415  return AVERROR(EINVAL);
416  }
417  av_log(avctx, AV_LOG_DEBUG, "cid %d\n", ctx->cid);
418 
419  if (ctx->cid >= 1270 && ctx->cid <= 1274)
420  avctx->codec_tag = MKTAG('A','V','d','h');
421 
422  if (avctx->width < 256 || avctx->height < 120) {
423  av_log(avctx, AV_LOG_ERROR,
424  "Input dimensions too small, input must be at least 256x120\n");
425  return AVERROR(EINVAL);
426  }
427 
428  index = ff_dnxhd_get_cid_table(ctx->cid);
429  av_assert0(index >= 0);
430 
432 
433  ctx->m.avctx = avctx;
434  ctx->m.mb_intra = 1;
435  ctx->m.h263_aic = 1;
436 
437  avctx->bits_per_raw_sample = ctx->bit_depth;
438 
439  ff_blockdsp_init(&ctx->bdsp, avctx);
440  ff_fdctdsp_init(&ctx->m.fdsp, avctx);
441  ff_mpv_idct_init(&ctx->m);
442  ff_mpegvideoencdsp_init(&ctx->m.mpvencdsp, avctx);
443  ff_pixblockdsp_init(&ctx->m.pdsp, avctx);
444  ff_dct_encode_init(&ctx->m);
445 
446  if (ctx->profile != FF_PROFILE_DNXHD)
447  ff_videodsp_init(&ctx->m.vdsp, ctx->bit_depth);
448 
449  if (!ctx->m.dct_quantize)
451 
452  if (ctx->is_444 || ctx->profile == FF_PROFILE_DNXHR_HQX) {
455  ctx->block_width_l2 = 4;
456  } else if (ctx->bit_depth == 10) {
459  ctx->block_width_l2 = 4;
460  } else {
462  ctx->block_width_l2 = 3;
463  }
464 
465  if (ARCH_X86)
467 
468  ctx->m.mb_height = (avctx->height + 15) / 16;
469  ctx->m.mb_width = (avctx->width + 15) / 16;
470 
471  if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
472  ctx->interlaced = 1;
473  ctx->m.mb_height /= 2;
474  }
475 
476  if (ctx->interlaced && ctx->profile != FF_PROFILE_DNXHD) {
477  av_log(avctx, AV_LOG_ERROR,
478  "Interlaced encoding is not supported for DNxHR profiles.\n");
479  return AVERROR(EINVAL);
480  }
481 
482  ctx->m.mb_num = ctx->m.mb_height * ctx->m.mb_width;
483 
484  if (ctx->cid_table->frame_size == DNXHD_VARIABLE) {
486  avctx->width, avctx->height);
487  av_assert0(ctx->frame_size >= 0);
488  ctx->coding_unit_size = ctx->frame_size;
489  } else {
490  ctx->frame_size = ctx->cid_table->frame_size;
492  }
493 
494  if (ctx->m.mb_height > 68)
495  ctx->data_offset = 0x170 + (ctx->m.mb_height << 2);
496  else
497  ctx->data_offset = 0x280;
498 
499  // XXX tune lbias/cbias
500  if ((ret = dnxhd_init_qmat(ctx, ctx->intra_quant_bias, 0)) < 0)
501  return ret;
502 
503  /* Avid Nitris hardware decoder requires a minimum amount of padding
504  * in the coding unit payload */
505  if (ctx->nitris_compat)
506  ctx->min_padding = 1600;
507 
508  if ((ret = dnxhd_init_vlc(ctx)) < 0)
509  return ret;
510  if ((ret = dnxhd_init_rc(ctx)) < 0)
511  return ret;
512 
513  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size,
514  ctx->m.mb_height * sizeof(uint32_t), fail);
515  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs,
516  ctx->m.mb_height * sizeof(uint32_t), fail);
517  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits,
518  ctx->m.mb_num * sizeof(uint16_t), fail);
519  FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale,
520  ctx->m.mb_num * sizeof(uint8_t), fail);
521 
522 #if FF_API_CODED_FRAME
524  avctx->coded_frame->key_frame = 1;
527 #endif
528 
529  if (avctx->active_thread_type == FF_THREAD_SLICE) {
530  if (avctx->thread_count > MAX_THREADS) {
531  av_log(avctx, AV_LOG_ERROR, "too many threads\n");
532  return AVERROR(EINVAL);
533  }
534  }
535 
536  if (avctx->qmax <= 1) {
537  av_log(avctx, AV_LOG_ERROR, "qmax must be at least 2\n");
538  return AVERROR(EINVAL);
539  }
540 
541  ctx->thread[0] = ctx;
542  if (avctx->active_thread_type == FF_THREAD_SLICE) {
543  for (i = 1; i < avctx->thread_count; i++) {
544  ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext));
545  memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext));
546  }
547  }
548 
549  return 0;
550 fail: // for FF_ALLOCZ_OR_GOTO
551  return AVERROR(ENOMEM);
552 }
553 
555 {
556  DNXHDEncContext *ctx = avctx->priv_data;
557 
558  memset(buf, 0, ctx->data_offset);
559 
560  // * write prefix */
561  AV_WB16(buf + 0x02, ctx->data_offset);
562  if (ctx->cid >= 1270 && ctx->cid <= 1274)
563  buf[4] = 0x03;
564  else
565  buf[4] = 0x01;
566 
567  buf[5] = ctx->interlaced ? ctx->cur_field + 2 : 0x01;
568  buf[6] = 0x80; // crc flag off
569  buf[7] = 0xa0; // reserved
570  AV_WB16(buf + 0x18, avctx->height >> ctx->interlaced); // ALPF
571  AV_WB16(buf + 0x1a, avctx->width); // SPL
572  AV_WB16(buf + 0x1d, avctx->height >> ctx->interlaced); // NAL
573 
574  buf[0x21] = ctx->bit_depth == 10 ? 0x58 : 0x38;
575  buf[0x22] = 0x88 + (ctx->interlaced << 2);
576  AV_WB32(buf + 0x28, ctx->cid); // CID
577  buf[0x2c] = (!ctx->interlaced << 7) | (ctx->is_444 << 6) | (avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
578 
579  buf[0x5f] = 0x01; // UDL
580 
581  buf[0x167] = 0x02; // reserved
582  AV_WB16(buf + 0x16a, ctx->m.mb_height * 4 + 4); // MSIPS
583  AV_WB16(buf + 0x16c, ctx->m.mb_height); // Ns
584  buf[0x16f] = 0x10; // reserved
585 
586  ctx->msip = buf + 0x170;
587  return 0;
588 }
589 
591 {
592  int nbits;
593  if (diff < 0) {
594  nbits = av_log2_16bit(-2 * diff);
595  diff--;
596  } else {
597  nbits = av_log2_16bit(2 * diff);
598  }
599  put_bits(&ctx->m.pb, ctx->cid_table->dc_bits[nbits] + nbits,
600  (ctx->cid_table->dc_codes[nbits] << nbits) +
601  av_mod_uintp2(diff, nbits));
602 }
603 
604 static av_always_inline
606  int last_index, int n)
607 {
608  int last_non_zero = 0;
609  int slevel, i, j;
610 
611  dnxhd_encode_dc(ctx, block[0] - ctx->m.last_dc[n]);
612  ctx->m.last_dc[n] = block[0];
613 
614  for (i = 1; i <= last_index; i++) {
615  j = ctx->m.intra_scantable.permutated[i];
616  slevel = block[j];
617  if (slevel) {
618  int run_level = i - last_non_zero - 1;
619  int rlevel = (slevel << 1) | !!run_level;
620  put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
621  if (run_level)
622  put_bits(&ctx->m.pb, ctx->run_bits[run_level],
623  ctx->run_codes[run_level]);
624  last_non_zero = i;
625  }
626  }
627  put_bits(&ctx->m.pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB
628 }
629 
630 static av_always_inline
632  int qscale, int last_index)
633 {
634  const uint8_t *weight_matrix;
635  int level;
636  int i;
637 
638  if (ctx->is_444) {
639  weight_matrix = ((n % 6) < 2) ? ctx->cid_table->luma_weight
640  : ctx->cid_table->chroma_weight;
641  } else {
642  weight_matrix = (n & 2) ? ctx->cid_table->chroma_weight
643  : ctx->cid_table->luma_weight;
644  }
645 
646  for (i = 1; i <= last_index; i++) {
647  int j = ctx->m.intra_scantable.permutated[i];
648  level = block[j];
649  if (level) {
650  if (level < 0) {
651  level = (1 - 2 * level) * qscale * weight_matrix[i];
652  if (ctx->bit_depth == 10) {
653  if (weight_matrix[i] != 8)
654  level += 8;
655  level >>= 4;
656  } else {
657  if (weight_matrix[i] != 32)
658  level += 32;
659  level >>= 6;
660  }
661  level = -level;
662  } else {
663  level = (2 * level + 1) * qscale * weight_matrix[i];
664  if (ctx->bit_depth == 10) {
665  if (weight_matrix[i] != 8)
666  level += 8;
667  level >>= 4;
668  } else {
669  if (weight_matrix[i] != 32)
670  level += 32;
671  level >>= 6;
672  }
673  }
674  block[j] = level;
675  }
676  }
677 }
678 
679 static av_always_inline int dnxhd_ssd_block(int16_t *qblock, int16_t *block)
680 {
681  int score = 0;
682  int i;
683  for (i = 0; i < 64; i++)
684  score += (block[i] - qblock[i]) * (block[i] - qblock[i]);
685  return score;
686 }
687 
688 static av_always_inline
689 int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
690 {
691  int last_non_zero = 0;
692  int bits = 0;
693  int i, j, level;
694  for (i = 1; i <= last_index; i++) {
695  j = ctx->m.intra_scantable.permutated[i];
696  level = block[j];
697  if (level) {
698  int run_level = i - last_non_zero - 1;
699  bits += ctx->vlc_bits[(level << 1) |
700  !!run_level] + ctx->run_bits[run_level];
701  last_non_zero = i;
702  }
703  }
704  return bits;
705 }
706 
707 static av_always_inline
708 void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
709 {
710  const int bs = ctx->block_width_l2;
711  const int bw = 1 << bs;
712  int dct_y_offset = ctx->dct_y_offset;
713  int dct_uv_offset = ctx->dct_uv_offset;
714  int linesize = ctx->m.linesize;
715  int uvlinesize = ctx->m.uvlinesize;
716  const uint8_t *ptr_y = ctx->thread[0]->src[0] +
717  ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs + 1);
718  const uint8_t *ptr_u = ctx->thread[0]->src[1] +
719  ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
720  const uint8_t *ptr_v = ctx->thread[0]->src[2] +
721  ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
722  PixblockDSPContext *pdsp = &ctx->m.pdsp;
723  VideoDSPContext *vdsp = &ctx->m.vdsp;
724 
725  if (ctx->bit_depth != 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
726  (mb_y << 4) + 16 > ctx->m.avctx->height)) {
727  int y_w = ctx->m.avctx->width - (mb_x << 4);
728  int y_h = ctx->m.avctx->height - (mb_y << 4);
729  int uv_w = (y_w + 1) / 2;
730  int uv_h = y_h;
731  linesize = 16;
732  uvlinesize = 8;
733 
734  vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
735  linesize, ctx->m.linesize,
736  linesize, 16,
737  0, 0, y_w, y_h);
738  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
739  uvlinesize, ctx->m.uvlinesize,
740  uvlinesize, 16,
741  0, 0, uv_w, uv_h);
742  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
743  uvlinesize, ctx->m.uvlinesize,
744  uvlinesize, 16,
745  0, 0, uv_w, uv_h);
746 
747  dct_y_offset = bw * linesize;
748  dct_uv_offset = bw * uvlinesize;
749  ptr_y = &ctx->edge_buf_y[0];
750  ptr_u = &ctx->edge_buf_uv[0][0];
751  ptr_v = &ctx->edge_buf_uv[1][0];
752  } else if (ctx->bit_depth == 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
753  (mb_y << 4) + 16 > ctx->m.avctx->height)) {
754  int y_w = ctx->m.avctx->width - (mb_x << 4);
755  int y_h = ctx->m.avctx->height - (mb_y << 4);
756  int uv_w = ctx->is_444 ? y_w : (y_w + 1) / 2;
757  int uv_h = y_h;
758  linesize = 32;
759  uvlinesize = 16 + 16 * ctx->is_444;
760 
761  vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
762  linesize, ctx->m.linesize,
763  linesize / 2, 16,
764  0, 0, y_w, y_h);
765  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
766  uvlinesize, ctx->m.uvlinesize,
767  uvlinesize / 2, 16,
768  0, 0, uv_w, uv_h);
769  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
770  uvlinesize, ctx->m.uvlinesize,
771  uvlinesize / 2, 16,
772  0, 0, uv_w, uv_h);
773 
774  dct_y_offset = bw * linesize / 2;
775  dct_uv_offset = bw * uvlinesize / 2;
776  ptr_y = &ctx->edge_buf_y[0];
777  ptr_u = &ctx->edge_buf_uv[0][0];
778  ptr_v = &ctx->edge_buf_uv[1][0];
779  }
780 
781  if (!ctx->is_444) {
782  pdsp->get_pixels(ctx->blocks[0], ptr_y, linesize);
783  pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
784  pdsp->get_pixels(ctx->blocks[2], ptr_u, uvlinesize);
785  pdsp->get_pixels(ctx->blocks[3], ptr_v, uvlinesize);
786 
787  if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
788  if (ctx->interlaced) {
789  ctx->get_pixels_8x4_sym(ctx->blocks[4],
790  ptr_y + dct_y_offset,
791  linesize);
792  ctx->get_pixels_8x4_sym(ctx->blocks[5],
793  ptr_y + dct_y_offset + bw,
794  linesize);
795  ctx->get_pixels_8x4_sym(ctx->blocks[6],
796  ptr_u + dct_uv_offset,
797  uvlinesize);
798  ctx->get_pixels_8x4_sym(ctx->blocks[7],
799  ptr_v + dct_uv_offset,
800  uvlinesize);
801  } else {
802  ctx->bdsp.clear_block(ctx->blocks[4]);
803  ctx->bdsp.clear_block(ctx->blocks[5]);
804  ctx->bdsp.clear_block(ctx->blocks[6]);
805  ctx->bdsp.clear_block(ctx->blocks[7]);
806  }
807  } else {
808  pdsp->get_pixels(ctx->blocks[4],
809  ptr_y + dct_y_offset, linesize);
810  pdsp->get_pixels(ctx->blocks[5],
811  ptr_y + dct_y_offset + bw, linesize);
812  pdsp->get_pixels(ctx->blocks[6],
813  ptr_u + dct_uv_offset, uvlinesize);
814  pdsp->get_pixels(ctx->blocks[7],
815  ptr_v + dct_uv_offset, uvlinesize);
816  }
817  } else {
818  pdsp->get_pixels(ctx->blocks[0], ptr_y, linesize);
819  pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
820  pdsp->get_pixels(ctx->blocks[6], ptr_y + dct_y_offset, linesize);
821  pdsp->get_pixels(ctx->blocks[7], ptr_y + dct_y_offset + bw, linesize);
822 
823  pdsp->get_pixels(ctx->blocks[2], ptr_u, uvlinesize);
824  pdsp->get_pixels(ctx->blocks[3], ptr_u + bw, uvlinesize);
825  pdsp->get_pixels(ctx->blocks[8], ptr_u + dct_uv_offset, uvlinesize);
826  pdsp->get_pixels(ctx->blocks[9], ptr_u + dct_uv_offset + bw, uvlinesize);
827 
828  pdsp->get_pixels(ctx->blocks[4], ptr_v, uvlinesize);
829  pdsp->get_pixels(ctx->blocks[5], ptr_v + bw, uvlinesize);
830  pdsp->get_pixels(ctx->blocks[10], ptr_v + dct_uv_offset, uvlinesize);
831  pdsp->get_pixels(ctx->blocks[11], ptr_v + dct_uv_offset + bw, uvlinesize);
832  }
833 }
834 
835 static av_always_inline
837 {
838  int x;
839 
840  if (ctx->is_444) {
841  x = (i >> 1) % 3;
842  } else {
843  const static uint8_t component[8]={0,0,1,2,0,0,1,2};
844  x = component[i];
845  }
846  return x;
847 }
848 
850  int jobnr, int threadnr)
851 {
852  DNXHDEncContext *ctx = avctx->priv_data;
853  int mb_y = jobnr, mb_x;
854  int qscale = ctx->qscale;
855  LOCAL_ALIGNED_16(int16_t, block, [64]);
856  ctx = ctx->thread[threadnr];
857 
858  ctx->m.last_dc[0] =
859  ctx->m.last_dc[1] =
860  ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
861 
862  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
863  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
864  int ssd = 0;
865  int ac_bits = 0;
866  int dc_bits = 0;
867  int i;
868 
869  dnxhd_get_blocks(ctx, mb_x, mb_y);
870 
871  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
872  int16_t *src_block = ctx->blocks[i];
873  int overflow, nbits, diff, last_index;
874  int n = dnxhd_switch_matrix(ctx, i);
875 
876  memcpy(block, src_block, 64 * sizeof(*block));
877  last_index = ctx->m.dct_quantize(&ctx->m, block,
878  ctx->is_444 ? 4 * (n > 0): 4 & (2*i),
879  qscale, &overflow);
880  ac_bits += dnxhd_calc_ac_bits(ctx, block, last_index);
881 
882  diff = block[0] - ctx->m.last_dc[n];
883  if (diff < 0)
884  nbits = av_log2_16bit(-2 * diff);
885  else
886  nbits = av_log2_16bit(2 * diff);
887 
888  av_assert1(nbits < ctx->bit_depth + 4);
889  dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
890 
891  ctx->m.last_dc[n] = block[0];
892 
893  if (avctx->mb_decision == FF_MB_DECISION_RD || !RC_VARIANCE) {
894  dnxhd_unquantize_c(ctx, block, i, qscale, last_index);
895  ctx->m.idsp.idct(block);
896  ssd += dnxhd_ssd_block(block, src_block);
897  }
898  }
899  ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].ssd = ssd;
900  ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].bits = ac_bits + dc_bits + 12 +
901  (1 + ctx->is_444) * 8 * ctx->vlc_bits[0];
902  }
903  return 0;
904 }
905 
907  int jobnr, int threadnr)
908 {
909  DNXHDEncContext *ctx = avctx->priv_data;
910  int mb_y = jobnr, mb_x;
911  ctx = ctx->thread[threadnr];
912  init_put_bits(&ctx->m.pb, (uint8_t *)arg + ctx->data_offset + ctx->slice_offs[jobnr],
913  ctx->slice_size[jobnr]);
914 
915  ctx->m.last_dc[0] =
916  ctx->m.last_dc[1] =
917  ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
918  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
919  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
920  int qscale = ctx->mb_qscale[mb];
921  int i;
922 
923  put_bits(&ctx->m.pb, 11, qscale);
924  put_bits(&ctx->m.pb, 1, avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
925 
926  dnxhd_get_blocks(ctx, mb_x, mb_y);
927 
928  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
929  int16_t *block = ctx->blocks[i];
930  int overflow, n = dnxhd_switch_matrix(ctx, i);
931  int last_index = ctx->m.dct_quantize(&ctx->m, block,
932  ctx->is_444 ? (((i >> 1) % 3) < 1 ? 0 : 4): 4 & (2*i),
933  qscale, &overflow);
934  // START_TIMER;
935  dnxhd_encode_block(ctx, block, last_index, n);
936  // STOP_TIMER("encode_block");
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:2913
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:679
#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:708
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:720
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:896
#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: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:403
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
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:1775
unsigned dct_uv_offset
Definition: dnxhdenc.h:63
static av_always_inline void dnxhd_encode_dc(DNXHDEncContext *ctx, int diff)
Definition: dnxhdenc.c:590
static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
Definition: dnxhdenc.c:205
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:206
static AVPacket pkt
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2796
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:2898
#define sample
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
AVCodec.
Definition: avcodec.h:3481
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:689
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:1067
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:1477
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:330
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:266
#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
high precision timer, useful to profile code
#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:1509
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:836
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:849
#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:88
#define RC_VARIANCE
Definition: dnxhdenc.c:42
int qmax
maximum quantizer
Definition: avcodec.h:2414
#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:2843
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:631
#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:1645
static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
Definition: dnxhdenc.c:554
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:3488
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
uint8_t bits
Definition: vp3data.h:202
#define FF_PROFILE_DNXHR_LB
Definition: avcodec.h:2914
#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:120
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1037
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:1483
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
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: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:605
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:1738
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: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:2836
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:418
ScanTable scantable
Definition: dnxhddec.c:66
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:2053
void ff_dnxhd_print_profiles(AVCodecContext *avctx, int loglevel)
Definition: dnxhddata.c:1163
#define FF_PROFILE_DNXHR_HQ
Definition: avcodec.h:2916
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:2824
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:1041
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:2884
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: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:1565
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:346
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:1590
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:2056
#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:2915
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:388
#define DNX10BIT_QMAT_SHIFT
Definition: dnxhdenc.c:41
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:207
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:2917
static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
Definition: dnxhdenc.c:906
static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
Definition: dnxhdenc.c:365
#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: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:2815
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:48
#define FF_PROFILE_DNXHR_444
Definition: avcodec.h:2918
void * priv_data
Definition: avcodec.h:1592
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:52
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:1454
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