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 Libav.
18 * Libav 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 * Libav 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 Libav; if not, write to the Free Software
30 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
38 #include "libavutil/pixdesc.h"
43 #include "simple_idct.h"
46 typedef struct BlockInfo
{
47 const uint32_t *factor_table
;
48 const uint8_t *scan_table
;
49 uint8_t pos
; /* position in block */
50 void (*idct_put
)(uint8_t *dest
, int line_size
, DCTELEM
*block
);
51 uint8_t partial_bit_count
;
52 uint32_t partial_bit_buffer
;
56 static const int dv_iweight_bits
= 14;
58 /* decode AC coefficients */
59 static void dv_decode_ac(GetBitContext
*gb
, BlockInfo
*mb
, DCTELEM
*block
)
61 int last_index
= gb
->size_in_bits
;
62 const uint8_t *scan_table
= mb
->scan_table
;
63 const uint32_t *factor_table
= mb
->factor_table
;
65 int partial_bit_count
= mb
->partial_bit_count
;
66 int level
, run
, vlc_len
, index
;
71 /* if we must parse a partial VLC, we do it here */
72 if (partial_bit_count
> 0) {
73 re_cache
= re_cache
>> partial_bit_count
| mb
->partial_bit_buffer
;
74 re_index
-= partial_bit_count
;
75 mb
->partial_bit_count
= 0;
78 /* get the AC coefficients until last_index is reached */
80 av_dlog(NULL
, "%2d: bits=%04x index=%d\n", pos
, SHOW_UBITS(re
, gb
, 16),
82 /* our own optimized GET_RL_VLC */
83 index
= NEG_USR32(re_cache
, TEX_VLC_BITS
);
84 vlc_len
= ff_dv_rl_vlc
[index
].len
;
86 index
= NEG_USR32((unsigned)re_cache
<< TEX_VLC_BITS
, -vlc_len
) +
87 ff_dv_rl_vlc
[index
].level
;
88 vlc_len
= TEX_VLC_BITS
- vlc_len
;
90 level
= ff_dv_rl_vlc
[index
].level
;
91 run
= ff_dv_rl_vlc
[index
].run
;
93 /* gotta check if we're still within gb boundaries */
94 if (re_index
+ vlc_len
> last_index
) {
95 /* should be < 16 bits otherwise a codeword could have been parsed */
96 mb
->partial_bit_count
= last_index
- re_index
;
97 mb
->partial_bit_buffer
= re_cache
& ~(-1u >> mb
->partial_bit_count
);
98 re_index
= last_index
;
103 av_dlog(NULL
, "run=%d level=%d\n", run
, level
);
108 level
= (level
* factor_table
[pos
] + (1 << (dv_iweight_bits
- 1))) >> dv_iweight_bits
;
109 block
[scan_table
[pos
]] = level
;
111 UPDATE_CACHE(re
, gb
);
113 CLOSE_READER(re
, gb
);
117 static inline void bit_copy(PutBitContext
*pb
, GetBitContext
*gb
)
119 int bits_left
= get_bits_left(gb
);
120 while (bits_left
>= MIN_CACHE_BITS
) {
121 put_bits(pb
, MIN_CACHE_BITS
, get_bits(gb
, MIN_CACHE_BITS
));
122 bits_left
-= MIN_CACHE_BITS
;
125 put_bits(pb
, bits_left
, get_bits(gb
, bits_left
));
129 /* mb_x and mb_y are in units of 8 pixels */
130 static int dv_decode_video_segment(AVCodecContext
*avctx
, void *arg
)
132 DVVideoContext
*s
= avctx
->priv_data
;
133 DVwork_chunk
*work_chunk
= arg
;
134 int quant
, dc
, dct_mode
, class1
, j
;
135 int mb_index
, mb_x
, mb_y
, last_index
;
136 int y_stride
, linesize
;
137 DCTELEM
*block
, *block1
;
140 const uint8_t *buf_ptr
;
141 PutBitContext pb
, vs_pb
;
143 BlockInfo mb_data
[5 * DV_MAX_BPM
], *mb
, *mb1
;
144 LOCAL_ALIGNED_16(DCTELEM
, sblock
, [5*DV_MAX_BPM
], [64]);
145 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer
, [ 80 + FF_INPUT_BUFFER_PADDING_SIZE
]); /* allow some slack */
146 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer
, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE
]); /* allow some slack */
147 const int log2_blocksize
= 3;
148 int is_field_mode
[5];
150 assert((((int)mb_bit_buffer
) & 7) == 0);
151 assert((((int)vs_bit_buffer
) & 7) == 0);
153 memset(sblock
, 0, 5*DV_MAX_BPM
*sizeof(*sblock
));
155 /* pass 1: read DC and AC coefficients in blocks */
156 buf_ptr
= &s
->buf
[work_chunk
->buf_offset
*80];
157 block1
= &sblock
[0][0];
159 init_put_bits(&vs_pb
, vs_bit_buffer
, 5 * 80);
160 for (mb_index
= 0; mb_index
< 5; mb_index
++, mb1
+= s
->sys
->bpm
, block1
+= s
->sys
->bpm
* 64) {
162 quant
= buf_ptr
[3] & 0x0f;
164 init_put_bits(&pb
, mb_bit_buffer
, 80);
167 is_field_mode
[mb_index
] = 0;
168 for (j
= 0; j
< s
->sys
->bpm
; j
++) {
169 last_index
= s
->sys
->block_sizes
[j
];
170 init_get_bits(&gb
, buf_ptr
, last_index
);
173 dc
= get_sbits(&gb
, 9);
174 dct_mode
= get_bits1(&gb
);
175 class1
= get_bits(&gb
, 2);
176 if (DV_PROFILE_IS_HD(s
->sys
)) {
177 mb
->idct_put
= s
->idct_put
[0];
178 mb
->scan_table
= s
->dv_zigzag
[0];
179 mb
->factor_table
= &s
->sys
->idct_factor
[(j
>= 4)*4*16*64 + class1
*16*64 + quant
*64];
180 is_field_mode
[mb_index
] |= !j
&& dct_mode
;
182 mb
->idct_put
= s
->idct_put
[dct_mode
&& log2_blocksize
== 3];
183 mb
->scan_table
= s
->dv_zigzag
[dct_mode
];
184 mb
->factor_table
= &s
->sys
->idct_factor
[(class1
== 3)*2*22*64 + dct_mode
*22*64 +
185 (quant
+ ff_dv_quant_offset
[class1
])*64];
188 /* convert to unsigned because 128 is not added in the
192 buf_ptr
+= last_index
>> 3;
194 mb
->partial_bit_count
= 0;
196 av_dlog(avctx
, "MB block: %d, %d ", mb_index
, j
);
197 dv_decode_ac(&gb
, mb
, block
);
199 /* write the remaining bits in a new buffer only if the
208 /* pass 2: we can do it just after */
209 av_dlog(avctx
, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb
), mb_index
);
212 init_get_bits(&gb
, mb_bit_buffer
, put_bits_count(&pb
));
213 put_bits32(&pb
, 0); // padding must be zeroed
215 for (j
= 0; j
< s
->sys
->bpm
; j
++, block
+= 64, mb
++) {
216 if (mb
->pos
< 64 && get_bits_left(&gb
) > 0) {
217 dv_decode_ac(&gb
, mb
, block
);
218 /* if still not finished, no need to parse other blocks */
223 /* all blocks are finished, so the extra bytes can be used at
224 the video segment level */
225 if (j
>= s
->sys
->bpm
)
226 bit_copy(&vs_pb
, &gb
);
229 /* we need a pass over the whole video segment */
230 av_dlog(avctx
, "***pass 3 size=%d\n", put_bits_count(&vs_pb
));
231 block
= &sblock
[0][0];
233 init_get_bits(&gb
, vs_bit_buffer
, put_bits_count(&vs_pb
));
234 put_bits32(&vs_pb
, 0); // padding must be zeroed
235 flush_put_bits(&vs_pb
);
236 for (mb_index
= 0; mb_index
< 5; mb_index
++) {
237 for (j
= 0; j
< s
->sys
->bpm
; j
++) {
239 av_dlog(avctx
, "start %d:%d\n", mb_index
, j
);
240 dv_decode_ac(&gb
, mb
, block
);
242 if (mb
->pos
>= 64 && mb
->pos
< 127)
243 av_log(avctx
, AV_LOG_ERROR
, "AC EOB marker is absent pos=%d\n", mb
->pos
);
249 /* compute idct and place blocks */
250 block
= &sblock
[0][0];
252 for (mb_index
= 0; mb_index
< 5; mb_index
++) {
253 dv_calculate_mb_xy(s
, work_chunk
, mb_index
, &mb_x
, &mb_y
);
255 /* idct_put'ting luminance */
256 if ((s
->sys
->pix_fmt
== PIX_FMT_YUV420P
) ||
257 (s
->sys
->pix_fmt
== PIX_FMT_YUV411P
&& mb_x
>= (704 / 8)) ||
258 (s
->sys
->height
>= 720 && mb_y
!= 134)) {
259 y_stride
= (s
->picture
.linesize
[0] << ((!is_field_mode
[mb_index
]) * log2_blocksize
));
261 y_stride
= (2 << log2_blocksize
);
263 y_ptr
= s
->picture
.data
[0] + ((mb_y
* s
->picture
.linesize
[0] + mb_x
) << log2_blocksize
);
264 linesize
= s
->picture
.linesize
[0] << is_field_mode
[mb_index
];
265 mb
[0] .idct_put(y_ptr
, linesize
, block
+ 0*64);
266 if (s
->sys
->video_stype
== 4) { /* SD 422 */
267 mb
[2].idct_put(y_ptr
+ (1 << log2_blocksize
) , linesize
, block
+ 2*64);
269 mb
[1].idct_put(y_ptr
+ (1 << log2_blocksize
) , linesize
, block
+ 1*64);
270 mb
[2].idct_put(y_ptr
+ y_stride
, linesize
, block
+ 2*64);
271 mb
[3].idct_put(y_ptr
+ (1 << log2_blocksize
) + y_stride
, linesize
, block
+ 3*64);
276 /* idct_put'ting chrominance */
277 c_offset
= (((mb_y
>> (s
->sys
->pix_fmt
== PIX_FMT_YUV420P
)) * s
->picture
.linesize
[1] +
278 (mb_x
>> ((s
->sys
->pix_fmt
== PIX_FMT_YUV411P
) ? 2 : 1))) << log2_blocksize
);
279 for (j
= 2; j
; j
--) {
280 uint8_t *c_ptr
= s
->picture
.data
[j
] + c_offset
;
281 if (s
->sys
->pix_fmt
== PIX_FMT_YUV411P
&& mb_x
>= (704 / 8)) {
282 uint64_t aligned_pixels
[64/8];
283 uint8_t *pixels
= (uint8_t*)aligned_pixels
;
284 uint8_t *c_ptr1
, *ptr1
;
286 mb
->idct_put(pixels
, 8, block
);
287 for (y
= 0; y
< (1 << log2_blocksize
); y
++, c_ptr
+= s
->picture
.linesize
[j
], pixels
+= 8) {
288 ptr1
= pixels
+ (1 << (log2_blocksize
- 1));
289 c_ptr1
= c_ptr
+ (s
->picture
.linesize
[j
] << log2_blocksize
);
290 for (x
= 0; x
< (1 << (log2_blocksize
- 1)); x
++) {
291 c_ptr
[x
] = pixels
[x
];
297 y_stride
= (mb_y
== 134) ? (1 << log2_blocksize
) :
298 s
->picture
.linesize
[j
] << ((!is_field_mode
[mb_index
]) * log2_blocksize
);
299 linesize
= s
->picture
.linesize
[j
] << is_field_mode
[mb_index
];
300 (mb
++)-> idct_put(c_ptr
, linesize
, block
); block
+= 64;
301 if (s
->sys
->bpm
== 8) {
302 (mb
++)->idct_put(c_ptr
+ y_stride
, linesize
, block
); block
+= 64;
310 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
311 144000 bytes for PAL - or twice those for 50Mbps) */
312 static int dvvideo_decode_frame(AVCodecContext
*avctx
,
313 void *data
, int *data_size
,
316 uint8_t *buf
= avpkt
->data
;
317 int buf_size
= avpkt
->size
;
318 DVVideoContext
*s
= avctx
->priv_data
;
319 const uint8_t* vsc_pack
;
322 s
->sys
= avpriv_dv_frame_profile(s
->sys
, buf
, buf_size
);
323 if (!s
->sys
|| buf_size
< s
->sys
->frame_size
|| ff_dv_init_dynamic_tables(s
->sys
)) {
324 av_log(avctx
, AV_LOG_ERROR
, "could not find dv frame profile\n");
325 return -1; /* NOTE: we only accept several full frames */
328 if (s
->picture
.data
[0])
329 avctx
->release_buffer(avctx
, &s
->picture
);
331 s
->picture
.reference
= 0;
332 s
->picture
.key_frame
= 1;
333 s
->picture
.pict_type
= AV_PICTURE_TYPE_I
;
334 avctx
->pix_fmt
= s
->sys
->pix_fmt
;
335 avctx
->time_base
= s
->sys
->time_base
;
336 avcodec_set_dimensions(avctx
, s
->sys
->width
, s
->sys
->height
);
337 if (avctx
->get_buffer(avctx
, &s
->picture
) < 0) {
338 av_log(avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
341 s
->picture
.interlaced_frame
= 1;
342 s
->picture
.top_field_first
= 0;
345 avctx
->execute(avctx
, dv_decode_video_segment
, s
->sys
->work_chunks
, NULL
,
346 dv_work_pool_size(s
->sys
), sizeof(DVwork_chunk
));
351 *data_size
= sizeof(AVFrame
);
352 *(AVFrame
*)data
= s
->picture
;
354 /* Determine the codec's sample_aspect ratio from the packet */
355 vsc_pack
= buf
+ 80*5 + 48 + 5;
356 if ( *vsc_pack
== dv_video_control
) {
358 is16_9
= (vsc_pack
&& ((vsc_pack
[2] & 0x07) == 0x02 || (!apt
&& (vsc_pack
[2] & 0x07) == 0x07)));
359 avctx
->sample_aspect_ratio
= s
->sys
->sar
[is16_9
];
362 return s
->sys
->frame_size
;
365 static int dvvideo_close(AVCodecContext
*c
)
367 DVVideoContext
*s
= c
->priv_data
;
369 if (s
->picture
.data
[0])
370 c
->release_buffer(c
, &s
->picture
);
375 AVCodec ff_dvvideo_decoder
= {
377 .type
= AVMEDIA_TYPE_VIDEO
,
378 .id
= CODEC_ID_DVVIDEO
,
379 .priv_data_size
= sizeof(DVVideoContext
),
380 .init
= ff_dvvideo_init
,
381 .close
= dvvideo_close
,
382 .decode
= dvvideo_decode_frame
,
383 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_SLICE_THREADS
,
384 .long_name
= NULL_IF_CONFIG_SMALL("DV (Digital Video)"),