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