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