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

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