1 /*
2 * DV decoder
3 * Copyright (c) 2002 Fabrice Bellard
4 * Copyright (c) 2004 Roman Shaposhnik
5 *
6 * 50 Mbps (DVCPRO50) support
7 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
8 *
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
12 *
13 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
14 * of DV technical info.
15 *
16 * This file is part of FFmpeg.
17 *
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.
22 *
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.
27 *
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
31 */
32
33 /**
34 * @file
35 * DV decoder
36 */
37
38 #include "libavutil/avassert.h"
39 #include "libavutil/imgutils.h"
40 #include "libavutil/internal.h"
41 #include "libavutil/mem_internal.h"
42 #include "libavutil/pixdesc.h"
43
44 #include "avcodec.h"
45 #include "dv.h"
46 #include "dv_profile_internal.h"
47 #include "dvdata.h"
48 #include "get_bits.h"
49 #include "internal.h"
50 #include "put_bits.h"
51 #include "simple_idct.h"
52 #include "thread.h"
53
54 typedef struct BlockInfo {
55 const uint32_t *factor_table;
56 const uint8_t *scan_table;
57 uint8_t pos; /* position in block */
58 void (*idct_put)(uint8_t *dest, ptrdiff_t stride, int16_t *block);
59 uint8_t partial_bit_count;
60 uint32_t partial_bit_buffer;
61 int shift_offset;
62 } BlockInfo;
63
64 static const int dv_iweight_bits = 14;
65
66 static const uint16_t dv_iweight_88[64] = {
67 32768, 16705, 16705, 17734, 17032, 17734, 18205, 18081,
68 18081, 18205, 18725, 18562, 19195, 18562, 18725, 19266,
69 19091, 19705, 19705, 19091, 19266, 21407, 19643, 20267,
70 20228, 20267, 19643, 21407, 22725, 21826, 20853, 20806,
71 20806, 20853, 21826, 22725, 23170, 23170, 21407, 21400,
72 21407, 23170, 23170, 24598, 23786, 22018, 22018, 23786,
73 24598, 25251, 24465, 22654, 24465, 25251, 25972, 25172,
74 25172, 25972, 26722, 27969, 26722, 29692, 29692, 31521,
75 };
76 static const uint16_t dv_iweight_248[64] = {
77 32768, 16384, 16705, 16705, 17734, 17734, 17734, 17734,
78 18081, 18081, 18725, 18725, 21407, 21407, 19091, 19091,
79 19195, 19195, 18205, 18205, 18725, 18725, 19705, 19705,
80 20267, 20267, 21826, 21826, 23170, 23170, 20806, 20806,
81 20267, 20267, 19266, 19266, 21407, 21407, 20853, 20853,
82 21400, 21400, 23786, 23786, 24465, 24465, 22018, 22018,
83 23170, 23170, 22725, 22725, 24598, 24598, 24465, 24465,
84 25172, 25172, 27969, 27969, 25972, 25972, 29692, 29692
85 };
86
87 /**
88 * The "inverse" DV100 weights are actually just the spec weights (zig-zagged).
89 */
90 static const uint16_t dv_iweight_1080_y[64] = {
91 128, 16, 16, 17, 17, 17, 18, 18,
92 18, 18, 18, 18, 19, 18, 18, 19,
93 19, 19, 19, 19, 19, 42, 38, 40,
94 40, 40, 38, 42, 44, 43, 41, 41,
95 41, 41, 43, 44, 45, 45, 42, 42,
96 42, 45, 45, 48, 46, 43, 43, 46,
97 48, 49, 48, 44, 48, 49, 101, 98,
98 98, 101, 104, 109, 104, 116, 116, 123,
99 };
100 static const uint16_t dv_iweight_1080_c[64] = {
101 128, 16, 16, 17, 17, 17, 25, 25,
102 25, 25, 26, 25, 26, 25, 26, 26,
103 26, 27, 27, 26, 26, 42, 38, 40,
104 40, 40, 38, 42, 44, 43, 41, 41,
105 41, 41, 43, 44, 91, 91, 84, 84,
106 84, 91, 91, 96, 93, 86, 86, 93,
107 96, 197, 191, 177, 191, 197, 203, 197,
108 197, 203, 209, 219, 209, 232, 232, 246,
109 };
110 static const uint16_t dv_iweight_720_y[64] = {
111 128, 16, 16, 17, 17, 17, 18, 18,
112 18, 18, 18, 18, 19, 18, 18, 19,
113 19, 19, 19, 19, 19, 42, 38, 40,
114 40, 40, 38, 42, 44, 43, 41, 41,
115 41, 41, 43, 44, 68, 68, 63, 63,
116 63, 68, 68, 96, 92, 86, 86, 92,
117 96, 98, 96, 88, 96, 98, 202, 196,
118 196, 202, 208, 218, 208, 232, 232, 246,
119 };
120 static const uint16_t dv_iweight_720_c[64] = {
121 128, 24, 24, 26, 26, 26, 36, 36,
122 36, 36, 36, 36, 38, 36, 36, 38,
123 38, 38, 38, 38, 38, 84, 76, 80,
124 80, 80, 76, 84, 88, 86, 82, 82,
125 82, 82, 86, 88, 182, 182, 168, 168,
126 168, 182, 182, 192, 186, 192, 172, 186,
127 192, 394, 382, 354, 382, 394, 406, 394,
128 394, 406, 418, 438, 418, 464, 464, 492,
129 };
130
dv_init_weight_tables(DVVideoContext * ctx,const AVDVProfile * d)131 static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
132 {
133 int j, i, c, s;
134 uint32_t *factor1 = &ctx->idct_factor[0],
135 *factor2 = &ctx->idct_factor[DV_PROFILE_IS_HD(d) ? 4096 : 2816];
136
137 if (DV_PROFILE_IS_HD(d)) {
138 /* quantization quanta by QNO for DV100 */
139 static const uint8_t dv100_qstep[16] = {
140 1, /* QNO = 0 and 1 both have no quantization */
141 1,
142 2, 3, 4, 5, 6, 7, 8, 16, 18, 20, 22, 24, 28, 52
143 };
144 const uint16_t *iweight1, *iweight2;
145
146 if (d->height == 720) {
147 iweight1 = &dv_iweight_720_y[0];
148 iweight2 = &dv_iweight_720_c[0];
149 } else {
150 iweight1 = &dv_iweight_1080_y[0];
151 iweight2 = &dv_iweight_1080_c[0];
152 }
153 for (c = 0; c < 4; c++) {
154 for (s = 0; s < 16; s++) {
155 for (i = 0; i < 64; i++) {
156 *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
157 *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
158 }
159 }
160 }
161 } else {
162 static const uint8_t dv_quant_areas[4] = { 6, 21, 43, 64 };
163 const uint16_t *iweight1 = &dv_iweight_88[0];
164 for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
165 for (s = 0; s < 22; s++) {
166 for (i = c = 0; c < 4; c++) {
167 for (; i < dv_quant_areas[c]; i++) {
168 *factor1 = iweight1[i] << (ff_dv_quant_shifts[s][c] + 1);
169 *factor2++ = (*factor1++) << 1;
170 }
171 }
172 }
173 }
174 }
175 }
176
dvvideo_decode_init(AVCodecContext * avctx)177 static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
178 {
179 DVVideoContext *s = avctx->priv_data;
180 int i;
181
182 ff_idctdsp_init(&s->idsp, avctx);
183
184 for (i = 0; i < 64; i++)
185 s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]];
186
187 if (avctx->lowres){
188 for (i = 0; i < 64; i++){
189 int j = ff_dv_zigzag248_direct[i];
190 s->dv_zigzag[1][i] = s->idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
191 }
192 }else
193 memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
194
195 s->idct_put[0] = s->idsp.idct_put;
196 s->idct_put[1] = ff_simple_idct248_put;
197
198 return ff_dvvideo_init(avctx);
199 }
200
201 /* decode AC coefficients */
dv_decode_ac(GetBitContext * gb,BlockInfo * mb,int16_t * block)202 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
203 {
204 int last_index = gb->size_in_bits;
205 const uint8_t *scan_table = mb->scan_table;
206 const uint32_t *factor_table = mb->factor_table;
207 int pos = mb->pos;
208 int partial_bit_count = mb->partial_bit_count;
209 int level, run, vlc_len, index;
210
211 OPEN_READER_NOSIZE(re, gb);
212 UPDATE_CACHE(re, gb);
213
214 /* if we must parse a partial VLC, we do it here */
215 if (partial_bit_count > 0) {
216 re_cache = re_cache >> partial_bit_count |
217 mb->partial_bit_buffer;
218 re_index -= partial_bit_count;
219 mb->partial_bit_count = 0;
220 }
221
222 /* get the AC coefficients until last_index is reached */
223 for (;;) {
224 ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
225 pos, SHOW_UBITS(re, gb, 16), re_index);
226 /* our own optimized GET_RL_VLC */
227 index = NEG_USR32(re_cache, TEX_VLC_BITS);
228 vlc_len = ff_dv_rl_vlc[index].len;
229 if (vlc_len < 0) {
230 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
231 ff_dv_rl_vlc[index].level;
232 vlc_len = TEX_VLC_BITS - vlc_len;
233 }
234 level = ff_dv_rl_vlc[index].level;
235 run = ff_dv_rl_vlc[index].run;
236
237 /* gotta check if we're still within gb boundaries */
238 if (re_index + vlc_len > last_index) {
239 /* should be < 16 bits otherwise a codeword could have been parsed */
240 mb->partial_bit_count = last_index - re_index;
241 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
242 re_index = last_index;
243 break;
244 }
245 re_index += vlc_len;
246
247 ff_dlog(NULL, "run=%d level=%d\n", run, level);
248 pos += run;
249 if (pos >= 64)
250 break;
251
252 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
253 dv_iweight_bits;
254 block[scan_table[pos]] = level;
255
256 UPDATE_CACHE(re, gb);
257 }
258 CLOSE_READER(re, gb);
259 mb->pos = pos;
260 }
261
bit_copy(PutBitContext * pb,GetBitContext * gb)262 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
263 {
264 int bits_left = get_bits_left(gb);
265 while (bits_left >= MIN_CACHE_BITS) {
266 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
267 bits_left -= MIN_CACHE_BITS;
268 }
269 if (bits_left > 0)
270 put_bits(pb, bits_left, get_bits(gb, bits_left));
271 }
272
put_block_8x4(int16_t * block,uint8_t * av_restrict p,int stride)273 static av_always_inline void put_block_8x4(int16_t *block, uint8_t *av_restrict p, int stride)
274 {
275 int i, j;
276
277 for (i = 0; i < 4; i++) {
278 for (j = 0; j < 8; j++)
279 p[j] = av_clip_uint8(block[j]);
280 block += 8;
281 p += stride;
282 }
283 }
284
dv100_idct_put_last_row_field_chroma(DVVideoContext * s,uint8_t * data,int stride,int16_t * blocks)285 static void dv100_idct_put_last_row_field_chroma(DVVideoContext *s, uint8_t *data,
286 int stride, int16_t *blocks)
287 {
288 s->idsp.idct(blocks + 0*64);
289 s->idsp.idct(blocks + 1*64);
290
291 put_block_8x4(blocks+0*64, data, stride<<1);
292 put_block_8x4(blocks+0*64 + 4*8, data + 8, stride<<1);
293 put_block_8x4(blocks+1*64, data + stride, stride<<1);
294 put_block_8x4(blocks+1*64 + 4*8, data + 8 + stride, stride<<1);
295 }
296
dv100_idct_put_last_row_field_luma(DVVideoContext * s,uint8_t * data,int stride,int16_t * blocks)297 static void dv100_idct_put_last_row_field_luma(DVVideoContext *s, uint8_t *data,
298 int stride, int16_t *blocks)
299 {
300 s->idsp.idct(blocks + 0*64);
301 s->idsp.idct(blocks + 1*64);
302 s->idsp.idct(blocks + 2*64);
303 s->idsp.idct(blocks + 3*64);
304
305 put_block_8x4(blocks+0*64, data, stride<<1);
306 put_block_8x4(blocks+0*64 + 4*8, data + 16, stride<<1);
307 put_block_8x4(blocks+1*64, data + 8, stride<<1);
308 put_block_8x4(blocks+1*64 + 4*8, data + 24, stride<<1);
309 put_block_8x4(blocks+2*64, data + stride, stride<<1);
310 put_block_8x4(blocks+2*64 + 4*8, data + 16 + stride, stride<<1);
311 put_block_8x4(blocks+3*64, data + 8 + stride, stride<<1);
312 put_block_8x4(blocks+3*64 + 4*8, data + 24 + stride, stride<<1);
313 }
314
315 /* mb_x and mb_y are in units of 8 pixels */
dv_decode_video_segment(AVCodecContext * avctx,void * arg)316 static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
317 {
318 DVVideoContext *s = avctx->priv_data;
319 DVwork_chunk *work_chunk = arg;
320 int quant, dc, dct_mode, class1, j;
321 int mb_index, mb_x, mb_y, last_index;
322 int y_stride, linesize;
323 int16_t *block, *block1;
324 int c_offset;
325 uint8_t *y_ptr;
326 const uint8_t *buf_ptr;
327 PutBitContext pb, vs_pb;
328 GetBitContext gb;
329 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
330 LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
331 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
332 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
333 const int log2_blocksize = 3-s->avctx->lowres;
334 int is_field_mode[5];
335 int vs_bit_buffer_damaged = 0;
336 int mb_bit_buffer_damaged[5] = {0};
337 int retried = 0;
338 int sta;
339
340 av_assert1((((int) mb_bit_buffer) & 7) == 0);
341 av_assert1((((int) vs_bit_buffer) & 7) == 0);
342
343 retry:
344
345 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
346
347 /* pass 1: read DC and AC coefficients in blocks */
348 buf_ptr = &s->buf[work_chunk->buf_offset * 80];
349 block1 = &sblock[0][0];
350 mb1 = mb_data;
351 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
352 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
353 /* skip header */
354 quant = buf_ptr[3] & 0x0f;
355 if (avctx->error_concealment) {
356 if ((buf_ptr[3] >> 4) == 0x0E)
357 vs_bit_buffer_damaged = 1;
358 if (!mb_index) {
359 sta = buf_ptr[3] >> 4;
360 } else if (sta != (buf_ptr[3] >> 4))
361 vs_bit_buffer_damaged = 1;
362 }
363 buf_ptr += 4;
364 init_put_bits(&pb, mb_bit_buffer, 80);
365 mb = mb1;
366 block = block1;
367 is_field_mode[mb_index] = 0;
368 for (j = 0; j < s->sys->bpm; j++) {
369 last_index = s->sys->block_sizes[j];
370 init_get_bits(&gb, buf_ptr, last_index);
371
372 /* get the DC */
373 dc = get_sbits(&gb, 9);
374 dct_mode = get_bits1(&gb);
375 class1 = get_bits(&gb, 2);
376 if (DV_PROFILE_IS_HD(s->sys)) {
377 mb->idct_put = s->idct_put[0];
378 mb->scan_table = s->dv_zigzag[0];
379 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
380 class1 * 16 * 64 +
381 quant * 64];
382 is_field_mode[mb_index] |= !j && dct_mode;
383 } else {
384 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
385 mb->scan_table = s->dv_zigzag[dct_mode];
386 mb->factor_table =
387 &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
388 dct_mode * 22 * 64 +
389 (quant + ff_dv_quant_offset[class1]) * 64];
390 }
391 dc = dc * 4;
392 /* convert to unsigned because 128 is not added in the
393 * standard IDCT */
394 dc += 1024;
395 block[0] = dc;
396 buf_ptr += last_index >> 3;
397 mb->pos = 0;
398 mb->partial_bit_count = 0;
399
400 ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
401 dv_decode_ac(&gb, mb, block);
402
403 /* write the remaining bits in a new buffer only if the
404 * block is finished */
405 if (mb->pos >= 64)
406 bit_copy(&pb, &gb);
407 if (mb->pos >= 64 && mb->pos < 127)
408 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
409
410 block += 64;
411 mb++;
412 }
413
414 if (mb_bit_buffer_damaged[mb_index] > 0)
415 continue;
416
417 /* pass 2: we can do it just after */
418 ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
419 block = block1;
420 mb = mb1;
421 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
422 put_bits32(&pb, 0); // padding must be zeroed
423 flush_put_bits(&pb);
424 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
425 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
426 dv_decode_ac(&gb, mb, block);
427 /* if still not finished, no need to parse other blocks */
428 if (mb->pos < 64)
429 break;
430 if (mb->pos < 127)
431 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
432 }
433 }
434 /* all blocks are finished, so the extra bytes can be used at
435 * the video segment level */
436 if (j >= s->sys->bpm)
437 bit_copy(&vs_pb, &gb);
438 }
439
440 /* we need a pass over the whole video segment */
441 ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
442 block = &sblock[0][0];
443 mb = mb_data;
444 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
445 put_bits32(&vs_pb, 0); // padding must be zeroed
446 flush_put_bits(&vs_pb);
447 for (mb_index = 0; mb_index < 5; mb_index++) {
448 for (j = 0; j < s->sys->bpm; j++) {
449 if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
450 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
451 dv_decode_ac(&gb, mb, block);
452 }
453
454 if (mb->pos >= 64 && mb->pos < 127) {
455 av_log(avctx, AV_LOG_ERROR,
456 "AC EOB marker is absent pos=%d\n", mb->pos);
457 vs_bit_buffer_damaged = 1;
458 }
459 block += 64;
460 mb++;
461 }
462 }
463 if (vs_bit_buffer_damaged && !retried) {
464 av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
465 retried = 1;
466 goto retry;
467 }
468
469 /* compute idct and place blocks */
470 block = &sblock[0][0];
471 mb = mb_data;
472 for (mb_index = 0; mb_index < 5; mb_index++) {
473 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
474
475 /* idct_put'ting luminance */
476 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
477 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
478 (s->sys->height >= 720 && mb_y != 134)) {
479 y_stride = (s->frame->linesize[0] <<
480 ((!is_field_mode[mb_index]) * log2_blocksize));
481 } else {
482 y_stride = (2 << log2_blocksize);
483 }
484 y_ptr = s->frame->data[0] +
485 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
486 if (mb_y == 134 && is_field_mode[mb_index]) {
487 dv100_idct_put_last_row_field_luma(s, y_ptr, s->frame->linesize[0], block);
488 } else {
489 linesize = s->frame->linesize[0] << is_field_mode[mb_index];
490 mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
491 if (s->sys->video_stype == 4) { /* SD 422 */
492 mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
493 } else {
494 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
495 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
496 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
497 }
498 }
499 mb += 4;
500 block += 4 * 64;
501
502 /* idct_put'ting chrominance */
503 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
504 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
505 for (j = 2; j; j--) {
506 uint8_t *c_ptr = s->frame->data[j] + c_offset;
507 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
508 uint64_t aligned_pixels[64 / 8];
509 uint8_t *pixels = (uint8_t *) aligned_pixels;
510 uint8_t *c_ptr1, *ptr1;
511 int x, y;
512 mb->idct_put(pixels, 8, block);
513 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
514 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
515 c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
516 for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
517 c_ptr[x] = pixels[x];
518 c_ptr1[x] = ptr1[x];
519 }
520 }
521 block += 64;
522 mb++;
523 } else {
524 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
525 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
526 if (mb_y == 134 && is_field_mode[mb_index]) {
527 dv100_idct_put_last_row_field_chroma(s, c_ptr, s->frame->linesize[j], block);
528 mb += 2;
529 block += 2*64;
530 } else {
531 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
532 (mb++)->idct_put(c_ptr, linesize, block);
533 block += 64;
534 if (s->sys->bpm == 8) {
535 (mb++)->idct_put(c_ptr + y_stride, linesize, block);
536 block += 64;
537 }
538 }
539 }
540 }
541 }
542 return 0;
543 }
544
545 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
546 * 144000 bytes for PAL - or twice those for 50Mbps) */
dvvideo_decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)547 static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
548 int *got_frame, AVPacket *avpkt)
549 {
550 uint8_t *buf = avpkt->data;
551 int buf_size = avpkt->size;
552 DVVideoContext *s = avctx->priv_data;
553 ThreadFrame frame = { .f = data };
554 const uint8_t *vsc_pack;
555 int apt, is16_9, ret;
556 const AVDVProfile *sys;
557
558 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
559 if (!sys || buf_size < sys->frame_size) {
560 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
561 return -1; /* NOTE: we only accept several full frames */
562 }
563
564 if (sys != s->sys) {
565 ret = ff_dv_init_dynamic_tables(s, sys);
566 if (ret < 0) {
567 av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
568 return ret;
569 }
570 dv_init_weight_tables(s, sys);
571 s->sys = sys;
572 }
573
574 s->frame = frame.f;
575 frame.f->key_frame = 1;
576 frame.f->pict_type = AV_PICTURE_TYPE_I;
577 avctx->pix_fmt = s->sys->pix_fmt;
578 avctx->framerate = av_inv_q(s->sys->time_base);
579
580 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
581 if (ret < 0)
582 return ret;
583
584 /* Determine the codec's sample_aspect ratio from the packet */
585 vsc_pack = buf + 80 * 5 + 48 + 5;
586 if (*vsc_pack == dv_video_control) {
587 apt = buf[4] & 0x07;
588 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
589 (!apt && (vsc_pack[2] & 0x07) == 0x07);
590 ff_set_sar(avctx, s->sys->sar[is16_9]);
591 }
592
593 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
594 return ret;
595
596 /* Determine the codec's field order from the packet */
597 if ( *vsc_pack == dv_video_control ) {
598 if (avctx->height == 720) {
599 frame.f->interlaced_frame = 0;
600 frame.f->top_field_first = 0;
601 } else if (avctx->height == 1080) {
602 frame.f->interlaced_frame = 1;
603 frame.f->top_field_first = (vsc_pack[3] & 0x40) == 0x40;
604 } else {
605 frame.f->interlaced_frame = (vsc_pack[3] & 0x10) == 0x10;
606 frame.f->top_field_first = !(vsc_pack[3] & 0x40);
607 }
608 }
609
610 s->buf = buf;
611 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
612 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
613
614 emms_c();
615
616 /* return image */
617 *got_frame = 1;
618
619 return s->sys->frame_size;
620 }
621
622 AVCodec ff_dvvideo_decoder = {
623 .name = "dvvideo",
624 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
625 .type = AVMEDIA_TYPE_VIDEO,
626 .id = AV_CODEC_ID_DVVIDEO,
627 .priv_data_size = sizeof(DVVideoContext),
628 .init = dvvideo_decode_init,
629 .decode = dvvideo_decode_frame,
630 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS,
631 .max_lowres = 3,
632 };
633