Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 4ad62d9a

History | View | Annotate | Download (43.4 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 file is part of FFmpeg.
16
 *
17
 * FFmpeg is free software; you can redistribute it and/or
18
 * modify it under the terms of the GNU Lesser General Public
19
 * License as published by the Free Software Foundation; either
20
 * version 2.1 of the License, or (at your option) any later version.
21
 *
22
 * FFmpeg is distributed in the hope that it will be useful,
23
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25
 * Lesser General Public License for more details.
26
 *
27
 * You should have received a copy of the GNU Lesser General Public
28
 * License along with FFmpeg; if not, write to the Free Software
29
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30
 */
31

    
32
/**
33
 * @file dv.c
34
 * DV codec.
35
 */
36
#define ALT_BITSTREAM_READER
37
#include "avcodec.h"
38
#include "dsputil.h"
39
#include "bitstream.h"
40
#include "simple_idct.h"
41
#include "dvdata.h"
42

    
43
//#undef NDEBUG
44
//#include <assert.h>
45

    
46
typedef struct DVVideoContext {
47
    const DVprofile* sys;
48
    AVFrame picture;
49
    AVCodecContext *avctx;
50
    uint8_t *buf;
51

    
52
    uint8_t dv_zigzag[2][64];
53
    uint8_t dv_idct_shift[2][2][22][64];
54

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

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

    
65
static void* dv_anchor[DV_ANCHOR_SIZE];
66

    
67
#define TEX_VLC_BITS 9
68

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

    
77
/* XXX: also include quantization */
78
static RL_VLC_ELEM dv_rl_vlc[1184];
79
/* VLC encoding lookup table */
80
static struct dv_vlc_pair {
81
   uint32_t vlc;
82
   uint8_t  size;
83
} dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
84

    
85
static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
86
{
87
    int i, q, j;
88

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

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

    
110
static av_cold int dvvideo_init(AVCodecContext *avctx)
111
{
112
    DVVideoContext *s = avctx->priv_data;
113
    DSPContext dsp;
114
    static int done=0;
115
    int i, j;
116

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

    
124
        done = 1;
125

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

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

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

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

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

    
155
        for(i = 0; i < dv_vlc.table_size; i++){
156
            int code= dv_vlc.table[i][0];
157
            int len = dv_vlc.table[i][1];
158
            int level, run;
159

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

    
173
        for (i = 0; i < NB_DV_VLC - 1; i++) {
174
           if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
175
               continue;
176
#ifdef DV_CODEC_TINY_TARGET
177
           if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
178
               continue;
179
#endif
180

    
181
           if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
182
               continue;
183

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

    
216
    /* Generic DSP setup */
217
    dsputil_init(&dsp, avctx);
218
    s->get_pixels = dsp.get_pixels;
219

    
220
    /* 88DCT setup */
221
    s->fdct[0] = dsp.fdct;
222
    s->idct_put[0] = dsp.idct_put;
223
    for (i=0; i<64; i++)
224
       s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
225

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

    
237
    /* XXX: do it only for constant case */
238
    dv_build_unquantize_tables(s, dsp.idct_permutation);
239

    
240
    avctx->coded_frame = &s->picture;
241
    s->avctx= avctx;
242

    
243
    return 0;
244
}
245

    
246
// #define VLC_DEBUG
247
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
248

    
249
typedef struct BlockInfo {
250
    const uint8_t *shift_table;
251
    const uint8_t *scan_table;
252
    const int *iweight_table;
253
    uint8_t pos; /* position in block */
254
    uint8_t dct_mode;
255
    uint8_t partial_bit_count;
256
    uint16_t partial_bit_buffer;
257
    int shift_offset;
258
} BlockInfo;
259

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

    
269
static inline int get_bits_left(GetBitContext *s)
270
{
271
    return s->size_in_bits - get_bits_count(s);
272
}
273

    
274
static inline int put_bits_left(PutBitContext* s)
275
{
276
    return (s->buf_end - s->buf) * 8 - put_bits_count(s);
277
}
278

    
279
/* decode ac coefs */
280
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
281
{
282
    int last_index = gb->size_in_bits;
283
    const uint8_t *scan_table = mb->scan_table;
284
    const uint8_t *shift_table = mb->shift_table;
285
    const int *iweight_table = mb->iweight_table;
286
    int pos = mb->pos;
287
    int partial_bit_count = mb->partial_bit_count;
288
    int level, pos1, run, vlc_len, index;
289

    
290
    OPEN_READER(re, gb);
291
    UPDATE_CACHE(re, gb);
292

    
293
    /* if we must parse a partial vlc, we do it here */
294
    if (partial_bit_count > 0) {
295
        re_cache = ((unsigned)re_cache >> partial_bit_count) |
296
                   (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
297
        re_index -= partial_bit_count;
298
        mb->partial_bit_count = 0;
299
    }
300

    
301
    /* get the AC coefficients until last_index is reached */
302
    for(;;) {
303
#ifdef VLC_DEBUG
304
        printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
305
#endif
306
        /* our own optimized GET_RL_VLC */
307
        index = NEG_USR32(re_cache, TEX_VLC_BITS);
308
        vlc_len = dv_rl_vlc[index].len;
309
        if (vlc_len < 0) {
310
            index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
311
            vlc_len = TEX_VLC_BITS - vlc_len;
312
        }
313
        level = dv_rl_vlc[index].level;
314
        run = dv_rl_vlc[index].run;
315

    
316
        /* gotta check if we're still within gb boundaries */
317
        if (re_index + vlc_len > last_index) {
318
            /* should be < 16 bits otherwise a codeword could have been parsed */
319
            mb->partial_bit_count = last_index - re_index;
320
            mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
321
            re_index = last_index;
322
            break;
323
        }
324
        re_index += vlc_len;
325

    
326
#ifdef VLC_DEBUG
327
        printf("run=%d level=%d\n", run, level);
328
#endif
329
        pos += run;
330
        if (pos >= 64)
331
            break;
332

    
333
        pos1 = scan_table[pos];
334
        level <<= shift_table[pos1];
335

    
336
        /* unweigh, round, and shift down */
337
        level = (level*iweight_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
338

    
339
        block[pos1] = level;
340

    
341
        UPDATE_CACHE(re, gb);
342
    }
343
    CLOSE_READER(re, gb);
344
    mb->pos = pos;
345
}
346

    
347
static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
348
{
349
    int bits_left = get_bits_left(gb);
350
    while (bits_left >= MIN_CACHE_BITS) {
351
        put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
352
        bits_left -= MIN_CACHE_BITS;
353
    }
354
    if (bits_left > 0) {
355
        put_bits(pb, bits_left, get_bits(gb, bits_left));
356
    }
357
}
358

    
359
/* mb_x and mb_y are in units of 8 pixels */
360
static inline void dv_decode_video_segment(DVVideoContext *s,
361
                                           const uint8_t *buf_ptr1,
362
                                           const uint16_t *mb_pos_ptr)
363
{
364
    int quant, dc, dct_mode, class1, j;
365
    int mb_index, mb_x, mb_y, v, last_index;
366
    DCTELEM *block, *block1;
367
    int c_offset;
368
    uint8_t *y_ptr;
369
    void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
370
    const uint8_t *buf_ptr;
371
    PutBitContext pb, vs_pb;
372
    GetBitContext gb;
373
    BlockInfo mb_data[5 * 6], *mb, *mb1;
374
    DECLARE_ALIGNED_16(DCTELEM, sblock[5*6][64]);
375
    DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
376
    DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
377
    const int log2_blocksize= 3-s->avctx->lowres;
378

    
379
    assert((((int)mb_bit_buffer)&7)==0);
380
    assert((((int)vs_bit_buffer)&7)==0);
381

    
382
    memset(sblock, 0, sizeof(sblock));
383

    
384
    /* pass 1 : read DC and AC coefficients in blocks */
385
    buf_ptr = buf_ptr1;
386
    block1 = &sblock[0][0];
387
    mb1 = mb_data;
388
    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
389
    for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
390
        /* skip header */
391
        quant = buf_ptr[3] & 0x0f;
392
        buf_ptr += 4;
393
        init_put_bits(&pb, mb_bit_buffer, 80);
394
        mb = mb1;
395
        block = block1;
396
        for(j = 0;j < 6; j++) {
397
            last_index = block_sizes[j];
398
            init_get_bits(&gb, buf_ptr, last_index);
399

    
400
            /* get the dc */
401
            dc = get_sbits(&gb, 9);
402
            dct_mode = get_bits1(&gb);
403
            mb->dct_mode = dct_mode;
404
            mb->scan_table = s->dv_zigzag[dct_mode];
405
            mb->iweight_table = dct_mode ? dv_iweight_248 : dv_iweight_88;
406
            class1 = get_bits(&gb, 2);
407
            mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
408
                [quant + dv_quant_offset[class1]];
409
            dc = dc << 2;
410
            /* convert to unsigned because 128 is not added in the
411
               standard IDCT */
412
            dc += 1024;
413
            block[0] = dc;
414
            buf_ptr += last_index >> 3;
415
            mb->pos = 0;
416
            mb->partial_bit_count = 0;
417

    
418
#ifdef VLC_DEBUG
419
            printf("MB block: %d, %d ", mb_index, j);
420
#endif
421
            dv_decode_ac(&gb, mb, block);
422

    
423
            /* write the remaining bits  in a new buffer only if the
424
               block is finished */
425
            if (mb->pos >= 64)
426
                bit_copy(&pb, &gb);
427

    
428
            block += 64;
429
            mb++;
430
        }
431

    
432
        /* pass 2 : we can do it just after */
433
#ifdef VLC_DEBUG
434
        printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
435
#endif
436
        block = block1;
437
        mb = mb1;
438
        init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
439
        flush_put_bits(&pb);
440
        for(j = 0;j < 6; j++, block += 64, mb++) {
441
            if (mb->pos < 64 && get_bits_left(&gb) > 0) {
442
                dv_decode_ac(&gb, mb, block);
443
                /* if still not finished, no need to parse other blocks */
444
                if (mb->pos < 64)
445
                    break;
446
            }
447
        }
448
        /* all blocks are finished, so the extra bytes can be used at
449
           the video segment level */
450
        if (j >= 6)
451
            bit_copy(&vs_pb, &gb);
452
    }
453

    
454
    /* we need a pass other the whole video segment */
455
#ifdef VLC_DEBUG
456
    printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
457
#endif
458
    block = &sblock[0][0];
459
    mb = mb_data;
460
    init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
461
    flush_put_bits(&vs_pb);
462
    for(mb_index = 0; mb_index < 5; mb_index++) {
463
        for(j = 0;j < 6; j++) {
464
            if (mb->pos < 64) {
465
#ifdef VLC_DEBUG
466
                printf("start %d:%d\n", mb_index, j);
467
#endif
468
                dv_decode_ac(&gb, mb, block);
469
            }
470
            if (mb->pos >= 64 && mb->pos < 127)
471
                av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
472
            block += 64;
473
            mb++;
474
        }
475
    }
476

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

    
549
#ifdef DV_CODEC_TINY_TARGET
550
/* Converts run and level (where level != 0) pair into vlc, returning bit size */
551
static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
552
{
553
    int size;
554
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
555
        *vlc = dv_vlc_map[run][level].vlc | sign;
556
        size = dv_vlc_map[run][level].size;
557
    }
558
    else {
559
        if (level < DV_VLC_MAP_LEV_SIZE) {
560
            *vlc = dv_vlc_map[0][level].vlc | sign;
561
            size = dv_vlc_map[0][level].size;
562
        } else {
563
            *vlc = 0xfe00 | (level << 1) | sign;
564
            size = 16;
565
        }
566
        if (run) {
567
            *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
568
                                  (0x1f80 | (run - 1))) << size;
569
            size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
570
        }
571
    }
572

    
573
    return size;
574
}
575

    
576
static av_always_inline int dv_rl2vlc_size(int run, int level)
577
{
578
    int size;
579

    
580
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
581
        size = dv_vlc_map[run][level].size;
582
    }
583
    else {
584
        size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
585
        if (run) {
586
            size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
587
        }
588
    }
589
    return size;
590
}
591
#else
592
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
593
{
594
    *vlc = dv_vlc_map[run][l].vlc | sign;
595
    return dv_vlc_map[run][l].size;
596
}
597

    
598
static av_always_inline int dv_rl2vlc_size(int run, int l)
599
{
600
    return dv_vlc_map[run][l].size;
601
}
602
#endif
603

    
604
typedef struct EncBlockInfo {
605
    int area_q[4];
606
    int bit_size[4];
607
    int prev[5];
608
    int cur_ac;
609
    int cno;
610
    int dct_mode;
611
    DCTELEM mb[64];
612
    uint8_t next[64];
613
    uint8_t sign[64];
614
    uint8_t partial_bit_count;
615
    uint32_t partial_bit_buffer; /* we can't use uint16_t here */
616
} EncBlockInfo;
617

    
618
static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
619
                                       PutBitContext* pb_end)
620
{
621
    int prev;
622
    int bits_left;
623
    PutBitContext* pb = pb_pool;
624
    int size = bi->partial_bit_count;
625
    uint32_t vlc = bi->partial_bit_buffer;
626

    
627
    bi->partial_bit_count = bi->partial_bit_buffer = 0;
628
    for(;;){
629
       /* Find suitable storage space */
630
       for (; size > (bits_left = put_bits_left(pb)); pb++) {
631
          if (bits_left) {
632
              size -= bits_left;
633
              put_bits(pb, bits_left, vlc >> size);
634
              vlc = vlc & ((1<<size)-1);
635
          }
636
          if (pb + 1 >= pb_end) {
637
              bi->partial_bit_count = size;
638
              bi->partial_bit_buffer = vlc;
639
              return pb;
640
          }
641
       }
642

    
643
       /* Store VLC */
644
       put_bits(pb, size, vlc);
645

    
646
       if(bi->cur_ac>=64)
647
           break;
648

    
649
       /* Construct the next VLC */
650
       prev= bi->cur_ac;
651
       bi->cur_ac = bi->next[prev];
652
       if(bi->cur_ac < 64){
653
           size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
654
       } else {
655
           size = 4; vlc = 6; /* End Of Block stamp */
656
       }
657
    }
658
    return pb;
659
}
660

    
661
static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
662
                                              const uint8_t* zigzag_scan, const int *weight, int bias)
663
{
664
    int i, area;
665
    /* We offer two different methods for class number assignment: the
666
       method suggested in SMPTE 314M Table 22, and an improved
667
       method. The SMPTE method is very conservative; it assigns class
668
       3 (i.e. severe quantization) to any block where the largest AC
669
       component is greater than 36. ffmpeg's DV encoder tracks AC bit
670
       consumption precisely, so there is no need to bias most blocks
671
       towards strongly lossy compression. Instead, we assign class 2
672
       to most blocks, and use class 3 only when strictly necessary
673
       (for blocks whose largest AC component exceeds 255). */
674

    
675
#if 0 /* SMPTE spec method */
676
    static const int classes[] = {12, 24, 36, 0xffff};
677
#else /* improved ffmpeg method */
678
    static const int classes[] = {-1, -1, 255, 0xffff};
679
#endif
680
    int max=classes[0];
681
    int prev=0;
682

    
683
    bi->mb[0] = blk[0];
684

    
685
    for (area = 0; area < 4; area++) {
686
       bi->prev[area] = prev;
687
       bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
688
       for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
689
          int level = blk[zigzag_scan[i]];
690

    
691
          if (level+15 > 30U) {
692
              bi->sign[i] = (level>>31)&1;
693
              /* weigh it and and shift down into range, adding for rounding */
694
              /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
695
                 AND the 2x doubling of the weights */
696
              level = (FFABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
697
              bi->mb[i] = level;
698
              if(level>max) max= level;
699
              bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
700
              bi->next[prev]= i;
701
              prev= i;
702
          }
703
       }
704
    }
705
    bi->next[prev]= i;
706
    for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
707

    
708
    bi->cno += bias;
709

    
710
    if (bi->cno >= 3) {
711
        bi->cno = 3;
712
        prev=0;
713
        i= bi->next[prev];
714
        for (area = 0; area < 4; area++) {
715
            bi->prev[area] = prev;
716
            bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
717
            for (; i<mb_area_start[area+1]; i= bi->next[i]) {
718
                bi->mb[i] >>=1;
719

    
720
                if (bi->mb[i]) {
721
                    bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
722
                    bi->next[prev]= i;
723
                    prev= i;
724
                }
725
            }
726
        }
727
        bi->next[prev]= i;
728
    }
729
}
730

    
731
//FIXME replace this by dsputil
732
#define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
733
static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
734
    DCTELEM *s;
735
    int score88 = 0;
736
    int score248 = 0;
737
    int i;
738

    
739
    /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
740
    s = blk;
741
    for(i=0; i<7; i++) {
742
        score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
743
                   SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
744
        s += 8;
745
    }
746
    /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
747
    s = blk;
748
    for(i=0; i<6; i++) {
749
        score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
750
                    SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
751
        s += 8;
752
    }
753

    
754
    return (score88 - score248 > -10);
755
}
756

    
757
static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
758
{
759
    int size[5];
760
    int i, j, k, a, prev, a2;
761
    EncBlockInfo* b;
762

    
763
    size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
764
    do {
765
       b = blks;
766
       for (i=0; i<5; i++) {
767
          if (!qnos[i])
768
              continue;
769

    
770
          qnos[i]--;
771
          size[i] = 0;
772
          for (j=0; j<6; j++, b++) {
773
             for (a=0; a<4; a++) {
774
                if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
775
                    b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
776
                    b->area_q[a]++;
777
                    prev= b->prev[a];
778
                    assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
779
                    for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
780
                       b->mb[k] >>= 1;
781
                       if (b->mb[k]) {
782
                           b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
783
                           prev= k;
784
                       } else {
785
                           if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
786
                                for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
787
                                    b->prev[a2] = prev;
788
                                assert(a2<4);
789
                                assert(b->mb[b->next[k]]);
790
                                b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
791
                                                  -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
792
                                assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
793
                                b->prev[a2] = prev;
794
                           }
795
                           b->next[prev] = b->next[k];
796
                       }
797
                    }
798
                    b->prev[a+1]= prev;
799
                }
800
                size[i] += b->bit_size[a];
801
             }
802
          }
803
          if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
804
                return;
805
       }
806
    } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
807

    
808

    
809
    for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
810
        b = blks;
811
        size[0] = 5*6*4; //EOB
812
        for (j=0; j<6*5; j++, b++) {
813
            prev= b->prev[0];
814
            for (k= b->next[prev]; k<64; k= b->next[k]) {
815
                if(b->mb[k] < a && b->mb[k] > -a){
816
                    b->next[prev] = b->next[k];
817
                }else{
818
                    size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
819
                    prev= k;
820
                }
821
            }
822
        }
823
    }
824
}
825

    
826
static inline void dv_encode_video_segment(DVVideoContext *s,
827
                                           uint8_t *dif,
828
                                           const uint16_t *mb_pos_ptr)
829
{
830
    int mb_index, i, j, v;
831
    int mb_x, mb_y, c_offset, linesize;
832
    uint8_t*  y_ptr;
833
    uint8_t*  data;
834
    uint8_t*  ptr;
835
    int       do_edge_wrap;
836
    DECLARE_ALIGNED_16(DCTELEM, block[64]);
837
    EncBlockInfo  enc_blks[5*6];
838
    PutBitContext pbs[5*6];
839
    PutBitContext* pb;
840
    EncBlockInfo* enc_blk;
841
    int       vs_bit_size = 0;
842
    int       qnos[5];
843

    
844
    assert((((int)block) & 15) == 0);
845

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

    
900
            /* Everything is set up -- now just copy data -> DCT block */
901
            if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
902
                uint8_t* d;
903
                DCTELEM *b = block;
904
                for (i=0;i<8;i++) {
905
                   d = data + 8 * linesize;
906
                   b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
907
                   b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
908
                   data += linesize;
909
                   b += 8;
910
                }
911
            } else {             /* Simple copy: 8x8 -> 8x8 */
912
                if (!dummy)
913
                    s->get_pixels(block, data, linesize);
914
            }
915

    
916
            if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
917
                enc_blk->dct_mode = dv_guess_dct_mode(block);
918
            else
919
                enc_blk->dct_mode = 0;
920
            enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
921
            enc_blk->partial_bit_count = 0;
922
            enc_blk->partial_bit_buffer = 0;
923
            enc_blk->cur_ac = 0;
924

    
925
            if (dummy) {
926
                /* We rely on the fact that encoding all zeros leads to an immediate EOB,
927
                   which is precisely what the spec calls for in the "dummy" blocks. */
928
                memset(block, 0, sizeof(block));
929
            } else {
930
                s->fdct[enc_blk->dct_mode](block);
931
            }
932

    
933
            dv_set_class_number(block, enc_blk,
934
                                enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
935
                                enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
936
                                j/4);
937

    
938
            init_put_bits(pb, ptr, block_sizes[j]/8);
939
            put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
940
            put_bits(pb, 1, enc_blk->dct_mode);
941
            put_bits(pb, 2, enc_blk->cno);
942

    
943
            vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
944
                           enc_blk->bit_size[2] + enc_blk->bit_size[3];
945
            ++enc_blk;
946
            ++pb;
947
            ptr += block_sizes[j]/8;
948
        }
949
    }
950

    
951
    if (vs_total_ac_bits < vs_bit_size)
952
        dv_guess_qnos(&enc_blks[0], &qnos[0]);
953

    
954
    for (i=0; i<5; i++) {
955
       dif[i*80 + 3] = qnos[i];
956
    }
957

    
958
    /* First pass over individual cells only */
959
    for (j=0; j<5*6; j++)
960
       dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
961

    
962
    /* Second pass over each MB space */
963
    for (j=0; j<5*6; j+=6) {
964
        pb= &pbs[j];
965
        for (i=0; i<6; i++) {
966
            if (enc_blks[i+j].partial_bit_count)
967
                pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
968
        }
969
    }
970

    
971
    /* Third and final pass over the whole vides segment space */
972
    pb= &pbs[0];
973
    for (j=0; j<5*6; j++) {
974
       if (enc_blks[j].partial_bit_count)
975
           pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
976
       if (enc_blks[j].partial_bit_count)
977
            av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
978
    }
979

    
980
    for (j=0; j<5*6; j++)
981
       flush_put_bits(&pbs[j]);
982
}
983

    
984
static int dv_decode_mt(AVCodecContext *avctx, void* sl)
985
{
986
    DVVideoContext *s = avctx->priv_data;
987
    int slice = (size_t)sl;
988

    
989
    /* which DIF channel is this? */
990
    int chan = slice / (s->sys->difseg_size * 27);
991

    
992
    /* slice within the DIF channel */
993
    int chan_slice = slice % (s->sys->difseg_size * 27);
994

    
995
    /* byte offset of this channel's data */
996
    int chan_offset = chan * s->sys->difseg_size * 150 * 80;
997

    
998
    dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
999
                            &s->sys->video_place[slice*5]);
1000
    return 0;
1001
}
1002

    
1003
#ifdef CONFIG_DVVIDEO_ENCODER
1004
static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1005
{
1006
    DVVideoContext *s = avctx->priv_data;
1007
    int slice = (size_t)sl;
1008

    
1009
    /* which DIF channel is this? */
1010
    int chan = slice / (s->sys->difseg_size * 27);
1011

    
1012
    /* slice within the DIF channel */
1013
    int chan_slice = slice % (s->sys->difseg_size * 27);
1014

    
1015
    /* byte offset of this channel's data */
1016
    int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1017

    
1018
    dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1019
                            &s->sys->video_place[slice*5]);
1020
    return 0;
1021
}
1022
#endif
1023

    
1024
#ifdef CONFIG_DECODERS
1025
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1026
   144000 bytes for PAL - or twice those for 50Mbps) */
1027
static int dvvideo_decode_frame(AVCodecContext *avctx,
1028
                                 void *data, int *data_size,
1029
                                 const uint8_t *buf, int buf_size)
1030
{
1031
    DVVideoContext *s = avctx->priv_data;
1032

    
1033
    s->sys = dv_frame_profile(buf);
1034
    if (!s->sys || buf_size < s->sys->frame_size)
1035
        return -1; /* NOTE: we only accept several full frames */
1036

    
1037
    if(s->picture.data[0])
1038
        avctx->release_buffer(avctx, &s->picture);
1039

    
1040
    s->picture.reference = 0;
1041
    s->picture.key_frame = 1;
1042
    s->picture.pict_type = FF_I_TYPE;
1043
    avctx->pix_fmt = s->sys->pix_fmt;
1044
    avctx->time_base = (AVRational){s->sys->frame_rate_base, s->sys->frame_rate};
1045
    avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1046
    if(avctx->get_buffer(avctx, &s->picture) < 0) {
1047
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1048
        return -1;
1049
    }
1050
    s->picture.interlaced_frame = 1;
1051
    s->picture.top_field_first = 0;
1052

    
1053
    s->buf = buf;
1054
    avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
1055
                   s->sys->n_difchan * s->sys->difseg_size * 27);
1056

    
1057
    emms_c();
1058

    
1059
    /* return image */
1060
    *data_size = sizeof(AVFrame);
1061
    *(AVFrame*)data= s->picture;
1062

    
1063
    return s->sys->frame_size;
1064
}
1065
#endif
1066

    
1067

    
1068
static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t* buf)
1069
{
1070
    /*
1071
     * Here's what SMPTE314M says about these two:
1072
     *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1073
     *             as track application IDs (APTn = 001, AP1n =
1074
     *             001, AP2n = 001, AP3n = 001), if the source signal
1075
     *             comes from a digital VCR. If the signal source is
1076
     *             unknown, all bits for these data shall be set to 1.
1077
     *    (page 12) STYPE: STYPE defines a signal type of video signal
1078
     *                     00000b = 4:1:1 compression
1079
     *                     00100b = 4:2:2 compression
1080
     *                     XXXXXX = Reserved
1081
     * Now, I've got two problems with these statements:
1082
     *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1083
     *      It seems that for PAL as defined in IEC 61834 we have to set
1084
     *      APT to 000 and for SMPTE314M to 001.
1085
     *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1086
     *      compression scheme (if any).
1087
     */
1088
    int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1089
    int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
1090

    
1091
    uint8_t aspect = 0;
1092
    if((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1093
        aspect = 0x02;
1094

    
1095
    buf[0] = (uint8_t)pack_id;
1096
    switch (pack_id) {
1097
    case dv_header525: /* I can't imagine why these two weren't defined as real */
1098
    case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1099
          buf[1] = 0xf8 |               /* reserved -- always 1 */
1100
                   (apt & 0x07);        /* APT: Track application ID */
1101
          buf[2] = (0 << 7)    | /* TF1: audio data is 0 - valid; 1 - invalid */
1102
                   (0x0f << 3) | /* reserved -- always 1 */
1103
                   (apt & 0x07); /* AP1: Audio application ID */
1104
          buf[3] = (0 << 7)    | /* TF2: video data is 0 - valid; 1 - invalid */
1105
                   (0x0f << 3) | /* reserved -- always 1 */
1106
                   (apt & 0x07); /* AP2: Video application ID */
1107
          buf[4] = (0 << 7)    | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1108
                   (0x0f << 3) | /* reserved -- always 1 */
1109
                   (apt & 0x07); /* AP3: Subcode application ID */
1110
          break;
1111
    case dv_video_source:
1112
          buf[1] = 0xff; /* reserved -- always 1 */
1113
          buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1114
                   (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1115
                   (3 << 4) | /* CLF: color frames id (see ITU-R BT.470-4) */
1116
                   0xf; /* reserved -- always 1 */
1117
          buf[3] = (3 << 6) | /* reserved -- always 1 */
1118
                   (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1119
                   stype; /* signal type video compression */
1120
          buf[4] = 0xff; /* VISC: 0xff -- no information */
1121
          break;
1122
    case dv_video_control:
1123
          buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1124
                   0x3f; /* reserved -- always 1 */
1125
          buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1126
                   aspect;
1127
          buf[3] = (1 << 7) | /* Frame/field flag 1 -- frame, 0 -- field */
1128
                   (1 << 6) | /* First/second field flag 0 -- field 2, 1 -- field 1 */
1129
                   (1 << 5) | /* Frame change flag 0 -- same picture as before, 1 -- different */
1130
                   (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1131
                   0xc; /* reserved -- always b1100 */
1132
          buf[4] = 0xff; /* reserved -- always 1 */
1133
          break;
1134
    default:
1135
          buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1136
    }
1137
    return 5;
1138
}
1139

    
1140
#ifdef CONFIG_DVVIDEO_ENCODER
1141
static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1142
{
1143
    int chan, i, j, k;
1144

    
1145
    for (chan = 0; chan < c->sys->n_difchan; chan++) {
1146
        for (i = 0; i < c->sys->difseg_size; i++) {
1147
            memset(buf, 0xff, 80 * 6); /* First 6 DIF blocks are for control data */
1148

    
1149
            /* DV header: 1DIF */
1150
            buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1151
            buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1152
            buf += 72; /* unused bytes */
1153

    
1154
            /* DV subcode: 2DIFs */
1155
            for (j = 0; j < 2; j++) {
1156
                buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1157
                for (k = 0; k < 6; k++)
1158
                     buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1159
                buf += 29; /* unused bytes */
1160
            }
1161

    
1162
            /* DV VAUX: 3DIFS */
1163
            for (j = 0; j < 3; j++) {
1164
                buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1165
                buf += dv_write_pack(dv_video_source,  c, buf);
1166
                buf += dv_write_pack(dv_video_control, c, buf);
1167
                buf += 7*5;
1168
                buf += dv_write_pack(dv_video_source,  c, buf);
1169
                buf += dv_write_pack(dv_video_control, c, buf);
1170
                buf += 4*5 + 2; /* unused bytes */
1171
            }
1172

    
1173
            /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1174
            for (j = 0; j < 135; j++) {
1175
                if (j%15 == 0) {
1176
                    memset(buf, 0xff, 80);
1177
                    buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1178
                    buf += 77; /* audio control & shuffled PCM audio */
1179
                }
1180
                buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1181
                buf += 77; /* 1 video macro block: 1 bytes control
1182
                              4 * 14 bytes Y 8x8 data
1183
                              10 bytes Cr 8x8 data
1184
                              10 bytes Cb 8x8 data */
1185
            }
1186
        }
1187
    }
1188
}
1189

    
1190

    
1191
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1192
                                void *data)
1193
{
1194
    DVVideoContext *s = c->priv_data;
1195

    
1196
    s->sys = dv_codec_profile(c);
1197
    if (!s->sys)
1198
        return -1;
1199
    if(buf_size < s->sys->frame_size)
1200
        return -1;
1201

    
1202
    c->pix_fmt = s->sys->pix_fmt;
1203
    s->picture = *((AVFrame *)data);
1204
    s->picture.key_frame = 1;
1205
    s->picture.pict_type = FF_I_TYPE;
1206

    
1207
    s->buf = buf;
1208
    c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1209
               s->sys->n_difchan * s->sys->difseg_size * 27);
1210

    
1211
    emms_c();
1212

    
1213
    dv_format_frame(s, buf);
1214

    
1215
    return s->sys->frame_size;
1216
}
1217
#endif
1218

    
1219
static int dvvideo_close(AVCodecContext *c)
1220
{
1221
    DVVideoContext *s = c->priv_data;
1222

    
1223
    if(s->picture.data[0])
1224
        c->release_buffer(c, &s->picture);
1225

    
1226
    return 0;
1227
}
1228

    
1229

    
1230
#ifdef CONFIG_DVVIDEO_ENCODER
1231
AVCodec dvvideo_encoder = {
1232
    "dvvideo",
1233
    CODEC_TYPE_VIDEO,
1234
    CODEC_ID_DVVIDEO,
1235
    sizeof(DVVideoContext),
1236
    dvvideo_init,
1237
    dvvideo_encode_frame,
1238
    .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1239
    .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1240
};
1241
#endif // CONFIG_DVVIDEO_ENCODER
1242

    
1243
#ifdef CONFIG_DVVIDEO_DECODER
1244
AVCodec dvvideo_decoder = {
1245
    "dvvideo",
1246
    CODEC_TYPE_VIDEO,
1247
    CODEC_ID_DVVIDEO,
1248
    sizeof(DVVideoContext),
1249
    dvvideo_init,
1250
    NULL,
1251
    dvvideo_close,
1252
    dvvideo_decode_frame,
1253
    CODEC_CAP_DR1,
1254
    NULL,
1255
    .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1256
};
1257
#endif