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