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