stereo3d: Support view type for frame sequence type
[ffmpeg.git] / libavcodec / dnxhdenc.c
1 /*
2  * VC3/DNxHD encoder
3  * Copyright (c) 2007 Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  * Copyright (c) 2011 MirriAd Ltd
5  *
6  * VC-3 encoder funded by the British Broadcasting Corporation
7  * 10 bit support added by MirriAd Ltd, Joseph Artsimovich <joseph@mirriad.com>
8  *
9  * This file is part of Libav.
10  *
11  * Libav is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * Libav is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with Libav; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25
26 #include "libavutil/attributes.h"
27 #include "libavutil/internal.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/timer.h"
30
31 #include "avcodec.h"
32 #include "blockdsp.h"
33 #include "fdctdsp.h"
34 #include "internal.h"
35 #include "mpegvideo.h"
36 #include "pixblockdsp.h"
37 #include "dnxhdenc.h"
38
39 // The largest value that will not lead to overflow for 10-bit samples.
40 #define DNX10BIT_QMAT_SHIFT 18
41 #define RC_VARIANCE 1 // use variance or ssd for fast rc
42 #define LAMBDA_FRAC_BITS 10
43
44 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
45 static const AVOption options[] = {
46     { "nitris_compat", "encode with Avid Nitris compatibility",
47         offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
48     { "ibias", "intra quant bias",
49         offsetof(DNXHDEncContext, intra_quant_bias), AV_OPT_TYPE_INT,
50         { .i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, VE },
51     { NULL }
52 };
53
54 static const AVClass class = {
55     .class_name = "dnxhd",
56     .item_name  = av_default_item_name,
57     .option     = options,
58     .version    = LIBAVUTIL_VERSION_INT,
59 };
60
61 static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *restrict block,
62                                           const uint8_t *pixels,
63                                           ptrdiff_t line_size)
64 {
65     int i;
66     for (i = 0; i < 4; i++) {
67         block[0] = pixels[0];
68         block[1] = pixels[1];
69         block[2] = pixels[2];
70         block[3] = pixels[3];
71         block[4] = pixels[4];
72         block[5] = pixels[5];
73         block[6] = pixels[6];
74         block[7] = pixels[7];
75         pixels  += line_size;
76         block   += 8;
77     }
78     memcpy(block,      block -  8, sizeof(*block) * 8);
79     memcpy(block +  8, block - 16, sizeof(*block) * 8);
80     memcpy(block + 16, block - 24, sizeof(*block) * 8);
81     memcpy(block + 24, block - 32, sizeof(*block) * 8);
82 }
83
84 static av_always_inline
85 void dnxhd_10bit_get_pixels_8x4_sym(int16_t *restrict block,
86                                     const uint8_t *pixels,
87                                     ptrdiff_t line_size)
88 {
89     int i;
90
91     block += 32;
92
93     for (i = 0; i < 4; i++) {
94         memcpy(block + i * 8, pixels + i * line_size, 8 * sizeof(*block));
95         memcpy(block - (i + 1) * 8, pixels + i * line_size, 8 * sizeof(*block));
96     }
97 }
98
99 static int dnxhd_10bit_dct_quantize(MpegEncContext *ctx, int16_t *block,
100                                     int n, int qscale, int *overflow)
101 {
102     const uint8_t *scantable= ctx->intra_scantable.scantable;
103     const int *qmat = ctx->q_intra_matrix[qscale];
104     int last_non_zero = 0;
105     int i;
106
107     ctx->fdsp.fdct(block);
108
109     // Divide by 4 with rounding, to compensate scaling of DCT coefficients
110     block[0] = (block[0] + 2) >> 2;
111
112     for (i = 1; i < 64; ++i) {
113         int j = scantable[i];
114         int sign = FF_SIGNBIT(block[j]);
115         int level = (block[j] ^ sign) - sign;
116         level = level * qmat[j] >> DNX10BIT_QMAT_SHIFT;
117         block[j] = (level ^ sign) - sign;
118         if (level)
119             last_non_zero = i;
120     }
121
122     return last_non_zero;
123 }
124
125 static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
126 {
127     int i, j, level, run;
128     int max_level = 1 << (ctx->cid_table->bit_depth + 2);
129
130     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_codes,
131                       max_level * 4 * sizeof(*ctx->vlc_codes), fail);
132     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_bits,
133                       max_level * 4 * sizeof(*ctx->vlc_bits), fail);
134     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes,
135                       63 * 2, fail);
136     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits,
137                       63, fail);
138
139     ctx->vlc_codes += max_level * 2;
140     ctx->vlc_bits  += max_level * 2;
141     for (level = -max_level; level < max_level; level++) {
142         for (run = 0; run < 2; run++) {
143             int index = (level << 1) | run;
144             int sign, offset = 0, alevel = level;
145
146             MASK_ABS(sign, alevel);
147             if (alevel > 64) {
148                 offset  = (alevel - 1) >> 6;
149                 alevel -= offset << 6;
150             }
151             for (j = 0; j < 257; j++) {
152                 if (ctx->cid_table->ac_level[j] == alevel &&
153                     (!offset || (ctx->cid_table->ac_index_flag[j] && offset)) &&
154                     (!run    || (ctx->cid_table->ac_run_flag  [j] && run))) {
155                     assert(!ctx->vlc_codes[index]);
156                     if (alevel) {
157                         ctx->vlc_codes[index] =
158                             (ctx->cid_table->ac_codes[j] << 1) | (sign & 1);
159                         ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j] + 1;
160                     } else {
161                         ctx->vlc_codes[index] = ctx->cid_table->ac_codes[j];
162                         ctx->vlc_bits[index]  = ctx->cid_table->ac_bits[j];
163                     }
164                     break;
165                 }
166             }
167             assert(!alevel || j < 257);
168             if (offset) {
169                 ctx->vlc_codes[index] =
170                     (ctx->vlc_codes[index] << ctx->cid_table->index_bits) | offset;
171                 ctx->vlc_bits[index] += ctx->cid_table->index_bits;
172             }
173         }
174     }
175     for (i = 0; i < 62; i++) {
176         int run = ctx->cid_table->run[i];
177         assert(run < 63);
178         ctx->run_codes[run] = ctx->cid_table->run_codes[i];
179         ctx->run_bits[run]  = ctx->cid_table->run_bits[i];
180     }
181     return 0;
182 fail:
183     return AVERROR(ENOMEM);
184 }
185
186 static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
187 {
188     // init first elem to 1 to avoid div by 0 in convert_matrix
189     uint16_t weight_matrix[64] = { 1, }; // convert_matrix needs uint16_t*
190     int qscale, i;
191     const uint8_t *luma_weight_table   = ctx->cid_table->luma_weight;
192     const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight;
193
194     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l,
195                       (ctx->m.avctx->qmax + 1) * 64 * sizeof(int), fail);
196     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c,
197                       (ctx->m.avctx->qmax + 1) * 64 * sizeof(int), fail);
198     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16,
199                       (ctx->m.avctx->qmax + 1) * 64 * 2 * sizeof(uint16_t),
200                       fail);
201     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16,
202                       (ctx->m.avctx->qmax + 1) * 64 * 2 * sizeof(uint16_t),
203                       fail);
204
205     if (ctx->cid_table->bit_depth == 8) {
206         for (i = 1; i < 64; i++) {
207             int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
208             weight_matrix[j] = ctx->cid_table->luma_weight[i];
209         }
210         ff_convert_matrix(&ctx->m, ctx->qmatrix_l, ctx->qmatrix_l16,
211                           weight_matrix, ctx->intra_quant_bias, 1,
212                           ctx->m.avctx->qmax, 1);
213         for (i = 1; i < 64; i++) {
214             int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
215             weight_matrix[j] = ctx->cid_table->chroma_weight[i];
216         }
217         ff_convert_matrix(&ctx->m, ctx->qmatrix_c, ctx->qmatrix_c16,
218                           weight_matrix, ctx->intra_quant_bias, 1,
219                           ctx->m.avctx->qmax, 1);
220
221         for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
222             for (i = 0; i < 64; i++) {
223                 ctx->qmatrix_l[qscale][i]      <<= 2;
224                 ctx->qmatrix_c[qscale][i]      <<= 2;
225                 ctx->qmatrix_l16[qscale][0][i] <<= 2;
226                 ctx->qmatrix_l16[qscale][1][i] <<= 2;
227                 ctx->qmatrix_c16[qscale][0][i] <<= 2;
228                 ctx->qmatrix_c16[qscale][1][i] <<= 2;
229             }
230         }
231     } else {
232         // 10-bit
233         for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
234             for (i = 1; i < 64; i++) {
235                 int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
236
237                 /* The quantization formula from the VC-3 standard is:
238                  * quantized = sign(block[i]) * floor(abs(block[i]/s) * p /
239                  *             (qscale * weight_table[i]))
240                  * Where p is 32 for 8-bit samples and 8 for 10-bit ones.
241                  * The s factor compensates scaling of DCT coefficients done by
242                  * the DCT routines, and therefore is not present in standard.
243                  * It's 8 for 8-bit samples and 4 for 10-bit ones.
244                  * We want values of ctx->qtmatrix_l and ctx->qtmatrix_r to be:
245                  *     ((1 << DNX10BIT_QMAT_SHIFT) * (p / s)) /
246                  *     (qscale * weight_table[i])
247                  * For 10-bit samples, p / s == 2 */
248                 ctx->qmatrix_l[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
249                                             (qscale * luma_weight_table[i]);
250                 ctx->qmatrix_c[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
251                                             (qscale * chroma_weight_table[i]);
252             }
253         }
254     }
255
256     return 0;
257 fail:
258     return AVERROR(ENOMEM);
259 }
260
261 static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
262 {
263     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_rc,
264                       8160 * ctx->m.avctx->qmax * sizeof(RCEntry), fail);
265     if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD)
266         FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_cmp,
267                           ctx->m.mb_num * sizeof(RCCMPEntry), fail);
268
269     ctx->frame_bits = (ctx->cid_table->coding_unit_size -
270                        640 - 4 - ctx->min_padding) * 8;
271     ctx->qscale = 1;
272     ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2
273     return 0;
274 fail:
275     return AVERROR(ENOMEM);
276 }
277
278 static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
279 {
280     DNXHDEncContext *ctx = avctx->priv_data;
281     int i, index, bit_depth, ret;
282
283     switch (avctx->pix_fmt) {
284     case AV_PIX_FMT_YUV422P:
285         bit_depth = 8;
286         break;
287     case AV_PIX_FMT_YUV422P10:
288         bit_depth = 10;
289         break;
290     default:
291         av_log(avctx, AV_LOG_ERROR,
292                "Pixel format is incompatible with DNxHD, use yuv422p or yuv422p10.\n");
293         return AVERROR(EINVAL);
294     }
295
296     ctx->cid = ff_dnxhd_find_cid(avctx, bit_depth);
297     if (!ctx->cid) {
298         av_log(avctx, AV_LOG_ERROR,
299                "Video parameters incompatible with DNxHD, available CIDs:\n");
300         ff_dnxhd_list_cid(avctx);
301         return AVERROR(EINVAL);
302     }
303     av_log(avctx, AV_LOG_DEBUG, "cid %d\n", ctx->cid);
304
305     index = ff_dnxhd_get_cid_table(ctx->cid);
306     if (index < 0)
307         return index;
308     ctx->cid_table = &ff_dnxhd_cid_table[index];
309
310     ctx->m.avctx    = avctx;
311     ctx->m.mb_intra = 1;
312     ctx->m.h263_aic = 1;
313
314     avctx->bits_per_raw_sample = ctx->cid_table->bit_depth;
315
316     ff_blockdsp_init(&ctx->bdsp);
317     ff_fdctdsp_init(&ctx->m.fdsp, avctx);
318     ff_mpv_idct_init(&ctx->m);
319     ff_mpegvideoencdsp_init(&ctx->m.mpvencdsp, avctx);
320     ff_pixblockdsp_init(&ctx->m.pdsp, avctx);
321     if (!ctx->m.dct_quantize)
322         ctx->m.dct_quantize = ff_dct_quantize_c;
323
324     if (ctx->cid_table->bit_depth == 10) {
325         ctx->m.dct_quantize     = dnxhd_10bit_dct_quantize;
326         ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym;
327         ctx->block_width_l2     = 4;
328     } else {
329         ctx->get_pixels_8x4_sym = dnxhd_8bit_get_pixels_8x4_sym;
330         ctx->block_width_l2     = 3;
331     }
332
333     if (ARCH_X86)
334         ff_dnxhdenc_init_x86(ctx);
335
336     ctx->m.mb_height = (avctx->height + 15) / 16;
337     ctx->m.mb_width  = (avctx->width  + 15) / 16;
338
339     if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
340         ctx->interlaced   = 1;
341         ctx->m.mb_height /= 2;
342     }
343
344     ctx->m.mb_num = ctx->m.mb_height * ctx->m.mb_width;
345
346     // XXX tune lbias/cbias
347     if ((ret = dnxhd_init_qmat(ctx, ctx->intra_quant_bias, 0)) < 0)
348         return ret;
349
350     /* Avid Nitris hardware decoder requires a minimum amount of padding
351      * in the coding unit payload */
352     if (ctx->nitris_compat)
353         ctx->min_padding = 1600;
354
355     if ((ret = dnxhd_init_vlc(ctx)) < 0)
356         return ret;
357     if ((ret = dnxhd_init_rc(ctx)) < 0)
358         return ret;
359
360     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size,
361                       ctx->m.mb_height * sizeof(uint32_t), fail);
362     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs,
363                       ctx->m.mb_height * sizeof(uint32_t), fail);
364     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits,
365                       ctx->m.mb_num * sizeof(uint16_t), fail);
366     FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale,
367                       ctx->m.mb_num * sizeof(uint8_t), fail);
368
369 #if FF_API_CODED_FRAME
370 FF_DISABLE_DEPRECATION_WARNINGS
371     avctx->coded_frame->key_frame = 1;
372     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
373 FF_ENABLE_DEPRECATION_WARNINGS
374 #endif
375
376     if (avctx->thread_count > MAX_THREADS) {
377         av_log(avctx, AV_LOG_ERROR, "too many threads\n");
378         return AVERROR(EINVAL);
379     }
380
381     ctx->thread[0] = ctx;
382     for (i = 1; i < avctx->thread_count; i++) {
383         ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext));
384         memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext));
385     }
386
387     return 0;
388 fail:  // for FF_ALLOCZ_OR_GOTO
389     return AVERROR(ENOMEM);
390 }
391
392 static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
393 {
394     DNXHDEncContext *ctx = avctx->priv_data;
395     static const uint8_t header_prefix[5] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
396
397     memset(buf, 0, 640);
398
399     memcpy(buf, header_prefix, 5);
400     buf[5] = ctx->interlaced ? ctx->cur_field + 2 : 0x01;
401     buf[6] = 0x80; // crc flag off
402     buf[7] = 0xa0; // reserved
403     AV_WB16(buf + 0x18, avctx->height >> ctx->interlaced); // ALPF
404     AV_WB16(buf + 0x1a, avctx->width);  // SPL
405     AV_WB16(buf + 0x1d, avctx->height >> ctx->interlaced); // NAL
406
407     buf[0x21] = ctx->cid_table->bit_depth == 10 ? 0x58 : 0x38;
408     buf[0x22] = 0x88 + (ctx->interlaced << 2);
409     AV_WB32(buf + 0x28, ctx->cid); // CID
410     buf[0x2c] = ctx->interlaced ? 0 : 0x80;
411
412     buf[0x5f] = 0x01; // UDL
413
414     buf[0x167] = 0x02; // reserved
415     AV_WB16(buf + 0x16a, ctx->m.mb_height * 4 + 4); // MSIPS
416     buf[0x16d] = ctx->m.mb_height; // Ns
417     buf[0x16f] = 0x10; // reserved
418
419     ctx->msip = buf + 0x170;
420     return 0;
421 }
422
423 static av_always_inline void dnxhd_encode_dc(DNXHDEncContext *ctx, int diff)
424 {
425     int nbits;
426     if (diff < 0) {
427         nbits = av_log2_16bit(-2 * diff);
428         diff--;
429     } else {
430         nbits = av_log2_16bit(2 * diff);
431     }
432     put_bits(&ctx->m.pb, ctx->cid_table->dc_bits[nbits] + nbits,
433              (ctx->cid_table->dc_codes[nbits] << nbits) +
434              (diff & ((1 << nbits) - 1)));
435 }
436
437 static av_always_inline
438 void dnxhd_encode_block(DNXHDEncContext *ctx, int16_t *block,
439                         int last_index, int n)
440 {
441     int last_non_zero = 0;
442     int slevel, i, j;
443
444     dnxhd_encode_dc(ctx, block[0] - ctx->m.last_dc[n]);
445     ctx->m.last_dc[n] = block[0];
446
447     for (i = 1; i <= last_index; i++) {
448         j = ctx->m.intra_scantable.permutated[i];
449         slevel = block[j];
450         if (slevel) {
451             int run_level = i - last_non_zero - 1;
452             int rlevel = (slevel << 1) | !!run_level;
453             put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
454             if (run_level)
455                 put_bits(&ctx->m.pb, ctx->run_bits[run_level],
456                          ctx->run_codes[run_level]);
457             last_non_zero = i;
458         }
459     }
460     put_bits(&ctx->m.pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB
461 }
462
463 static av_always_inline
464 void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n,
465                         int qscale, int last_index)
466 {
467     const uint8_t *weight_matrix;
468     int level;
469     int i;
470
471     weight_matrix = (n & 2) ? ctx->cid_table->chroma_weight
472                             : ctx->cid_table->luma_weight;
473
474     for (i = 1; i <= last_index; i++) {
475         int j = ctx->m.intra_scantable.permutated[i];
476         level = block[j];
477         if (level) {
478             if (level < 0) {
479                 level = (1 - 2 * level) * qscale * weight_matrix[i];
480                 if (ctx->cid_table->bit_depth == 10) {
481                     if (weight_matrix[i] != 8)
482                         level += 8;
483                     level >>= 4;
484                 } else {
485                     if (weight_matrix[i] != 32)
486                         level += 32;
487                     level >>= 6;
488                 }
489                 level = -level;
490             } else {
491                 level = (2 * level + 1) * qscale * weight_matrix[i];
492                 if (ctx->cid_table->bit_depth == 10) {
493                     if (weight_matrix[i] != 8)
494                         level += 8;
495                     level >>= 4;
496                 } else {
497                     if (weight_matrix[i] != 32)
498                         level += 32;
499                     level >>= 6;
500                 }
501             }
502             block[j] = level;
503         }
504     }
505 }
506
507 static av_always_inline int dnxhd_ssd_block(int16_t *qblock, int16_t *block)
508 {
509     int score = 0;
510     int i;
511     for (i = 0; i < 64; i++)
512         score += (block[i] - qblock[i]) * (block[i] - qblock[i]);
513     return score;
514 }
515
516 static av_always_inline
517 int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
518 {
519     int last_non_zero = 0;
520     int bits = 0;
521     int i, j, level;
522     for (i = 1; i <= last_index; i++) {
523         j = ctx->m.intra_scantable.permutated[i];
524         level = block[j];
525         if (level) {
526             int run_level = i - last_non_zero - 1;
527             bits += ctx->vlc_bits[(level << 1) |
528                     !!run_level] + ctx->run_bits[run_level];
529             last_non_zero = i;
530         }
531     }
532     return bits;
533 }
534
535 static av_always_inline
536 void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
537 {
538     const int bs = ctx->block_width_l2;
539     const int bw = 1 << bs;
540     const uint8_t *ptr_y = ctx->thread[0]->src[0] +
541                            ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs + 1);
542     const uint8_t *ptr_u = ctx->thread[0]->src[1] +
543                            ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs);
544     const uint8_t *ptr_v = ctx->thread[0]->src[2] +
545                            ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs);
546     PixblockDSPContext *pdsp = &ctx->m.pdsp;
547
548     pdsp->get_pixels(ctx->blocks[0], ptr_y,      ctx->m.linesize);
549     pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, ctx->m.linesize);
550     pdsp->get_pixels(ctx->blocks[2], ptr_u,      ctx->m.uvlinesize);
551     pdsp->get_pixels(ctx->blocks[3], ptr_v,      ctx->m.uvlinesize);
552
553     if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
554         if (ctx->interlaced) {
555             ctx->get_pixels_8x4_sym(ctx->blocks[4],
556                                     ptr_y + ctx->dct_y_offset,
557                                     ctx->m.linesize);
558             ctx->get_pixels_8x4_sym(ctx->blocks[5],
559                                     ptr_y + ctx->dct_y_offset + bw,
560                                     ctx->m.linesize);
561             ctx->get_pixels_8x4_sym(ctx->blocks[6],
562                                     ptr_u + ctx->dct_uv_offset,
563                                     ctx->m.uvlinesize);
564             ctx->get_pixels_8x4_sym(ctx->blocks[7],
565                                     ptr_v + ctx->dct_uv_offset,
566                                     ctx->m.uvlinesize);
567         } else {
568             ctx->bdsp.clear_block(ctx->blocks[4]);
569             ctx->bdsp.clear_block(ctx->blocks[5]);
570             ctx->bdsp.clear_block(ctx->blocks[6]);
571             ctx->bdsp.clear_block(ctx->blocks[7]);
572         }
573     } else {
574         pdsp->get_pixels(ctx->blocks[4],
575                          ptr_y + ctx->dct_y_offset, ctx->m.linesize);
576         pdsp->get_pixels(ctx->blocks[5],
577                          ptr_y + ctx->dct_y_offset + bw, ctx->m.linesize);
578         pdsp->get_pixels(ctx->blocks[6],
579                          ptr_u + ctx->dct_uv_offset, ctx->m.uvlinesize);
580         pdsp->get_pixels(ctx->blocks[7],
581                          ptr_v + ctx->dct_uv_offset, ctx->m.uvlinesize);
582     }
583 }
584
585 static av_always_inline
586 int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i)
587 {
588     if (i & 2) {
589         ctx->m.q_intra_matrix16 = ctx->qmatrix_c16;
590         ctx->m.q_intra_matrix   = ctx->qmatrix_c;
591         return 1 + (i & 1);
592     } else {
593         ctx->m.q_intra_matrix16 = ctx->qmatrix_l16;
594         ctx->m.q_intra_matrix   = ctx->qmatrix_l;
595         return 0;
596     }
597 }
598
599 static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
600                                   int jobnr, int threadnr)
601 {
602     DNXHDEncContext *ctx = avctx->priv_data;
603     int mb_y = jobnr, mb_x;
604     int qscale = ctx->qscale;
605     LOCAL_ALIGNED_16(int16_t, block, [64]);
606     ctx = ctx->thread[threadnr];
607
608     ctx->m.last_dc[0] =
609     ctx->m.last_dc[1] =
610     ctx->m.last_dc[2] = 1 << (ctx->cid_table->bit_depth + 2);
611
612     for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
613         unsigned mb = mb_y * ctx->m.mb_width + mb_x;
614         int ssd     = 0;
615         int ac_bits = 0;
616         int dc_bits = 0;
617         int i;
618
619         dnxhd_get_blocks(ctx, mb_x, mb_y);
620
621         for (i = 0; i < 8; i++) {
622             int16_t *src_block = ctx->blocks[i];
623             int overflow, nbits, diff, last_index;
624             int n = dnxhd_switch_matrix(ctx, i);
625
626             memcpy(block, src_block, 64 * sizeof(*block));
627             last_index = ctx->m.dct_quantize(&ctx->m, block, i,
628                                              qscale, &overflow);
629             ac_bits   += dnxhd_calc_ac_bits(ctx, block, last_index);
630
631             diff = block[0] - ctx->m.last_dc[n];
632             if (diff < 0)
633                 nbits = av_log2_16bit(-2 * diff);
634             else
635                 nbits = av_log2_16bit(2 * diff);
636
637             assert(nbits < ctx->cid_table->bit_depth + 4);
638             dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
639
640             ctx->m.last_dc[n] = block[0];
641
642             if (avctx->mb_decision == FF_MB_DECISION_RD || !RC_VARIANCE) {
643                 dnxhd_unquantize_c(ctx, block, i, qscale, last_index);
644                 ctx->m.idsp.idct(block);
645                 ssd += dnxhd_ssd_block(block, src_block);
646             }
647         }
648         ctx->mb_rc[qscale][mb].ssd  = ssd;
649         ctx->mb_rc[qscale][mb].bits = ac_bits + dc_bits + 12 +
650                                       8 * ctx->vlc_bits[0];
651     }
652     return 0;
653 }
654
655 static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg,
656                                int jobnr, int threadnr)
657 {
658     DNXHDEncContext *ctx = avctx->priv_data;
659     int mb_y = jobnr, mb_x;
660     ctx = ctx->thread[threadnr];
661     init_put_bits(&ctx->m.pb, (uint8_t *)arg + 640 + ctx->slice_offs[jobnr],
662                   ctx->slice_size[jobnr]);
663
664     ctx->m.last_dc[0] =
665     ctx->m.last_dc[1] =
666     ctx->m.last_dc[2] = 1 << (ctx->cid_table->bit_depth + 2);
667     for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
668         unsigned mb = mb_y * ctx->m.mb_width + mb_x;
669         int qscale = ctx->mb_qscale[mb];
670         int i;
671
672         put_bits(&ctx->m.pb, 12, qscale << 1);
673
674         dnxhd_get_blocks(ctx, mb_x, mb_y);
675
676         for (i = 0; i < 8; i++) {
677             int16_t *block = ctx->blocks[i];
678             int overflow, n = dnxhd_switch_matrix(ctx, i);
679             int last_index = ctx->m.dct_quantize(&ctx->m, block, i,
680                                                  qscale, &overflow);
681             // START_TIMER;
682             dnxhd_encode_block(ctx, block, last_index, n);
683             // STOP_TIMER("encode_block");
684         }
685     }
686     if (put_bits_count(&ctx->m.pb) & 31)
687         put_bits(&ctx->m.pb, 32 - (put_bits_count(&ctx->m.pb) & 31), 0);
688     flush_put_bits(&ctx->m.pb);
689     return 0;
690 }
691
692 static void dnxhd_setup_threads_slices(DNXHDEncContext *ctx)
693 {
694     int mb_y, mb_x;
695     int offset = 0;
696     for (mb_y = 0; mb_y < ctx->m.mb_height; mb_y++) {
697         int thread_size;
698         ctx->slice_offs[mb_y] = offset;
699         ctx->slice_size[mb_y] = 0;
700         for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) {
701             unsigned mb = mb_y * ctx->m.mb_width + mb_x;
702             ctx->slice_size[mb_y] += ctx->mb_bits[mb];
703         }
704         ctx->slice_size[mb_y]   = (ctx->slice_size[mb_y] + 31) & ~31;
705         ctx->slice_size[mb_y] >>= 3;
706         thread_size = ctx->slice_size[mb_y];
707         offset += thread_size;
708     }
709 }
710
711 static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg,
712                                int jobnr, int threadnr)
713 {
714     DNXHDEncContext *ctx = avctx->priv_data;
715     int mb_y = jobnr, mb_x, x, y;
716     int partial_last_row = (mb_y == ctx->m.mb_height - 1) &&
717                            ((avctx->height >> ctx->interlaced) & 0xF);
718
719     ctx = ctx->thread[threadnr];
720     if (ctx->cid_table->bit_depth == 8) {
721         uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y << 4) * ctx->m.linesize);
722         for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x, pix += 16) {
723             unsigned mb = mb_y * ctx->m.mb_width + mb_x;
724             int sum;
725             int varc;
726
727             if (!partial_last_row && mb_x * 16 <= avctx->width - 16) {
728                 sum  = ctx->m.mpvencdsp.pix_sum(pix, ctx->m.linesize);
729                 varc = ctx->m.mpvencdsp.pix_norm1(pix, ctx->m.linesize);
730             } else {
731                 int bw = FFMIN(avctx->width - 16 * mb_x, 16);
732                 int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16);
733                 sum = varc = 0;
734                 for (y = 0; y < bh; y++) {
735                     for (x = 0; x < bw; x++) {
736                         uint8_t val = pix[x + y * ctx->m.linesize];
737                         sum  += val;
738                         varc += val * val;
739                     }
740                 }
741             }
742             varc = (varc - (((unsigned) sum * sum) >> 8) + 128) >> 8;
743
744             ctx->mb_cmp[mb].value = varc;
745             ctx->mb_cmp[mb].mb    = mb;
746         }
747     } else { // 10-bit
748         const int linesize = ctx->m.linesize >> 1;
749         for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) {
750             uint16_t *pix = (uint16_t *)ctx->thread[0]->src[0] +
751                             ((mb_y << 4) * linesize) + (mb_x << 4);
752             unsigned mb  = mb_y * ctx->m.mb_width + mb_x;
753             int sum = 0;
754             int sqsum = 0;
755             int mean, sqmean;
756             int i, j;
757             // Macroblocks are 16x16 pixels, unlike DCT blocks which are 8x8.
758             for (i = 0; i < 16; ++i) {
759                 for (j = 0; j < 16; ++j) {
760                     // Turn 16-bit pixels into 10-bit ones.
761                     const int sample = (unsigned) pix[j] >> 6;
762                     sum   += sample;
763                     sqsum += sample * sample;
764                     // 2^10 * 2^10 * 16 * 16 = 2^28, which is less than INT_MAX
765                 }
766                 pix += linesize;
767             }
768             mean = sum >> 8; // 16*16 == 2^8
769             sqmean = sqsum >> 8;
770             ctx->mb_cmp[mb].value = sqmean - mean * mean;
771             ctx->mb_cmp[mb].mb    = mb;
772         }
773     }
774     return 0;
775 }
776
777 static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx)
778 {
779     int lambda, up_step, down_step;
780     int last_lower = INT_MAX, last_higher = 0;
781     int x, y, q;
782
783     for (q = 1; q < avctx->qmax; q++) {
784         ctx->qscale = q;
785         avctx->execute2(avctx, dnxhd_calc_bits_thread,
786                         NULL, NULL, ctx->m.mb_height);
787     }
788     up_step = down_step = 2 << LAMBDA_FRAC_BITS;
789     lambda  = ctx->lambda;
790
791     for (;;) {
792         int bits = 0;
793         int end  = 0;
794         if (lambda == last_higher) {
795             lambda++;
796             end = 1; // need to set final qscales/bits
797         }
798         for (y = 0; y < ctx->m.mb_height; y++) {
799             for (x = 0; x < ctx->m.mb_width; x++) {
800                 unsigned min = UINT_MAX;
801                 int qscale = 1;
802                 int mb     = y * ctx->m.mb_width + x;
803                 for (q = 1; q < avctx->qmax; q++) {
804                     unsigned score = ctx->mb_rc[q][mb].bits * lambda +
805                                      ((unsigned) ctx->mb_rc[q][mb].ssd << LAMBDA_FRAC_BITS);
806                     if (score < min) {
807                         min    = score;
808                         qscale = q;
809                     }
810                 }
811                 bits += ctx->mb_rc[qscale][mb].bits;
812                 ctx->mb_qscale[mb] = qscale;
813                 ctx->mb_bits[mb]   = ctx->mb_rc[qscale][mb].bits;
814             }
815             bits = (bits + 31) & ~31; // padding
816             if (bits > ctx->frame_bits)
817                 break;
818         }
819         if (end) {
820             if (bits > ctx->frame_bits)
821                 return AVERROR(EINVAL);
822             break;
823         }
824         if (bits < ctx->frame_bits) {
825             last_lower = FFMIN(lambda, last_lower);
826             if (last_higher != 0)
827                 lambda = (lambda+last_higher)>>1;
828             else
829                 lambda -= down_step;
830             down_step = FFMIN((int64_t)down_step*5, INT_MAX);
831             up_step = 1<<LAMBDA_FRAC_BITS;
832             lambda = FFMAX(1, lambda);
833             if (lambda == last_lower)
834                 break;
835         } else {
836             last_higher = FFMAX(lambda, last_higher);
837             if (last_lower != INT_MAX)
838                 lambda = (lambda+last_lower)>>1;
839             else if ((int64_t)lambda + up_step > INT_MAX)
840                 return AVERROR(EINVAL);
841             else
842                 lambda += up_step;
843             up_step = FFMIN((int64_t)up_step*5, INT_MAX);
844             down_step = 1<<LAMBDA_FRAC_BITS;
845         }
846     }
847     ctx->lambda = lambda;
848     return 0;
849 }
850
851 static int dnxhd_find_qscale(DNXHDEncContext *ctx)
852 {
853     int bits = 0;
854     int up_step = 1;
855     int down_step = 1;
856     int last_higher = 0;
857     int last_lower = INT_MAX;
858     int qscale;
859     int x, y;
860
861     qscale = ctx->qscale;
862     for (;;) {
863         bits = 0;
864         ctx->qscale = qscale;
865         // XXX avoid recalculating bits
866         ctx->m.avctx->execute2(ctx->m.avctx, dnxhd_calc_bits_thread,
867                                NULL, NULL, ctx->m.mb_height);
868         for (y = 0; y < ctx->m.mb_height; y++) {
869             for (x = 0; x < ctx->m.mb_width; x++)
870                 bits += ctx->mb_rc[qscale][y*ctx->m.mb_width+x].bits;
871             bits = (bits+31)&~31; // padding
872             if (bits > ctx->frame_bits)
873                 break;
874         }
875         if (bits < ctx->frame_bits) {
876             if (qscale == 1)
877                 return 1;
878             if (last_higher == qscale - 1) {
879                 qscale = last_higher;
880                 break;
881             }
882             last_lower = FFMIN(qscale, last_lower);
883             if (last_higher != 0)
884                 qscale = (qscale + last_higher) >> 1;
885             else
886                 qscale -= down_step++;
887             if (qscale < 1)
888                 qscale = 1;
889             up_step = 1;
890         } else {
891             if (last_lower == qscale + 1)
892                 break;
893             last_higher = FFMAX(qscale, last_higher);
894             if (last_lower != INT_MAX)
895                 qscale = (qscale + last_lower) >> 1;
896             else
897                 qscale += up_step++;
898             down_step = 1;
899             if (qscale >= ctx->m.avctx->qmax)
900                 return AVERROR(EINVAL);
901         }
902     }
903     ctx->qscale = qscale;
904     return 0;
905 }
906
907 #define BUCKET_BITS 8
908 #define RADIX_PASSES 4
909 #define NBUCKETS (1 << BUCKET_BITS)
910
911 static inline int get_bucket(int value, int shift)
912 {
913     value >>= shift;
914     value  &= NBUCKETS - 1;
915     return NBUCKETS - 1 - value;
916 }
917
918 static void radix_count(const RCCMPEntry *data, int size,
919                         int buckets[RADIX_PASSES][NBUCKETS])
920 {
921     int i, j;
922     memset(buckets, 0, sizeof(buckets[0][0]) * RADIX_PASSES * NBUCKETS);
923     for (i = 0; i < size; i++) {
924         int v = data[i].value;
925         for (j = 0; j < RADIX_PASSES; j++) {
926             buckets[j][get_bucket(v, 0)]++;
927             v >>= BUCKET_BITS;
928         }
929         assert(!v);
930     }
931     for (j = 0; j < RADIX_PASSES; j++) {
932         int offset = size;
933         for (i = NBUCKETS - 1; i >= 0; i--)
934             buckets[j][i] = offset -= buckets[j][i];
935         assert(!buckets[j][0]);
936     }
937 }
938
939 static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data,
940                             int size, int buckets[NBUCKETS], int pass)
941 {
942     int shift = pass * BUCKET_BITS;
943     int i;
944     for (i = 0; i < size; i++) {
945         int v   = get_bucket(data[i].value, shift);
946         int pos = buckets[v]++;
947         dst[pos] = data[i];
948     }
949 }
950
951 static void radix_sort(RCCMPEntry *data, int size)
952 {
953     int buckets[RADIX_PASSES][NBUCKETS];
954     RCCMPEntry *tmp = av_malloc(sizeof(*tmp) * size);
955     radix_count(data, size, buckets);
956     radix_sort_pass(tmp, data, size, buckets[0], 0);
957     radix_sort_pass(data, tmp, size, buckets[1], 1);
958     if (buckets[2][NBUCKETS - 1] || buckets[3][NBUCKETS - 1]) {
959         radix_sort_pass(tmp, data, size, buckets[2], 2);
960         radix_sort_pass(data, tmp, size, buckets[3], 3);
961     }
962     av_free(tmp);
963 }
964
965 static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx)
966 {
967     int max_bits = 0;
968     int ret, x, y;
969     if ((ret = dnxhd_find_qscale(ctx)) < 0)
970         return ret;
971     for (y = 0; y < ctx->m.mb_height; y++) {
972         for (x = 0; x < ctx->m.mb_width; x++) {
973             int mb = y * ctx->m.mb_width + x;
974             int delta_bits;
975             ctx->mb_qscale[mb] = ctx->qscale;
976             ctx->mb_bits[mb] = ctx->mb_rc[ctx->qscale][mb].bits;
977             max_bits += ctx->mb_rc[ctx->qscale][mb].bits;
978             if (!RC_VARIANCE) {
979                 delta_bits = ctx->mb_rc[ctx->qscale][mb].bits -
980                              ctx->mb_rc[ctx->qscale + 1][mb].bits;
981                 ctx->mb_cmp[mb].mb = mb;
982                 ctx->mb_cmp[mb].value =
983                     delta_bits ? ((ctx->mb_rc[ctx->qscale][mb].ssd -
984                                    ctx->mb_rc[ctx->qscale + 1][mb].ssd) * 100) /
985                                   delta_bits
986                                : INT_MIN; // avoid increasing qscale
987             }
988         }
989         max_bits += 31; // worst padding
990     }
991     if (!ret) {
992         if (RC_VARIANCE)
993             avctx->execute2(avctx, dnxhd_mb_var_thread,
994                             NULL, NULL, ctx->m.mb_height);
995         radix_sort(ctx->mb_cmp, ctx->m.mb_num);
996         for (x = 0; x < ctx->m.mb_num && max_bits > ctx->frame_bits; x++) {
997             int mb = ctx->mb_cmp[x].mb;
998             max_bits -= ctx->mb_rc[ctx->qscale][mb].bits -
999                         ctx->mb_rc[ctx->qscale + 1][mb].bits;
1000             ctx->mb_qscale[mb] = ctx->qscale + 1;
1001             ctx->mb_bits[mb]   = ctx->mb_rc[ctx->qscale + 1][mb].bits;
1002         }
1003     }
1004     return 0;
1005 }
1006
1007 static void dnxhd_load_picture(DNXHDEncContext *ctx, const AVFrame *frame)
1008 {
1009     int i;
1010
1011     for (i = 0; i < ctx->m.avctx->thread_count; i++) {
1012         ctx->thread[i]->m.linesize    = frame->linesize[0] << ctx->interlaced;
1013         ctx->thread[i]->m.uvlinesize  = frame->linesize[1] << ctx->interlaced;
1014         ctx->thread[i]->dct_y_offset  = ctx->m.linesize  *8;
1015         ctx->thread[i]->dct_uv_offset = ctx->m.uvlinesize*8;
1016     }
1017
1018 #if FF_API_CODED_FRAME
1019 FF_DISABLE_DEPRECATION_WARNINGS
1020     ctx->m.avctx->coded_frame->interlaced_frame = frame->interlaced_frame;
1021 FF_ENABLE_DEPRECATION_WARNINGS
1022 #endif
1023     ctx->cur_field = frame->interlaced_frame && !frame->top_field_first;
1024 }
1025
1026 static int dnxhd_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1027                                 const AVFrame *frame, int *got_packet)
1028 {
1029     DNXHDEncContext *ctx = avctx->priv_data;
1030     int first_field = 1;
1031     int offset, i, ret;
1032     uint8_t *buf, *sd;
1033
1034     if ((ret = ff_alloc_packet(pkt, ctx->cid_table->frame_size)) < 0) {
1035         av_log(avctx, AV_LOG_ERROR,
1036                "output buffer is too small to compress picture\n");
1037         return ret;
1038     }
1039     buf = pkt->data;
1040
1041     dnxhd_load_picture(ctx, frame);
1042
1043 encode_coding_unit:
1044     for (i = 0; i < 3; i++) {
1045         ctx->src[i] = frame->data[i];
1046         if (ctx->interlaced && ctx->cur_field)
1047             ctx->src[i] += frame->linesize[i];
1048     }
1049
1050     dnxhd_write_header(avctx, buf);
1051
1052     if (avctx->mb_decision == FF_MB_DECISION_RD)
1053         ret = dnxhd_encode_rdo(avctx, ctx);
1054     else
1055         ret = dnxhd_encode_fast(avctx, ctx);
1056     if (ret < 0) {
1057         av_log(avctx, AV_LOG_ERROR,
1058                "picture could not fit ratecontrol constraints, increase qmax\n");
1059         return ret;
1060     }
1061
1062     dnxhd_setup_threads_slices(ctx);
1063
1064     offset = 0;
1065     for (i = 0; i < ctx->m.mb_height; i++) {
1066         AV_WB32(ctx->msip + i * 4, offset);
1067         offset += ctx->slice_size[i];
1068         assert(!(ctx->slice_size[i] & 3));
1069     }
1070
1071     avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height);
1072
1073     assert(640 + offset + 4 <= ctx->cid_table->coding_unit_size);
1074     memset(buf + 640 + offset, 0,
1075            ctx->cid_table->coding_unit_size - 4 - offset - 640);
1076
1077     AV_WB32(buf + ctx->cid_table->coding_unit_size - 4, 0x600DC0DE); // EOF
1078
1079     if (ctx->interlaced && first_field) {
1080         first_field     = 0;
1081         ctx->cur_field ^= 1;
1082         buf            += ctx->cid_table->coding_unit_size;
1083         goto encode_coding_unit;
1084     }
1085
1086 #if FF_API_CODED_FRAME
1087 FF_DISABLE_DEPRECATION_WARNINGS
1088     avctx->coded_frame->quality = ctx->qscale * FF_QP2LAMBDA;
1089 FF_ENABLE_DEPRECATION_WARNINGS
1090 #endif
1091
1092     sd = av_packet_new_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR, sizeof(int));
1093     if (!sd)
1094         return AVERROR(ENOMEM);
1095     *(int *)sd = ctx->qscale * FF_QP2LAMBDA;
1096
1097     pkt->flags |= AV_PKT_FLAG_KEY;
1098     *got_packet = 1;
1099     return 0;
1100 }
1101
1102 static av_cold int dnxhd_encode_end(AVCodecContext *avctx)
1103 {
1104     DNXHDEncContext *ctx = avctx->priv_data;
1105     int max_level        = 1 << (ctx->cid_table->bit_depth + 2);
1106     int i;
1107
1108     av_free(ctx->vlc_codes - max_level * 2);
1109     av_free(ctx->vlc_bits - max_level * 2);
1110     av_freep(&ctx->run_codes);
1111     av_freep(&ctx->run_bits);
1112
1113     av_freep(&ctx->mb_bits);
1114     av_freep(&ctx->mb_qscale);
1115     av_freep(&ctx->mb_rc);
1116     av_freep(&ctx->mb_cmp);
1117     av_freep(&ctx->slice_size);
1118     av_freep(&ctx->slice_offs);
1119
1120     av_freep(&ctx->qmatrix_c);
1121     av_freep(&ctx->qmatrix_l);
1122     av_freep(&ctx->qmatrix_c16);
1123     av_freep(&ctx->qmatrix_l16);
1124
1125     for (i = 1; i < avctx->thread_count; i++)
1126         av_freep(&ctx->thread[i]);
1127
1128     return 0;
1129 }
1130
1131 AVCodec ff_dnxhd_encoder = {
1132     .name           = "dnxhd",
1133     .long_name      = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
1134     .type           = AVMEDIA_TYPE_VIDEO,
1135     .id             = AV_CODEC_ID_DNXHD,
1136     .priv_data_size = sizeof(DNXHDEncContext),
1137     .init           = dnxhd_encode_init,
1138     .encode2        = dnxhd_encode_picture,
1139     .close          = dnxhd_encode_end,
1140     .capabilities   = AV_CODEC_CAP_SLICE_THREADS,
1141     .pix_fmts       = (const enum AVPixelFormat[]) {
1142         AV_PIX_FMT_YUV422P,
1143         AV_PIX_FMT_YUV422P10,
1144         AV_PIX_FMT_NONE
1145     },
1146     .priv_class     = &class,
1147 };