Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 7a886063

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 "mpegvideo.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;
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_LEV_SIZE] = NULL;
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 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_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
127
        if (!dv_vlc_map)
128
            return -ENOMEM;
129

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

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

    
141
            if (dv_vlc_level[i]) {
142
                new_dv_vlc_bits[j] <<= 1;
143
                new_dv_vlc_len[j]++;
144

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

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

    
158
        dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
159
        if (!dv_rl_vlc)
160
            return -ENOMEM;
161

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

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

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

    
188
           if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
189
               continue;
190

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

    
223
    /* Generic DSP setup */
224
    dsputil_init(&dsp, avctx);
225
    s->get_pixels = dsp.get_pixels;
226

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

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

    
244
    /* XXX: do it only for constant case */
245
    dv_build_unquantize_tables(s, dsp.idct_permutation);
246

    
247
    avctx->coded_frame = &s->picture;
248
    s->avctx= avctx;
249

    
250
    return 0;
251
}
252

    
253
// #define VLC_DEBUG
254
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
255

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

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

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

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

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

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

    
302
    OPEN_READER(re, gb);
303
    UPDATE_CACHE(re, gb);
304

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

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

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

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

    
345
        pos1 = scan_table[pos];
346
        level <<= shift_table[pos1];
347

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

    
351
        block[pos1] = level;
352

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

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

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

    
391
    assert((((int)mb_bit_buffer)&7)==0);
392
    assert((((int)vs_bit_buffer)&7)==0);
393

    
394
    memset(sblock, 0, sizeof(sblock));
395

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

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

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

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

    
440
            block += 64;
441
            mb++;
442
        }
443

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

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

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

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

    
585
    return size;
586
}
587

    
588
static av_always_inline int dv_rl2vlc_size(int run, int level)
589
{
590
    int size;
591

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

    
610
static av_always_inline int dv_rl2vlc_size(int run, int l)
611
{
612
    return dv_vlc_map[run][l].size;
613
}
614
#endif
615

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

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

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

    
655
       /* Store VLC */
656
       put_bits(pb, size, vlc);
657

    
658
       if(bi->cur_ac>=64)
659
           break;
660

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

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

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

    
695
    bi->mb[0] = blk[0];
696

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

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

    
720
    bi->cno += bias;
721

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

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

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

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

    
766
    return (score88 - score248 > -10);
767
}
768

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

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

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

    
820

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

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

    
856
    assert((((int)block) & 7) == 0);
857

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1068
    emms_c();
1069

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

    
1074
    return s->sys->frame_size;
1075
}
1076
#endif
1077

    
1078

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

    
1102
    uint8_t aspect = 0;
1103
    if((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1104
        aspect = 0x02;
1105

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

    
1151
static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1152
{
1153
    int chan, i, j, k;
1154

    
1155
    for (chan = 0; chan < c->sys->n_difchan; chan++) {
1156
        for (i = 0; i < c->sys->difseg_size; i++) {
1157
            memset(buf, 0xff, 80 * 6); /* First 6 DIF blocks are for control data */
1158

    
1159
            /* DV header: 1DIF */
1160
            buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1161
            buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1162
            buf += 72; /* unused bytes */
1163

    
1164
            /* DV subcode: 2DIFs */
1165
            for (j = 0; j < 2; j++) {
1166
                buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1167
                for (k = 0; k < 6; k++)
1168
                     buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1169
                buf += 29; /* unused bytes */
1170
            }
1171

    
1172
            /* DV VAUX: 3DIFS */
1173
            for (j = 0; j < 3; j++) {
1174
                buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1175
                buf += dv_write_pack(dv_video_source,  c, buf);
1176
                buf += dv_write_pack(dv_video_control, c, buf);
1177
                buf += 7*5;
1178
                buf += dv_write_pack(dv_video_source,  c, buf);
1179
                buf += dv_write_pack(dv_video_control, c, buf);
1180
                buf += 4*5 + 2; /* unused bytes */
1181
            }
1182

    
1183
            /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1184
            for (j = 0; j < 135; j++) {
1185
                if (j%15 == 0) {
1186
                    memset(buf, 0xff, 80);
1187
                    buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1188
                    buf += 77; /* audio control & shuffled PCM audio */
1189
                }
1190
                buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1191
                buf += 77; /* 1 video macro block: 1 bytes control
1192
                              4 * 14 bytes Y 8x8 data
1193
                              10 bytes Cr 8x8 data
1194
                              10 bytes Cb 8x8 data */
1195
            }
1196
        }
1197
    }
1198
}
1199

    
1200

    
1201
#ifdef CONFIG_ENCODERS
1202
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1203
                                void *data)
1204
{
1205
    DVVideoContext *s = c->priv_data;
1206

    
1207
    s->sys = dv_codec_profile(c);
1208
    if (!s->sys)
1209
        return -1;
1210
    if(buf_size < s->sys->frame_size)
1211
        return -1;
1212

    
1213
    c->pix_fmt = s->sys->pix_fmt;
1214
    s->picture = *((AVFrame *)data);
1215
    s->picture.key_frame = 1;
1216
    s->picture.pict_type = FF_I_TYPE;
1217

    
1218
    s->buf = buf;
1219
    c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1220
               s->sys->n_difchan * s->sys->difseg_size * 27);
1221

    
1222
    emms_c();
1223

    
1224
    dv_format_frame(s, buf);
1225

    
1226
    return s->sys->frame_size;
1227
}
1228
#endif
1229

    
1230
static int dvvideo_close(AVCodecContext *c)
1231
{
1232

    
1233
    return 0;
1234
}
1235

    
1236

    
1237
#ifdef CONFIG_DVVIDEO_ENCODER
1238
AVCodec dvvideo_encoder = {
1239
    "dvvideo",
1240
    CODEC_TYPE_VIDEO,
1241
    CODEC_ID_DVVIDEO,
1242
    sizeof(DVVideoContext),
1243
    dvvideo_init,
1244
    dvvideo_encode_frame,
1245
    dvvideo_close,
1246
    NULL,
1247
    CODEC_CAP_DR1,
1248
    NULL
1249
};
1250
#endif // CONFIG_DVVIDEO_ENCODER
1251

    
1252
#ifdef CONFIG_DVVIDEO_DECODER
1253
AVCodec dvvideo_decoder = {
1254
    "dvvideo",
1255
    CODEC_TYPE_VIDEO,
1256
    CODEC_ID_DVVIDEO,
1257
    sizeof(DVVideoContext),
1258
    dvvideo_init,
1259
    NULL,
1260
    dvvideo_close,
1261
    dvvideo_decode_frame,
1262
    CODEC_CAP_DR1,
1263
    NULL
1264
};
1265
#endif