summaryrefslogtreecommitdiff
path: root/libavcodec/dvdec.c (plain)
blob: 7b16787e2745cf34315d68207c844952ecfde413
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 "idctdsp.h"
49#include "internal.h"
50#include "put_bits.h"
51#include "simple_idct.h"
52
53typedef 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
63static const int dv_iweight_bits = 14;
64
65static 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};
75static 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 */
89static 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};
99static 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};
109static 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};
119static 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
130static 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
176static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
177{
178 DVVideoContext *s = avctx->priv_data;
179 IDCTDSPContext idsp;
180 int i;
181
182 memset(&idsp,0, sizeof(idsp));
183 ff_idctdsp_init(&idsp, avctx);
184
185 for (i = 0; i < 64; i++)
186 s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];
187
188 if (avctx->lowres){
189 for (i = 0; i < 64; i++){
190 int j = ff_dv_zigzag248_direct[i];
191 s->dv_zigzag[1][i] = idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
192 }
193 }else
194 memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
195
196 s->idct_put[0] = idsp.idct_put;
197 s->idct_put[1] = ff_simple_idct248_put;
198
199 return ff_dvvideo_init(avctx);
200}
201
202/* decode AC coefficients */
203static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
204{
205 int last_index = gb->size_in_bits;
206 const uint8_t *scan_table = mb->scan_table;
207 const uint32_t *factor_table = mb->factor_table;
208 int pos = mb->pos;
209 int partial_bit_count = mb->partial_bit_count;
210 int level, run, vlc_len, index;
211
212 OPEN_READER_NOSIZE(re, gb);
213 UPDATE_CACHE(re, gb);
214
215 /* if we must parse a partial VLC, we do it here */
216 if (partial_bit_count > 0) {
217 re_cache = re_cache >> partial_bit_count |
218 mb->partial_bit_buffer;
219 re_index -= partial_bit_count;
220 mb->partial_bit_count = 0;
221 }
222
223 /* get the AC coefficients until last_index is reached */
224 for (;;) {
225 ff_dlog(NULL, "%2d: bits=%04"PRIx32" index=%u\n",
226 pos, SHOW_UBITS(re, gb, 16), re_index);
227 /* our own optimized GET_RL_VLC */
228 index = NEG_USR32(re_cache, TEX_VLC_BITS);
229 vlc_len = ff_dv_rl_vlc[index].len;
230 if (vlc_len < 0) {
231 index = NEG_USR32((unsigned) re_cache << TEX_VLC_BITS, -vlc_len) +
232 ff_dv_rl_vlc[index].level;
233 vlc_len = TEX_VLC_BITS - vlc_len;
234 }
235 level = ff_dv_rl_vlc[index].level;
236 run = ff_dv_rl_vlc[index].run;
237
238 /* gotta check if we're still within gb boundaries */
239 if (re_index + vlc_len > last_index) {
240 /* should be < 16 bits otherwise a codeword could have been parsed */
241 mb->partial_bit_count = last_index - re_index;
242 mb->partial_bit_buffer = re_cache & ~(-1u >> mb->partial_bit_count);
243 re_index = last_index;
244 break;
245 }
246 re_index += vlc_len;
247
248 ff_dlog(NULL, "run=%d level=%d\n", run, level);
249 pos += run;
250 if (pos >= 64)
251 break;
252
253 level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >>
254 dv_iweight_bits;
255 block[scan_table[pos]] = level;
256
257 UPDATE_CACHE(re, gb);
258 }
259 CLOSE_READER(re, gb);
260 mb->pos = pos;
261}
262
263static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
264{
265 int bits_left = get_bits_left(gb);
266 while (bits_left >= MIN_CACHE_BITS) {
267 put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
268 bits_left -= MIN_CACHE_BITS;
269 }
270 if (bits_left > 0)
271 put_bits(pb, bits_left, get_bits(gb, bits_left));
272}
273
274/* mb_x and mb_y are in units of 8 pixels */
275static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
276{
277 DVVideoContext *s = avctx->priv_data;
278 DVwork_chunk *work_chunk = arg;
279 int quant, dc, dct_mode, class1, j;
280 int mb_index, mb_x, mb_y, last_index;
281 int y_stride, linesize;
282 int16_t *block, *block1;
283 int c_offset;
284 uint8_t *y_ptr;
285 const uint8_t *buf_ptr;
286 PutBitContext pb, vs_pb;
287 GetBitContext gb;
288 BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
289 LOCAL_ALIGNED_16(int16_t, sblock, [5 * DV_MAX_BPM], [64]);
290 LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
291 LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [80 * 5 + AV_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
292 const int log2_blocksize = 3-s->avctx->lowres;
293 int is_field_mode[5];
294 int vs_bit_buffer_damaged = 0;
295 int mb_bit_buffer_damaged[5] = {0};
296 int retried = 0;
297 int sta;
298
299 av_assert1((((int) mb_bit_buffer) & 7) == 0);
300 av_assert1((((int) vs_bit_buffer) & 7) == 0);
301
302retry:
303
304 memset(sblock, 0, 5 * DV_MAX_BPM * sizeof(*sblock));
305
306 /* pass 1: read DC and AC coefficients in blocks */
307 buf_ptr = &s->buf[work_chunk->buf_offset * 80];
308 block1 = &sblock[0][0];
309 mb1 = mb_data;
310 init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
311 for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
312 /* skip header */
313 quant = buf_ptr[3] & 0x0f;
314 if (avctx->error_concealment) {
315 if ((buf_ptr[3] >> 4) == 0x0E)
316 vs_bit_buffer_damaged = 1;
317 if (!mb_index) {
318 sta = buf_ptr[3] >> 4;
319 } else if (sta != (buf_ptr[3] >> 4))
320 vs_bit_buffer_damaged = 1;
321 }
322 buf_ptr += 4;
323 init_put_bits(&pb, mb_bit_buffer, 80);
324 mb = mb1;
325 block = block1;
326 is_field_mode[mb_index] = 0;
327 for (j = 0; j < s->sys->bpm; j++) {
328 last_index = s->sys->block_sizes[j];
329 init_get_bits(&gb, buf_ptr, last_index);
330
331 /* get the DC */
332 dc = get_sbits(&gb, 9);
333 dct_mode = get_bits1(&gb);
334 class1 = get_bits(&gb, 2);
335 if (DV_PROFILE_IS_HD(s->sys)) {
336 mb->idct_put = s->idct_put[0];
337 mb->scan_table = s->dv_zigzag[0];
338 mb->factor_table = &s->idct_factor[(j >= 4) * 4 * 16 * 64 +
339 class1 * 16 * 64 +
340 quant * 64];
341 is_field_mode[mb_index] |= !j && dct_mode;
342 } else {
343 mb->idct_put = s->idct_put[dct_mode && log2_blocksize == 3];
344 mb->scan_table = s->dv_zigzag[dct_mode];
345 mb->factor_table =
346 &s->idct_factor[(class1 == 3) * 2 * 22 * 64 +
347 dct_mode * 22 * 64 +
348 (quant + ff_dv_quant_offset[class1]) * 64];
349 }
350 dc = dc * 4;
351 /* convert to unsigned because 128 is not added in the
352 * standard IDCT */
353 dc += 1024;
354 block[0] = dc;
355 buf_ptr += last_index >> 3;
356 mb->pos = 0;
357 mb->partial_bit_count = 0;
358
359 ff_dlog(avctx, "MB block: %d, %d ", mb_index, j);
360 dv_decode_ac(&gb, mb, block);
361
362 /* write the remaining bits in a new buffer only if the
363 * block is finished */
364 if (mb->pos >= 64)
365 bit_copy(&pb, &gb);
366 if (mb->pos >= 64 && mb->pos < 127)
367 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
368
369 block += 64;
370 mb++;
371 }
372
373 if (mb_bit_buffer_damaged[mb_index] > 0)
374 continue;
375
376 /* pass 2: we can do it just after */
377 ff_dlog(avctx, "***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
378 block = block1;
379 mb = mb1;
380 init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
381 put_bits32(&pb, 0); // padding must be zeroed
382 flush_put_bits(&pb);
383 for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
384 if (mb->pos < 64 && get_bits_left(&gb) > 0) {
385 dv_decode_ac(&gb, mb, block);
386 /* if still not finished, no need to parse other blocks */
387 if (mb->pos < 64)
388 break;
389 if (mb->pos < 127)
390 vs_bit_buffer_damaged = mb_bit_buffer_damaged[mb_index] = 1;
391 }
392 }
393 /* all blocks are finished, so the extra bytes can be used at
394 * the video segment level */
395 if (j >= s->sys->bpm)
396 bit_copy(&vs_pb, &gb);
397 }
398
399 /* we need a pass over the whole video segment */
400 ff_dlog(avctx, "***pass 3 size=%d\n", put_bits_count(&vs_pb));
401 block = &sblock[0][0];
402 mb = mb_data;
403 init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
404 put_bits32(&vs_pb, 0); // padding must be zeroed
405 flush_put_bits(&vs_pb);
406 for (mb_index = 0; mb_index < 5; mb_index++) {
407 for (j = 0; j < s->sys->bpm; j++) {
408 if (mb->pos < 64 && get_bits_left(&gb) > 0 && !vs_bit_buffer_damaged) {
409 ff_dlog(avctx, "start %d:%d\n", mb_index, j);
410 dv_decode_ac(&gb, mb, block);
411 }
412
413 if (mb->pos >= 64 && mb->pos < 127) {
414 av_log(avctx, AV_LOG_ERROR,
415 "AC EOB marker is absent pos=%d\n", mb->pos);
416 vs_bit_buffer_damaged = 1;
417 }
418 block += 64;
419 mb++;
420 }
421 }
422 if (vs_bit_buffer_damaged && !retried) {
423 av_log(avctx, AV_LOG_ERROR, "Concealing bitstream errors\n");
424 retried = 1;
425 goto retry;
426 }
427
428 /* compute idct and place blocks */
429 block = &sblock[0][0];
430 mb = mb_data;
431 for (mb_index = 0; mb_index < 5; mb_index++) {
432 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
433
434 /* idct_put'ting luminance */
435 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
436 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
437 (s->sys->height >= 720 && mb_y != 134)) {
438 y_stride = (s->frame->linesize[0] <<
439 ((!is_field_mode[mb_index]) * log2_blocksize));
440 } else {
441 y_stride = (2 << log2_blocksize);
442 }
443 y_ptr = s->frame->data[0] +
444 ((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
445 linesize = s->frame->linesize[0] << is_field_mode[mb_index];
446 mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
447 if (s->sys->video_stype == 4) { /* SD 422 */
448 mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
449 } else {
450 mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
451 mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
452 mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
453 }
454 mb += 4;
455 block += 4 * 64;
456
457 /* idct_put'ting chrominance */
458 c_offset = (((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
459 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
460 for (j = 2; j; j--) {
461 uint8_t *c_ptr = s->frame->data[j] + c_offset;
462 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
463 uint64_t aligned_pixels[64 / 8];
464 uint8_t *pixels = (uint8_t *) aligned_pixels;
465 uint8_t *c_ptr1, *ptr1;
466 int x, y;
467 mb->idct_put(pixels, 8, block);
468 for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
469 ptr1 = pixels + ((1 << (log2_blocksize))>>1);
470 c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
471 for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
472 c_ptr[x] = pixels[x];
473 c_ptr1[x] = ptr1[x];
474 }
475 }
476 block += 64;
477 mb++;
478 } else {
479 y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
480 s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
481 linesize = s->frame->linesize[j] << is_field_mode[mb_index];
482 (mb++)->idct_put(c_ptr, linesize, block);
483 block += 64;
484 if (s->sys->bpm == 8) {
485 (mb++)->idct_put(c_ptr + y_stride, linesize, block);
486 block += 64;
487 }
488 }
489 }
490 }
491 return 0;
492}
493
494/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
495 * 144000 bytes for PAL - or twice those for 50Mbps) */
496static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
497 int *got_frame, AVPacket *avpkt)
498{
499 uint8_t *buf = avpkt->data;
500 int buf_size = avpkt->size;
501 DVVideoContext *s = avctx->priv_data;
502 AVFrame *frame = data;
503 const uint8_t *vsc_pack;
504 int apt, is16_9, ret;
505 const AVDVProfile *sys;
506
507 sys = ff_dv_frame_profile(avctx, s->sys, buf, buf_size);
508 if (!sys || buf_size < sys->frame_size) {
509 av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
510 return -1; /* NOTE: we only accept several full frames */
511 }
512
513 if (sys != s->sys) {
514 ret = ff_dv_init_dynamic_tables(s, sys);
515 if (ret < 0) {
516 av_log(avctx, AV_LOG_ERROR, "Error initializing the work tables.\n");
517 return ret;
518 }
519 dv_init_weight_tables(s, sys);
520 s->sys = sys;
521 }
522
523 s->frame = frame;
524 frame->key_frame = 1;
525 frame->pict_type = AV_PICTURE_TYPE_I;
526 avctx->pix_fmt = s->sys->pix_fmt;
527 avctx->framerate = av_inv_q(s->sys->time_base);
528
529 ret = ff_set_dimensions(avctx, s->sys->width, s->sys->height);
530 if (ret < 0)
531 return ret;
532
533 /* Determine the codec's sample_aspect ratio from the packet */
534 vsc_pack = buf + 80 * 5 + 48 + 5;
535 if (*vsc_pack == dv_video_control) {
536 apt = buf[4] & 0x07;
537 is16_9 = (vsc_pack[2] & 0x07) == 0x02 ||
538 (!apt && (vsc_pack[2] & 0x07) == 0x07);
539 ff_set_sar(avctx, s->sys->sar[is16_9]);
540 }
541
542 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
543 return ret;
544 frame->interlaced_frame = 1;
545 frame->top_field_first = 0;
546
547 /* Determine the codec's field order from the packet */
548 if ( *vsc_pack == dv_video_control ) {
549 frame->top_field_first = !(vsc_pack[3] & 0x40);
550 }
551
552 s->buf = buf;
553 avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
554 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
555
556 emms_c();
557
558 /* return image */
559 *got_frame = 1;
560
561 return s->sys->frame_size;
562}
563
564AVCodec ff_dvvideo_decoder = {
565 .name = "dvvideo",
566 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
567 .type = AVMEDIA_TYPE_VIDEO,
568 .id = AV_CODEC_ID_DVVIDEO,
569 .priv_data_size = sizeof(DVVideoContext),
570 .init = dvvideo_decode_init,
571 .decode = dvvideo_decode_frame,
572 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS,
573 .max_lowres = 3,
574};
575
generated by cgit at 2024-05-17 03:06:40 (GMT)