FFmpeg
vc2enc.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2016 Open Broadcast Systems Ltd.
3  * Author 2016 Rostislav Pehlivanov <atomnuker@gmail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/pixdesc.h"
23 #include "libavutil/opt.h"
24 #include "dirac.h"
25 #include "encode.h"
26 #include "put_bits.h"
27 #include "internal.h"
28 #include "version.h"
29 
30 #include "vc2enc_dwt.h"
31 #include "diractab.h"
32 
33 /* The limited size resolution of each slice forces us to do this */
34 #define SSIZE_ROUND(b) (FFALIGN((b), s->size_scaler) + 4 + s->prefix_bytes)
35 
36 /* Decides the cutoff point in # of slices to distribute the leftover bytes */
37 #define SLICE_REDIST_TOTAL 150
38 
39 typedef struct VC2BaseVideoFormat {
43  const char *name;
45 
47  { 0 }, /* Custom format, here just to make indexing equal to base_vf */
48  { AV_PIX_FMT_YUV420P, { 1001, 15000 }, 176, 120, 0, 1, "QSIF525" },
49  { AV_PIX_FMT_YUV420P, { 2, 25 }, 176, 144, 0, 1, "QCIF" },
50  { AV_PIX_FMT_YUV420P, { 1001, 15000 }, 352, 240, 0, 1, "SIF525" },
51  { AV_PIX_FMT_YUV420P, { 2, 25 }, 352, 288, 0, 1, "CIF" },
52  { AV_PIX_FMT_YUV420P, { 1001, 15000 }, 704, 480, 0, 1, "4SIF525" },
53  { AV_PIX_FMT_YUV420P, { 2, 25 }, 704, 576, 0, 1, "4CIF" },
54 
55  { AV_PIX_FMT_YUV422P10, { 1001, 30000 }, 720, 480, 1, 2, "SD480I-60" },
56  { AV_PIX_FMT_YUV422P10, { 1, 25 }, 720, 576, 1, 2, "SD576I-50" },
57 
58  { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 1280, 720, 0, 3, "HD720P-60" },
59  { AV_PIX_FMT_YUV422P10, { 1, 50 }, 1280, 720, 0, 3, "HD720P-50" },
60  { AV_PIX_FMT_YUV422P10, { 1001, 30000 }, 1920, 1080, 1, 3, "HD1080I-60" },
61  { AV_PIX_FMT_YUV422P10, { 1, 25 }, 1920, 1080, 1, 3, "HD1080I-50" },
62  { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 1920, 1080, 0, 3, "HD1080P-60" },
63  { AV_PIX_FMT_YUV422P10, { 1, 50 }, 1920, 1080, 0, 3, "HD1080P-50" },
64 
65  { AV_PIX_FMT_YUV444P12, { 1, 24 }, 2048, 1080, 0, 4, "DC2K" },
66  { AV_PIX_FMT_YUV444P12, { 1, 24 }, 4096, 2160, 0, 5, "DC4K" },
67 
68  { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 3840, 2160, 0, 6, "UHDTV 4K-60" },
69  { AV_PIX_FMT_YUV422P10, { 1, 50 }, 3840, 2160, 0, 6, "UHDTV 4K-50" },
70 
71  { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 7680, 4320, 0, 7, "UHDTV 8K-60" },
72  { AV_PIX_FMT_YUV422P10, { 1, 50 }, 7680, 4320, 0, 7, "UHDTV 8K-50" },
73 
74  { AV_PIX_FMT_YUV422P10, { 1001, 24000 }, 1920, 1080, 0, 3, "HD1080P-24" },
75  { AV_PIX_FMT_YUV422P10, { 1001, 30000 }, 720, 486, 1, 2, "SD Pro486" },
76 };
78 
79 enum VC2_QM {
83 
85 };
86 
87 typedef struct SubBand {
89  ptrdiff_t stride;
90  int width;
91  int height;
92 } SubBand;
93 
94 typedef struct Plane {
97  int width;
98  int height;
99  int dwt_width;
101  ptrdiff_t coef_stride;
102 } Plane;
103 
104 typedef struct SliceArgs {
107  void *ctx;
108  int x;
109  int y;
113  int bytes;
114 } SliceArgs;
115 
116 typedef struct TransformArgs {
117  void *ctx;
119  void *idata;
120  ptrdiff_t istride;
121  int field;
123 } TransformArgs;
124 
125 typedef struct VC2EncContext {
131 
134 
135  /* For conversion from unsigned pixel values to signed */
137  int bpp;
138  int bpp_idx;
139 
140  /* Picture number */
141  uint32_t picture_number;
142 
143  /* Base video format */
144  int base_vf;
145  int level;
146  int profile;
147 
148  /* Quantization matrix */
149  uint8_t quant[MAX_DWT_LEVELS][4];
151 
152  /* Division LUT */
153  uint32_t qmagic_lut[116][2];
154 
155  int num_x; /* #slices horizontally */
156  int num_y; /* #slices vertically */
161 
162  /* Rate control stuff */
166  int q_ceil;
167  int q_avg;
168 
169  /* Options */
170  double tolerance;
178 
179  /* Parse code state */
182 } VC2EncContext;
183 
185 {
186  int i;
187  int pbits = 0, bits = 0, topbit = 1, maxval = 1;
188 
189  if (!val++) {
190  put_bits(pb, 1, 1);
191  return;
192  }
193 
194  while (val > maxval) {
195  topbit <<= 1;
196  maxval <<= 1;
197  maxval |= 1;
198  }
199 
200  bits = ff_log2(topbit);
201 
202  for (i = 0; i < bits; i++) {
203  topbit >>= 1;
204  pbits <<= 2;
205  if (val & topbit)
206  pbits |= 0x1;
207  }
208 
209  put_bits(pb, bits*2 + 1, (pbits << 1) | 1);
210 }
211 
213 {
214  int topbit = 1, maxval = 1;
215 
216  if (!val++)
217  return 1;
218 
219  while (val > maxval) {
220  topbit <<= 1;
221  maxval <<= 1;
222  maxval |= 1;
223  }
224 
225  return ff_log2(topbit)*2 + 1;
226 }
227 
228 /* VC-2 10.4 - parse_info() */
230 {
231  uint32_t cur_pos, dist;
232 
233  align_put_bits(&s->pb);
234 
235  cur_pos = put_bits_count(&s->pb) >> 3;
236 
237  /* Magic string */
238  ff_put_string(&s->pb, "BBCD", 0);
239 
240  /* Parse code */
241  put_bits(&s->pb, 8, pcode);
242 
243  /* Next parse offset */
244  dist = cur_pos - s->next_parse_offset;
245  AV_WB32(s->pb.buf + s->next_parse_offset + 5, dist);
246  s->next_parse_offset = cur_pos;
247  put_bits32(&s->pb, pcode == DIRAC_PCODE_END_SEQ ? 13 : 0);
248 
249  /* Last parse offset */
250  put_bits32(&s->pb, s->last_parse_code == DIRAC_PCODE_END_SEQ ? 13 : dist);
251 
252  s->last_parse_code = pcode;
253 }
254 
255 /* VC-2 11.1 - parse_parameters()
256  * The level dictates what the decoder should expect in terms of resolution
257  * and allows it to quickly reject whatever it can't support. Remember,
258  * this codec kinda targets cheapo FPGAs without much memory. Unfortunately
259  * it also limits us greatly in our choice of formats, hence the flag to disable
260  * strict_compliance */
262 {
263  put_vc2_ue_uint(&s->pb, s->ver.major); /* VC-2 demands this to be 2 */
264  put_vc2_ue_uint(&s->pb, s->ver.minor); /* ^^ and this to be 0 */
265  put_vc2_ue_uint(&s->pb, s->profile); /* 3 to signal HQ profile */
266  put_vc2_ue_uint(&s->pb, s->level); /* 3 - 1080/720, 6 - 4K */
267 }
268 
269 /* VC-2 11.3 - frame_size() */
271 {
272  put_bits(&s->pb, 1, !s->strict_compliance);
273  if (!s->strict_compliance) {
274  AVCodecContext *avctx = s->avctx;
275  put_vc2_ue_uint(&s->pb, avctx->width);
276  put_vc2_ue_uint(&s->pb, avctx->height);
277  }
278 }
279 
280 /* VC-2 11.3.3 - color_diff_sampling_format() */
282 {
283  put_bits(&s->pb, 1, !s->strict_compliance);
284  if (!s->strict_compliance) {
285  int idx;
286  if (s->chroma_x_shift == 1 && s->chroma_y_shift == 0)
287  idx = 1; /* 422 */
288  else if (s->chroma_x_shift == 1 && s->chroma_y_shift == 1)
289  idx = 2; /* 420 */
290  else
291  idx = 0; /* 444 */
292  put_vc2_ue_uint(&s->pb, idx);
293  }
294 }
295 
296 /* VC-2 11.3.4 - scan_format() */
298 {
299  put_bits(&s->pb, 1, !s->strict_compliance);
300  if (!s->strict_compliance)
301  put_vc2_ue_uint(&s->pb, s->interlaced);
302 }
303 
304 /* VC-2 11.3.5 - frame_rate() */
306 {
307  put_bits(&s->pb, 1, !s->strict_compliance);
308  if (!s->strict_compliance) {
309  AVCodecContext *avctx = s->avctx;
310  put_vc2_ue_uint(&s->pb, 0);
311  put_vc2_ue_uint(&s->pb, avctx->time_base.den);
312  put_vc2_ue_uint(&s->pb, avctx->time_base.num);
313  }
314 }
315 
316 /* VC-2 11.3.6 - aspect_ratio() */
318 {
319  put_bits(&s->pb, 1, !s->strict_compliance);
320  if (!s->strict_compliance) {
321  AVCodecContext *avctx = s->avctx;
322  put_vc2_ue_uint(&s->pb, 0);
325  }
326 }
327 
328 /* VC-2 11.3.7 - clean_area() */
330 {
331  put_bits(&s->pb, 1, 0);
332 }
333 
334 /* VC-2 11.3.8 - signal_range() */
336 {
337  put_bits(&s->pb, 1, !s->strict_compliance);
338  if (!s->strict_compliance)
339  put_vc2_ue_uint(&s->pb, s->bpp_idx);
340 }
341 
342 /* VC-2 11.3.9 - color_spec() */
344 {
345  AVCodecContext *avctx = s->avctx;
346  put_bits(&s->pb, 1, !s->strict_compliance);
347  if (!s->strict_compliance) {
348  int val;
349  put_vc2_ue_uint(&s->pb, 0);
350 
351  /* primaries */
352  put_bits(&s->pb, 1, 1);
353  if (avctx->color_primaries == AVCOL_PRI_BT470BG)
354  val = 2;
355  else if (avctx->color_primaries == AVCOL_PRI_SMPTE170M)
356  val = 1;
357  else if (avctx->color_primaries == AVCOL_PRI_SMPTE240M)
358  val = 1;
359  else
360  val = 0;
361  put_vc2_ue_uint(&s->pb, val);
362 
363  /* color matrix */
364  put_bits(&s->pb, 1, 1);
365  if (avctx->colorspace == AVCOL_SPC_RGB)
366  val = 3;
367  else if (avctx->colorspace == AVCOL_SPC_YCOCG)
368  val = 2;
369  else if (avctx->colorspace == AVCOL_SPC_BT470BG)
370  val = 1;
371  else
372  val = 0;
373  put_vc2_ue_uint(&s->pb, val);
374 
375  /* transfer function */
376  put_bits(&s->pb, 1, 1);
377  if (avctx->color_trc == AVCOL_TRC_LINEAR)
378  val = 2;
379  else if (avctx->color_trc == AVCOL_TRC_BT1361_ECG)
380  val = 1;
381  else
382  val = 0;
383  put_vc2_ue_uint(&s->pb, val);
384  }
385 }
386 
387 /* VC-2 11.3 - source_parameters() */
389 {
398 }
399 
400 /* VC-2 11 - sequence_header() */
402 {
403  align_put_bits(&s->pb);
405  put_vc2_ue_uint(&s->pb, s->base_vf);
407  put_vc2_ue_uint(&s->pb, s->interlaced); /* Frames or fields coding */
408 }
409 
410 /* VC-2 12.1 - picture_header() */
412 {
413  align_put_bits(&s->pb);
414  put_bits32(&s->pb, s->picture_number++);
415 }
416 
417 /* VC-2 12.3.4.1 - slice_parameters() */
419 {
420  put_vc2_ue_uint(&s->pb, s->num_x);
421  put_vc2_ue_uint(&s->pb, s->num_y);
422  put_vc2_ue_uint(&s->pb, s->prefix_bytes);
423  put_vc2_ue_uint(&s->pb, s->size_scaler);
424 }
425 
426 /* 1st idx = LL, second - vertical, third - horizontal, fourth - total */
427 static const uint8_t vc2_qm_col_tab[][4] = {
428  {20, 9, 15, 4},
429  { 0, 6, 6, 4},
430  { 0, 3, 3, 5},
431  { 0, 3, 5, 1},
432  { 0, 11, 10, 11}
433 };
434 
435 static const uint8_t vc2_qm_flat_tab[][4] = {
436  { 0, 0, 0, 0},
437  { 0, 0, 0, 0},
438  { 0, 0, 0, 0},
439  { 0, 0, 0, 0},
440  { 0, 0, 0, 0}
441 };
442 
444 {
445  int level, orientation;
446 
447  if (s->wavelet_depth <= 4 && s->quant_matrix == VC2_QM_DEF) {
448  s->custom_quant_matrix = 0;
449  for (level = 0; level < s->wavelet_depth; level++) {
450  s->quant[level][0] = ff_dirac_default_qmat[s->wavelet_idx][level][0];
451  s->quant[level][1] = ff_dirac_default_qmat[s->wavelet_idx][level][1];
452  s->quant[level][2] = ff_dirac_default_qmat[s->wavelet_idx][level][2];
453  s->quant[level][3] = ff_dirac_default_qmat[s->wavelet_idx][level][3];
454  }
455  return;
456  }
457 
458  s->custom_quant_matrix = 1;
459 
460  if (s->quant_matrix == VC2_QM_DEF) {
461  for (level = 0; level < s->wavelet_depth; level++) {
462  for (orientation = 0; orientation < 4; orientation++) {
463  if (level <= 3)
464  s->quant[level][orientation] = ff_dirac_default_qmat[s->wavelet_idx][level][orientation];
465  else
466  s->quant[level][orientation] = vc2_qm_col_tab[level][orientation];
467  }
468  }
469  } else if (s->quant_matrix == VC2_QM_COL) {
470  for (level = 0; level < s->wavelet_depth; level++) {
471  for (orientation = 0; orientation < 4; orientation++) {
472  s->quant[level][orientation] = vc2_qm_col_tab[level][orientation];
473  }
474  }
475  } else {
476  for (level = 0; level < s->wavelet_depth; level++) {
477  for (orientation = 0; orientation < 4; orientation++) {
478  s->quant[level][orientation] = vc2_qm_flat_tab[level][orientation];
479  }
480  }
481  }
482 }
483 
484 /* VC-2 12.3.4.2 - quant_matrix() */
486 {
487  int level;
488  put_bits(&s->pb, 1, s->custom_quant_matrix);
489  if (s->custom_quant_matrix) {
490  put_vc2_ue_uint(&s->pb, s->quant[0][0]);
491  for (level = 0; level < s->wavelet_depth; level++) {
492  put_vc2_ue_uint(&s->pb, s->quant[level][1]);
493  put_vc2_ue_uint(&s->pb, s->quant[level][2]);
494  put_vc2_ue_uint(&s->pb, s->quant[level][3]);
495  }
496  }
497 }
498 
499 /* VC-2 12.3 - transform_parameters() */
501 {
502  put_vc2_ue_uint(&s->pb, s->wavelet_idx);
503  put_vc2_ue_uint(&s->pb, s->wavelet_depth);
504 
507 }
508 
509 /* VC-2 12.2 - wavelet_transform() */
511 {
513  align_put_bits(&s->pb);
514 }
515 
516 /* VC-2 12 - picture_parse() */
518 {
519  align_put_bits(&s->pb);
521  align_put_bits(&s->pb);
523 }
524 
525 #define QUANT(c, mul, add, shift) (((mul) * (c) + (add)) >> (shift))
526 
527 /* VC-2 13.5.5.2 - slice_band() */
528 static void encode_subband(VC2EncContext *s, PutBitContext *pb, int sx, int sy,
529  SubBand *b, int quant)
530 {
531  int x, y;
532 
533  const int left = b->width * (sx+0) / s->num_x;
534  const int right = b->width * (sx+1) / s->num_x;
535  const int top = b->height * (sy+0) / s->num_y;
536  const int bottom = b->height * (sy+1) / s->num_y;
537 
538  dwtcoef *coeff = b->buf + top * b->stride;
539  const uint64_t q_m = ((uint64_t)(s->qmagic_lut[quant][0])) << 2;
540  const uint64_t q_a = s->qmagic_lut[quant][1];
541  const int q_s = av_log2(ff_dirac_qscale_tab[quant]) + 32;
542 
543  for (y = top; y < bottom; y++) {
544  for (x = left; x < right; x++) {
545  uint32_t c_abs = QUANT(FFABS(coeff[x]), q_m, q_a, q_s);
546  put_vc2_ue_uint(pb, c_abs);
547  if (c_abs)
548  put_bits(pb, 1, coeff[x] < 0);
549  }
550  coeff += b->stride;
551  }
552 }
553 
554 static int count_hq_slice(SliceArgs *slice, int quant_idx)
555 {
556  int x, y;
557  uint8_t quants[MAX_DWT_LEVELS][4];
558  int bits = 0, p, level, orientation;
559  VC2EncContext *s = slice->ctx;
560 
561  if (slice->cache[quant_idx])
562  return slice->cache[quant_idx];
563 
564  bits += 8*s->prefix_bytes;
565  bits += 8; /* quant_idx */
566 
567  for (level = 0; level < s->wavelet_depth; level++)
568  for (orientation = !!level; orientation < 4; orientation++)
569  quants[level][orientation] = FFMAX(quant_idx - s->quant[level][orientation], 0);
570 
571  for (p = 0; p < 3; p++) {
572  int bytes_start, bytes_len, pad_s, pad_c;
573  bytes_start = bits >> 3;
574  bits += 8;
575  for (level = 0; level < s->wavelet_depth; level++) {
576  for (orientation = !!level; orientation < 4; orientation++) {
577  SubBand *b = &s->plane[p].band[level][orientation];
578 
579  const int q_idx = quants[level][orientation];
580  const uint64_t q_m = ((uint64_t)s->qmagic_lut[q_idx][0]) << 2;
581  const uint64_t q_a = s->qmagic_lut[q_idx][1];
582  const int q_s = av_log2(ff_dirac_qscale_tab[q_idx]) + 32;
583 
584  const int left = b->width * slice->x / s->num_x;
585  const int right = b->width *(slice->x+1) / s->num_x;
586  const int top = b->height * slice->y / s->num_y;
587  const int bottom = b->height *(slice->y+1) / s->num_y;
588 
589  dwtcoef *buf = b->buf + top * b->stride;
590 
591  for (y = top; y < bottom; y++) {
592  for (x = left; x < right; x++) {
593  uint32_t c_abs = QUANT(FFABS(buf[x]), q_m, q_a, q_s);
594  bits += count_vc2_ue_uint(c_abs);
595  bits += !!c_abs;
596  }
597  buf += b->stride;
598  }
599  }
600  }
601  bits += FFALIGN(bits, 8) - bits;
602  bytes_len = (bits >> 3) - bytes_start - 1;
603  pad_s = FFALIGN(bytes_len, s->size_scaler)/s->size_scaler;
604  pad_c = (pad_s*s->size_scaler) - bytes_len;
605  bits += pad_c*8;
606  }
607 
608  slice->cache[quant_idx] = bits;
609 
610  return bits;
611 }
612 
613 /* Approaches the best possible quantizer asymptotically, its kinda exaustive
614  * but we have a LUT to get the coefficient size in bits. Guaranteed to never
615  * overshoot, which is apparently very important when streaming */
616 static int rate_control(AVCodecContext *avctx, void *arg)
617 {
618  SliceArgs *slice_dat = arg;
619  VC2EncContext *s = slice_dat->ctx;
620  const int top = slice_dat->bits_ceil;
621  const int bottom = slice_dat->bits_floor;
622  int quant_buf[2] = {-1, -1};
623  int quant = slice_dat->quant_idx, step = 1;
624  int bits_last, bits = count_hq_slice(slice_dat, quant);
625  while ((bits > top) || (bits < bottom)) {
626  const int signed_step = bits > top ? +step : -step;
627  quant = av_clip(quant + signed_step, 0, s->q_ceil-1);
628  bits = count_hq_slice(slice_dat, quant);
629  if (quant_buf[1] == quant) {
630  quant = FFMAX(quant_buf[0], quant);
631  bits = quant == quant_buf[0] ? bits_last : bits;
632  break;
633  }
634  step = av_clip(step/2, 1, (s->q_ceil-1)/2);
635  quant_buf[1] = quant_buf[0];
636  quant_buf[0] = quant;
637  bits_last = bits;
638  }
639  slice_dat->quant_idx = av_clip(quant, 0, s->q_ceil-1);
640  slice_dat->bytes = SSIZE_ROUND(bits >> 3);
641  return 0;
642 }
643 
645 {
646  int i, j, slice_x, slice_y, bytes_left = 0;
647  int bytes_top[SLICE_REDIST_TOTAL] = {0};
648  int64_t total_bytes_needed = 0;
649  int slice_redist_range = FFMIN(SLICE_REDIST_TOTAL, s->num_x*s->num_y);
650  SliceArgs *enc_args = s->slice_args;
651  SliceArgs *top_loc[SLICE_REDIST_TOTAL] = {NULL};
652 
654 
655  for (slice_y = 0; slice_y < s->num_y; slice_y++) {
656  for (slice_x = 0; slice_x < s->num_x; slice_x++) {
657  SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x];
658  args->ctx = s;
659  args->x = slice_x;
660  args->y = slice_y;
661  args->bits_ceil = s->slice_max_bytes << 3;
662  args->bits_floor = s->slice_min_bytes << 3;
663  memset(args->cache, 0, s->q_ceil*sizeof(*args->cache));
664  }
665  }
666 
667  /* First pass - determine baseline slice sizes w.r.t. max_slice_size */
668  s->avctx->execute(s->avctx, rate_control, enc_args, NULL, s->num_x*s->num_y,
669  sizeof(SliceArgs));
670 
671  for (i = 0; i < s->num_x*s->num_y; i++) {
672  SliceArgs *args = &enc_args[i];
673  bytes_left += args->bytes;
674  for (j = 0; j < slice_redist_range; j++) {
675  if (args->bytes > bytes_top[j]) {
676  bytes_top[j] = args->bytes;
677  top_loc[j] = args;
678  break;
679  }
680  }
681  }
682 
683  bytes_left = s->frame_max_bytes - bytes_left;
684 
685  /* Second pass - distribute leftover bytes */
686  while (bytes_left > 0) {
687  int distributed = 0;
688  for (i = 0; i < slice_redist_range; i++) {
689  SliceArgs *args;
690  int bits, bytes, diff, prev_bytes, new_idx;
691  if (bytes_left <= 0)
692  break;
693  if (!top_loc[i] || !top_loc[i]->quant_idx)
694  break;
695  args = top_loc[i];
696  prev_bytes = args->bytes;
697  new_idx = FFMAX(args->quant_idx - 1, 0);
698  bits = count_hq_slice(args, new_idx);
699  bytes = SSIZE_ROUND(bits >> 3);
700  diff = bytes - prev_bytes;
701  if ((bytes_left - diff) > 0) {
702  args->quant_idx = new_idx;
703  args->bytes = bytes;
704  bytes_left -= diff;
705  distributed++;
706  }
707  }
708  if (!distributed)
709  break;
710  }
711 
712  for (i = 0; i < s->num_x*s->num_y; i++) {
713  SliceArgs *args = &enc_args[i];
714  total_bytes_needed += args->bytes;
715  s->q_avg = (s->q_avg + args->quant_idx)/2;
716  }
717 
718  return total_bytes_needed;
719 }
720 
721 /* VC-2 13.5.3 - hq_slice */
722 static int encode_hq_slice(AVCodecContext *avctx, void *arg)
723 {
724  SliceArgs *slice_dat = arg;
725  VC2EncContext *s = slice_dat->ctx;
726  PutBitContext *pb = &slice_dat->pb;
727  const int slice_x = slice_dat->x;
728  const int slice_y = slice_dat->y;
729  const int quant_idx = slice_dat->quant_idx;
730  const int slice_bytes_max = slice_dat->bytes;
731  uint8_t quants[MAX_DWT_LEVELS][4];
732  int p, level, orientation;
733 
734  /* The reference decoder ignores it, and its typical length is 0 */
735  memset(put_bits_ptr(pb), 0, s->prefix_bytes);
736  skip_put_bytes(pb, s->prefix_bytes);
737 
738  put_bits(pb, 8, quant_idx);
739 
740  /* Slice quantization (slice_quantizers() in the specs) */
741  for (level = 0; level < s->wavelet_depth; level++)
742  for (orientation = !!level; orientation < 4; orientation++)
743  quants[level][orientation] = FFMAX(quant_idx - s->quant[level][orientation], 0);
744 
745  /* Luma + 2 Chroma planes */
746  for (p = 0; p < 3; p++) {
747  int bytes_start, bytes_len, pad_s, pad_c;
748  bytes_start = put_bits_count(pb) >> 3;
749  put_bits(pb, 8, 0);
750  for (level = 0; level < s->wavelet_depth; level++) {
751  for (orientation = !!level; orientation < 4; orientation++) {
752  encode_subband(s, pb, slice_x, slice_y,
753  &s->plane[p].band[level][orientation],
754  quants[level][orientation]);
755  }
756  }
757  align_put_bits(pb);
758  bytes_len = (put_bits_count(pb) >> 3) - bytes_start - 1;
759  if (p == 2) {
760  int len_diff = slice_bytes_max - (put_bits_count(pb) >> 3);
761  pad_s = FFALIGN((bytes_len + len_diff), s->size_scaler)/s->size_scaler;
762  pad_c = (pad_s*s->size_scaler) - bytes_len;
763  } else {
764  pad_s = FFALIGN(bytes_len, s->size_scaler)/s->size_scaler;
765  pad_c = (pad_s*s->size_scaler) - bytes_len;
766  }
767  pb->buf[bytes_start] = pad_s;
768  flush_put_bits(pb);
769  /* vc2-reference uses that padding that decodes to '0' coeffs */
770  memset(put_bits_ptr(pb), 0xFF, pad_c);
771  skip_put_bytes(pb, pad_c);
772  }
773 
774  return 0;
775 }
776 
777 /* VC-2 13.5.1 - low_delay_transform_data() */
779 {
780  uint8_t *buf;
781  int slice_x, slice_y, skip = 0;
782  SliceArgs *enc_args = s->slice_args;
783 
784  flush_put_bits(&s->pb);
785  buf = put_bits_ptr(&s->pb);
786 
787  for (slice_y = 0; slice_y < s->num_y; slice_y++) {
788  for (slice_x = 0; slice_x < s->num_x; slice_x++) {
789  SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x];
790  init_put_bits(&args->pb, buf + skip, args->bytes+s->prefix_bytes);
791  skip += args->bytes;
792  }
793  }
794 
795  s->avctx->execute(s->avctx, encode_hq_slice, enc_args, NULL, s->num_x*s->num_y,
796  sizeof(SliceArgs));
797 
798  skip_put_bytes(&s->pb, skip);
799 
800  return 0;
801 }
802 
803 /*
804  * Transform basics for a 3 level transform
805  * |---------------------------------------------------------------------|
806  * | LL-0 | HL-0 | | |
807  * |--------|-------| HL-1 | |
808  * | LH-0 | HH-0 | | |
809  * |----------------|-----------------| HL-2 |
810  * | | | |
811  * | LH-1 | HH-1 | |
812  * | | | |
813  * |----------------------------------|----------------------------------|
814  * | | |
815  * | | |
816  * | | |
817  * | LH-2 | HH-2 |
818  * | | |
819  * | | |
820  * | | |
821  * |---------------------------------------------------------------------|
822  *
823  * DWT transforms are generally applied by splitting the image in two vertically
824  * and applying a low pass transform on the left part and a corresponding high
825  * pass transform on the right hand side. This is known as the horizontal filter
826  * stage.
827  * After that, the same operation is performed except the image is divided
828  * horizontally, with the high pass on the lower and the low pass on the higher
829  * side.
830  * Therefore, you're left with 4 subdivisions - known as low-low, low-high,
831  * high-low and high-high. They're referred to as orientations in the decoder
832  * and encoder.
833  *
834  * The LL (low-low) area contains the original image downsampled by the amount
835  * of levels. The rest of the areas can be thought as the details needed
836  * to restore the image perfectly to its original size.
837  */
838 static int dwt_plane(AVCodecContext *avctx, void *arg)
839 {
840  TransformArgs *transform_dat = arg;
841  VC2EncContext *s = transform_dat->ctx;
842  const void *frame_data = transform_dat->idata;
843  const ptrdiff_t linesize = transform_dat->istride;
844  const int field = transform_dat->field;
845  const Plane *p = transform_dat->plane;
846  VC2TransformContext *t = &transform_dat->t;
847  dwtcoef *buf = p->coef_buf;
848  const int idx = s->wavelet_idx;
849  const int skip = 1 + s->interlaced;
850 
851  int x, y, level, offset;
852  ptrdiff_t pix_stride = linesize >> (s->bpp - 1);
853 
854  if (field == 1) {
855  offset = 0;
856  pix_stride <<= 1;
857  } else if (field == 2) {
858  offset = pix_stride;
859  pix_stride <<= 1;
860  } else {
861  offset = 0;
862  }
863 
864  if (s->bpp == 1) {
865  const uint8_t *pix = (const uint8_t *)frame_data + offset;
866  for (y = 0; y < p->height*skip; y+=skip) {
867  for (x = 0; x < p->width; x++) {
868  buf[x] = pix[x] - s->diff_offset;
869  }
870  memset(&buf[x], 0, (p->coef_stride - p->width)*sizeof(dwtcoef));
871  buf += p->coef_stride;
872  pix += pix_stride;
873  }
874  } else {
875  const uint16_t *pix = (const uint16_t *)frame_data + offset;
876  for (y = 0; y < p->height*skip; y+=skip) {
877  for (x = 0; x < p->width; x++) {
878  buf[x] = pix[x] - s->diff_offset;
879  }
880  memset(&buf[x], 0, (p->coef_stride - p->width)*sizeof(dwtcoef));
881  buf += p->coef_stride;
882  pix += pix_stride;
883  }
884  }
885 
886  memset(buf, 0, p->coef_stride * (p->dwt_height - p->height) * sizeof(dwtcoef));
887 
888  for (level = s->wavelet_depth-1; level >= 0; level--) {
889  const SubBand *b = &p->band[level][0];
890  t->vc2_subband_dwt[idx](t, p->coef_buf, p->coef_stride,
891  b->width, b->height);
892  }
893 
894  return 0;
895 }
896 
897 static int encode_frame(VC2EncContext *s, AVPacket *avpkt, const AVFrame *frame,
898  const char *aux_data, const int header_size, int field)
899 {
900  int i, ret;
901  int64_t max_frame_bytes;
902 
903  /* Threaded DWT transform */
904  for (i = 0; i < 3; i++) {
905  s->transform_args[i].ctx = s;
906  s->transform_args[i].field = field;
907  s->transform_args[i].plane = &s->plane[i];
908  s->transform_args[i].idata = frame->data[i];
909  s->transform_args[i].istride = frame->linesize[i];
910  }
911  s->avctx->execute(s->avctx, dwt_plane, s->transform_args, NULL, 3,
912  sizeof(TransformArgs));
913 
914  /* Calculate per-slice quantizers and sizes */
915  max_frame_bytes = header_size + calc_slice_sizes(s);
916 
917  if (field < 2) {
918  ret = ff_get_encode_buffer(s->avctx, avpkt,
919  max_frame_bytes << s->interlaced, 0);
920  if (ret) {
921  av_log(s->avctx, AV_LOG_ERROR, "Error getting output packet.\n");
922  return ret;
923  }
924  init_put_bits(&s->pb, avpkt->data, avpkt->size);
925  }
926 
927  /* Sequence header */
930 
931  /* Encoder version */
932  if (aux_data) {
934  ff_put_string(&s->pb, aux_data, 1);
935  }
936 
937  /* Picture header */
940 
941  /* Encode slices */
942  encode_slices(s);
943 
944  /* End sequence */
946 
947  return 0;
948 }
949 
951  const AVFrame *frame, int *got_packet)
952 {
953  int ret = 0;
954  int slice_ceil, sig_size = 256;
955  VC2EncContext *s = avctx->priv_data;
956  const int bitexact = avctx->flags & AV_CODEC_FLAG_BITEXACT;
957  const char *aux_data = bitexact ? "Lavc" : LIBAVCODEC_IDENT;
958  const int aux_data_size = bitexact ? sizeof("Lavc") : sizeof(LIBAVCODEC_IDENT);
959  const int header_size = 100 + aux_data_size;
960  int64_t r_bitrate = avctx->bit_rate >> (s->interlaced);
961 
962  s->avctx = avctx;
963  s->size_scaler = 2;
964  s->prefix_bytes = 0;
965  s->last_parse_code = 0;
966  s->next_parse_offset = 0;
967 
968  /* Rate control */
969  s->frame_max_bytes = (av_rescale(r_bitrate, s->avctx->time_base.num,
970  s->avctx->time_base.den) >> 3) - header_size;
971  s->slice_max_bytes = slice_ceil = av_rescale(s->frame_max_bytes, 1, s->num_x*s->num_y);
972 
973  /* Find an appropriate size scaler */
974  while (sig_size > 255) {
975  int r_size = SSIZE_ROUND(s->slice_max_bytes);
976  if (r_size > slice_ceil) {
977  s->slice_max_bytes -= r_size - slice_ceil;
978  r_size = SSIZE_ROUND(s->slice_max_bytes);
979  }
980  sig_size = r_size/s->size_scaler; /* Signalled slize size */
981  s->size_scaler <<= 1;
982  }
983 
984  s->slice_min_bytes = s->slice_max_bytes - s->slice_max_bytes*(s->tolerance/100.0f);
985  if (s->slice_min_bytes < 0)
986  return AVERROR(EINVAL);
987 
988  ret = encode_frame(s, avpkt, frame, aux_data, header_size, s->interlaced);
989  if (ret)
990  return ret;
991  if (s->interlaced) {
992  ret = encode_frame(s, avpkt, frame, aux_data, header_size, 2);
993  if (ret)
994  return ret;
995  }
996 
997  flush_put_bits(&s->pb);
998  av_shrink_packet(avpkt, put_bytes_output(&s->pb));
999 
1000  *got_packet = 1;
1001 
1002  return 0;
1003 }
1004 
1006 {
1007  int i;
1008  VC2EncContext *s = avctx->priv_data;
1009 
1010  av_log(avctx, AV_LOG_INFO, "Qavg: %i\n", s->q_avg);
1011 
1012  for (i = 0; i < 3; i++) {
1013  ff_vc2enc_free_transforms(&s->transform_args[i].t);
1014  av_freep(&s->plane[i].coef_buf);
1015  }
1016 
1017  av_freep(&s->slice_args);
1018 
1019  return 0;
1020 }
1021 
1023 {
1024  Plane *p;
1025  SubBand *b;
1026  int i, level, o, shift, ret;
1027  const AVPixFmtDescriptor *fmt = av_pix_fmt_desc_get(avctx->pix_fmt);
1028  const int depth = fmt->comp[0].depth;
1029  VC2EncContext *s = avctx->priv_data;
1030 
1031  s->picture_number = 0;
1032 
1033  /* Total allowed quantization range */
1034  s->q_ceil = DIRAC_MAX_QUANT_INDEX;
1035 
1036  s->ver.major = 2;
1037  s->ver.minor = 0;
1038  s->profile = 3;
1039  s->level = 3;
1040 
1041  s->base_vf = -1;
1042  s->strict_compliance = 1;
1043 
1044  s->q_avg = 0;
1045  s->slice_max_bytes = 0;
1046  s->slice_min_bytes = 0;
1047 
1048  /* Mark unknown as progressive */
1049  s->interlaced = !((avctx->field_order == AV_FIELD_UNKNOWN) ||
1050  (avctx->field_order == AV_FIELD_PROGRESSIVE));
1051 
1052  for (i = 0; i < base_video_fmts_len; i++) {
1053  const VC2BaseVideoFormat *fmt = &base_video_fmts[i];
1054  if (avctx->pix_fmt != fmt->pix_fmt)
1055  continue;
1056  if (avctx->time_base.num != fmt->time_base.num)
1057  continue;
1058  if (avctx->time_base.den != fmt->time_base.den)
1059  continue;
1060  if (avctx->width != fmt->width)
1061  continue;
1062  if (avctx->height != fmt->height)
1063  continue;
1064  if (s->interlaced != fmt->interlaced)
1065  continue;
1066  s->base_vf = i;
1067  s->level = base_video_fmts[i].level;
1068  break;
1069  }
1070 
1071  if (s->interlaced)
1072  av_log(avctx, AV_LOG_WARNING, "Interlacing enabled!\n");
1073 
1074  if ((s->slice_width & (s->slice_width - 1)) ||
1075  (s->slice_height & (s->slice_height - 1))) {
1076  av_log(avctx, AV_LOG_ERROR, "Slice size is not a power of two!\n");
1077  return AVERROR_UNKNOWN;
1078  }
1079 
1080  if ((s->slice_width > avctx->width) ||
1081  (s->slice_height > avctx->height)) {
1082  av_log(avctx, AV_LOG_ERROR, "Slice size is bigger than the image!\n");
1083  return AVERROR_UNKNOWN;
1084  }
1085 
1086  if (s->base_vf <= 0) {
1088  s->strict_compliance = s->base_vf = 0;
1089  av_log(avctx, AV_LOG_WARNING, "Format does not strictly comply with VC2 specs\n");
1090  } else {
1091  av_log(avctx, AV_LOG_WARNING, "Given format does not strictly comply with "
1092  "the specifications, decrease strictness to use it.\n");
1093  return AVERROR_UNKNOWN;
1094  }
1095  } else {
1096  av_log(avctx, AV_LOG_INFO, "Selected base video format = %i (%s)\n",
1097  s->base_vf, base_video_fmts[s->base_vf].name);
1098  }
1099 
1100  /* Chroma subsampling */
1101  ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
1102  if (ret)
1103  return ret;
1104 
1105  /* Bit depth and color range index */
1106  if (depth == 8 && avctx->color_range == AVCOL_RANGE_JPEG) {
1107  s->bpp = 1;
1108  s->bpp_idx = 1;
1109  s->diff_offset = 128;
1110  } else if (depth == 8 && (avctx->color_range == AVCOL_RANGE_MPEG ||
1111  avctx->color_range == AVCOL_RANGE_UNSPECIFIED)) {
1112  s->bpp = 1;
1113  s->bpp_idx = 2;
1114  s->diff_offset = 128;
1115  } else if (depth == 10) {
1116  s->bpp = 2;
1117  s->bpp_idx = 3;
1118  s->diff_offset = 512;
1119  } else {
1120  s->bpp = 2;
1121  s->bpp_idx = 4;
1122  s->diff_offset = 2048;
1123  }
1124 
1125  /* Planes initialization */
1126  for (i = 0; i < 3; i++) {
1127  int w, h;
1128  p = &s->plane[i];
1129  p->width = avctx->width >> (i ? s->chroma_x_shift : 0);
1130  p->height = avctx->height >> (i ? s->chroma_y_shift : 0);
1131  if (s->interlaced)
1132  p->height >>= 1;
1133  p->dwt_width = w = FFALIGN(p->width, (1 << s->wavelet_depth));
1134  p->dwt_height = h = FFALIGN(p->height, (1 << s->wavelet_depth));
1135  p->coef_stride = FFALIGN(p->dwt_width, 32);
1136  p->coef_buf = av_mallocz(p->coef_stride*p->dwt_height*sizeof(dwtcoef));
1137  if (!p->coef_buf)
1138  goto alloc_fail;
1139  for (level = s->wavelet_depth-1; level >= 0; level--) {
1140  w = w >> 1;
1141  h = h >> 1;
1142  for (o = 0; o < 4; o++) {
1143  b = &p->band[level][o];
1144  b->width = w;
1145  b->height = h;
1146  b->stride = p->coef_stride;
1147  shift = (o > 1)*b->height*b->stride + (o & 1)*b->width;
1148  b->buf = p->coef_buf + shift;
1149  }
1150  }
1151 
1152  /* DWT init */
1153  if (ff_vc2enc_init_transforms(&s->transform_args[i].t,
1154  s->plane[i].coef_stride,
1155  s->plane[i].dwt_height,
1156  s->slice_width, s->slice_height))
1157  goto alloc_fail;
1158  }
1159 
1160  /* Slices */
1161  s->num_x = s->plane[0].dwt_width/s->slice_width;
1162  s->num_y = s->plane[0].dwt_height/s->slice_height;
1163 
1164  s->slice_args = av_calloc(s->num_x*s->num_y, sizeof(SliceArgs));
1165  if (!s->slice_args)
1166  goto alloc_fail;
1167 
1168  for (i = 0; i < 116; i++) {
1169  const uint64_t qf = ff_dirac_qscale_tab[i];
1170  const uint32_t m = av_log2(qf);
1171  const uint32_t t = (1ULL << (m + 32)) / qf;
1172  const uint32_t r = (t*qf + qf) & UINT32_MAX;
1173  if (!(qf & (qf - 1))) {
1174  s->qmagic_lut[i][0] = 0xFFFFFFFF;
1175  s->qmagic_lut[i][1] = 0xFFFFFFFF;
1176  } else if (r <= 1 << m) {
1177  s->qmagic_lut[i][0] = t + 1;
1178  s->qmagic_lut[i][1] = 0;
1179  } else {
1180  s->qmagic_lut[i][0] = t;
1181  s->qmagic_lut[i][1] = t;
1182  }
1183  }
1184 
1185  return 0;
1186 
1187 alloc_fail:
1188  vc2_encode_end(avctx);
1189  av_log(avctx, AV_LOG_ERROR, "Unable to allocate memory!\n");
1190  return AVERROR(ENOMEM);
1191 }
1192 
1193 #define VC2ENC_FLAGS (AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)
1194 static const AVOption vc2enc_options[] = {
1195  {"tolerance", "Max undershoot in percent", offsetof(VC2EncContext, tolerance), AV_OPT_TYPE_DOUBLE, {.dbl = 5.0f}, 0.0f, 45.0f, VC2ENC_FLAGS, "tolerance"},
1196  {"slice_width", "Slice width", offsetof(VC2EncContext, slice_width), AV_OPT_TYPE_INT, {.i64 = 32}, 32, 1024, VC2ENC_FLAGS, "slice_width"},
1197  {"slice_height", "Slice height", offsetof(VC2EncContext, slice_height), AV_OPT_TYPE_INT, {.i64 = 16}, 8, 1024, VC2ENC_FLAGS, "slice_height"},
1198  {"wavelet_depth", "Transform depth", offsetof(VC2EncContext, wavelet_depth), AV_OPT_TYPE_INT, {.i64 = 4}, 1, 5, VC2ENC_FLAGS, "wavelet_depth"},
1199  {"wavelet_type", "Transform type", offsetof(VC2EncContext, wavelet_idx), AV_OPT_TYPE_INT, {.i64 = VC2_TRANSFORM_9_7}, 0, VC2_TRANSFORMS_NB, VC2ENC_FLAGS, "wavelet_idx"},
1200  {"9_7", "Deslauriers-Dubuc (9,7)", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_TRANSFORM_9_7}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "wavelet_idx"},
1201  {"5_3", "LeGall (5,3)", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_TRANSFORM_5_3}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "wavelet_idx"},
1202  {"haar", "Haar (with shift)", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_TRANSFORM_HAAR_S}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "wavelet_idx"},
1203  {"haar_noshift", "Haar (without shift)", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_TRANSFORM_HAAR}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "wavelet_idx"},
1204  {"qm", "Custom quantization matrix", offsetof(VC2EncContext, quant_matrix), AV_OPT_TYPE_INT, {.i64 = VC2_QM_DEF}, 0, VC2_QM_NB, VC2ENC_FLAGS, "quant_matrix"},
1205  {"default", "Default from the specifications", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_QM_DEF}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "quant_matrix"},
1206  {"color", "Prevents low bitrate discoloration", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_QM_COL}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "quant_matrix"},
1207  {"flat", "Optimize for PSNR", 0, AV_OPT_TYPE_CONST, {.i64 = VC2_QM_FLAT}, INT_MIN, INT_MAX, VC2ENC_FLAGS, "quant_matrix"},
1208  {NULL}
1209 };
1210 
1211 static const AVClass vc2enc_class = {
1212  .class_name = "SMPTE VC-2 encoder",
1213  .category = AV_CLASS_CATEGORY_ENCODER,
1214  .option = vc2enc_options,
1215  .item_name = av_default_item_name,
1216  .version = LIBAVUTIL_VERSION_INT
1217 };
1218 
1220  { "b", "600000000" },
1221  { NULL },
1222 };
1223 
1224 static const enum AVPixelFormat allowed_pix_fmts[] = {
1229 };
1230 
1232  .name = "vc2",
1233  .long_name = NULL_IF_CONFIG_SMALL("SMPTE VC-2"),
1234  .type = AVMEDIA_TYPE_VIDEO,
1235  .id = AV_CODEC_ID_DIRAC,
1236  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS,
1237  .priv_data_size = sizeof(VC2EncContext),
1238  .init = vc2_encode_init,
1239  .close = vc2_encode_end,
1240  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1241  .encode2 = vc2_encode_frame,
1242  .priv_class = &vc2enc_class,
1245 };
init_quant_matrix
static void init_quant_matrix(VC2EncContext *s)
Definition: vc2enc.c:443
vc2_qm_col_tab
static const uint8_t vc2_qm_col_tab[][4]
Definition: vc2enc.c:427
AVCodec
AVCodec.
Definition: codec.h:202
SliceArgs::bits_floor
int bits_floor
Definition: vc2enc.c:112
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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
VC2EncContext::slice_args
SliceArgs * slice_args
Definition: vc2enc.c:132
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
level
uint8_t level
Definition: svq3.c:204
av_clip
#define av_clip
Definition: common.h:96
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
r
const char * r
Definition: vf_curves.c:116
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
vc2_qm_flat_tab
static const uint8_t vc2_qm_flat_tab[][4]
Definition: vc2enc.c:435
DiracVersionInfo
Definition: dirac.h:76
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:290
LIBAVCODEC_IDENT
#define LIBAVCODEC_IDENT
Definition: version.h:42
VC2_TRANSFORM_9_7
@ VC2_TRANSFORM_9_7
Definition: vc2enc_dwt.h:31
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:960
Plane::coef_buf
dwtcoef * coef_buf
Definition: vc2enc.c:96
align_put_bits
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: put_bits.h:412
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:88
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2564
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:485
MAX_DWT_LEVELS
#define MAX_DWT_LEVELS
The spec limits the number of wavelet decompositions to 4 for both level 1 (VC-2) and 128 (long-gop d...
Definition: dirac.h:45
dwtcoef
int32_t dwtcoef
Definition: vc2enc_dwt.h:28
AV_CODEC_ID_DIRAC
@ AV_CODEC_ID_DIRAC
Definition: codec_id.h:166
VC2EncContext::chroma_x_shift
int chroma_x_shift
Definition: vc2enc.c:159
VC2BaseVideoFormat::interlaced
int interlaced
Definition: vc2enc.c:42
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
TransformArgs::idata
void * idata
Definition: vc2enc.c:119
TransformArgs::plane
Plane * plane
Definition: vc2enc.c:118
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
pixdesc.h
step
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
Definition: rate_distortion.txt:58
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:953
VC2EncContext::q_avg
int q_avg
Definition: vc2enc.c:167
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:579
internal.h
AVCOL_SPC_YCOCG
@ AVCOL_SPC_YCOCG
Definition: pixfmt.h:515
AVPacket::data
uint8_t * data
Definition: packet.h:373
VC2EncContext::diff_offset
int diff_offset
Definition: vc2enc.c:136
SubBand::width
int width
Definition: cfhd.h:112
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
SliceArgs::y
int y
Definition: vc2enc.c:109
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:989
AVOption
AVOption.
Definition: opt.h:247
encode.h
b
#define b
Definition: input.c:40
SliceArgs::bytes
int bytes
Definition: vc2enc.c:113
encode_scan_format
static void encode_scan_format(VC2EncContext *s)
Definition: vc2enc.c:297
encode_slices
static int encode_slices(VC2EncContext *s)
Definition: vc2enc.c:778
rate_control
static int rate_control(AVCodecContext *avctx, void *arg)
Definition: vc2enc.c:616
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:391
VC2EncContext::pb
PutBitContext pb
Definition: vc2enc.c:127
ff_vc2enc_free_transforms
av_cold void ff_vc2enc_free_transforms(VC2TransformContext *s)
Definition: vc2enc_dwt.c:277
version.h
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:506
base_video_fmts
static const VC2BaseVideoFormat base_video_fmts[]
Definition: vc2enc.c:46
SliceArgs::pb
PutBitContext pb
Definition: vc2enc.c:105
encode_picture_header
static void encode_picture_header(VC2EncContext *s)
Definition: vc2enc.c:411
encode_slice_params
static void encode_slice_params(VC2EncContext *s)
Definition: vc2enc.c:418
SliceArgs::ctx
void * ctx
Definition: vc2enc.c:107
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
vc2_encode_frame
static av_cold int vc2_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet)
Definition: vc2enc.c:950
VC2TransformContext::vc2_subband_dwt
void(* vc2_subband_dwt[VC2_TRANSFORMS_NB])(struct VC2TransformContext *t, dwtcoef *data, ptrdiff_t stride, int width, int height)
Definition: vc2enc_dwt.h:45
VC2EncContext::qmagic_lut
uint32_t qmagic_lut[116][2]
Definition: vc2enc.c:153
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
ff_dirac_qscale_tab
const int32_t ff_dirac_qscale_tab[116]
Definition: diractab.c:34
VC2_QM_NB
@ VC2_QM_NB
Definition: vc2enc.c:84
VC2EncContext::slice_min_bytes
int slice_min_bytes
Definition: vc2enc.c:165
encode_clean_area
static void encode_clean_area(VC2EncContext *s)
Definition: vc2enc.c:329
encode_frame_size
static void encode_frame_size(VC2EncContext *s)
Definition: vc2enc.c:270
encode_quant_matrix
static void encode_quant_matrix(VC2EncContext *s)
Definition: vc2enc.c:485
diractab.h
ff_dirac_default_qmat
const uint8_t ff_dirac_default_qmat[7][4][4]
Definition: diractab.c:24
VC2EncContext::prefix_bytes
int prefix_bytes
Definition: vc2enc.c:157
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:511
VC2EncContext::custom_quant_matrix
int custom_quant_matrix
Definition: vc2enc.c:150
encode_color_spec
static void encode_color_spec(VC2EncContext *s)
Definition: vc2enc.c:343
count_hq_slice
static int count_hq_slice(SliceArgs *slice, int quant_idx)
Definition: vc2enc.c:554
VC2BaseVideoFormat
Definition: vc2enc.c:39
VC2_TRANSFORMS_NB
@ VC2_TRANSFORMS_NB
Definition: vc2enc_dwt.h:39
ff_vc2_encoder
const AVCodec ff_vc2_encoder
Definition: vc2enc.c:1231
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:114
TransformArgs
Definition: vc2enc.c:116
VC2_QM_FLAT
@ VC2_QM_FLAT
Definition: vc2enc.c:82
defaults
static const AVCodecDefault defaults[]
Definition: amfenc_h264.c:361
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
val
static double val(void *priv, double ch)
Definition: aeval.c:76
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2592
AVRational::num
int num
Numerator.
Definition: rational.h:59
quant
static int quant(float coef, const float Q, const float rounding)
Quantize one coefficient.
Definition: aacenc_utils.h:59
encode_subband
static void encode_subband(VC2EncContext *s, PutBitContext *pb, int sx, int sy, SubBand *b, int quant)
Definition: vc2enc.c:528
SliceArgs::x
int x
Definition: vc2enc.c:108
dirac.h
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:394
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:946
SSIZE_ROUND
#define SSIZE_ROUND(b)
Definition: vc2enc.c:34
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
VC2EncContext::next_parse_offset
uint32_t next_parse_offset
Definition: vc2enc.c:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
VC2EncContext::tolerance
double tolerance
Definition: vc2enc.c:170
av_cold
#define av_cold
Definition: attributes.h:90
ff_vc2enc_init_transforms
av_cold int ff_vc2enc_init_transforms(VC2TransformContext *s, int p_stride, int p_height, int slice_w, int slice_h)
Definition: vc2enc_dwt.c:258
DiracParseCodes
DiracParseCodes
Parse code values:
Definition: dirac.h:57
VC2EncContext::slice_width
int slice_width
Definition: vc2enc.c:175
vc2enc_class
static const AVClass vc2enc_class
Definition: vc2enc.c:1211
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVCOL_TRC_BT1361_ECG
@ AVCOL_TRC_BT1361_ECG
ITU-R BT1361 Extended Colour Gamut.
Definition: pixfmt.h:489
TransformArgs::t
VC2TransformContext t
Definition: vc2enc.c:122
VC2EncContext::quant_matrix
enum VC2_QM quant_matrix
Definition: vc2enc.c:177
AV_OPT_TYPE_DOUBLE
@ AV_OPT_TYPE_DOUBLE
Definition: opt.h:226
bits
uint8_t bits
Definition: vp3data.h:141
encode_frame
static int encode_frame(VC2EncContext *s, AVPacket *avpkt, const AVFrame *frame, const char *aux_data, const int header_size, int field)
Definition: vc2enc.c:897
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
encode_transform_params
static void encode_transform_params(VC2EncContext *s)
Definition: vc2enc.c:500
VC2EncContext::chroma_y_shift
int chroma_y_shift
Definition: vc2enc.c:160
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: codec_par.h:37
dwt_plane
static int dwt_plane(AVCodecContext *avctx, void *arg)
Definition: vc2enc.c:838
vc2enc_dwt.h
VC2EncContext::wavelet_idx
int wavelet_idx
Definition: vc2enc.c:171
ff_put_string
void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)
Put the string string in the bitstream.
Definition: bitstream.c:59
field
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 field
Definition: writing_filters.txt:78
VC2EncContext::slice_max_bytes
int slice_max_bytes
Definition: vc2enc.c:164
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AVCOL_PRI_SMPTE240M
@ AVCOL_PRI_SMPTE240M
identical to above, also called "SMPTE C" even though it uses D65
Definition: pixfmt.h:460
PutBitContext
Definition: put_bits.h:49
VC2EncContext::avctx
AVCodecContext * avctx
Definition: vc2enc.c:129
AVCOL_PRI_BT470BG
@ AVCOL_PRI_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:458
arg
const char * arg
Definition: jacosubdec.c:67
AVCOL_PRI_SMPTE170M
@ AVCOL_PRI_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:459
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
AVCodecDefault
Definition: internal.h:211
VC2_QM
VC2_QM
Definition: vc2enc.c:79
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
encode_frame_rate
static void encode_frame_rate(VC2EncContext *s)
Definition: vc2enc.c:305
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:52
NULL
#define NULL
Definition: coverity.c:32
VC2BaseVideoFormat::pix_fmt
enum AVPixelFormat pix_fmt
Definition: vc2enc.c:40
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:967
VC2EncContext::quant
uint8_t quant[MAX_DWT_LEVELS][4]
Definition: vc2enc.c:149
Plane::dwt_width
int dwt_width
Definition: vc2enc.c:99
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
VC2EncContext::size_scaler
int size_scaler
Definition: vc2enc.c:158
encode_wavelet_transform
static void encode_wavelet_transform(VC2EncContext *s)
Definition: vc2enc.c:510
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:433
vc2enc_options
static const AVOption vc2enc_options[]
Definition: vc2enc.c:1194
base_video_fmts_len
static const int base_video_fmts_len
Definition: vc2enc.c:77
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
encode_aspect_ratio
static void encode_aspect_ratio(VC2EncContext *s)
Definition: vc2enc.c:317
SliceArgs::quant_idx
int quant_idx
Definition: vc2enc.c:110
VC2BaseVideoFormat::height
int height
Definition: vc2enc.c:42
ff_log2
#define ff_log2
Definition: intmath.h:50
VC2_QM_COL
@ VC2_QM_COL
Definition: vc2enc.c:81
VC2EncContext::av_class
AVClass * av_class
Definition: vc2enc.c:126
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:392
DIRAC_MAX_QUANT_INDEX
#define DIRAC_MAX_QUANT_INDEX
Definition: diractab.h:41
DIRAC_PCODE_AUX
@ DIRAC_PCODE_AUX
Definition: dirac.h:60
SliceArgs::bits_ceil
int bits_ceil
Definition: vc2enc.c:111
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:545
allowed_pix_fmts
static enum AVPixelFormat allowed_pix_fmts[]
Definition: vc2enc.c:1224
encode_hq_slice
static int encode_hq_slice(AVCodecContext *avctx, void *arg)
Definition: vc2enc.c:722
VC2BaseVideoFormat::level
int level
Definition: vc2enc.c:42
VC2EncContext::interlaced
int interlaced
Definition: vc2enc.c:176
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
VC2EncContext::picture_number
uint32_t picture_number
Definition: vc2enc.c:141
VC2EncContext::last_parse_code
enum DiracParseCodes last_parse_code
Definition: vc2enc.c:181
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:506
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
AVPacket::size
int size
Definition: packet.h:374
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
VC2TransformContext
Definition: vc2enc_dwt.h:42
VC2BaseVideoFormat::time_base
AVRational time_base
Definition: vc2enc.c:41
SubBand::stride
ptrdiff_t stride
Definition: cfhd.h:110
Plane::height
int height
Definition: cfhd.h:120
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: avcodec.h:1282
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:396
vc2_encode_init
static av_cold int vc2_encode_init(AVCodecContext *avctx)
Definition: vc2enc.c:1022
VC2EncContext::level
int level
Definition: vc2enc.c:145
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:398
SubBand
Definition: cfhd.h:109
VC2EncContext::bpp
int bpp
Definition: vc2enc.c:137
encode_source_params
static void encode_source_params(VC2EncContext *s)
Definition: vc2enc.c:388
Plane::width
int width
Definition: cfhd.h:119
VC2EncContext::ver
DiracVersionInfo ver
Definition: vc2enc.c:130
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
encode_picture_start
static void encode_picture_start(VC2EncContext *s)
Definition: vc2enc.c:517
DIRAC_PCODE_SEQ_HEADER
@ DIRAC_PCODE_SEQ_HEADER
Definition: dirac.h:58
Plane::coef_stride
ptrdiff_t coef_stride
Definition: vc2enc.c:101
VC2EncContext::num_y
int num_y
Definition: vc2enc.c:156
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
encode_parse_params
static void encode_parse_params(VC2EncContext *s)
Definition: vc2enc.c:261
SliceArgs
Definition: vc2enc.c:104
TransformArgs::ctx
void * ctx
Definition: vc2enc.c:117
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
vc2enc_defaults
static const AVCodecDefault vc2enc_defaults[]
Definition: vc2enc.c:1219
VC2EncContext::wavelet_depth
int wavelet_depth
Definition: vc2enc.c:172
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:128
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
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:562
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
encode_parse_info
static void encode_parse_info(VC2EncContext *s, enum DiracParseCodes pcode)
Definition: vc2enc.c:229
vc2_encode_end
static av_cold int vc2_encode_end(AVCodecContext *avctx)
Definition: vc2enc.c:1005
SubBand::buf
dwtcoef * buf
Definition: vc2enc.c:88
ret
ret
Definition: filter_design.txt:187
VC2BaseVideoFormat::name
const char * name
Definition: vc2enc.c:43
VC2EncContext::transform_args
TransformArgs transform_args[3]
Definition: vc2enc.c:133
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
VC2EncContext
Definition: vc2enc.c:125
VC2EncContext::num_x
int num_x
Definition: vc2enc.c:155
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1280
VC2EncContext::q_ceil
int q_ceil
Definition: vc2enc.c:166
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:395
VC2EncContext::profile
int profile
Definition: vc2enc.c:146
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
DIRAC_PCODE_END_SEQ
@ DIRAC_PCODE_END_SEQ
Definition: dirac.h:59
AVCodecContext
main external API structure.
Definition: avcodec.h:383
put_bits_ptr
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:369
SliceArgs::cache
int cache[DIRAC_MAX_QUANT_INDEX]
Definition: vc2enc.c:106
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
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
encode_seq_header
static void encode_seq_header(VC2EncContext *s)
Definition: vc2enc.c:401
skip_put_bytes
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
Definition: put_bits.h:378
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
VC2_TRANSFORM_HAAR
@ VC2_TRANSFORM_HAAR
Definition: vc2enc_dwt.h:34
VC2ENC_FLAGS
#define VC2ENC_FLAGS
Definition: vc2enc.c:1193
Plane
Definition: cfhd.h:118
VC2EncContext::strict_compliance
int strict_compliance
Definition: vc2enc.c:173
put_vc2_ue_uint
static av_always_inline void put_vc2_ue_uint(PutBitContext *pb, uint32_t val)
Definition: vc2enc.c:184
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
shift
static int shift(int a, int b)
Definition: sonic.c:83
QUANT
#define QUANT(c, mul, add, shift)
Definition: vc2enc.c:525
Plane::dwt_height
int dwt_height
Definition: vc2enc.c:100
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
count_vc2_ue_uint
static av_always_inline int count_vc2_ue_uint(uint32_t val)
Definition: vc2enc.c:212
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
Plane::band
SubBand band[DWT_LEVELS_3D][4]
Definition: cfhd.h:131
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:272
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:38
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
TransformArgs::field
int field
Definition: vc2enc.c:121
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
calc_slice_sizes
static int calc_slice_sizes(VC2EncContext *s)
Definition: vc2enc.c:644
VC2EncContext::base_vf
int base_vf
Definition: vc2enc.c:144
VC2EncContext::slice_height
int slice_height
Definition: vc2enc.c:174
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVPacket
This structure stores compressed data.
Definition: packet.h:350
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
VC2EncContext::plane
Plane plane[3]
Definition: vc2enc.c:128
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
VC2_QM_DEF
@ VC2_QM_DEF
Definition: vc2enc.c:80
AV_CLASS_CATEGORY_ENCODER
@ AV_CLASS_CATEGORY_ENCODER
Definition: log.h:34
h
h
Definition: vp9dsp_template.c:2038
DIRAC_PCODE_PICTURE_HQ
@ DIRAC_PCODE_PICTURE_HQ
Definition: dirac.h:65
TransformArgs::istride
ptrdiff_t istride
Definition: vc2enc.c:120
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
SLICE_REDIST_TOTAL
#define SLICE_REDIST_TOTAL
Definition: vc2enc.c:37
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
VC2_TRANSFORM_HAAR_S
@ VC2_TRANSFORM_HAAR_S
Definition: vc2enc_dwt.h:35
encode_sample_fmt
static void encode_sample_fmt(VC2EncContext *s)
Definition: vc2enc.c:281
VC2EncContext::frame_max_bytes
int frame_max_bytes
Definition: vc2enc.c:163
VC2BaseVideoFormat::width
int width
Definition: vc2enc.c:42
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:753
VC2_TRANSFORM_5_3
@ VC2_TRANSFORM_5_3
Definition: vc2enc_dwt.h:32
encode_signal_range
static void encode_signal_range(VC2EncContext *s)
Definition: vc2enc.c:335
SubBand::height
int height
Definition: cfhd.h:114
VC2EncContext::bpp_idx
int bpp_idx
Definition: vc2enc.c:138