FFmpeg: libavcodec/vc2enc.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /