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