3 * Copyright (c) 2007 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4 * Copyright (c) 2011 MirriAd Ltd
6 * 10 bit support added by MirriAd Ltd, Joseph Artsimovich <joseph@mirriad.com>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 #include "libavutil/imgutils.h"
26 #include "libavutil/timer.h"
30 #include "dnxhddata.h"
35 typedef struct DNXHDContext
{
36 AVCodecContext
*avctx
;
39 int64_t cid
; ///< compression id
40 unsigned int width
, height
;
41 enum AVPixelFormat pix_fmt
;
42 unsigned int mb_width
, mb_height
;
43 uint32_t mb_scan_index
[68]; /* max for 1080p */
44 int cur_field
; ///< current interlaced field
45 VLC ac_vlc
, dc_vlc
, run_vlc
;
48 DECLARE_ALIGNED(16, int16_t, blocks
)[12][64];
50 const CIDEntry
*cid_table
;
51 int bit_depth
; // 8, 10 or 0 if not initialized at all.
53 void (*decode_dct_block
)(struct DNXHDContext
*ctx
, int16_t *block
,
60 #define DNXHD_VLC_BITS 9
61 #define DNXHD_DC_VLC_BITS 7
63 static void dnxhd_decode_dct_block_8(DNXHDContext
*ctx
, int16_t *block
,
65 static void dnxhd_decode_dct_block_10(DNXHDContext
*ctx
, int16_t *block
,
67 static void dnxhd_decode_dct_block_10_444(DNXHDContext
*ctx
, int16_t *block
,
70 static av_cold
int dnxhd_decode_init(AVCodecContext
*avctx
)
72 DNXHDContext
*ctx
= avctx
->priv_data
;
79 static int dnxhd_init_vlc(DNXHDContext
*ctx
, uint32_t cid
)
81 if (cid
!= ctx
->cid
) {
84 if ((index
= ff_dnxhd_get_cid_table(cid
)) < 0) {
85 av_log(ctx
->avctx
, AV_LOG_ERROR
, "unsupported cid %d\n", cid
);
86 return AVERROR(ENOSYS
);
88 if (ff_dnxhd_cid_table
[index
].bit_depth
!= ctx
->bit_depth
) {
89 av_log(ctx
->avctx
, AV_LOG_ERROR
, "bit depth mismatches %d %d\n", ff_dnxhd_cid_table
[index
].bit_depth
, ctx
->bit_depth
);
90 return AVERROR_INVALIDDATA
;
92 ctx
->cid_table
= &ff_dnxhd_cid_table
[index
];
94 ff_free_vlc(&ctx
->ac_vlc
);
95 ff_free_vlc(&ctx
->dc_vlc
);
96 ff_free_vlc(&ctx
->run_vlc
);
98 init_vlc(&ctx
->ac_vlc
, DNXHD_VLC_BITS
, 257,
99 ctx
->cid_table
->ac_bits
, 1, 1,
100 ctx
->cid_table
->ac_codes
, 2, 2, 0);
101 init_vlc(&ctx
->dc_vlc
, DNXHD_DC_VLC_BITS
, ctx
->bit_depth
+ 4,
102 ctx
->cid_table
->dc_bits
, 1, 1,
103 ctx
->cid_table
->dc_codes
, 1, 1, 0);
104 init_vlc(&ctx
->run_vlc
, DNXHD_VLC_BITS
, 62,
105 ctx
->cid_table
->run_bits
, 1, 1,
106 ctx
->cid_table
->run_codes
, 2, 2, 0);
108 ff_init_scantable(ctx
->idsp
.idct_permutation
, &ctx
->scantable
,
115 static int dnxhd_decode_header(DNXHDContext
*ctx
, AVFrame
*frame
,
116 const uint8_t *buf
, int buf_size
,
119 static const uint8_t header_prefix
[] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
120 static const uint8_t header_prefix444
[] = { 0x00, 0x00, 0x02, 0x80, 0x02 };
123 if (buf_size
< 0x280)
124 return AVERROR_INVALIDDATA
;
126 if (memcmp(buf
, header_prefix
, 5) && memcmp(buf
, header_prefix444
, 5)) {
127 av_log(ctx
->avctx
, AV_LOG_ERROR
, "error in header\n");
128 return AVERROR_INVALIDDATA
;
130 if (buf
[5] & 2) { /* interlaced */
131 ctx
->cur_field
= buf
[5] & 1;
132 frame
->interlaced_frame
= 1;
133 frame
->top_field_first
= first_field
^ ctx
->cur_field
;
134 av_log(ctx
->avctx
, AV_LOG_DEBUG
,
135 "interlaced %d, cur field %d\n", buf
[5] & 3, ctx
->cur_field
);
138 ctx
->height
= AV_RB16(buf
+ 0x18);
139 ctx
->width
= AV_RB16(buf
+ 0x1a);
141 av_dlog(ctx
->avctx
, "width %d, height %d\n", ctx
->width
, ctx
->height
);
144 if (buf
[0x4] == 0x2) {
145 ctx
->pix_fmt
= AV_PIX_FMT_YUV444P10
;
146 ctx
->avctx
->bits_per_raw_sample
= 10;
147 if (ctx
->bit_depth
!= 10) {
148 ff_blockdsp_init(&ctx
->bdsp
, ctx
->avctx
);
149 ff_idctdsp_init(&ctx
->idsp
, ctx
->avctx
);
151 ctx
->decode_dct_block
= dnxhd_decode_dct_block_10_444
;
154 } else if (buf
[0x21] & 0x40) {
155 ctx
->pix_fmt
= AV_PIX_FMT_YUV422P10
;
156 ctx
->avctx
->bits_per_raw_sample
= 10;
157 if (ctx
->bit_depth
!= 10) {
158 ff_blockdsp_init(&ctx
->bdsp
, ctx
->avctx
);
159 ff_idctdsp_init(&ctx
->idsp
, ctx
->avctx
);
161 ctx
->decode_dct_block
= dnxhd_decode_dct_block_10
;
164 ctx
->pix_fmt
= AV_PIX_FMT_YUV422P
;
165 ctx
->avctx
->bits_per_raw_sample
= 8;
166 if (ctx
->bit_depth
!= 8) {
167 ff_blockdsp_init(&ctx
->bdsp
, ctx
->avctx
);
168 ff_idctdsp_init(&ctx
->idsp
, ctx
->avctx
);
170 ctx
->decode_dct_block
= dnxhd_decode_dct_block_8
;
174 cid
= AV_RB32(buf
+ 0x28);
175 av_dlog(ctx
->avctx
, "compression id %d\n", cid
);
177 if ((ret
= dnxhd_init_vlc(ctx
, cid
)) < 0)
180 if (buf_size
< ctx
->cid_table
->coding_unit_size
) {
181 av_log(ctx
->avctx
, AV_LOG_ERROR
, "incorrect frame size\n");
182 return AVERROR_INVALIDDATA
;
185 ctx
->mb_width
= ctx
->width
>> 4;
186 ctx
->mb_height
= buf
[0x16d];
189 "mb width %d, mb height %d\n", ctx
->mb_width
, ctx
->mb_height
);
191 if ((ctx
->height
+ 15) >> 4 == ctx
->mb_height
&& frame
->interlaced_frame
)
194 if (ctx
->mb_height
> 68 ||
195 (ctx
->mb_height
<< frame
->interlaced_frame
) > (ctx
->height
+ 15) >> 4) {
196 av_log(ctx
->avctx
, AV_LOG_ERROR
,
197 "mb height too big: %d\n", ctx
->mb_height
);
198 return AVERROR_INVALIDDATA
;
201 for (i
= 0; i
< ctx
->mb_height
; i
++) {
202 ctx
->mb_scan_index
[i
] = AV_RB32(buf
+ 0x170 + (i
<< 2));
203 av_dlog(ctx
->avctx
, "mb scan index %d\n", ctx
->mb_scan_index
[i
]);
204 if (buf_size
< ctx
->mb_scan_index
[i
] + 0x280LL
) {
205 av_log(ctx
->avctx
, AV_LOG_ERROR
, "invalid mb scan index\n");
206 return AVERROR_INVALIDDATA
;
213 static av_always_inline
void dnxhd_decode_dct_block(DNXHDContext
*ctx
,
214 int16_t *block
, int n
,
220 int i
, j
, index1
, index2
, len
, flags
;
221 int level
, component
, sign
;
223 const uint8_t *weight_matrix
;
224 const uint8_t *ac_level
= ctx
->cid_table
->ac_level
;
225 const uint8_t *ac_flags
= ctx
->cid_table
->ac_flags
;
226 const int eob_index
= ctx
->cid_table
->eob_index
;
227 OPEN_READER(bs
, &ctx
->gb
);
231 component
= 1 + (n
& 1);
232 scale
= ctx
->chroma_scale
;
233 weight_matrix
= ctx
->cid_table
->chroma_weight
;
236 scale
= ctx
->luma_scale
;
237 weight_matrix
= ctx
->cid_table
->luma_weight
;
240 component
= (n
>> 1) % 3;
242 scale
= ctx
->chroma_scale
;
243 weight_matrix
= ctx
->cid_table
->chroma_weight
;
245 scale
= ctx
->luma_scale
;
246 weight_matrix
= ctx
->cid_table
->luma_weight
;
250 UPDATE_CACHE(bs
, &ctx
->gb
);
251 GET_VLC(len
, bs
, &ctx
->gb
, ctx
->dc_vlc
.table
, DNXHD_DC_VLC_BITS
, 1);
253 level
= GET_CACHE(bs
, &ctx
->gb
);
254 LAST_SKIP_BITS(bs
, &ctx
->gb
, len
);
256 level
= (NEG_USR32(sign
^ level
, len
) ^ sign
) - sign
;
257 ctx
->last_dc
[component
] += level
;
259 block
[0] = ctx
->last_dc
[component
];
263 UPDATE_CACHE(bs
, &ctx
->gb
);
264 GET_VLC(index1
, bs
, &ctx
->gb
, ctx
->ac_vlc
.table
,
267 while (index1
!= eob_index
) {
268 level
= ac_level
[index1
];
269 flags
= ac_flags
[index1
];
271 sign
= SHOW_SBITS(bs
, &ctx
->gb
, 1);
272 SKIP_BITS(bs
, &ctx
->gb
, 1);
275 level
+= SHOW_UBITS(bs
, &ctx
->gb
, index_bits
) << 7;
276 SKIP_BITS(bs
, &ctx
->gb
, index_bits
);
280 UPDATE_CACHE(bs
, &ctx
->gb
);
281 GET_VLC(index2
, bs
, &ctx
->gb
, ctx
->run_vlc
.table
,
283 i
+= ctx
->cid_table
->run
[index2
];
287 av_log(ctx
->avctx
, AV_LOG_ERROR
, "ac tex damaged %d, %d\n", n
, i
);
291 j
= ctx
->scantable
.permutated
[i
];
293 if (level_bias
< 32 || weight_matrix
[i
] != level_bias
)
295 level
>>= level_shift
;
297 block
[j
] = (level
^ sign
) - sign
;
299 UPDATE_CACHE(bs
, &ctx
->gb
);
300 GET_VLC(index1
, bs
, &ctx
->gb
, ctx
->ac_vlc
.table
,
304 CLOSE_READER(bs
, &ctx
->gb
);
307 static void dnxhd_decode_dct_block_8(DNXHDContext
*ctx
, int16_t *block
,
310 dnxhd_decode_dct_block(ctx
, block
, n
, qscale
, 4, 32, 6);
313 static void dnxhd_decode_dct_block_10(DNXHDContext
*ctx
, int16_t *block
,
316 dnxhd_decode_dct_block(ctx
, block
, n
, qscale
, 6, 8, 4);
319 static void dnxhd_decode_dct_block_10_444(DNXHDContext
*ctx
, int16_t *block
,
322 dnxhd_decode_dct_block(ctx
, block
, n
, qscale
, 6, 32, 6);
325 static int dnxhd_decode_macroblock(DNXHDContext
*ctx
, AVFrame
*frame
,
328 int shift1
= ctx
->bit_depth
== 10;
329 int dct_linesize_luma
= frame
->linesize
[0];
330 int dct_linesize_chroma
= frame
->linesize
[1];
331 uint8_t *dest_y
, *dest_u
, *dest_v
;
332 int dct_y_offset
, dct_x_offset
;
335 qscale
= get_bits(&ctx
->gb
, 11);
336 skip_bits1(&ctx
->gb
);
338 if (qscale
!= ctx
->last_qscale
) {
339 for (i
= 0; i
< 64; i
++) {
340 ctx
->luma_scale
[i
] = qscale
* ctx
->cid_table
->luma_weight
[i
];
341 ctx
->chroma_scale
[i
] = qscale
* ctx
->cid_table
->chroma_weight
[i
];
343 ctx
->last_qscale
= qscale
;
346 for (i
= 0; i
< 8; i
++) {
347 ctx
->bdsp
.clear_block(ctx
->blocks
[i
]);
348 ctx
->decode_dct_block(ctx
, ctx
->blocks
[i
], i
, qscale
);
351 for (; i
< 12; i
++) {
352 ctx
->bdsp
.clear_block(ctx
->blocks
[i
]);
353 ctx
->decode_dct_block(ctx
, ctx
->blocks
[i
], i
, qscale
);
357 if (frame
->interlaced_frame
) {
358 dct_linesize_luma
<<= 1;
359 dct_linesize_chroma
<<= 1;
362 dest_y
= frame
->data
[0] + ((y
* dct_linesize_luma
) << 4) + (x
<< (4 + shift1
));
363 dest_u
= frame
->data
[1] + ((y
* dct_linesize_chroma
) << 4) + (x
<< (3 + shift1
+ ctx
->is_444
));
364 dest_v
= frame
->data
[2] + ((y
* dct_linesize_chroma
) << 4) + (x
<< (3 + shift1
+ ctx
->is_444
));
366 if (ctx
->cur_field
) {
367 dest_y
+= frame
->linesize
[0];
368 dest_u
+= frame
->linesize
[1];
369 dest_v
+= frame
->linesize
[2];
372 dct_y_offset
= dct_linesize_luma
<< 3;
373 dct_x_offset
= 8 << shift1
;
375 ctx
->idsp
.idct_put(dest_y
, dct_linesize_luma
, ctx
->blocks
[0]);
376 ctx
->idsp
.idct_put(dest_y
+ dct_x_offset
, dct_linesize_luma
, ctx
->blocks
[1]);
377 ctx
->idsp
.idct_put(dest_y
+ dct_y_offset
, dct_linesize_luma
, ctx
->blocks
[4]);
378 ctx
->idsp
.idct_put(dest_y
+ dct_y_offset
+ dct_x_offset
, dct_linesize_luma
, ctx
->blocks
[5]);
380 if (!(ctx
->avctx
->flags
& CODEC_FLAG_GRAY
)) {
381 dct_y_offset
= dct_linesize_chroma
<< 3;
382 ctx
->idsp
.idct_put(dest_u
, dct_linesize_chroma
, ctx
->blocks
[2]);
383 ctx
->idsp
.idct_put(dest_v
, dct_linesize_chroma
, ctx
->blocks
[3]);
384 ctx
->idsp
.idct_put(dest_u
+ dct_y_offset
, dct_linesize_chroma
, ctx
->blocks
[6]);
385 ctx
->idsp
.idct_put(dest_v
+ dct_y_offset
, dct_linesize_chroma
, ctx
->blocks
[7]);
388 ctx
->idsp
.idct_put(dest_y
, dct_linesize_luma
, ctx
->blocks
[0]);
389 ctx
->idsp
.idct_put(dest_y
+ dct_x_offset
, dct_linesize_luma
, ctx
->blocks
[1]);
390 ctx
->idsp
.idct_put(dest_y
+ dct_y_offset
, dct_linesize_luma
, ctx
->blocks
[6]);
391 ctx
->idsp
.idct_put(dest_y
+ dct_y_offset
+ dct_x_offset
, dct_linesize_luma
, ctx
->blocks
[7]);
393 if (!(ctx
->avctx
->flags
& CODEC_FLAG_GRAY
)) {
394 dct_y_offset
= dct_linesize_chroma
<< 3;
395 ctx
->idsp
.idct_put(dest_u
, dct_linesize_chroma
, ctx
->blocks
[2]);
396 ctx
->idsp
.idct_put(dest_u
+ dct_x_offset
, dct_linesize_chroma
, ctx
->blocks
[3]);
397 ctx
->idsp
.idct_put(dest_u
+ dct_y_offset
, dct_linesize_chroma
, ctx
->blocks
[8]);
398 ctx
->idsp
.idct_put(dest_u
+ dct_y_offset
+ dct_x_offset
, dct_linesize_chroma
, ctx
->blocks
[9]);
399 ctx
->idsp
.idct_put(dest_v
, dct_linesize_chroma
, ctx
->blocks
[4]);
400 ctx
->idsp
.idct_put(dest_v
+ dct_x_offset
, dct_linesize_chroma
, ctx
->blocks
[5]);
401 ctx
->idsp
.idct_put(dest_v
+ dct_y_offset
, dct_linesize_chroma
, ctx
->blocks
[10]);
402 ctx
->idsp
.idct_put(dest_v
+ dct_y_offset
+ dct_x_offset
, dct_linesize_chroma
, ctx
->blocks
[11]);
409 static int dnxhd_decode_macroblocks(DNXHDContext
*ctx
, AVFrame
*frame
,
410 const uint8_t *buf
, int buf_size
)
413 for (y
= 0; y
< ctx
->mb_height
; y
++) {
416 ctx
->last_dc
[2] = 1 << (ctx
->bit_depth
+ 2); // for levels +2^(bitdepth-1)
417 init_get_bits(&ctx
->gb
, buf
+ ctx
->mb_scan_index
[y
], (buf_size
- ctx
->mb_scan_index
[y
]) << 3);
418 for (x
= 0; x
< ctx
->mb_width
; x
++) {
420 dnxhd_decode_macroblock(ctx
, frame
, x
, y
);
421 //STOP_TIMER("decode macroblock");
427 static int dnxhd_decode_frame(AVCodecContext
*avctx
, void *data
,
428 int *got_frame
, AVPacket
*avpkt
)
430 const uint8_t *buf
= avpkt
->data
;
431 int buf_size
= avpkt
->size
;
432 DNXHDContext
*ctx
= avctx
->priv_data
;
433 ThreadFrame frame
= { .f
= data
};
434 AVFrame
*picture
= data
;
438 av_dlog(avctx
, "frame size %d\n", buf_size
);
441 if ((ret
= dnxhd_decode_header(ctx
, picture
, buf
, buf_size
, first_field
)) < 0)
444 if ((avctx
->width
|| avctx
->height
) &&
445 (ctx
->width
!= avctx
->width
|| ctx
->height
!= avctx
->height
)) {
446 av_log(avctx
, AV_LOG_WARNING
, "frame size changed: %dx%d -> %dx%d\n",
447 avctx
->width
, avctx
->height
, ctx
->width
, ctx
->height
);
450 if (avctx
->pix_fmt
!= AV_PIX_FMT_NONE
&& avctx
->pix_fmt
!= ctx
->pix_fmt
) {
451 av_log(avctx
, AV_LOG_WARNING
, "pix_fmt changed: %s -> %s\n",
452 av_get_pix_fmt_name(avctx
->pix_fmt
), av_get_pix_fmt_name(ctx
->pix_fmt
));
456 avctx
->pix_fmt
= ctx
->pix_fmt
;
457 ret
= ff_set_dimensions(avctx
, ctx
->width
, ctx
->height
);
462 if ((ret
= ff_thread_get_buffer(avctx
, &frame
, 0)) < 0)
464 picture
->pict_type
= AV_PICTURE_TYPE_I
;
465 picture
->key_frame
= 1;
468 dnxhd_decode_macroblocks(ctx
, picture
, buf
+ 0x280, buf_size
- 0x280);
470 if (first_field
&& picture
->interlaced_frame
) {
471 buf
+= ctx
->cid_table
->coding_unit_size
;
472 buf_size
-= ctx
->cid_table
->coding_unit_size
;
474 goto decode_coding_unit
;
481 static av_cold
int dnxhd_decode_close(AVCodecContext
*avctx
)
483 DNXHDContext
*ctx
= avctx
->priv_data
;
485 ff_free_vlc(&ctx
->ac_vlc
);
486 ff_free_vlc(&ctx
->dc_vlc
);
487 ff_free_vlc(&ctx
->run_vlc
);
491 AVCodec ff_dnxhd_decoder
= {
493 .long_name
= NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
494 .type
= AVMEDIA_TYPE_VIDEO
,
495 .id
= AV_CODEC_ID_DNXHD
,
496 .priv_data_size
= sizeof(DNXHDContext
),
497 .init
= dnxhd_decode_init
,
498 .close
= dnxhd_decode_close
,
499 .decode
= dnxhd_decode_frame
,
500 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_FRAME_THREADS
,