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/internal.h"
39 #include "libavutil/pixdesc.h"
44 #include "simple_idct.h"
47 typedef struct BlockInfo
{
48 const uint32_t *factor_table
;
49 const uint8_t *scan_table
;
50 uint8_t pos
; /* position in block */
51 void (*idct_put
)(uint8_t *dest
, int line_size
, int16_t *block
);
52 uint8_t partial_bit_count
;
53 uint32_t partial_bit_buffer
;
57 static const int dv_iweight_bits
= 14;
59 /* decode AC coefficients */
60 static void dv_decode_ac(GetBitContext
*gb
, BlockInfo
*mb
, int16_t *block
)
62 int last_index
= gb
->size_in_bits
;
63 const uint8_t *scan_table
= mb
->scan_table
;
64 const uint32_t *factor_table
= mb
->factor_table
;
66 int partial_bit_count
= mb
->partial_bit_count
;
67 int level
, run
, vlc_len
, index
;
72 /* if we must parse a partial VLC, we do it here */
73 if (partial_bit_count
> 0) {
74 re_cache
= re_cache
>> partial_bit_count
| mb
->partial_bit_buffer
;
75 re_index
-= partial_bit_count
;
76 mb
->partial_bit_count
= 0;
79 /* get the AC coefficients until last_index is reached */
81 av_dlog(NULL
, "%2d: bits=%04x index=%d\n", pos
, SHOW_UBITS(re
, gb
, 16),
83 /* our own optimized GET_RL_VLC */
84 index
= NEG_USR32(re_cache
, TEX_VLC_BITS
);
85 vlc_len
= ff_dv_rl_vlc
[index
].len
;
87 index
= NEG_USR32((unsigned)re_cache
<< TEX_VLC_BITS
, -vlc_len
) +
88 ff_dv_rl_vlc
[index
].level
;
89 vlc_len
= TEX_VLC_BITS
- vlc_len
;
91 level
= ff_dv_rl_vlc
[index
].level
;
92 run
= ff_dv_rl_vlc
[index
].run
;
94 /* gotta check if we're still within gb boundaries */
95 if (re_index
+ vlc_len
> last_index
) {
96 /* should be < 16 bits otherwise a codeword could have been parsed */
97 mb
->partial_bit_count
= last_index
- re_index
;
98 mb
->partial_bit_buffer
= re_cache
& ~(-1u >> mb
->partial_bit_count
);
99 re_index
= last_index
;
104 av_dlog(NULL
, "run=%d level=%d\n", run
, level
);
109 level
= (level
* factor_table
[pos
] + (1 << (dv_iweight_bits
- 1))) >> dv_iweight_bits
;
110 block
[scan_table
[pos
]] = level
;
112 UPDATE_CACHE(re
, gb
);
114 CLOSE_READER(re
, gb
);
118 static inline void bit_copy(PutBitContext
*pb
, GetBitContext
*gb
)
120 int bits_left
= get_bits_left(gb
);
121 while (bits_left
>= MIN_CACHE_BITS
) {
122 put_bits(pb
, MIN_CACHE_BITS
, get_bits(gb
, MIN_CACHE_BITS
));
123 bits_left
-= MIN_CACHE_BITS
;
126 put_bits(pb
, bits_left
, get_bits(gb
, bits_left
));
130 /* mb_x and mb_y are in units of 8 pixels */
131 static int dv_decode_video_segment(AVCodecContext
*avctx
, void *arg
)
133 DVVideoContext
*s
= avctx
->priv_data
;
134 DVwork_chunk
*work_chunk
= arg
;
135 int quant
, dc
, dct_mode
, class1
, j
;
136 int mb_index
, mb_x
, mb_y
, last_index
;
137 int y_stride
, linesize
;
138 int16_t *block
, *block1
;
141 const uint8_t *buf_ptr
;
142 PutBitContext pb
, vs_pb
;
144 BlockInfo mb_data
[5 * DV_MAX_BPM
], *mb
, *mb1
;
145 LOCAL_ALIGNED_16(int16_t, sblock
, [5*DV_MAX_BPM
], [64]);
146 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer
, [ 80 + FF_INPUT_BUFFER_PADDING_SIZE
]); /* allow some slack */
147 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer
, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE
]); /* allow some slack */
148 const int log2_blocksize
= 3;
149 int is_field_mode
[5];
151 assert((((int)mb_bit_buffer
) & 7) == 0);
152 assert((((int)vs_bit_buffer
) & 7) == 0);
154 memset(sblock
, 0, 5*DV_MAX_BPM
*sizeof(*sblock
));
156 /* pass 1: read DC and AC coefficients in blocks */
157 buf_ptr
= &s
->buf
[work_chunk
->buf_offset
*80];
158 block1
= &sblock
[0][0];
160 init_put_bits(&vs_pb
, vs_bit_buffer
, 5 * 80);
161 for (mb_index
= 0; mb_index
< 5; mb_index
++, mb1
+= s
->sys
->bpm
, block1
+= s
->sys
->bpm
* 64) {
163 quant
= buf_ptr
[3] & 0x0f;
165 init_put_bits(&pb
, mb_bit_buffer
, 80);
168 is_field_mode
[mb_index
] = 0;
169 for (j
= 0; j
< s
->sys
->bpm
; j
++) {
170 last_index
= s
->sys
->block_sizes
[j
];
171 init_get_bits(&gb
, buf_ptr
, last_index
);
174 dc
= get_sbits(&gb
, 9);
175 dct_mode
= get_bits1(&gb
);
176 class1
= get_bits(&gb
, 2);
177 if (DV_PROFILE_IS_HD(s
->sys
)) {
178 mb
->idct_put
= s
->idct_put
[0];
179 mb
->scan_table
= s
->dv_zigzag
[0];
180 mb
->factor_table
= &s
->sys
->idct_factor
[(j
>= 4)*4*16*64 + class1
*16*64 + quant
*64];
181 is_field_mode
[mb_index
] |= !j
&& dct_mode
;
183 mb
->idct_put
= s
->idct_put
[dct_mode
&& log2_blocksize
== 3];
184 mb
->scan_table
= s
->dv_zigzag
[dct_mode
];
185 mb
->factor_table
= &s
->sys
->idct_factor
[(class1
== 3)*2*22*64 + dct_mode
*22*64 +
186 (quant
+ ff_dv_quant_offset
[class1
])*64];
189 /* convert to unsigned because 128 is not added in the
193 buf_ptr
+= last_index
>> 3;
195 mb
->partial_bit_count
= 0;
197 av_dlog(avctx
, "MB block: %d, %d ", mb_index
, j
);
198 dv_decode_ac(&gb
, mb
, block
);
200 /* write the remaining bits in a new buffer only if the
209 /* pass 2: we can do it just after */
210 av_dlog(avctx
, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb
), mb_index
);
213 init_get_bits(&gb
, mb_bit_buffer
, put_bits_count(&pb
));
214 put_bits32(&pb
, 0); // padding must be zeroed
216 for (j
= 0; j
< s
->sys
->bpm
; j
++, block
+= 64, mb
++) {
217 if (mb
->pos
< 64 && get_bits_left(&gb
) > 0) {
218 dv_decode_ac(&gb
, mb
, block
);
219 /* if still not finished, no need to parse other blocks */
224 /* all blocks are finished, so the extra bytes can be used at
225 the video segment level */
226 if (j
>= s
->sys
->bpm
)
227 bit_copy(&vs_pb
, &gb
);
230 /* we need a pass over the whole video segment */
231 av_dlog(avctx
, "***pass 3 size=%d\n", put_bits_count(&vs_pb
));
232 block
= &sblock
[0][0];
234 init_get_bits(&gb
, vs_bit_buffer
, put_bits_count(&vs_pb
));
235 put_bits32(&vs_pb
, 0); // padding must be zeroed
236 flush_put_bits(&vs_pb
);
237 for (mb_index
= 0; mb_index
< 5; mb_index
++) {
238 for (j
= 0; j
< s
->sys
->bpm
; j
++) {
240 av_dlog(avctx
, "start %d:%d\n", mb_index
, j
);
241 dv_decode_ac(&gb
, mb
, block
);
243 if (mb
->pos
>= 64 && mb
->pos
< 127)
244 av_log(avctx
, AV_LOG_ERROR
, "AC EOB marker is absent pos=%d\n", mb
->pos
);
250 /* compute idct and place blocks */
251 block
= &sblock
[0][0];
253 for (mb_index
= 0; mb_index
< 5; mb_index
++) {
254 dv_calculate_mb_xy(s
, work_chunk
, mb_index
, &mb_x
, &mb_y
);
256 /* idct_put'ting luminance */
257 if ((s
->sys
->pix_fmt
== AV_PIX_FMT_YUV420P
) ||
258 (s
->sys
->pix_fmt
== AV_PIX_FMT_YUV411P
&& mb_x
>= (704 / 8)) ||
259 (s
->sys
->height
>= 720 && mb_y
!= 134)) {
260 y_stride
= (s
->picture
.linesize
[0] << ((!is_field_mode
[mb_index
]) * log2_blocksize
));
262 y_stride
= (2 << log2_blocksize
);
264 y_ptr
= s
->picture
.data
[0] + ((mb_y
* s
->picture
.linesize
[0] + mb_x
) << log2_blocksize
);
265 linesize
= s
->picture
.linesize
[0] << is_field_mode
[mb_index
];
266 mb
[0] .idct_put(y_ptr
, linesize
, block
+ 0*64);
267 if (s
->sys
->video_stype
== 4) { /* SD 422 */
268 mb
[2].idct_put(y_ptr
+ (1 << log2_blocksize
) , linesize
, block
+ 2*64);
270 mb
[1].idct_put(y_ptr
+ (1 << log2_blocksize
) , linesize
, block
+ 1*64);
271 mb
[2].idct_put(y_ptr
+ y_stride
, linesize
, block
+ 2*64);
272 mb
[3].idct_put(y_ptr
+ (1 << log2_blocksize
) + y_stride
, linesize
, block
+ 3*64);
277 /* idct_put'ting chrominance */
278 c_offset
= (((mb_y
>> (s
->sys
->pix_fmt
== AV_PIX_FMT_YUV420P
)) * s
->picture
.linesize
[1] +
279 (mb_x
>> ((s
->sys
->pix_fmt
== AV_PIX_FMT_YUV411P
) ? 2 : 1))) << log2_blocksize
);
280 for (j
= 2; j
; j
--) {
281 uint8_t *c_ptr
= s
->picture
.data
[j
] + c_offset
;
282 if (s
->sys
->pix_fmt
== AV_PIX_FMT_YUV411P
&& mb_x
>= (704 / 8)) {
283 uint64_t aligned_pixels
[64/8];
284 uint8_t *pixels
= (uint8_t*)aligned_pixels
;
285 uint8_t *c_ptr1
, *ptr1
;
287 mb
->idct_put(pixels
, 8, block
);
288 for (y
= 0; y
< (1 << log2_blocksize
); y
++, c_ptr
+= s
->picture
.linesize
[j
], pixels
+= 8) {
289 ptr1
= pixels
+ (1 << (log2_blocksize
- 1));
290 c_ptr1
= c_ptr
+ (s
->picture
.linesize
[j
] << log2_blocksize
);
291 for (x
= 0; x
< (1 << (log2_blocksize
- 1)); x
++) {
292 c_ptr
[x
] = pixels
[x
];
298 y_stride
= (mb_y
== 134) ? (1 << log2_blocksize
) :
299 s
->picture
.linesize
[j
] << ((!is_field_mode
[mb_index
]) * log2_blocksize
);
300 linesize
= s
->picture
.linesize
[j
] << is_field_mode
[mb_index
];
301 (mb
++)-> idct_put(c_ptr
, linesize
, block
); block
+= 64;
302 if (s
->sys
->bpm
== 8) {
303 (mb
++)->idct_put(c_ptr
+ y_stride
, linesize
, block
); block
+= 64;
311 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
312 144000 bytes for PAL - or twice those for 50Mbps) */
313 static int dvvideo_decode_frame(AVCodecContext
*avctx
,
314 void *data
, int *got_frame
,
317 uint8_t *buf
= avpkt
->data
;
318 int buf_size
= avpkt
->size
;
319 DVVideoContext
*s
= avctx
->priv_data
;
320 const uint8_t* vsc_pack
;
323 s
->sys
= avpriv_dv_frame_profile(s
->sys
, buf
, buf_size
);
324 if (!s
->sys
|| buf_size
< s
->sys
->frame_size
|| ff_dv_init_dynamic_tables(s
->sys
)) {
325 av_log(avctx
, AV_LOG_ERROR
, "could not find dv frame profile\n");
326 return -1; /* NOTE: we only accept several full frames */
329 if (s
->picture
.data
[0])
330 avctx
->release_buffer(avctx
, &s
->picture
);
332 s
->picture
.reference
= 0;
333 s
->picture
.key_frame
= 1;
334 s
->picture
.pict_type
= AV_PICTURE_TYPE_I
;
335 avctx
->pix_fmt
= s
->sys
->pix_fmt
;
336 avctx
->time_base
= s
->sys
->time_base
;
337 avcodec_set_dimensions(avctx
, s
->sys
->width
, s
->sys
->height
);
338 if (ff_get_buffer(avctx
, &s
->picture
) < 0) {
339 av_log(avctx
, AV_LOG_ERROR
, "get_buffer() failed\n");
342 s
->picture
.interlaced_frame
= 1;
343 s
->picture
.top_field_first
= 0;
346 avctx
->execute(avctx
, dv_decode_video_segment
, s
->sys
->work_chunks
, NULL
,
347 dv_work_pool_size(s
->sys
), sizeof(DVwork_chunk
));
353 *(AVFrame
*)data
= s
->picture
;
355 /* Determine the codec's sample_aspect ratio from the packet */
356 vsc_pack
= buf
+ 80*5 + 48 + 5;
357 if ( *vsc_pack
== dv_video_control
) {
359 is16_9
= (vsc_pack
&& ((vsc_pack
[2] & 0x07) == 0x02 || (!apt
&& (vsc_pack
[2] & 0x07) == 0x07)));
360 avctx
->sample_aspect_ratio
= s
->sys
->sar
[is16_9
];
363 return s
->sys
->frame_size
;
366 static int dvvideo_close(AVCodecContext
*c
)
368 DVVideoContext
*s
= c
->priv_data
;
370 if (s
->picture
.data
[0])
371 c
->release_buffer(c
, &s
->picture
);
376 AVCodec ff_dvvideo_decoder
= {
378 .type
= AVMEDIA_TYPE_VIDEO
,
379 .id
= AV_CODEC_ID_DVVIDEO
,
380 .priv_data_size
= sizeof(DVVideoContext
),
381 .init
= ff_dvvideo_init
,
382 .close
= dvvideo_close
,
383 .decode
= dvvideo_decode_frame
,
384 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_SLICE_THREADS
,
385 .long_name
= NULL_IF_CONFIG_SMALL("DV (Digital Video)"),