3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
6 * 50 Mbps (DVCPRO50) support
7 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
9 * 100 Mbps (DVCPRO HD) support
10 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
11 * Final code by Roman Shaposhnik
13 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
14 * of DV technical info.
16 * This file is part of FFmpeg.
18 * FFmpeg is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU Lesser General Public
20 * License as published by the Free Software Foundation; either
21 * version 2.1 of the License, or (at your option) any later version.
23 * FFmpeg is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 * Lesser General Public License for more details.
28 * You should have received a copy of the GNU Lesser General Public
29 * License along with FFmpeg; if not, write to the Free Software
30 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
38 #include "libavutil/avassert.h"
39 #include "libavutil/imgutils.h"
40 #include "libavutil/internal.h"
41 #include "libavutil/pixdesc.h"
50 #include "simple_idct.h"
52 typedef struct BlockInfo
{
53 const uint32_t *factor_table
;
54 const uint8_t *scan_table
;
55 uint8_t pos
; /* position in block */
56 void (*idct_put
)(uint8_t *dest
, int line_size
, int16_t *block
);
57 uint8_t partial_bit_count
;
58 uint32_t partial_bit_buffer
;
62 static const int dv_iweight_bits
= 14;
64 static av_cold
int dvvideo_decode_init(AVCodecContext
*avctx
)
66 DVVideoContext
*s
= avctx
->priv_data
;
70 memset(&idsp
,0, sizeof(idsp
));
71 ff_idctdsp_init(&idsp
, avctx
);
73 for (i
= 0; i
< 64; i
++)
74 s
->dv_zigzag
[0][i
] = idsp
.idct_permutation
[ff_zigzag_direct
[i
]];
77 for (i
= 0; i
< 64; i
++){
78 int j
= ff_dv_zigzag248_direct
[i
];
79 s
->dv_zigzag
[1][i
] = idsp
.idct_permutation
[(j
& 7) + (j
& 8) * 4 + (j
& 48) / 2];
82 memcpy(s
->dv_zigzag
[1], ff_dv_zigzag248_direct
, sizeof(s
->dv_zigzag
[1]));
84 s
->idct_put
[0] = idsp
.idct_put
;
85 s
->idct_put
[1] = ff_simple_idct248_put
;
87 return ff_dvvideo_init(avctx
);
90 /* decode AC coefficients */
91 static void dv_decode_ac(GetBitContext
*gb
, BlockInfo
*mb
, int16_t *block
)
93 int last_index
= gb
->size_in_bits
;
94 const uint8_t *scan_table
= mb
->scan_table
;
95 const uint32_t *factor_table
= mb
->factor_table
;
97 int partial_bit_count
= mb
->partial_bit_count
;
98 int level
, run
, vlc_len
, index
;
100 OPEN_READER_NOSIZE(re
, gb
);
101 UPDATE_CACHE(re
, gb
);
103 /* if we must parse a partial VLC, we do it here */
104 if (partial_bit_count
> 0) {
105 re_cache
= re_cache
>> partial_bit_count
|
106 mb
->partial_bit_buffer
;
107 re_index
-= partial_bit_count
;
108 mb
->partial_bit_count
= 0;
111 /* get the AC coefficients until last_index is reached */
113 av_dlog(NULL
, "%2d: bits=%04x index=%d\n", pos
, SHOW_UBITS(re
, gb
, 16),
115 /* our own optimized GET_RL_VLC */
116 index
= NEG_USR32(re_cache
, TEX_VLC_BITS
);
117 vlc_len
= ff_dv_rl_vlc
[index
].len
;
119 index
= NEG_USR32((unsigned) re_cache
<< TEX_VLC_BITS
, -vlc_len
) +
120 ff_dv_rl_vlc
[index
].level
;
121 vlc_len
= TEX_VLC_BITS
- vlc_len
;
123 level
= ff_dv_rl_vlc
[index
].level
;
124 run
= ff_dv_rl_vlc
[index
].run
;
126 /* gotta check if we're still within gb boundaries */
127 if (re_index
+ vlc_len
> last_index
) {
128 /* should be < 16 bits otherwise a codeword could have been parsed */
129 mb
->partial_bit_count
= last_index
- re_index
;
130 mb
->partial_bit_buffer
= re_cache
& ~(-1u >> mb
->partial_bit_count
);
131 re_index
= last_index
;
136 av_dlog(NULL
, "run=%d level=%d\n", run
, level
);
141 level
= (level
* factor_table
[pos
] + (1 << (dv_iweight_bits
- 1))) >>
143 block
[scan_table
[pos
]] = level
;
145 UPDATE_CACHE(re
, gb
);
147 CLOSE_READER(re
, gb
);
151 static inline void bit_copy(PutBitContext
*pb
, GetBitContext
*gb
)
153 int bits_left
= get_bits_left(gb
);
154 while (bits_left
>= MIN_CACHE_BITS
) {
155 put_bits(pb
, MIN_CACHE_BITS
, get_bits(gb
, MIN_CACHE_BITS
));
156 bits_left
-= MIN_CACHE_BITS
;
159 put_bits(pb
, bits_left
, get_bits(gb
, bits_left
));
162 /* mb_x and mb_y are in units of 8 pixels */
163 static int dv_decode_video_segment(AVCodecContext
*avctx
, void *arg
)
165 DVVideoContext
*s
= avctx
->priv_data
;
166 DVwork_chunk
*work_chunk
= arg
;
167 int quant
, dc
, dct_mode
, class1
, j
;
168 int mb_index
, mb_x
, mb_y
, last_index
;
169 int y_stride
, linesize
;
170 int16_t *block
, *block1
;
173 const uint8_t *buf_ptr
;
174 PutBitContext pb
, vs_pb
;
176 BlockInfo mb_data
[5 * DV_MAX_BPM
], *mb
, *mb1
;
177 LOCAL_ALIGNED_16(int16_t, sblock
, [5 * DV_MAX_BPM
], [64]);
178 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer
, [80 + FF_INPUT_BUFFER_PADDING_SIZE
]); /* allow some slack */
179 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer
, [80 * 5 + FF_INPUT_BUFFER_PADDING_SIZE
]); /* allow some slack */
180 const int log2_blocksize
= 3-s
->avctx
->lowres
;
181 int is_field_mode
[5];
183 av_assert1((((int) mb_bit_buffer
) & 7) == 0);
184 av_assert1((((int) vs_bit_buffer
) & 7) == 0);
186 memset(sblock
, 0, 5 * DV_MAX_BPM
* sizeof(*sblock
));
188 /* pass 1: read DC and AC coefficients in blocks */
189 buf_ptr
= &s
->buf
[work_chunk
->buf_offset
* 80];
190 block1
= &sblock
[0][0];
192 init_put_bits(&vs_pb
, vs_bit_buffer
, 5 * 80);
193 for (mb_index
= 0; mb_index
< 5; mb_index
++, mb1
+= s
->sys
->bpm
, block1
+= s
->sys
->bpm
* 64) {
195 quant
= buf_ptr
[3] & 0x0f;
197 init_put_bits(&pb
, mb_bit_buffer
, 80);
200 is_field_mode
[mb_index
] = 0;
201 for (j
= 0; j
< s
->sys
->bpm
; j
++) {
202 last_index
= s
->sys
->block_sizes
[j
];
203 init_get_bits(&gb
, buf_ptr
, last_index
);
206 dc
= get_sbits(&gb
, 9);
207 dct_mode
= get_bits1(&gb
);
208 class1
= get_bits(&gb
, 2);
209 if (DV_PROFILE_IS_HD(s
->sys
)) {
210 mb
->idct_put
= s
->idct_put
[0];
211 mb
->scan_table
= s
->dv_zigzag
[0];
212 mb
->factor_table
= &s
->idct_factor
[(j
>= 4) * 4 * 16 * 64 +
215 is_field_mode
[mb_index
] |= !j
&& dct_mode
;
217 mb
->idct_put
= s
->idct_put
[dct_mode
&& log2_blocksize
== 3];
218 mb
->scan_table
= s
->dv_zigzag
[dct_mode
];
220 &s
->idct_factor
[(class1
== 3) * 2 * 22 * 64 +
222 (quant
+ ff_dv_quant_offset
[class1
]) * 64];
225 /* convert to unsigned because 128 is not added in the
229 buf_ptr
+= last_index
>> 3;
231 mb
->partial_bit_count
= 0;
233 av_dlog(avctx
, "MB block: %d, %d ", mb_index
, j
);
234 dv_decode_ac(&gb
, mb
, block
);
236 /* write the remaining bits in a new buffer only if the
237 * block is finished */
245 /* pass 2: we can do it just after */
246 av_dlog(avctx
, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb
), mb_index
);
249 init_get_bits(&gb
, mb_bit_buffer
, put_bits_count(&pb
));
250 put_bits32(&pb
, 0); // padding must be zeroed
252 for (j
= 0; j
< s
->sys
->bpm
; j
++, block
+= 64, mb
++) {
253 if (mb
->pos
< 64 && get_bits_left(&gb
) > 0) {
254 dv_decode_ac(&gb
, mb
, block
);
255 /* if still not finished, no need to parse other blocks */
260 /* all blocks are finished, so the extra bytes can be used at
261 * the video segment level */
262 if (j
>= s
->sys
->bpm
)
263 bit_copy(&vs_pb
, &gb
);
266 /* we need a pass over the whole video segment */
267 av_dlog(avctx
, "***pass 3 size=%d\n", put_bits_count(&vs_pb
));
268 block
= &sblock
[0][0];
270 init_get_bits(&gb
, vs_bit_buffer
, put_bits_count(&vs_pb
));
271 put_bits32(&vs_pb
, 0); // padding must be zeroed
272 flush_put_bits(&vs_pb
);
273 for (mb_index
= 0; mb_index
< 5; mb_index
++) {
274 for (j
= 0; j
< s
->sys
->bpm
; j
++) {
275 if (mb
->pos
< 64 && get_bits_left(&gb
) > 0) {
276 av_dlog(avctx
, "start %d:%d\n", mb_index
, j
);
277 dv_decode_ac(&gb
, mb
, block
);
279 if (mb
->pos
>= 64 && mb
->pos
< 127)
280 av_log(avctx
, AV_LOG_ERROR
,
281 "AC EOB marker is absent pos=%d\n", mb
->pos
);
287 /* compute idct and place blocks */
288 block
= &sblock
[0][0];
290 for (mb_index
= 0; mb_index
< 5; mb_index
++) {
291 dv_calculate_mb_xy(s
, work_chunk
, mb_index
, &mb_x
, &mb_y
);
293 /* idct_put'ting luminance */
294 if ((s
->sys
->pix_fmt
== AV_PIX_FMT_YUV420P
) ||
295 (s
->sys
->pix_fmt
== AV_PIX_FMT_YUV411P
&& mb_x
>= (704 / 8)) ||
296 (s
->sys
->height
>= 720 && mb_y
!= 134)) {
297 y_stride
= (s
->frame
->linesize
[0] <<
298 ((!is_field_mode
[mb_index
]) * log2_blocksize
));
300 y_stride
= (2 << log2_blocksize
);
302 y_ptr
= s
->frame
->data
[0] +
303 ((mb_y
* s
->frame
->linesize
[0] + mb_x
) << log2_blocksize
);
304 linesize
= s
->frame
->linesize
[0] << is_field_mode
[mb_index
];
305 mb
[0].idct_put(y_ptr
, linesize
, block
+ 0 * 64);
306 if (s
->sys
->video_stype
== 4) { /* SD 422 */
307 mb
[2].idct_put(y_ptr
+ (1 << log2_blocksize
), linesize
, block
+ 2 * 64);
309 mb
[1].idct_put(y_ptr
+ (1 << log2_blocksize
), linesize
, block
+ 1 * 64);
310 mb
[2].idct_put(y_ptr
+ y_stride
, linesize
, block
+ 2 * 64);
311 mb
[3].idct_put(y_ptr
+ (1 << log2_blocksize
) + y_stride
, linesize
, block
+ 3 * 64);
316 /* idct_put'ting chrominance */
317 c_offset
= (((mb_y
>> (s
->sys
->pix_fmt
== AV_PIX_FMT_YUV420P
)) * s
->frame
->linesize
[1] +
318 (mb_x
>> ((s
->sys
->pix_fmt
== AV_PIX_FMT_YUV411P
) ? 2 : 1))) << log2_blocksize
);
319 for (j
= 2; j
; j
--) {
320 uint8_t *c_ptr
= s
->frame
->data
[j
] + c_offset
;
321 if (s
->sys
->pix_fmt
== AV_PIX_FMT_YUV411P
&& mb_x
>= (704 / 8)) {
322 uint64_t aligned_pixels
[64 / 8];
323 uint8_t *pixels
= (uint8_t *) aligned_pixels
;
324 uint8_t *c_ptr1
, *ptr1
;
326 mb
->idct_put(pixels
, 8, block
);
327 for (y
= 0; y
< (1 << log2_blocksize
); y
++, c_ptr
+= s
->frame
->linesize
[j
], pixels
+= 8) {
328 ptr1
= pixels
+ ((1 << (log2_blocksize
))>>1);
329 c_ptr1
= c_ptr
+ (s
->frame
->linesize
[j
] << log2_blocksize
);
330 for (x
= 0; x
< (1 << FFMAX(log2_blocksize
- 1, 0)); x
++) {
331 c_ptr
[x
] = pixels
[x
];
338 y_stride
= (mb_y
== 134) ? (1 << log2_blocksize
) :
339 s
->frame
->linesize
[j
] << ((!is_field_mode
[mb_index
]) * log2_blocksize
);
340 linesize
= s
->frame
->linesize
[j
] << is_field_mode
[mb_index
];
341 (mb
++)->idct_put(c_ptr
, linesize
, block
);
343 if (s
->sys
->bpm
== 8) {
344 (mb
++)->idct_put(c_ptr
+ y_stride
, linesize
, block
);
353 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
354 * 144000 bytes for PAL - or twice those for 50Mbps) */
355 static int dvvideo_decode_frame(AVCodecContext
*avctx
, void *data
,
356 int *got_frame
, AVPacket
*avpkt
)
358 uint8_t *buf
= avpkt
->data
;
359 int buf_size
= avpkt
->size
;
360 DVVideoContext
*s
= avctx
->priv_data
;
361 const uint8_t *vsc_pack
;
362 int apt
, is16_9
, ret
;
363 const AVDVProfile
*sys
;
365 sys
= avpriv_dv_frame_profile2(avctx
, s
->sys
, buf
, buf_size
);
366 if (!sys
|| buf_size
< sys
->frame_size
) {
367 av_log(avctx
, AV_LOG_ERROR
, "could not find dv frame profile\n");
368 return -1; /* NOTE: we only accept several full frames */
372 ret
= ff_dv_init_dynamic_tables(s
, sys
);
374 av_log(avctx
, AV_LOG_ERROR
, "Error initializing the work tables.\n");
381 s
->frame
->key_frame
= 1;
382 s
->frame
->pict_type
= AV_PICTURE_TYPE_I
;
383 avctx
->pix_fmt
= s
->sys
->pix_fmt
;
384 avctx
->time_base
= s
->sys
->time_base
;
386 ret
= ff_set_dimensions(avctx
, s
->sys
->width
, s
->sys
->height
);
390 /* Determine the codec's sample_aspect ratio from the packet */
391 vsc_pack
= buf
+ 80 * 5 + 48 + 5;
392 if (*vsc_pack
== dv_video_control
) {
394 is16_9
= (vsc_pack
[2] & 0x07) == 0x02 ||
395 (!apt
&& (vsc_pack
[2] & 0x07) == 0x07);
396 ff_set_sar(avctx
, s
->sys
->sar
[is16_9
]);
399 if ((ret
= ff_get_buffer(avctx
, s
->frame
, 0)) < 0)
401 s
->frame
->interlaced_frame
= 1;
402 s
->frame
->top_field_first
= 0;
404 /* Determine the codec's field order from the packet */
405 if ( *vsc_pack
== dv_video_control
) {
406 s
->frame
->top_field_first
= !(vsc_pack
[3] & 0x40);
410 avctx
->execute(avctx
, dv_decode_video_segment
, s
->work_chunks
, NULL
,
411 dv_work_pool_size(s
->sys
), sizeof(DVwork_chunk
));
418 return s
->sys
->frame_size
;
421 AVCodec ff_dvvideo_decoder
= {
423 .long_name
= NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
424 .type
= AVMEDIA_TYPE_VIDEO
,
425 .id
= AV_CODEC_ID_DVVIDEO
,
426 .priv_data_size
= sizeof(DVVideoContext
),
427 .init
= dvvideo_decode_init
,
428 .decode
= dvvideo_decode_frame
,
429 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_SLICE_THREADS
,