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  default:
368  "pixel format is incompatible with DNxHD\n");
369  return AVERROR(EINVAL);
370  }
371 
372  if ((ctx->profile == FF_PROFILE_DNXHR_444 && (avctx->pix_fmt != AV_PIX_FMT_YUV444P10 &&
377  "pixel format is incompatible with DNxHD profile\n");
378  return AVERROR(EINVAL);
379  }
380 
381  if (ctx->profile == FF_PROFILE_DNXHR_HQX && avctx->pix_fmt != AV_PIX_FMT_YUV422P10) {
383  "pixel format is incompatible with DNxHR HQX profile\n");
384  return AVERROR(EINVAL);
385  }
386 
387  if ((ctx->profile == FF_PROFILE_DNXHR_LB ||
388  ctx->profile == FF_PROFILE_DNXHR_SQ ||
391  "pixel format is incompatible with DNxHR LB/SQ/HQ profile\n");
392  return AVERROR(EINVAL);
393  }
394 
395  ctx->is_444 = ctx->profile == FF_PROFILE_DNXHR_444;
396  avctx->profile = ctx->profile;
397  ctx->cid = ff_dnxhd_find_cid(avctx, ctx->bit_depth);
398  if (!ctx->cid) {
400  "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n");
402  return AVERROR(EINVAL);
403  }
404  av_log(avctx, AV_LOG_DEBUG, "cid %d\n", ctx->cid);
405 
406  if (ctx->cid >= 1270 && ctx->cid <= 1274)
407  avctx->codec_tag = MKTAG('A','V','d','h');
408 
409  if (avctx->width < 256 || avctx->height < 120) {
411  "Input dimensions too small, input must be at least 256x120\n");
412  return AVERROR(EINVAL);
413  }
414 
415  ctx->cid_table = ff_dnxhd_get_cid_table(ctx->cid);
416  av_assert0(ctx->cid_table);
417 
418  ctx->m.avctx = avctx;
419  ctx->m.mb_intra = 1;
420  ctx->m.h263_aic = 1;
421 
422  avctx->bits_per_raw_sample = ctx->bit_depth;
423 
424  ff_blockdsp_init(&ctx->bdsp, avctx);
425  ff_fdctdsp_init(&ctx->m.fdsp, avctx);
426  ff_mpv_idct_init(&ctx->m);
427  ff_mpegvideoencdsp_init(&ctx->m.mpvencdsp, avctx);
428  ff_pixblockdsp_init(&ctx->m.pdsp, avctx);
429  ff_dct_encode_init(&ctx->m);
430 
431  if (ctx->profile != FF_PROFILE_DNXHD)
432  ff_videodsp_init(&ctx->m.vdsp, ctx->bit_depth);
433 
434  if (!ctx->m.dct_quantize)
435  ctx->m.dct_quantize = ff_dct_quantize_c;
436 
437  if (ctx->is_444 || ctx->profile == FF_PROFILE_DNXHR_HQX) {
438  ctx->m.dct_quantize = dnxhd_10bit_dct_quantize_444;
439  ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym;
440  ctx->block_width_l2 = 4;
441  } else if (ctx->bit_depth == 10) {
442  ctx->m.dct_quantize = dnxhd_10bit_dct_quantize;
443  ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym;
444  ctx->block_width_l2 = 4;
445  } else {
446  ctx->get_pixels_8x4_sym = dnxhd_8bit_get_pixels_8x4_sym;
447  ctx->block_width_l2 = 3;
448  }
449 
450  if (ARCH_X86)
452 
453  ctx->m.mb_height = (avctx->height + 15) / 16;
454  ctx->m.mb_width = (avctx->width + 15) / 16;
455 
457  ctx->interlaced = 1;
458  ctx->m.mb_height /= 2;
459  }
460 
461  if (ctx->interlaced && ctx->profile != FF_PROFILE_DNXHD) {
463  "Interlaced encoding is not supported for DNxHR profiles.\n");
464  return AVERROR(EINVAL);
465  }
466 
467  ctx->m.mb_num = ctx->m.mb_height * ctx->m.mb_width;
468 
469  if (ctx->cid_table->frame_size == DNXHD_VARIABLE) {
470  ctx->frame_size = avpriv_dnxhd_get_hr_frame_size(ctx->cid,
471  avctx->width, avctx->height);
472  av_assert0(ctx->frame_size >= 0);
473  ctx->coding_unit_size = ctx->frame_size;
474  } else {
475  ctx->frame_size = ctx->cid_table->frame_size;
476  ctx->coding_unit_size = ctx->cid_table->coding_unit_size;
477  }
478 
479  if (ctx->m.mb_height > 68)
480  ctx->data_offset = 0x170 + (ctx->m.mb_height << 2);
481  else
482  ctx->data_offset = 0x280;
483 
484  // XXX tune lbias/cbias
485  if ((ret = dnxhd_init_qmat(ctx, ctx->intra_quant_bias, 0)) < 0)
486  return ret;
487 
488  /* Avid Nitris hardware decoder requires a minimum amount of padding
489  * in the coding unit payload */
490  if (ctx->nitris_compat)
491  ctx->min_padding = 1600;
492 
493  if ((ret = dnxhd_init_vlc(ctx)) < 0)
494  return ret;
495  if ((ret = dnxhd_init_rc(ctx)) < 0)
496  return ret;
497 
498  if (!FF_ALLOCZ_TYPED_ARRAY(ctx->slice_size, ctx->m.mb_height) ||
499  !FF_ALLOCZ_TYPED_ARRAY(ctx->slice_offs, ctx->m.mb_height) ||
500  !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_bits, ctx->m.mb_num) ||
501  !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_qscale, ctx->m.mb_num))
502  return AVERROR(ENOMEM);
503 
505  if (avctx->thread_count > MAX_THREADS) {
506  av_log(avctx, AV_LOG_ERROR, "too many threads\n");
507  return AVERROR(EINVAL);
508  }
509  }
510 
511  if (avctx->qmax <= 1) {
512  av_log(avctx, AV_LOG_ERROR, "qmax must be at least 2\n");
513  return AVERROR(EINVAL);
514  }
515 
516  ctx->thread[0] = ctx;
518  for (i = 1; i < avctx->thread_count; i++) {
519  ctx->thread[i] = av_memdup(ctx, sizeof(DNXHDEncContext));
520  if (!ctx->thread[i])
521  return AVERROR(ENOMEM);
522  }
523  }
524 
525  return 0;
526 }
527 
529 {
531 
532  memset(buf, 0, ctx->data_offset);
533 
534  // * write prefix */
535  AV_WB16(buf + 0x02, ctx->data_offset);
536  if (ctx->cid >= 1270 && ctx->cid <= 1274)
537  buf[4] = 0x03;
538  else
539  buf[4] = 0x01;
540 
541  buf[5] = ctx->interlaced ? ctx->cur_field + 2 : 0x01;
542  buf[6] = 0x80; // crc flag off
543  buf[7] = 0xa0; // reserved
544  AV_WB16(buf + 0x18, avctx->height >> ctx->interlaced); // ALPF
545  AV_WB16(buf + 0x1a, avctx->width); // SPL
546  AV_WB16(buf + 0x1d, avctx->height >> ctx->interlaced); // NAL
547 
548  buf[0x21] = ctx->bit_depth == 10 ? 0x58 : 0x38;
549  buf[0x22] = 0x88 + (ctx->interlaced << 2);
550  AV_WB32(buf + 0x28, ctx->cid); // CID
551  buf[0x2c] = (!ctx->interlaced << 7) | (ctx->is_444 << 6) | (avctx->pix_fmt == AV_PIX_FMT_YUV444P10);
552 
553  buf[0x5f] = 0x01; // UDL
554 
555  buf[0x167] = 0x02; // reserved
556  AV_WB16(buf + 0x16a, ctx->m.mb_height * 4 + 4); // MSIPS
557  AV_WB16(buf + 0x16c, ctx->m.mb_height); // Ns
558  buf[0x16f] = 0x10; // reserved
559 
560  ctx->msip = buf + 0x170;
561  return 0;
562 }
563 
565 {
566  int nbits;
567  if (diff < 0) {
568  nbits = av_log2_16bit(-2 * diff);
569  diff--;
570  } else {
571  nbits = av_log2_16bit(2 * diff);
572  }
573  put_bits(&ctx->m.pb, ctx->cid_table->dc_bits[nbits] + nbits,
574  (ctx->cid_table->dc_codes[nbits] << nbits) +
575  av_mod_uintp2(diff, nbits));
576 }
577 
578 static av_always_inline
580  int last_index, int n)
581 {
582  int last_non_zero = 0;
583  int slevel, i, j;
584 
585  dnxhd_encode_dc(ctx, block[0] - ctx->m.last_dc[n]);
586  ctx->m.last_dc[n] = block[0];
587 
588  for (i = 1; i <= last_index; i++) {
589  j = ctx->m.intra_scantable.permutated[i];
590  slevel = block[j];
591  if (slevel) {
592  int run_level = i - last_non_zero - 1;
593  int rlevel = slevel * (1 << 1) | !!run_level;
594  put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
595  if (run_level)
596  put_bits(&ctx->m.pb, ctx->run_bits[run_level],
597  ctx->run_codes[run_level]);
598  last_non_zero = i;
599  }
600  }
601  put_bits(&ctx->m.pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB
602 }
603 
604 static av_always_inline
606  int qscale, int last_index)
607 {
608  const uint8_t *weight_matrix;
609  int level;
610  int i;
611 
612  if (ctx->is_444) {
613  weight_matrix = ((n % 6) < 2) ? ctx->cid_table->luma_weight
614  : ctx->cid_table->chroma_weight;
615  } else {
616  weight_matrix = (n & 2) ? ctx->cid_table->chroma_weight
617  : ctx->cid_table->luma_weight;
618  }
619 
620  for (i = 1; i <= last_index; i++) {
621  int j = ctx->m.intra_scantable.permutated[i];
622  level = block[j];
623  if (level) {
624  if (level < 0) {
625  level = (1 - 2 * level) * qscale * weight_matrix[i];
626  if (ctx->bit_depth == 10) {
627  if (weight_matrix[i] != 8)
628  level += 8;
629  level >>= 4;
630  } else {
631  if (weight_matrix[i] != 32)
632  level += 32;
633  level >>= 6;
634  }
635  level = -level;
636  } else {
637  level = (2 * level + 1) * qscale * weight_matrix[i];
638  if (ctx->bit_depth == 10) {
639  if (weight_matrix[i] != 8)
640  level += 8;
641  level >>= 4;
642  } else {
643  if (weight_matrix[i] != 32)
644  level += 32;
645  level >>= 6;
646  }
647  }
648  block[j] = level;
649  }
650  }
651 }
652 
653 static av_always_inline int dnxhd_ssd_block(int16_t *qblock, int16_t *block)
654 {
655  int score = 0;
656  int i;
657  for (i = 0; i < 64; i++)
658  score += (block[i] - qblock[i]) * (block[i] - qblock[i]);
659  return score;
660 }
661 
662 static av_always_inline
663 int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
664 {
665  int last_non_zero = 0;
666  int bits = 0;
667  int i, j, level;
668  for (i = 1; i <= last_index; i++) {
669  j = ctx->m.intra_scantable.permutated[i];
670  level = block[j];
671  if (level) {
672  int run_level = i - last_non_zero - 1;
673  bits += ctx->vlc_bits[level * (1 << 1) |
674  !!run_level] + ctx->run_bits[run_level];
675  last_non_zero = i;
676  }
677  }
678  return bits;
679 }
680 
681 static av_always_inline
682 void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
683 {
684  const int bs = ctx->block_width_l2;
685  const int bw = 1 << bs;
686  int dct_y_offset = ctx->dct_y_offset;
687  int dct_uv_offset = ctx->dct_uv_offset;
688  int linesize = ctx->m.linesize;
689  int uvlinesize = ctx->m.uvlinesize;
690  const uint8_t *ptr_y = ctx->thread[0]->src[0] +
691  ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs + 1);
692  const uint8_t *ptr_u = ctx->thread[0]->src[1] +
693  ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
694  const uint8_t *ptr_v = ctx->thread[0]->src[2] +
695  ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444);
696  PixblockDSPContext *pdsp = &ctx->m.pdsp;
697  VideoDSPContext *vdsp = &ctx->m.vdsp;
698 
699  if (ctx->bit_depth != 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
700  (mb_y << 4) + 16 > ctx->m.avctx->height)) {
701  int y_w = ctx->m.avctx->width - (mb_x << 4);
702  int y_h = ctx->m.avctx->height - (mb_y << 4);
703  int uv_w = (y_w + 1) / 2;
704  int uv_h = y_h;
705  linesize = 16;
706  uvlinesize = 8;
707 
708  vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
709  linesize, ctx->m.linesize,
710  linesize, 16,
711  0, 0, y_w, y_h);
712  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
713  uvlinesize, ctx->m.uvlinesize,
714  uvlinesize, 16,
715  0, 0, uv_w, uv_h);
716  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
717  uvlinesize, ctx->m.uvlinesize,
718  uvlinesize, 16,
719  0, 0, uv_w, uv_h);
720 
721  dct_y_offset = bw * linesize;
722  dct_uv_offset = bw * uvlinesize;
723  ptr_y = &ctx->edge_buf_y[0];
724  ptr_u = &ctx->edge_buf_uv[0][0];
725  ptr_v = &ctx->edge_buf_uv[1][0];
726  } else if (ctx->bit_depth == 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width ||
727  (mb_y << 4) + 16 > ctx->m.avctx->height)) {
728  int y_w = ctx->m.avctx->width - (mb_x << 4);
729  int y_h = ctx->m.avctx->height - (mb_y << 4);
730  int uv_w = ctx->is_444 ? y_w : (y_w + 1) / 2;
731  int uv_h = y_h;
732  linesize = 32;
733  uvlinesize = 16 + 16 * ctx->is_444;
734 
735  vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y,
736  linesize, ctx->m.linesize,
737  linesize / 2, 16,
738  0, 0, y_w, y_h);
739  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u,
740  uvlinesize, ctx->m.uvlinesize,
741  uvlinesize / 2, 16,
742  0, 0, uv_w, uv_h);
743  vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v,
744  uvlinesize, ctx->m.uvlinesize,
745  uvlinesize / 2, 16,
746  0, 0, uv_w, uv_h);
747 
748  dct_y_offset = bw * linesize / 2;
749  dct_uv_offset = bw * uvlinesize / 2;
750  ptr_y = &ctx->edge_buf_y[0];
751  ptr_u = &ctx->edge_buf_uv[0][0];
752  ptr_v = &ctx->edge_buf_uv[1][0];
753  }
754 
755  if (!ctx->is_444) {
756  pdsp->get_pixels(ctx->blocks[0], ptr_y, linesize);
757  pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
758  pdsp->get_pixels(ctx->blocks[2], ptr_u, uvlinesize);
759  pdsp->get_pixels(ctx->blocks[3], ptr_v, uvlinesize);
760 
761  if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
762  if (ctx->interlaced) {
763  ctx->get_pixels_8x4_sym(ctx->blocks[4],
764  ptr_y + dct_y_offset,
765  linesize);
766  ctx->get_pixels_8x4_sym(ctx->blocks[5],
767  ptr_y + dct_y_offset + bw,
768  linesize);
769  ctx->get_pixels_8x4_sym(ctx->blocks[6],
770  ptr_u + dct_uv_offset,
771  uvlinesize);
772  ctx->get_pixels_8x4_sym(ctx->blocks[7],
773  ptr_v + dct_uv_offset,
774  uvlinesize);
775  } else {
776  ctx->bdsp.clear_block(ctx->blocks[4]);
777  ctx->bdsp.clear_block(ctx->blocks[5]);
778  ctx->bdsp.clear_block(ctx->blocks[6]);
779  ctx->bdsp.clear_block(ctx->blocks[7]);
780  }
781  } else {
782  pdsp->get_pixels(ctx->blocks[4],
783  ptr_y + dct_y_offset, linesize);
784  pdsp->get_pixels(ctx->blocks[5],
785  ptr_y + dct_y_offset + bw, linesize);
786  pdsp->get_pixels(ctx->blocks[6],
787  ptr_u + dct_uv_offset, uvlinesize);
788  pdsp->get_pixels(ctx->blocks[7],
789  ptr_v + dct_uv_offset, uvlinesize);
790  }
791  } else {
792  pdsp->get_pixels(ctx->blocks[0], ptr_y, linesize);
793  pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize);
794  pdsp->get_pixels(ctx->blocks[6], ptr_y + dct_y_offset, linesize);
795  pdsp->get_pixels(ctx->blocks[7], ptr_y + dct_y_offset + bw, linesize);
796 
797  pdsp->get_pixels(ctx->blocks[2], ptr_u, uvlinesize);
798  pdsp->get_pixels(ctx->blocks[3], ptr_u + bw, uvlinesize);
799  pdsp->get_pixels(ctx->blocks[8], ptr_u + dct_uv_offset, uvlinesize);
800  pdsp->get_pixels(ctx->blocks[9], ptr_u + dct_uv_offset + bw, uvlinesize);
801 
802  pdsp->get_pixels(ctx->blocks[4], ptr_v, uvlinesize);
803  pdsp->get_pixels(ctx->blocks[5], ptr_v + bw, uvlinesize);
804  pdsp->get_pixels(ctx->blocks[10], ptr_v + dct_uv_offset, uvlinesize);
805  pdsp->get_pixels(ctx->blocks[11], ptr_v + dct_uv_offset + bw, uvlinesize);
806  }
807 }
808 
809 static av_always_inline
811 {
812  int x;
813 
814  if (ctx->is_444) {
815  x = (i >> 1) % 3;
816  } else {
817  const static uint8_t component[8]={0,0,1,2,0,0,1,2};
818  x = component[i];
819  }
820  return x;
821 }
822 
824  int jobnr, int threadnr)
825 {
827  int mb_y = jobnr, mb_x;
828  int qscale = ctx->qscale;
829  LOCAL_ALIGNED_16(int16_t, block, [64]);
830  ctx = ctx->thread[threadnr];
831 
832  ctx->m.last_dc[0] =
833  ctx->m.last_dc[1] =
834  ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
835 
836  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
837  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
838  int ssd = 0;
839  int ac_bits = 0;
840  int dc_bits = 0;
841  int i;
842 
843  dnxhd_get_blocks(ctx, mb_x, mb_y);
844 
845  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
846  int16_t *src_block = ctx->blocks[i];
847  int overflow, nbits, diff, last_index;
848  int n = dnxhd_switch_matrix(ctx, i);
849 
850  memcpy(block, src_block, 64 * sizeof(*block));
851  last_index = ctx->m.dct_quantize(&ctx->m, block,
852  ctx->is_444 ? 4 * (n > 0): 4 & (2*i),
853  qscale, &overflow);
854  ac_bits += dnxhd_calc_ac_bits(ctx, block, last_index);
855 
856  diff = block[0] - ctx->m.last_dc[n];
857  if (diff < 0)
858  nbits = av_log2_16bit(-2 * diff);
859  else
860  nbits = av_log2_16bit(2 * diff);
861 
862  av_assert1(nbits < ctx->bit_depth + 4);
863  dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
864 
865  ctx->m.last_dc[n] = block[0];
866 
868  dnxhd_unquantize_c(ctx, block, i, qscale, last_index);
869  ctx->m.idsp.idct(block);
870  ssd += dnxhd_ssd_block(block, src_block);
871  }
872  }
873  ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].ssd = ssd;
874  ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].bits = ac_bits + dc_bits + 12 +
875  (1 + ctx->is_444) * 8 * ctx->vlc_bits[0];
876  }
877  return 0;
878 }
879 
881  int jobnr, int threadnr)
882 {
884  int mb_y = jobnr, mb_x;
885  ctx = ctx->thread[threadnr];
886  init_put_bits(&ctx->m.pb, (uint8_t *)arg + ctx->data_offset + ctx->slice_offs[jobnr],
887  ctx->slice_size[jobnr]);
888 
889  ctx->m.last_dc[0] =
890  ctx->m.last_dc[1] =
891  ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2);
892  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
893  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
894  int qscale = ctx->mb_qscale[mb];
895  int i;
896 
897  put_bits(&ctx->m.pb, 11, qscale);
899 
900  dnxhd_get_blocks(ctx, mb_x, mb_y);
901 
902  for (i = 0; i < 8 + 4 * ctx->is_444; i++) {
903  int16_t *block = ctx->blocks[i];
904  int overflow, n = dnxhd_switch_matrix(ctx, i);
905  int last_index = ctx->m.dct_quantize(&ctx->m, block,
906  ctx->is_444 ? (((i >> 1) % 3) < 1 ? 0 : 4): 4 & (2*i),
907  qscale, &overflow);
908 
909  dnxhd_encode_block(ctx, block, last_index, n);
910  }
911  }
912  if (put_bits_count(&ctx->m.pb) & 31)
913  put_bits(&ctx->m.pb, 32 - (put_bits_count(&ctx->m.pb) & 31), 0);
914  flush_put_bits(&ctx->m.pb);
915  return 0;
916 }
917 
919 {
920  int mb_y, mb_x;
921  int offset = 0;
922  for (mb_y = 0; mb_y < ctx->m.mb_height; mb_y++) {
923  int thread_size;
924  ctx->slice_offs[mb_y] = offset;
925  ctx->slice_size[mb_y] = 0;
926  for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
927  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
928  ctx->slice_size[mb_y] += ctx->mb_bits[mb];
929  }
930  ctx->slice_size[mb_y] = (ctx->slice_size[mb_y] + 31) & ~31;
931  ctx->slice_size[mb_y] >>= 3;
932  thread_size = ctx->slice_size[mb_y];
933  offset += thread_size;
934  }
935 }
936 
938  int jobnr, int threadnr)
939 {
941  int mb_y = jobnr, mb_x, x, y;
942  int partial_last_row = (mb_y == ctx->m.mb_height - 1) &&
943  ((avctx->height >> ctx->interlaced) & 0xF);
944 
945  ctx = ctx->thread[threadnr];
946  if (ctx->bit_depth == 8) {
947  uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y << 4) * ctx->m.linesize);
948  for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x, pix += 16) {
949  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
950  int sum;
951  int varc;
952 
953  if (!partial_last_row && mb_x * 16 <= avctx->width - 16 && (avctx->width % 16) == 0) {
954  sum = ctx->m.mpvencdsp.pix_sum(pix, ctx->m.linesize);
955  varc = ctx->m.mpvencdsp.pix_norm1(pix, ctx->m.linesize);
956  } else {
957  int bw = FFMIN(avctx->width - 16 * mb_x, 16);
958  int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16);
959  sum = varc = 0;
960  for (y = 0; y < bh; y++) {
961  for (x = 0; x < bw; x++) {
962  uint8_t val = pix[x + y * ctx->m.linesize];
963  sum += val;
964  varc += val * val;
965  }
966  }
967  }
968  varc = (varc - (((unsigned) sum * sum) >> 8) + 128) >> 8;
969 
970  ctx->mb_cmp[mb].value = varc;
971  ctx->mb_cmp[mb].mb = mb;
972  }
973  } else { // 10-bit
974  const int linesize = ctx->m.linesize >> 1;
975  for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) {
976  uint16_t *pix = (uint16_t *)ctx->thread[0]->src[0] +
977  ((mb_y << 4) * linesize) + (mb_x << 4);
978  unsigned mb = mb_y * ctx->m.mb_width + mb_x;
979  int sum = 0;
980  int sqsum = 0;
981  int bw = FFMIN(avctx->width - 16 * mb_x, 16);
982  int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16);
983  int mean, sqmean;
984  int i, j;
985  // Macroblocks are 16x16 pixels, unlike DCT blocks which are 8x8.
986  for (i = 0; i < bh; ++i) {
987  for (j = 0; j < bw; ++j) {
988  // Turn 16-bit pixels into 10-bit ones.
989  const int sample = (unsigned) pix[j] >> 6;
990  sum += sample;
991  sqsum += sample * sample;
992  // 2^10 * 2^10 * 16 * 16 = 2^28, which is less than INT_MAX
993  }
994  pix += linesize;
995  }
996  mean = sum >> 8; // 16*16 == 2^8
997  sqmean = sqsum >> 8;
998  ctx->mb_cmp[mb].value = sqmean - mean * mean;
999  ctx->mb_cmp[mb].mb = mb;
1000  }
1001  }
1002  return 0;
1003 }
1004 
1006 {
1007  int lambda, up_step, down_step;
1008  int last_lower = INT_MAX, last_higher = 0;
1009  int x, y, q;
1010 
1011  for (q = 1; q < avctx->qmax; q++) {
1012  ctx->qscale = q;
1014  NULL, NULL, ctx->m.mb_height);
1015  }
1016  up_step = down_step = 2 << LAMBDA_FRAC_BITS;
1017  lambda = ctx->lambda;
1018 
1019  for (;;) {
1020  int bits = 0;
1021  int end = 0;
1022  if (lambda == last_higher) {
1023  lambda++;
1024  end = 1; // need to set final qscales/bits
1025  }
1026  for (y = 0; y < ctx->m.mb_height; y++) {
1027  for (x = 0; x < ctx->m.mb_width; x++) {
1028  unsigned min = UINT_MAX;
1029  int qscale = 1;
1030  int mb = y * ctx->m.mb_width + x;
1031  int rc = 0;
1032  for (q = 1; q < avctx->qmax; q++) {
1033  int i = (q*ctx->m.mb_num) + mb;
1034  unsigned score = ctx->mb_rc[i].bits * lambda +
1035  ((unsigned) ctx->mb_rc[i].ssd << LAMBDA_FRAC_BITS);
1036  if (score < min) {
1037  min = score;
1038  qscale = q;
1039  rc = i;
1040  }
1041  }
1042  bits += ctx->mb_rc[rc].bits;
1043  ctx->mb_qscale[mb] = qscale;
1044  ctx->mb_bits[mb] = ctx->mb_rc[rc].bits;
1045  }
1046  bits = (bits + 31) & ~31; // padding
1047  if (bits > ctx->frame_bits)
1048  break;
1049  }
1050  if (end) {
1051  if (bits > ctx->frame_bits)
1052  return AVERROR(EINVAL);
1053  break;
1054  }
1055  if (bits < ctx->frame_bits) {
1056  last_lower = FFMIN(lambda, last_lower);
1057  if (last_higher != 0)
1058  lambda = (lambda+last_higher)>>1;
1059  else
1060  lambda -= down_step;
1061  down_step = FFMIN((int64_t)down_step*5, INT_MAX);
1062  up_step = 1<<LAMBDA_FRAC_BITS;
1063  lambda = FFMAX(1, lambda);
1064  if (lambda == last_lower)
1065  break;
1066  } else {
1067  last_higher = FFMAX(lambda, last_higher);
1068  if (last_lower != INT_MAX)
1069  lambda = (lambda+last_lower)>>1;
1070  else if ((int64_t)lambda + up_step > INT_MAX)
1071  return AVERROR(EINVAL);
1072  else
1073  lambda += up_step;
1074  up_step = FFMIN((int64_t)up_step*5, INT_MAX);
1075  down_step = 1<<LAMBDA_FRAC_BITS;
1076  }
1077  }
1078  ctx->lambda = lambda;
1079  return 0;
1080 }
1081 
1083 {
1084  int bits = 0;
1085  int up_step = 1;
1086  int down_step = 1;
1087  int last_higher = 0;
1088  int last_lower = INT_MAX;
1089  int qscale;
1090  int x, y;
1091 
1092  qscale = ctx->qscale;
1093  for (;;) {
1094  bits = 0;
1095  ctx->qscale = qscale;
1096  // XXX avoid recalculating bits
1097  ctx->m.avctx->execute2(ctx->m.avctx, dnxhd_calc_bits_thread,
1098  NULL, NULL, ctx->m.mb_height);
1099  for (y = 0; y < ctx->m.mb_height; y++) {
1100  for (x = 0; x < ctx->m.mb_width; x++)
1101  bits += ctx->mb_rc[(qscale*ctx->m.mb_num) + (y*ctx->m.mb_width+x)].bits;
1102  bits = (bits+31)&~31; // padding
1103  if (bits > ctx->frame_bits)
1104  break;
1105  }
1106  if (bits < ctx->frame_bits) {
1107  if (qscale == 1)
1108  return 1;
1109  if (last_higher == qscale - 1) {
1110  qscale = last_higher;
1111  break;
1112  }
1113  last_lower = FFMIN(qscale, last_lower);
1114  if (last_higher != 0)
1115  qscale = (qscale + last_higher) >> 1;
1116  else
1117  qscale -= down_step++;
1118  if (qscale < 1)
1119  qscale = 1;
1120  up_step = 1;
1121  } else {
1122  if (last_lower == qscale + 1)
1123  break;
1124  last_higher = FFMAX(qscale, last_higher);
1125  if (last_lower != INT_MAX)
1126  qscale = (qscale + last_lower) >> 1;
1127  else
1128  qscale += up_step++;
1129  down_step = 1;
1130  if (qscale >= ctx->m.avctx->qmax)
1131  return AVERROR(EINVAL);
1132  }
1133  }
1134  ctx->qscale = qscale;
1135  return 0;
1136 }
1137 
1138 #define BUCKET_BITS 8
1139 #define RADIX_PASSES 4
1140 #define NBUCKETS (1 << BUCKET_BITS)
1141 
1142 static inline int get_bucket(int value, int shift)
1143 {
1144  value >>= shift;
1145  value &= NBUCKETS - 1;
1146  return NBUCKETS - 1 - value;
1147 }
1148 
1149 static void radix_count(const RCCMPEntry *data, int size,
1150  int buckets[RADIX_PASSES][NBUCKETS])
1151 {
1152  int i, j;
1153  memset(buckets, 0, sizeof(buckets[0][0]) * RADIX_PASSES * NBUCKETS);
1154  for (i = 0; i < size; i++) {
1155  int v = data[i].value;
1156  for (j = 0; j < RADIX_PASSES; j++) {
1157  buckets[j][get_bucket(v, 0)]++;
1158  v >>= BUCKET_BITS;
1159  }
1160  av_assert1(!v);
1161  }
1162  for (j = 0; j < RADIX_PASSES; j++) {
1163  int offset = size;
1164  for (i = NBUCKETS - 1; i >= 0; i--)
1165  buckets[j][i] = offset -= buckets[j][i];
1166  av_assert1(!buckets[j][0]);
1167  }
1168 }
1169 
1170 static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data,
1171  int size, int buckets[NBUCKETS], int pass)
1172 {
1173  int shift = pass * BUCKET_BITS;
1174  int i;
1175  for (i = 0; i < size; i++) {
1176  int v = get_bucket(data[i].value, shift);
1177  int pos = buckets[v]++;
1178  dst[pos] = data[i];
1179  }
1180 }
1181 
1183 {
1184  int buckets[RADIX_PASSES][NBUCKETS];
1185  radix_count(data, size, buckets);
1186  radix_sort_pass(tmp, data, size, buckets[0], 0);
1187  radix_sort_pass(data, tmp, size, buckets[1], 1);
1188  if (buckets[2][NBUCKETS - 1] || buckets[3][NBUCKETS - 1]) {
1189  radix_sort_pass(tmp, data, size, buckets[2], 2);
1190  radix_sort_pass(data, tmp, size, buckets[3], 3);
1191  }
1192 }
1193 
1195 {
1196  int max_bits = 0;
1197  int ret, x, y;
1198  if ((ret = dnxhd_find_qscale(ctx)) < 0)
1199  return ret;
1200  for (y = 0; y < ctx->m.mb_height; y++) {
1201  for (x = 0; x < ctx->m.mb_width; x++) {
1202  int mb = y * ctx->m.mb_width + x;
1203  int rc = (ctx->qscale * ctx->m.mb_num ) + mb;
1204  int delta_bits;
1205  ctx->mb_qscale[mb] = ctx->qscale;
1206  ctx->mb_bits[mb] = ctx->mb_rc[rc].bits;
1207  max_bits += ctx->mb_rc[rc].bits;
1208  if (!RC_VARIANCE) {
1209  delta_bits = ctx->mb_rc[rc].bits -
1210  ctx->mb_rc[rc + ctx->m.mb_num].bits;
1211  ctx->mb_cmp[mb].mb = mb;
1212  ctx->mb_cmp[mb].value =
1213  delta_bits ? ((ctx->mb_rc[rc].ssd -
1214  ctx->mb_rc[rc + ctx->m.mb_num].ssd) * 100) /
1215  delta_bits
1216  : INT_MIN; // avoid increasing qscale
1217  }
1218  }
1219  max_bits += 31; // worst padding
1220  }
1221  if (!ret) {
1222  if (RC_VARIANCE)
1224  NULL, NULL, ctx->m.mb_height);
1225  radix_sort(ctx->mb_cmp, ctx->mb_cmp_tmp, ctx->m.mb_num);
1226  for (x = 0; x < ctx->m.mb_num && max_bits > ctx->frame_bits; x++) {
1227  int mb = ctx->mb_cmp[x].mb;
1228  int rc = (ctx->qscale * ctx->m.mb_num ) + mb;
1229  max_bits -= ctx->mb_rc[rc].bits -
1230  ctx->mb_rc[rc + ctx->m.mb_num].bits;
1231  ctx->mb_qscale[mb] = ctx->qscale + 1;
1232  ctx->mb_bits[mb] = ctx->mb_rc[rc + ctx->m.mb_num].bits;
1233  }
1234  }
1235  return 0;
1236 }
1237 
1239 {
1240  int i;
1241 
1242  for (i = 0; i < ctx->m.avctx->thread_count; i++) {
1243  ctx->thread[i]->m.linesize = frame->linesize[0] << ctx->interlaced;
1244  ctx->thread[i]->m.uvlinesize = frame->linesize[1] << ctx->interlaced;
1245  ctx->thread[i]->dct_y_offset = ctx->m.linesize *8;
1246  ctx->thread[i]->dct_uv_offset = ctx->m.uvlinesize*8;
1247  }
1248 
1249  ctx->cur_field = frame->interlaced_frame && !frame->top_field_first;
1250 }
1251 
1253  const AVFrame *frame, int *got_packet)
1254 {
1256  int first_field = 1;
1257  int offset, i, ret;
1258  uint8_t *buf;
1259 
1260  if ((ret = ff_get_encode_buffer(avctx, pkt, ctx->frame_size, 0)) < 0)
1261  return ret;
1262  buf = pkt->data;
1263 
1265 
1266 encode_coding_unit:
1267  for (i = 0; i < 3; i++) {
1268  ctx->src[i] = frame->data[i];
1269  if (ctx->interlaced && ctx->cur_field)
1270  ctx->src[i] += frame->linesize[i];
1271  }
1272 
1274 
1277  else
1279  if (ret < 0) {
1281  "picture could not fit ratecontrol constraints, increase qmax\n");
1282  return ret;
1283  }
1284 
1286 
1287  offset = 0;
1288  for (i = 0; i < ctx->m.mb_height; i++) {
1289  AV_WB32(ctx->msip + i * 4, offset);
1290  offset += ctx->slice_size[i];
1291  av_assert1(!(ctx->slice_size[i] & 3));
1292  }
1293 
1294  avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height);
1295 
1296  av_assert1(ctx->data_offset + offset + 4 <= ctx->coding_unit_size);
1297  memset(buf + ctx->data_offset + offset, 0,
1298  ctx->coding_unit_size - 4 - offset - ctx->data_offset);
1299 
1300  AV_WB32(buf + ctx->coding_unit_size - 4, 0x600DC0DE); // EOF
1301 
1302  if (ctx->interlaced && first_field) {
1303  first_field = 0;
1304  ctx->cur_field ^= 1;
1305  buf += ctx->coding_unit_size;
1306  goto encode_coding_unit;
1307  }
1308 
1310 
1312  *got_packet = 1;
1313  return 0;
1314 }
1315 
1317 {
1319  int i;
1320 
1321  av_freep(&ctx->orig_vlc_codes);
1322  av_freep(&ctx->orig_vlc_bits);
1323  av_freep(&ctx->run_codes);
1324  av_freep(&ctx->run_bits);
1325 
1326  av_freep(&ctx->mb_bits);
1327  av_freep(&ctx->mb_qscale);
1328  av_freep(&ctx->mb_rc);
1329  av_freep(&ctx->mb_cmp);
1330  av_freep(&ctx->mb_cmp_tmp);
1331  av_freep(&ctx->slice_size);
1332  av_freep(&ctx->slice_offs);
1333 
1334  av_freep(&ctx->qmatrix_c);
1335  av_freep(&ctx->qmatrix_l);
1336  av_freep(&ctx->qmatrix_c16);
1337  av_freep(&ctx->qmatrix_l16);
1338 
1339  if (ctx->thread[1]) {
1340  for (i = 1; i < avctx->thread_count; i++)
1341  av_freep(&ctx->thread[i]);
1342  }
1343 
1344  return 0;
1345 }
1346 
1347 static const AVCodecDefault dnxhd_defaults[] = {
1348  { "qmax", "1024" }, /* Maximum quantization scale factor allowed for VC-3 */
1349  { NULL },
1350 };
1351 
1353  .name = "dnxhd",
1354  .long_name = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
1355  .type = AVMEDIA_TYPE_VIDEO,
1356  .id = AV_CODEC_ID_DNXHD,
1357  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
1359  .priv_data_size = sizeof(DNXHDEncContext),
1361  .encode2 = dnxhd_encode_picture,
1362  .close = dnxhd_encode_end,
1363  .pix_fmts = (const enum AVPixelFormat[]) {
1369  },
1370  .priv_class = &dnxhd_class,
1371  .defaults = dnxhd_defaults,
1374 };
FF_ALLOCZ_TYPED_ARRAY
#define FF_ALLOCZ_TYPED_ARRAY(p, nelem)
Definition: internal.h:102
dnxhd_encode_init
static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
Definition: dnxhdenc.c:352
AVCodec
AVCodec.
Definition: codec.h:197
bit_depth
static void bit_depth(AudioStatsContext *s, uint64_t mask, uint64_t imask, AVRational *depth)
Definition: af_astats.c:254
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:579
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:663
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:4478
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:1194
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:1536
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:1138
RADIX_PASSES
#define RADIX_PASSES
Definition: dnxhdenc.c:1139
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:528
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
dnxhd_encode_rdo
static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
Definition: dnxhdenc.c:1005
AVCodecContext::mb_decision
int mb_decision
macroblock decision mode
Definition: avcodec.h:852
AVCodecContext::qmax
int qmax
maximum quantizer
Definition: avcodec.h:1161
dnxhd_encode_end
static av_cold int dnxhd_encode_end(AVCodecContext *avctx)
Definition: dnxhdenc.c:1316
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:291
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:564
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1436
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:405
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:459
MAX_THREADS
#define MAX_THREADS
Definition: frame_thread_encoder.c:34
val
static double val(void *priv, double ch)
Definition: aeval.c:75
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:880
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:1537
DNXHDEncContext
Definition: dnxhdenc.h:46
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:256
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:392
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:937
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:1421
dnxhd_load_picture
static void dnxhd_load_picture(DNXHDEncContext *ctx, const AVFrame *frame)
Definition: dnxhdenc.c:1238
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:1182
pass
#define pass
Definition: fft_template.c:603
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:213
FF_PROFILE_DNXHR_HQ
#define FF_PROFILE_DNXHR_HQ
Definition: avcodec.h:1539
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:108
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:1170
ff_dct_quantize_c
int ff_dct_quantize_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow)
Definition: mpegvideo_enc.c:4503
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:1149
profiles.h
radix_count
static void radix_count(const RCCMPEntry *data, int size, int buckets[RADIX_PASSES][NBUCKETS])
Definition: dnxhdenc.c:1149
dnxhd_class
static const AVClass dnxhd_class
Definition: dnxhdenc.c:72
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:390
dnxhd_setup_threads_slices
static void dnxhd_setup_threads_slices(DNXHDEncContext *ctx)
Definition: dnxhdenc.c:918
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:1252
FF_SIGNBIT
#define FF_SIGNBIT(x)
Definition: internal.h:110
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:116
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:1448
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:653
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:112
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
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
dnxhd_find_qscale
static int dnxhd_find_qscale(DNXHDEncContext *ctx)
Definition: dnxhdenc.c:1082
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
i
int i
Definition: input.c:406
FF_PROFILE_DNXHR_SQ
#define FF_PROFILE_DNXHR_SQ
Definition: avcodec.h:1538
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
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:243
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:552
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:589
avcodec.h
ff_dnxhd_encoder
const AVCodec ff_dnxhd_encoder
Definition: dnxhdenc.c:1352
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:1142
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:379
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1455
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:682
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1521
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:810
mean
static float mean(const float *input, int size)
Definition: vf_nnedi.c:862
FF_PROFILE_DNXHR_HQX
#define FF_PROFILE_DNXHR_HQX
Definition: avcodec.h:1540
VideoDSPContext
Definition: videodsp.h:41
FF_MB_DECISION_RD
#define FF_MB_DECISION_RD
rate distortion
Definition: avcodec.h:855
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:136
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:404
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
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:1541
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:552
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:823
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:81
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:1507
RC_VARIANCE
#define RC_VARIANCE
Definition: dnxhdenc.c:44
NBUCKETS
#define NBUCKETS
Definition: dnxhdenc.c:1140
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:605
pixblockdsp.h
dnxhd_defaults
static const AVCodecDefault dnxhd_defaults[]
Definition: dnxhdenc.c:1347
DNXHDContext::scantable
ScanTable scantable
Definition: dnxhddec.c:67
min
float min
Definition: vorbis_enc_data.h:429