Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 1449b722

History | View | Annotate | Download (38.1 KB)

1
/*
2
 * DV decoder
3
 * Copyright (c) 2002 Fabrice Bellard.
4
 * Copyright (c) 2004 Roman Shaposhnik.
5
 *
6
 * DV encoder
7
 * Copyright (c) 2003 Roman Shaposhnik.
8
 *
9
 * 50 Mbps (DVCPRO50) support
10
 * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
11
 *
12
 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
13
 * of DV technical info.
14
 *
15
 * This library is free software; you can redistribute it and/or
16
 * modify it under the terms of the GNU Lesser General Public
17
 * License as published by the Free Software Foundation; either
18
 * version 2 of the License, or (at your option) any later version.
19
 *
20
 * This library is distributed in the hope that it will be useful,
21
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23
 * Lesser General Public License for more details.
24
 *
25
 * You should have received a copy of the GNU Lesser General Public
26
 * License along with this library; if not, write to the Free Software
27
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
28
 */
29

    
30
/**
31
 * @file dv.c
32
 * DV codec.
33
 */
34
#include "avcodec.h"
35
#include "dsputil.h"
36
#include "mpegvideo.h"
37
#include "simple_idct.h"
38
#include "dvdata.h"
39

    
40
//#undef NDEBUG
41
//#include <assert.h>
42

    
43
typedef struct DVVideoContext {
44
    const DVprofile* sys;
45
    AVFrame picture;
46
    AVCodecContext *avctx;
47
    uint8_t *buf;
48

    
49
    uint8_t dv_zigzag[2][64];
50
    uint8_t dv_idct_shift[2][2][22][64];
51

    
52
    void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
53
    void (*fdct[2])(DCTELEM *block);
54
    void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
55
} DVVideoContext;
56

    
57
/* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */
58
/* one element is needed for each video segment in a DV frame */
59
/* at most there are 2 DIF channels * 12 DIF sequences * 27 video segments (PAL 50Mbps) */
60
#define DV_ANCHOR_SIZE (2*12*27)
61

    
62
static void* dv_anchor[DV_ANCHOR_SIZE];
63

    
64
#define TEX_VLC_BITS 9
65

    
66
#ifdef DV_CODEC_TINY_TARGET
67
#define DV_VLC_MAP_RUN_SIZE 15
68
#define DV_VLC_MAP_LEV_SIZE 23
69
#else
70
#define DV_VLC_MAP_RUN_SIZE  64
71
#define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
72
#endif
73

    
74
/* XXX: also include quantization */
75
static RL_VLC_ELEM *dv_rl_vlc;
76
/* VLC encoding lookup table */
77
static struct dv_vlc_pair {
78
   uint32_t vlc;
79
   uint8_t  size;
80
} (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;
81

    
82
static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
83
{
84
    int i, q, j;
85

    
86
    /* NOTE: max left shift is 6 */
87
    for(q = 0; q < 22; q++) {
88
        /* 88DCT */
89
        for(i = 1; i < 64; i++) {
90
            /* 88 table */
91
            j = perm[i];
92
            s->dv_idct_shift[0][0][q][j] =
93
                dv_quant_shifts[q][dv_88_areas[i]] + 1;
94
            s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
95
        }
96

    
97
        /* 248DCT */
98
        for(i = 1; i < 64; i++) {
99
            /* 248 table */
100
            s->dv_idct_shift[0][1][q][i] =
101
                dv_quant_shifts[q][dv_248_areas[i]] + 1;
102
            s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
103
        }
104
    }
105
}
106

    
107
static int dvvideo_init(AVCodecContext *avctx)
108
{
109
    DVVideoContext *s = avctx->priv_data;
110
    DSPContext dsp;
111
    static int done=0;
112
    int i, j;
113

    
114
    if (!done) {
115
        VLC dv_vlc;
116
        uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
117
        uint8_t new_dv_vlc_len[NB_DV_VLC*2];
118
        uint8_t new_dv_vlc_run[NB_DV_VLC*2];
119
        int16_t new_dv_vlc_level[NB_DV_VLC*2];
120

    
121
        done = 1;
122

    
123
        dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
124
        if (!dv_vlc_map)
125
            return -ENOMEM;
126

    
127
        /* dv_anchor lets each thread know its Id */
128
        for (i=0; i<DV_ANCHOR_SIZE; i++)
129
            dv_anchor[i] = (void*)(size_t)i;
130

    
131
        /* it's faster to include sign bit in a generic VLC parsing scheme */
132
        for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
133
            new_dv_vlc_bits[j] = dv_vlc_bits[i];
134
            new_dv_vlc_len[j] = dv_vlc_len[i];
135
            new_dv_vlc_run[j] = dv_vlc_run[i];
136
            new_dv_vlc_level[j] = dv_vlc_level[i];
137

    
138
            if (dv_vlc_level[i]) {
139
                new_dv_vlc_bits[j] <<= 1;
140
                new_dv_vlc_len[j]++;
141

    
142
                j++;
143
                new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
144
                new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
145
                new_dv_vlc_run[j] = dv_vlc_run[i];
146
                new_dv_vlc_level[j] = -dv_vlc_level[i];
147
            }
148
        }
149

    
150
        /* NOTE: as a trick, we use the fact the no codes are unused
151
           to accelerate the parsing of partial codes */
152
        init_vlc(&dv_vlc, TEX_VLC_BITS, j,
153
                 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
154

    
155
        dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
156
        if (!dv_rl_vlc)
157
            return -ENOMEM;
158

    
159
        for(i = 0; i < dv_vlc.table_size; i++){
160
            int code= dv_vlc.table[i][0];
161
            int len = dv_vlc.table[i][1];
162
            int level, run;
163

    
164
            if(len<0){ //more bits needed
165
                run= 0;
166
                level= code;
167
            } else {
168
                run=   new_dv_vlc_run[code] + 1;
169
                level= new_dv_vlc_level[code];
170
            }
171
            dv_rl_vlc[i].len = len;
172
            dv_rl_vlc[i].level = level;
173
            dv_rl_vlc[i].run = run;
174
        }
175
        free_vlc(&dv_vlc);
176

    
177
        for (i = 0; i < NB_DV_VLC - 1; i++) {
178
           if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
179
               continue;
180
#ifdef DV_CODEC_TINY_TARGET
181
           if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
182
               continue;
183
#endif
184

    
185
           if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
186
               continue;
187

    
188
           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
189
                                                            (!!dv_vlc_level[i]);
190
           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
191
                                                             (!!dv_vlc_level[i]);
192
        }
193
        for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
194
#ifdef DV_CODEC_TINY_TARGET
195
           for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
196
              if (dv_vlc_map[i][j].size == 0) {
197
                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
198
                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
199
                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
200
                                          dv_vlc_map[0][j].size;
201
              }
202
           }
203
#else
204
           for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
205
              if (dv_vlc_map[i][j].size == 0) {
206
                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
207
                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
208
                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
209
                                          dv_vlc_map[0][j].size;
210
              }
211
              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
212
                                            dv_vlc_map[i][j].vlc | 1;
213
              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
214
                                            dv_vlc_map[i][j].size;
215
           }
216
#endif
217
        }
218
    }
219

    
220
    /* Generic DSP setup */
221
    dsputil_init(&dsp, avctx);
222
    s->get_pixels = dsp.get_pixels;
223

    
224
    /* 88DCT setup */
225
    s->fdct[0] = dsp.fdct;
226
    s->idct_put[0] = dsp.idct_put;
227
    for (i=0; i<64; i++)
228
       s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
229

    
230
    /* 248DCT setup */
231
    s->fdct[1] = dsp.fdct248;
232
    s->idct_put[1] = simple_idct248_put;  // FIXME: need to add it to DSP
233
    if(avctx->lowres){
234
        for (i=0; i<64; i++){
235
            int j= ff_zigzag248_direct[i];
236
            s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
237
        }
238
    }else
239
        memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
240

    
241
    /* XXX: do it only for constant case */
242
    dv_build_unquantize_tables(s, dsp.idct_permutation);
243

    
244
    avctx->coded_frame = &s->picture;
245
    s->avctx= avctx;
246

    
247
    return 0;
248
}
249

    
250
// #define VLC_DEBUG
251
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
252

    
253
typedef struct BlockInfo {
254
    const uint8_t *shift_table;
255
    const uint8_t *scan_table;
256
    const int *iweight_table;
257
    uint8_t pos; /* position in block */
258
    uint8_t dct_mode;
259
    uint8_t partial_bit_count;
260
    uint16_t partial_bit_buffer;
261
    int shift_offset;
262
} BlockInfo;
263

    
264
/* block size in bits */
265
static const uint16_t block_sizes[6] = {
266
    112, 112, 112, 112, 80, 80
267
};
268
/* bit budget for AC only in 5 MBs */
269
static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
270
/* see dv_88_areas and dv_248_areas for details */
271
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
272

    
273
#ifndef ALT_BITSTREAM_READER
274
#warning only works with ALT_BITSTREAM_READER
275
static int re_index; //Hack to make it compile
276
#endif
277

    
278
static inline int get_bits_left(GetBitContext *s)
279
{
280
    return s->size_in_bits - get_bits_count(s);
281
}
282

    
283
static inline int get_bits_size(GetBitContext *s)
284
{
285
    return s->size_in_bits;
286
}
287

    
288
static inline int put_bits_left(PutBitContext* s)
289
{
290
    return (s->buf_end - s->buf) * 8 - put_bits_count(s);
291
}
292

    
293
/* decode ac coefs */
294
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
295
{
296
    int last_index = get_bits_size(gb);
297
    const uint8_t *scan_table = mb->scan_table;
298
    const uint8_t *shift_table = mb->shift_table;
299
    const int *iweight_table = mb->iweight_table;
300
    int pos = mb->pos;
301
    int partial_bit_count = mb->partial_bit_count;
302
    int level, pos1, run, vlc_len, index;
303

    
304
    OPEN_READER(re, gb);
305
    UPDATE_CACHE(re, gb);
306

    
307
    /* if we must parse a partial vlc, we do it here */
308
    if (partial_bit_count > 0) {
309
        re_cache = ((unsigned)re_cache >> partial_bit_count) |
310
                   (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
311
        re_index -= partial_bit_count;
312
        mb->partial_bit_count = 0;
313
    }
314

    
315
    /* get the AC coefficients until last_index is reached */
316
    for(;;) {
317
#ifdef VLC_DEBUG
318
        printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
319
#endif
320
        /* our own optimized GET_RL_VLC */
321
        index = NEG_USR32(re_cache, TEX_VLC_BITS);
322
        vlc_len = dv_rl_vlc[index].len;
323
        if (vlc_len < 0) {
324
            index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
325
            vlc_len = TEX_VLC_BITS - vlc_len;
326
        }
327
        level = dv_rl_vlc[index].level;
328
        run = dv_rl_vlc[index].run;
329

    
330
        /* gotta check if we're still within gb boundaries */
331
        if (re_index + vlc_len > last_index) {
332
            /* should be < 16 bits otherwise a codeword could have been parsed */
333
            mb->partial_bit_count = last_index - re_index;
334
            mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
335
            re_index = last_index;
336
            break;
337
        }
338
        re_index += vlc_len;
339

    
340
#ifdef VLC_DEBUG
341
        printf("run=%d level=%d\n", run, level);
342
#endif
343
        pos += run;
344
        if (pos >= 64)
345
            break;
346

    
347
        pos1 = scan_table[pos];
348
        level <<= shift_table[pos1];
349

    
350
        /* unweigh, round, and shift down */
351
        level = (level*iweight_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
352

    
353
        block[pos1] = level;
354

    
355
        UPDATE_CACHE(re, gb);
356
    }
357
    CLOSE_READER(re, gb);
358
    mb->pos = pos;
359
}
360

    
361
static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
362
{
363
    int bits_left = get_bits_left(gb);
364
    while (bits_left >= MIN_CACHE_BITS) {
365
        put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
366
        bits_left -= MIN_CACHE_BITS;
367
    }
368
    if (bits_left > 0) {
369
        put_bits(pb, bits_left, get_bits(gb, bits_left));
370
    }
371
}
372

    
373
/* mb_x and mb_y are in units of 8 pixels */
374
static inline void dv_decode_video_segment(DVVideoContext *s,
375
                                           uint8_t *buf_ptr1,
376
                                           const uint16_t *mb_pos_ptr)
377
{
378
    int quant, dc, dct_mode, class1, j;
379
    int mb_index, mb_x, mb_y, v, last_index;
380
    DCTELEM *block, *block1;
381
    int c_offset;
382
    uint8_t *y_ptr;
383
    void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
384
    uint8_t *buf_ptr;
385
    PutBitContext pb, vs_pb;
386
    GetBitContext gb;
387
    BlockInfo mb_data[5 * 6], *mb, *mb1;
388
    DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]);
389
    DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
390
    DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
391
    const int log2_blocksize= 3-s->avctx->lowres;
392

    
393
    assert((((int)mb_bit_buffer)&7)==0);
394
    assert((((int)vs_bit_buffer)&7)==0);
395

    
396
    memset(sblock, 0, sizeof(sblock));
397

    
398
    /* pass 1 : read DC and AC coefficients in blocks */
399
    buf_ptr = buf_ptr1;
400
    block1 = &sblock[0][0];
401
    mb1 = mb_data;
402
    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
403
    for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
404
        /* skip header */
405
        quant = buf_ptr[3] & 0x0f;
406
        buf_ptr += 4;
407
        init_put_bits(&pb, mb_bit_buffer, 80);
408
        mb = mb1;
409
        block = block1;
410
        for(j = 0;j < 6; j++) {
411
            last_index = block_sizes[j];
412
            init_get_bits(&gb, buf_ptr, last_index);
413

    
414
            /* get the dc */
415
            dc = get_sbits(&gb, 9);
416
            dct_mode = get_bits1(&gb);
417
            mb->dct_mode = dct_mode;
418
            mb->scan_table = s->dv_zigzag[dct_mode];
419
            mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88;
420
            class1 = get_bits(&gb, 2);
421
            mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
422
                [quant + dv_quant_offset[class1]];
423
            dc = dc << 2;
424
            /* convert to unsigned because 128 is not added in the
425
               standard IDCT */
426
            dc += 1024;
427
            block[0] = dc;
428
            buf_ptr += last_index >> 3;
429
            mb->pos = 0;
430
            mb->partial_bit_count = 0;
431

    
432
#ifdef VLC_DEBUG
433
            printf("MB block: %d, %d ", mb_index, j);
434
#endif
435
            dv_decode_ac(&gb, mb, block);
436

    
437
            /* write the remaining bits  in a new buffer only if the
438
               block is finished */
439
            if (mb->pos >= 64)
440
                bit_copy(&pb, &gb);
441

    
442
            block += 64;
443
            mb++;
444
        }
445

    
446
        /* pass 2 : we can do it just after */
447
#ifdef VLC_DEBUG
448
        printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
449
#endif
450
        block = block1;
451
        mb = mb1;
452
        init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
453
        flush_put_bits(&pb);
454
        for(j = 0;j < 6; j++, block += 64, mb++) {
455
            if (mb->pos < 64 && get_bits_left(&gb) > 0) {
456
                dv_decode_ac(&gb, mb, block);
457
                /* if still not finished, no need to parse other blocks */
458
                if (mb->pos < 64)
459
                    break;
460
            }
461
        }
462
        /* all blocks are finished, so the extra bytes can be used at
463
           the video segment level */
464
        if (j >= 6)
465
            bit_copy(&vs_pb, &gb);
466
    }
467

    
468
    /* we need a pass other the whole video segment */
469
#ifdef VLC_DEBUG
470
    printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
471
#endif
472
    block = &sblock[0][0];
473
    mb = mb_data;
474
    init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
475
    flush_put_bits(&vs_pb);
476
    for(mb_index = 0; mb_index < 5; mb_index++) {
477
        for(j = 0;j < 6; j++) {
478
            if (mb->pos < 64) {
479
#ifdef VLC_DEBUG
480
                printf("start %d:%d\n", mb_index, j);
481
#endif
482
                dv_decode_ac(&gb, mb, block);
483
            }
484
            if (mb->pos >= 64 && mb->pos < 127)
485
                av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
486
            block += 64;
487
            mb++;
488
        }
489
    }
490

    
491
    /* compute idct and place blocks */
492
    block = &sblock[0][0];
493
    mb = mb_data;
494
    for(mb_index = 0; mb_index < 5; mb_index++) {
495
        v = *mb_pos_ptr++;
496
        mb_x = v & 0xff;
497
        mb_y = v >> 8;
498
        if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
499
            y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + (mb_x>>1))<<log2_blocksize);
500
            c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
501
        } else { /* 4:1:1 or 4:2:0 */
502
            y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
503
            if (s->sys->pix_fmt == PIX_FMT_YUV411P)
504
                c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
505
            else /* 4:2:0 */
506
                c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);
507
        }
508
        for(j = 0;j < 6; j++) {
509
            idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
510
            if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
511
                if (j == 0 || j == 2) {
512
                    /* Y0 Y1 */
513
                    idct_put(y_ptr + ((j >> 1)<<log2_blocksize),
514
                             s->picture.linesize[0], block);
515
                } else if(j > 3) {
516
                    /* Cr Cb */
517
                    idct_put(s->picture.data[6 - j] + c_offset,
518
                             s->picture.linesize[6 - j], block);
519
                }
520
                /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */
521
            } else { /* 4:1:1 or 4:2:0 */
522
                if (j < 4) {
523
                    if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
524
                        /* NOTE: at end of line, the macroblock is handled as 420 */
525
                        idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
526
                    } else {
527
                        idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
528
                                 s->picture.linesize[0], block);
529
                    }
530
                } else {
531
                    if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
532
                        uint64_t aligned_pixels[64/8];
533
                        uint8_t *pixels= (uint8_t*)aligned_pixels;
534
                        uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
535
                        int x, y, linesize;
536
                        /* NOTE: at end of line, the macroblock is handled as 420 */
537
                        idct_put(pixels, 8, block);
538
                        linesize = s->picture.linesize[6 - j];
539
                        c_ptr = s->picture.data[6 - j] + c_offset;
540
                        ptr = pixels;
541
                        for(y = 0;y < (1<<log2_blocksize); y++) {
542
                            ptr1= ptr + (1<<(log2_blocksize-1));
543
                            c_ptr1 = c_ptr + (linesize<<log2_blocksize);
544
                            for(x=0; x < (1<<(log2_blocksize-1)); x++){
545
                                c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
546
                            }
547
                            c_ptr += linesize;
548
                            ptr += 8;
549
                        }
550
                    } else {
551
                        /* don't ask me why they inverted Cb and Cr ! */
552
                        idct_put(s->picture.data[6 - j] + c_offset,
553
                                 s->picture.linesize[6 - j], block);
554
                    }
555
                }
556
            }
557
            block += 64;
558
            mb++;
559
        }
560
    }
561
}
562

    
563
#ifdef DV_CODEC_TINY_TARGET
564
/* Converts run and level (where level != 0) pair into vlc, returning bit size */
565
static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
566
{
567
    int size;
568
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
569
        *vlc = dv_vlc_map[run][level].vlc | sign;
570
        size = dv_vlc_map[run][level].size;
571
    }
572
    else {
573
        if (level < DV_VLC_MAP_LEV_SIZE) {
574
            *vlc = dv_vlc_map[0][level].vlc | sign;
575
            size = dv_vlc_map[0][level].size;
576
        } else {
577
            *vlc = 0xfe00 | (level << 1) | sign;
578
            size = 16;
579
        }
580
        if (run) {
581
            *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
582
                                  (0x1f80 | (run - 1))) << size;
583
            size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
584
        }
585
    }
586

    
587
    return size;
588
}
589

    
590
static always_inline int dv_rl2vlc_size(int run, int level)
591
{
592
    int size;
593

    
594
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
595
        size = dv_vlc_map[run][level].size;
596
    }
597
    else {
598
        size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
599
        if (run) {
600
            size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
601
        }
602
    }
603
    return size;
604
}
605
#else
606
static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
607
{
608
    *vlc = dv_vlc_map[run][l].vlc | sign;
609
    return dv_vlc_map[run][l].size;
610
}
611

    
612
static always_inline int dv_rl2vlc_size(int run, int l)
613
{
614
    return dv_vlc_map[run][l].size;
615
}
616
#endif
617

    
618
typedef struct EncBlockInfo {
619
    int area_q[4];
620
    int bit_size[4];
621
    int prev[5];
622
    int cur_ac;
623
    int cno;
624
    int dct_mode;
625
    DCTELEM mb[64];
626
    uint8_t next[64];
627
    uint8_t sign[64];
628
    uint8_t partial_bit_count;
629
    uint32_t partial_bit_buffer; /* we can't use uint16_t here */
630
} EncBlockInfo;
631

    
632
static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
633
                                       PutBitContext* pb_end)
634
{
635
    int prev;
636
    int bits_left;
637
    PutBitContext* pb = pb_pool;
638
    int size = bi->partial_bit_count;
639
    uint32_t vlc = bi->partial_bit_buffer;
640

    
641
    bi->partial_bit_count = bi->partial_bit_buffer = 0;
642
    for(;;){
643
       /* Find suitable storage space */
644
       for (; size > (bits_left = put_bits_left(pb)); pb++) {
645
          if (bits_left) {
646
              size -= bits_left;
647
              put_bits(pb, bits_left, vlc >> size);
648
              vlc = vlc & ((1<<size)-1);
649
          }
650
          if (pb + 1 >= pb_end) {
651
              bi->partial_bit_count = size;
652
              bi->partial_bit_buffer = vlc;
653
              return pb;
654
          }
655
       }
656

    
657
       /* Store VLC */
658
       put_bits(pb, size, vlc);
659

    
660
       if(bi->cur_ac>=64)
661
           break;
662

    
663
       /* Construct the next VLC */
664
       prev= bi->cur_ac;
665
       bi->cur_ac = bi->next[prev];
666
       if(bi->cur_ac < 64){
667
           size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
668
       } else {
669
           size = 4; vlc = 6; /* End Of Block stamp */
670
       }
671
    }
672
    return pb;
673
}
674

    
675
static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
676
                                              const uint8_t* zigzag_scan, const int *weight, int bias)
677
{
678
    int i, area;
679
    /* We offer two different methods for class number assignment: the
680
       method suggested in SMPTE 314M Table 22, and an improved
681
       method. The SMPTE method is very conservative; it assigns class
682
       3 (i.e. severe quantization) to any block where the largest AC
683
       component is greater than 36. ffmpeg's DV encoder tracks AC bit
684
       consumption precisely, so there is no need to bias most blocks
685
       towards strongly lossy compression. Instead, we assign class 2
686
       to most blocks, and use class 3 only when strictly necessary
687
       (for blocks whose largest AC component exceeds 255). */
688

    
689
#if 0 /* SMPTE spec method */
690
    static const int classes[] = {12, 24, 36, 0xffff};
691
#else /* improved ffmpeg method */
692
    static const int classes[] = {-1, -1, 255, 0xffff};
693
#endif
694
    int max=classes[0];
695
    int prev=0;
696

    
697
    bi->mb[0] = blk[0];
698

    
699
    for (area = 0; area < 4; area++) {
700
       bi->prev[area] = prev;
701
       bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
702
       for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
703
          int level = blk[zigzag_scan[i]];
704

    
705
          if (level+15 > 30U) {
706
              bi->sign[i] = (level>>31)&1;
707
              /* weigh it and and shift down into range, adding for rounding */
708
              /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
709
                 AND the 2x doubling of the weights */
710
              level = (ABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
711
              bi->mb[i] = level;
712
              if(level>max) max= level;
713
              bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
714
              bi->next[prev]= i;
715
              prev= i;
716
          }
717
       }
718
    }
719
    bi->next[prev]= i;
720
    for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
721

    
722
    bi->cno += bias;
723

    
724
    if (bi->cno >= 3) {
725
        bi->cno = 3;
726
        prev=0;
727
        i= bi->next[prev];
728
        for (area = 0; area < 4; area++) {
729
            bi->prev[area] = prev;
730
            bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
731
            for (; i<mb_area_start[area+1]; i= bi->next[i]) {
732
                bi->mb[i] >>=1;
733

    
734
                if (bi->mb[i]) {
735
                    bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
736
                    bi->next[prev]= i;
737
                    prev= i;
738
                }
739
            }
740
        }
741
        bi->next[prev]= i;
742
    }
743
}
744

    
745
//FIXME replace this by dsputil
746
#define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
747
static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
748
    DCTELEM *s;
749
    int score88 = 0;
750
    int score248 = 0;
751
    int i;
752

    
753
    /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
754
    s = blk;
755
    for(i=0; i<7; i++) {
756
        score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
757
                   SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
758
        s += 8;
759
    }
760
    /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
761
    s = blk;
762
    for(i=0; i<6; i++) {
763
        score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
764
                    SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
765
        s += 8;
766
    }
767

    
768
    return (score88 - score248 > -10);
769
}
770

    
771
static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
772
{
773
    int size[5];
774
    int i, j, k, a, prev, a2;
775
    EncBlockInfo* b;
776

    
777
    size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
778
    do {
779
       b = blks;
780
       for (i=0; i<5; i++) {
781
          if (!qnos[i])
782
              continue;
783

    
784
          qnos[i]--;
785
          size[i] = 0;
786
          for (j=0; j<6; j++, b++) {
787
             for (a=0; a<4; a++) {
788
                if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
789
                    b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
790
                    b->area_q[a]++;
791
                    prev= b->prev[a];
792
                    assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
793
                    for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
794
                       b->mb[k] >>= 1;
795
                       if (b->mb[k]) {
796
                           b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
797
                           prev= k;
798
                       } else {
799
                           if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
800
                                for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
801
                                    b->prev[a2] = prev;
802
                                assert(a2<4);
803
                                assert(b->mb[b->next[k]]);
804
                                b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
805
                                                  -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
806
                                assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
807
                                b->prev[a2] = prev;
808
                           }
809
                           b->next[prev] = b->next[k];
810
                       }
811
                    }
812
                    b->prev[a+1]= prev;
813
                }
814
                size[i] += b->bit_size[a];
815
             }
816
          }
817
          if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
818
                return;
819
       }
820
    } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
821

    
822

    
823
    for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
824
        b = blks;
825
        size[0] = 5*6*4; //EOB
826
        for (j=0; j<6*5; j++, b++) {
827
            prev= b->prev[0];
828
            for (k= b->next[prev]; k<64; k= b->next[k]) {
829
                if(b->mb[k] < a && b->mb[k] > -a){
830
                    b->next[prev] = b->next[k];
831
                }else{
832
                    size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
833
                    prev= k;
834
                }
835
            }
836
        }
837
    }
838
}
839

    
840
static inline void dv_encode_video_segment(DVVideoContext *s,
841
                                           uint8_t *dif,
842
                                           const uint16_t *mb_pos_ptr)
843
{
844
    int mb_index, i, j, v;
845
    int mb_x, mb_y, c_offset, linesize;
846
    uint8_t*  y_ptr;
847
    uint8_t*  data;
848
    uint8_t*  ptr;
849
    int       do_edge_wrap;
850
    DECLARE_ALIGNED_8(DCTELEM, block[64]);
851
    EncBlockInfo  enc_blks[5*6];
852
    PutBitContext pbs[5*6];
853
    PutBitContext* pb;
854
    EncBlockInfo* enc_blk;
855
    int       vs_bit_size = 0;
856
    int       qnos[5];
857

    
858
    assert((((int)block) & 7) == 0);
859

    
860
    enc_blk = &enc_blks[0];
861
    pb = &pbs[0];
862
    for(mb_index = 0; mb_index < 5; mb_index++) {
863
        v = *mb_pos_ptr++;
864
        mb_x = v & 0xff;
865
        mb_y = v >> 8;
866
        if (s->sys->pix_fmt == PIX_FMT_YUV422P) {
867
            y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 4);
868
        } else { /* 4:1:1 */
869
            y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
870
        }
871
        if (s->sys->pix_fmt == PIX_FMT_YUV420P) {
872
            c_offset = (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
873
        } else { /* 4:2:2 or 4:1:1 */
874
            c_offset = ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8));
875
        }
876
        do_edge_wrap = 0;
877
        qnos[mb_index] = 15; /* No quantization */
878
        ptr = dif + mb_index*80 + 4;
879
        for(j = 0;j < 6; j++) {
880
            int dummy = 0;
881
            if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
882
                if (j == 0 || j == 2) {
883
                    /* Y0 Y1 */
884
                    data = y_ptr + ((j>>1) * 8);
885
                    linesize = s->picture.linesize[0];
886
                } else if (j > 3) {
887
                    /* Cr Cb */
888
                    data = s->picture.data[6 - j] + c_offset;
889
                    linesize = s->picture.linesize[6 - j];
890
                } else {
891
                    /* j=1 and j=3 are "dummy" blocks, used for AC data only */
892
                    data = 0;
893
                    linesize = 0;
894
                    dummy = 1;
895
                }
896
            } else { /* 4:1:1 or 4:2:0 */
897
                if (j < 4) {  /* Four Y blocks */
898
                    /* NOTE: at end of line, the macroblock is handled as 420 */
899
                    if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
900
                        data = y_ptr + (j * 8);
901
                    } else {
902
                        data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
903
                    }
904
                    linesize = s->picture.linesize[0];
905
                } else {      /* Cr and Cb blocks */
906
                    /* don't ask Fabrice why they inverted Cb and Cr ! */
907
                    data = s->picture.data[6 - j] + c_offset;
908
                    linesize = s->picture.linesize[6 - j];
909
                    if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
910
                        do_edge_wrap = 1;
911
                }
912
            }
913

    
914
            /* Everything is set up -- now just copy data -> DCT block */
915
            if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
916
                uint8_t* d;
917
                DCTELEM *b = block;
918
                for (i=0;i<8;i++) {
919
                   d = data + 8 * linesize;
920
                   b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
921
                   b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
922
                   data += linesize;
923
                   b += 8;
924
                }
925
            } else {             /* Simple copy: 8x8 -> 8x8 */
926
                if (!dummy)
927
                    s->get_pixels(block, data, linesize);
928
            }
929

    
930
            if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
931
                enc_blk->dct_mode = dv_guess_dct_mode(block);
932
            else
933
                enc_blk->dct_mode = 0;
934
            enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
935
            enc_blk->partial_bit_count = 0;
936
            enc_blk->partial_bit_buffer = 0;
937
            enc_blk->cur_ac = 0;
938

    
939
            if (dummy) {
940
                /* We rely on the fact that encoding all zeros leads to an immediate EOB,
941
                   which is precisely what the spec calls for in the "dummy" blocks. */
942
                memset(block, 0, sizeof(block));
943
            } else {
944
                s->fdct[enc_blk->dct_mode](block);
945
            }
946

    
947
            dv_set_class_number(block, enc_blk,
948
                                enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
949
                                enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
950
                                j/4);
951

    
952
            init_put_bits(pb, ptr, block_sizes[j]/8);
953
            put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
954
            put_bits(pb, 1, enc_blk->dct_mode);
955
            put_bits(pb, 2, enc_blk->cno);
956

    
957
            vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
958
                           enc_blk->bit_size[2] + enc_blk->bit_size[3];
959
            ++enc_blk;
960
            ++pb;
961
            ptr += block_sizes[j]/8;
962
        }
963
    }
964

    
965
    if (vs_total_ac_bits < vs_bit_size)
966
        dv_guess_qnos(&enc_blks[0], &qnos[0]);
967

    
968
    for (i=0; i<5; i++) {
969
       dif[i*80 + 3] = qnos[i];
970
    }
971

    
972
    /* First pass over individual cells only */
973
    for (j=0; j<5*6; j++)
974
       dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
975

    
976
    /* Second pass over each MB space */
977
    for (j=0; j<5*6; j+=6) {
978
        pb= &pbs[j];
979
        for (i=0; i<6; i++) {
980
            if (enc_blks[i+j].partial_bit_count)
981
                pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
982
        }
983
    }
984

    
985
    /* Third and final pass over the whole vides segment space */
986
    pb= &pbs[0];
987
    for (j=0; j<5*6; j++) {
988
       if (enc_blks[j].partial_bit_count)
989
           pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
990
       if (enc_blks[j].partial_bit_count)
991
            av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
992
    }
993

    
994
    for (j=0; j<5*6; j++)
995
       flush_put_bits(&pbs[j]);
996
}
997

    
998
static int dv_decode_mt(AVCodecContext *avctx, void* sl)
999
{
1000
    DVVideoContext *s = avctx->priv_data;
1001
    int slice = (size_t)sl;
1002

    
1003
    /* which DIF channel is this? */
1004
    int chan = slice / (s->sys->difseg_size * 27);
1005

    
1006
    /* slice within the DIF channel */
1007
    int chan_slice = slice % (s->sys->difseg_size * 27);
1008

    
1009
    /* byte offset of this channel's data */
1010
    int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1011

    
1012
    dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1013
                            &s->sys->video_place[slice*5]);
1014
    return 0;
1015
}
1016

    
1017
static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1018
{
1019
    DVVideoContext *s = avctx->priv_data;
1020
    int slice = (size_t)sl;
1021

    
1022
    /* which DIF channel is this? */
1023
    int chan = slice / (s->sys->difseg_size * 27);
1024

    
1025
    /* slice within the DIF channel */
1026
    int chan_slice = slice % (s->sys->difseg_size * 27);
1027

    
1028
    /* byte offset of this channel's data */
1029
    int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1030

    
1031
    dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1032
                            &s->sys->video_place[slice*5]);
1033
    return 0;
1034
}
1035

    
1036
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1037
   144000 bytes for PAL - or twice those for 50Mbps) */
1038
static int dvvideo_decode_frame(AVCodecContext *avctx,
1039
                                 void *data, int *data_size,
1040
                                 uint8_t *buf, int buf_size)
1041
{
1042
    DVVideoContext *s = avctx->priv_data;
1043

    
1044
    s->sys = dv_frame_profile(buf);
1045
    if (!s->sys || buf_size < s->sys->frame_size)
1046
        return -1; /* NOTE: we only accept several full frames */
1047

    
1048
    if(s->picture.data[0])
1049
        avctx->release_buffer(avctx, &s->picture);
1050

    
1051
    s->picture.reference = 0;
1052
    s->picture.key_frame = 1;
1053
    s->picture.pict_type = FF_I_TYPE;
1054
    avctx->pix_fmt = s->sys->pix_fmt;
1055
    avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1056
    if(avctx->get_buffer(avctx, &s->picture) < 0) {
1057
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1058
        return -1;
1059
    }
1060
    s->picture.interlaced_frame = 1;
1061
    s->picture.top_field_first = 0;
1062

    
1063
    s->buf = buf;
1064
    avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
1065
                   s->sys->n_difchan * s->sys->difseg_size * 27);
1066

    
1067
    emms_c();
1068

    
1069
    /* return image */
1070
    *data_size = sizeof(AVFrame);
1071
    *(AVFrame*)data= s->picture;
1072

    
1073
    return s->sys->frame_size;
1074
}
1075

    
1076
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1077
                                void *data)
1078
{
1079
    DVVideoContext *s = c->priv_data;
1080

    
1081
    s->sys = dv_codec_profile(c);
1082
    if (!s->sys)
1083
        return -1;
1084
    if(buf_size < s->sys->frame_size)
1085
        return -1;
1086

    
1087
    c->pix_fmt = s->sys->pix_fmt;
1088
    s->picture = *((AVFrame *)data);
1089
    s->picture.key_frame = 1;
1090
    s->picture.pict_type = FF_I_TYPE;
1091

    
1092
    s->buf = buf;
1093
    c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1094
               s->sys->n_difchan * s->sys->difseg_size * 27);
1095

    
1096
    emms_c();
1097

    
1098
    /* Fill in just enough of the header for dv_frame_profile() to
1099
       return the correct result, so that the frame can be decoded
1100
       correctly. The rest of the metadata is filled in by the dvvideo
1101
       avformat. (this should probably change so that encode_frame()
1102
       fills in ALL of the metadata - e.g. for Quicktime-wrapped DV
1103
       streams) */
1104

    
1105
    /* NTSC/PAL format */
1106
    buf[3] = s->sys->dsf ? 0x80 : 0x00;
1107

    
1108
    /* 25Mbps or 50Mbps */
1109
    buf[80*5 + 48 + 3] = (s->sys->pix_fmt == PIX_FMT_YUV422P) ? 0x4 : 0x0;
1110

    
1111
    return s->sys->frame_size;
1112
}
1113

    
1114
static int dvvideo_close(AVCodecContext *c)
1115
{
1116

    
1117
    return 0;
1118
}
1119

    
1120

    
1121
#ifdef CONFIG_DVVIDEO_ENCODER
1122
AVCodec dvvideo_encoder = {
1123
    "dvvideo",
1124
    CODEC_TYPE_VIDEO,
1125
    CODEC_ID_DVVIDEO,
1126
    sizeof(DVVideoContext),
1127
    dvvideo_init,
1128
    dvvideo_encode_frame,
1129
    dvvideo_close,
1130
    NULL,
1131
    CODEC_CAP_DR1,
1132
    NULL
1133
};
1134
#endif // CONFIG_DVVIDEO_ENCODER
1135

    
1136
AVCodec dvvideo_decoder = {
1137
    "dvvideo",
1138
    CODEC_TYPE_VIDEO,
1139
    CODEC_ID_DVVIDEO,
1140
    sizeof(DVVideoContext),
1141
    dvvideo_init,
1142
    NULL,
1143
    dvvideo_close,
1144
    dvvideo_decode_frame,
1145
    CODEC_CAP_DR1,
1146
    NULL
1147
};