Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 75f2c209

History | View | Annotate | Download (44 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
 * 100 Mbps (DVCPRO HD) support
13
 * Initial code by Daniel Maas <dmaas@maasdigital.com> (funded by BBC R&D)
14
 * Final code by Roman Shaposhnik
15
 *
16
 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
17
 * of DV technical info.
18
 *
19
 * This file is part of FFmpeg.
20
 *
21
 * FFmpeg is free software; you can redistribute it and/or
22
 * modify it under the terms of the GNU Lesser General Public
23
 * License as published by the Free Software Foundation; either
24
 * version 2.1 of the License, or (at your option) any later version.
25
 *
26
 * FFmpeg is distributed in the hope that it will be useful,
27
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
29
 * Lesser General Public License for more details.
30
 *
31
 * You should have received a copy of the GNU Lesser General Public
32
 * License along with FFmpeg; if not, write to the Free Software
33
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
34
 */
35

    
36
/**
37
 * @file dv.c
38
 * DV codec.
39
 */
40
#define ALT_BITSTREAM_READER
41
#include "avcodec.h"
42
#include "dsputil.h"
43
#include "bitstream.h"
44
#include "simple_idct.h"
45
#include "dvdata.h"
46

    
47
//#undef NDEBUG
48
//#include <assert.h>
49

    
50
typedef struct DVVideoContext {
51
    const DVprofile* sys;
52
    AVFrame picture;
53
    AVCodecContext *avctx;
54
    uint8_t *buf;
55

    
56
    uint8_t dv_zigzag[2][64];
57
    uint32_t dv_idct_factor[2][2][22][64];
58
    uint32_t dv100_idct_factor[4][4][16][64];
59

    
60
    void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
61
    void (*fdct[2])(DCTELEM *block);
62
    void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
63
} DVVideoContext;
64

    
65
/**
66
 * MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext
67
 * one element is needed for each video segment in a DV frame
68
 * at most there are 4 DIF channels * 12 DIF sequences * 27 video segments (1080i50)
69
 */
70
#define DV_ANCHOR_SIZE (4*12*27)
71

    
72
static void* dv_anchor[DV_ANCHOR_SIZE];
73

    
74
#define TEX_VLC_BITS 9
75

    
76
#ifdef DV_CODEC_TINY_TARGET
77
#define DV_VLC_MAP_RUN_SIZE 15
78
#define DV_VLC_MAP_LEV_SIZE 23
79
#else
80
#define DV_VLC_MAP_RUN_SIZE  64
81
#define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
82
#endif
83

    
84
/* XXX: also include quantization */
85
static RL_VLC_ELEM dv_rl_vlc[1184];
86
/* VLC encoding lookup table */
87
static struct dv_vlc_pair {
88
   uint32_t vlc;
89
   uint8_t  size;
90
} dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
91

    
92
static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
93
{
94
    int i, q, a;
95

    
96
    /* NOTE: max left shift is 6 */
97
    for(q = 0; q < 22; q++) {
98
        /* 88DCT */
99
        i=1;
100
        for(a = 0; a<4; a++) {
101
            for(; i < dv_quant_areas[a]; i++) {
102
                /* 88 table */
103
                s->dv_idct_factor[0][0][q][i] = dv_iweight_88[i]<<(dv_quant_shifts[q][a] + 1);
104
                s->dv_idct_factor[1][0][q][i] = s->dv_idct_factor[0][0][q][i]<<1;
105

    
106
                /* 248 table */
107
                s->dv_idct_factor[0][1][q][i] = dv_iweight_248[i]<<(dv_quant_shifts[q][a] + 1);
108
                s->dv_idct_factor[1][1][q][i] = s->dv_idct_factor[0][1][q][i]<<1;
109
            }
110
        }
111
    }
112

    
113
    for(a = 0; a < 4; a++) {
114
        for(q = 0; q < 16; q++) {
115
            for(i = 1; i < 64; i++) {
116
                s->dv100_idct_factor[0][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_1080_y[i];
117
                s->dv100_idct_factor[1][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_1080_c[i];
118
                s->dv100_idct_factor[2][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_y[i];
119
                s->dv100_idct_factor[3][a][q][i]= (dv100_qstep[q]<<(a+9))*dv_iweight_720_c[i];
120
            }
121
        }
122
    }
123
}
124

    
125
static av_cold int dvvideo_init(AVCodecContext *avctx)
126
{
127
    DVVideoContext *s = avctx->priv_data;
128
    DSPContext dsp;
129
    static int done=0;
130
    int i, j;
131

    
132
    if (!done) {
133
        VLC dv_vlc;
134
        uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
135
        uint8_t new_dv_vlc_len[NB_DV_VLC*2];
136
        uint8_t new_dv_vlc_run[NB_DV_VLC*2];
137
        int16_t new_dv_vlc_level[NB_DV_VLC*2];
138

    
139
        done = 1;
140

    
141
        /* dv_anchor lets each thread know its ID */
142
        for (i=0; i<DV_ANCHOR_SIZE; i++)
143
            dv_anchor[i] = (void*)(size_t)i;
144

    
145
        /* it's faster to include sign bit in a generic VLC parsing scheme */
146
        for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
147
            new_dv_vlc_bits[j] = dv_vlc_bits[i];
148
            new_dv_vlc_len[j] = dv_vlc_len[i];
149
            new_dv_vlc_run[j] = dv_vlc_run[i];
150
            new_dv_vlc_level[j] = dv_vlc_level[i];
151

    
152
            if (dv_vlc_level[i]) {
153
                new_dv_vlc_bits[j] <<= 1;
154
                new_dv_vlc_len[j]++;
155

    
156
                j++;
157
                new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
158
                new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
159
                new_dv_vlc_run[j] = dv_vlc_run[i];
160
                new_dv_vlc_level[j] = -dv_vlc_level[i];
161
            }
162
        }
163

    
164
        /* NOTE: as a trick, we use the fact the no codes are unused
165
           to accelerate the parsing of partial codes */
166
        init_vlc(&dv_vlc, TEX_VLC_BITS, j,
167
                 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
168
        assert(dv_vlc.table_size == 1184);
169

    
170
        for(i = 0; i < dv_vlc.table_size; i++){
171
            int code= dv_vlc.table[i][0];
172
            int len = dv_vlc.table[i][1];
173
            int level, run;
174

    
175
            if(len<0){ //more bits needed
176
                run= 0;
177
                level= code;
178
            } else {
179
                run=   new_dv_vlc_run[code] + 1;
180
                level= new_dv_vlc_level[code];
181
            }
182
            dv_rl_vlc[i].len = len;
183
            dv_rl_vlc[i].level = level;
184
            dv_rl_vlc[i].run = run;
185
        }
186
        free_vlc(&dv_vlc);
187

    
188
        for (i = 0; i < NB_DV_VLC - 1; i++) {
189
           if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
190
               continue;
191
#ifdef DV_CODEC_TINY_TARGET
192
           if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
193
               continue;
194
#endif
195

    
196
           if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
197
               continue;
198

    
199
           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
200
                                                            (!!dv_vlc_level[i]);
201
           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
202
                                                             (!!dv_vlc_level[i]);
203
        }
204
        for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
205
#ifdef DV_CODEC_TINY_TARGET
206
           for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
207
              if (dv_vlc_map[i][j].size == 0) {
208
                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
209
                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
210
                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
211
                                          dv_vlc_map[0][j].size;
212
              }
213
           }
214
#else
215
           for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
216
              if (dv_vlc_map[i][j].size == 0) {
217
                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
218
                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
219
                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
220
                                          dv_vlc_map[0][j].size;
221
              }
222
              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
223
                                            dv_vlc_map[i][j].vlc | 1;
224
              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
225
                                            dv_vlc_map[i][j].size;
226
           }
227
#endif
228
        }
229
    }
230

    
231
    /* Generic DSP setup */
232
    dsputil_init(&dsp, avctx);
233
    s->get_pixels = dsp.get_pixels;
234

    
235
    /* 88DCT setup */
236
    s->fdct[0] = dsp.fdct;
237
    s->idct_put[0] = dsp.idct_put;
238
    for (i=0; i<64; i++)
239
       s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
240

    
241
    /* 248DCT setup */
242
    s->fdct[1] = dsp.fdct248;
243
    s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
244
    if(avctx->lowres){
245
        for (i=0; i<64; i++){
246
            int j= ff_zigzag248_direct[i];
247
            s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
248
        }
249
    }else
250
        memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
251

    
252
    /* XXX: do it only for constant case */
253
    dv_build_unquantize_tables(s, dsp.idct_permutation);
254

    
255
    avctx->coded_frame = &s->picture;
256
    s->avctx= avctx;
257

    
258
    return 0;
259
}
260

    
261
// #define VLC_DEBUG
262
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
263

    
264
typedef struct BlockInfo {
265
    const uint32_t *factor_table;
266
    const uint8_t *scan_table;
267
    uint8_t pos; /* position in block */
268
    void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
269
    uint8_t partial_bit_count;
270
    uint16_t partial_bit_buffer;
271
    int shift_offset;
272
} BlockInfo;
273

    
274
/* bit budget for AC only in 5 MBs */
275
static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
276
/* see dv_88_areas and dv_248_areas for details */
277
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
278

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

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

    
289
/* decode ac coefficients */
290
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
291
{
292
    int last_index = gb->size_in_bits;
293
    const uint8_t *scan_table = mb->scan_table;
294
    const uint32_t *factor_table = mb->factor_table;
295
    int pos = mb->pos;
296
    int partial_bit_count = mb->partial_bit_count;
297
    int level, run, vlc_len, index;
298

    
299
    OPEN_READER(re, gb);
300
    UPDATE_CACHE(re, gb);
301

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

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

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

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

    
342
        level = (level*factor_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
343
        block[scan_table[pos]] = level;
344

    
345
        UPDATE_CACHE(re, gb);
346
    }
347
    CLOSE_READER(re, gb);
348
    mb->pos = pos;
349
}
350

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

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

    
384
    assert((((int)mb_bit_buffer)&7)==0);
385
    assert((((int)vs_bit_buffer)&7)==0);
386

    
387
    memset(sblock, 0, sizeof(sblock));
388

    
389
    /* pass 1 : read DC and AC coefficients in blocks */
390
    buf_ptr = buf_ptr1;
391
    block1 = &sblock[0][0];
392
    mb1 = mb_data;
393
    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
394
    for(mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
395
        /* skip header */
396
        quant = buf_ptr[3] & 0x0f;
397
        buf_ptr += 4;
398
        init_put_bits(&pb, mb_bit_buffer, 80);
399
        mb = mb1;
400
        block = block1;
401
        is_field_mode[mb_index] = 0;
402
        for(j = 0;j < s->sys->bpm; j++) {
403
            last_index = s->sys->block_sizes[j];
404
            init_get_bits(&gb, buf_ptr, last_index);
405

    
406
            /* get the dc */
407
            dc = get_sbits(&gb, 9);
408
            dct_mode = get_bits1(&gb);
409
            class1 = get_bits(&gb, 2);
410
            if (DV_PROFILE_IS_HD(s->sys)) {
411
                mb->idct_put = s->idct_put[0];
412
                mb->scan_table = s->dv_zigzag[0];
413
                mb->factor_table = s->dv100_idct_factor[((s->sys->height == 720)<<1)|(j >= 4)][class1][quant];
414
                is_field_mode[mb_index] |= !j && dct_mode;
415
            } else {
416
                mb->idct_put = s->idct_put[dct_mode && log2_blocksize==3];
417
                mb->scan_table = s->dv_zigzag[dct_mode];
418
                mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode]
419
                    [quant + dv_quant_offset[class1]];
420
            }
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 < s->sys->bpm; 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 >= s->sys->bpm)
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 < s->sys->bpm; 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
        /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
497
        if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
498
               mb_y -= (mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macroblocks */
499
        }
500

    
501
        /* idct_put'ting luminance */
502
        if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
503
            (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
504
            (s->sys->height >= 720 && mb_y != 134)) {
505
            y_stride = (s->picture.linesize[0]<<((!is_field_mode[mb_index])*log2_blocksize));
506
        } else {
507
            y_stride = (2<<log2_blocksize);
508
        }
509
        y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
510
        linesize = s->picture.linesize[0]<<is_field_mode[mb_index];
511
        mb[0]    .idct_put(y_ptr                                 , linesize, block + 0*64);
512
        if (s->sys->video_stype == 4) { /* SD 422 */
513
            mb[2].idct_put(y_ptr + (1<<log2_blocksize)           , linesize, block + 2*64);
514
        } else {
515
            mb[1].idct_put(y_ptr + (1<<log2_blocksize)           , linesize, block + 1*64);
516
            mb[2].idct_put(y_ptr                       + y_stride, linesize, block + 2*64);
517
            mb[3].idct_put(y_ptr + (1<<log2_blocksize) + y_stride, linesize, block + 3*64);
518
        }
519
        mb += 4;
520
        block += 4*64;
521

    
522
        /* idct_put'ting chrominance */
523
        c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
524
                     (mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<log2_blocksize);
525
        for(j=2; j; j--) {
526
            uint8_t *c_ptr = s->picture.data[j] + c_offset;
527
            if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
528
                  uint64_t aligned_pixels[64/8];
529
                  uint8_t *pixels = (uint8_t*)aligned_pixels;
530
                  uint8_t *c_ptr1, *ptr1;
531
                  int x, y;
532
                  mb->idct_put(pixels, 8, block);
533
                  for(y = 0; y < (1<<log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
534
                      ptr1= pixels + (1<<(log2_blocksize-1));
535
                      c_ptr1 = c_ptr + (s->picture.linesize[j]<<log2_blocksize);
536
                      for(x=0; x < (1<<(log2_blocksize-1)); x++) {
537
                          c_ptr[x]= pixels[x];
538
                          c_ptr1[x]= ptr1[x];
539
                      }
540
                  }
541
                  block += 64; mb++;
542
            } else {
543
                  y_stride = (mb_y == 134) ? (1<<log2_blocksize) :
544
                                             s->picture.linesize[j]<<((!is_field_mode[mb_index])*log2_blocksize);
545
                  linesize = s->picture.linesize[j]<<is_field_mode[mb_index];
546
                  (mb++)->    idct_put(c_ptr           , linesize, block); block+=64;
547
                  if (s->sys->bpm == 8) {
548
                      (mb++)->idct_put(c_ptr + y_stride, linesize, block); block+=64;
549
                  }
550
            }
551
        }
552
    }
553
}
554

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

    
579
    return size;
580
}
581

    
582
static av_always_inline int dv_rl2vlc_size(int run, int level)
583
{
584
    int size;
585

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

    
604
static av_always_inline int dv_rl2vlc_size(int run, int l)
605
{
606
    return dv_vlc_map[run][l].size;
607
}
608
#endif
609

    
610
typedef struct EncBlockInfo {
611
    int area_q[4];
612
    int bit_size[4];
613
    int prev[5];
614
    int cur_ac;
615
    int cno;
616
    int dct_mode;
617
    DCTELEM mb[64];
618
    uint8_t next[64];
619
    uint8_t sign[64];
620
    uint8_t partial_bit_count;
621
    uint32_t partial_bit_buffer; /* we can't use uint16_t here */
622
} EncBlockInfo;
623

    
624
static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
625
                                       PutBitContext* pb_end)
626
{
627
    int prev;
628
    int bits_left;
629
    PutBitContext* pb = pb_pool;
630
    int size = bi->partial_bit_count;
631
    uint32_t vlc = bi->partial_bit_buffer;
632

    
633
    bi->partial_bit_count = bi->partial_bit_buffer = 0;
634
    for(;;){
635
       /* Find suitable storage space */
636
       for (; size > (bits_left = put_bits_left(pb)); pb++) {
637
          if (bits_left) {
638
              size -= bits_left;
639
              put_bits(pb, bits_left, vlc >> size);
640
              vlc = vlc & ((1<<size)-1);
641
          }
642
          if (pb + 1 >= pb_end) {
643
              bi->partial_bit_count = size;
644
              bi->partial_bit_buffer = vlc;
645
              return pb;
646
          }
647
       }
648

    
649
       /* Store VLC */
650
       put_bits(pb, size, vlc);
651

    
652
       if(bi->cur_ac>=64)
653
           break;
654

    
655
       /* Construct the next VLC */
656
       prev= bi->cur_ac;
657
       bi->cur_ac = bi->next[prev];
658
       if(bi->cur_ac < 64){
659
           size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
660
       } else {
661
           size = 4; vlc = 6; /* End Of Block stamp */
662
       }
663
    }
664
    return pb;
665
}
666

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

    
681
#if 0 /* SMPTE spec method */
682
    static const int classes[] = {12, 24, 36, 0xffff};
683
#else /* improved FFmpeg method */
684
    static const int classes[] = {-1, -1, 255, 0xffff};
685
#endif
686
    int max=classes[0];
687
    int prev=0;
688

    
689
    bi->mb[0] = blk[0];
690

    
691
    for (area = 0; area < 4; area++) {
692
       bi->prev[area] = prev;
693
       bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
694
       for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
695
          int level = blk[zigzag_scan[i]];
696

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

    
714
    bi->cno += bias;
715

    
716
    if (bi->cno >= 3) {
717
        bi->cno = 3;
718
        prev=0;
719
        i= bi->next[prev];
720
        for (area = 0; area < 4; area++) {
721
            bi->prev[area] = prev;
722
            bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
723
            for (; i<mb_area_start[area+1]; i= bi->next[i]) {
724
                bi->mb[i] >>=1;
725

    
726
                if (bi->mb[i]) {
727
                    bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
728
                    bi->next[prev]= i;
729
                    prev= i;
730
                }
731
            }
732
        }
733
        bi->next[prev]= i;
734
    }
735
}
736

    
737
//FIXME replace this by dsputil
738
#define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
739
static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
740
    DCTELEM *s;
741
    int score88 = 0;
742
    int score248 = 0;
743
    int i;
744

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

    
760
    return (score88 - score248 > -10);
761
}
762

    
763
static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
764
{
765
    int size[5];
766
    int i, j, k, a, prev, a2;
767
    EncBlockInfo* b;
768

    
769
    size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
770
    do {
771
       b = blks;
772
       for (i=0; i<5; i++) {
773
          if (!qnos[i])
774
              continue;
775

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

    
814

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

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

    
850
    assert((((int)block) & 15) == 0);
851

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
997
    /* DIF sequence */
998
    int seq = chan_slice / 27;
999

    
1000
    /* in 1080i50 and 720p50 some seq are unused */
1001
    if ((DV_PROFILE_IS_1080i50(s->sys) && chan != 0 && seq == 11) ||
1002
        (DV_PROFILE_IS_720p50(s->sys) && seq > 9))
1003
        return 0;
1004

    
1005
    dv_decode_video_segment(s, &s->buf[(seq*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1006
                            &s->sys->video_place[slice*5]);
1007
    return 0;
1008
}
1009

    
1010
#ifdef CONFIG_DVVIDEO_ENCODER
1011
static int dv_encode_mt(AVCodecContext *avctx, void* sl)
1012
{
1013
    DVVideoContext *s = avctx->priv_data;
1014
    int slice = (size_t)sl;
1015

    
1016
    /* which DIF channel is this? */
1017
    int chan = slice / (s->sys->difseg_size * 27);
1018

    
1019
    /* slice within the DIF channel */
1020
    int chan_slice = slice % (s->sys->difseg_size * 27);
1021

    
1022
    /* byte offset of this channel's data */
1023
    int chan_offset = chan * s->sys->difseg_size * 150 * 80;
1024

    
1025
    dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
1026
                            &s->sys->video_place[slice*5]);
1027
    return 0;
1028
}
1029
#endif
1030

    
1031
#ifdef CONFIG_DVVIDEO_DECODER
1032
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1033
   144000 bytes for PAL - or twice those for 50Mbps) */
1034
static int dvvideo_decode_frame(AVCodecContext *avctx,
1035
                                 void *data, int *data_size,
1036
                                 const uint8_t *buf, int buf_size)
1037
{
1038
    DVVideoContext *s = avctx->priv_data;
1039

    
1040
    s->sys = dv_frame_profile(buf);
1041
    if (!s->sys || buf_size < s->sys->frame_size)
1042
        return -1; /* NOTE: we only accept several full frames */
1043

    
1044
    if(s->picture.data[0])
1045
        avctx->release_buffer(avctx, &s->picture);
1046

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

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

    
1064
    emms_c();
1065

    
1066
    /* return image */
1067
    *data_size = sizeof(AVFrame);
1068
    *(AVFrame*)data= s->picture;
1069

    
1070
    return s->sys->frame_size;
1071
}
1072
#endif /* CONFIG_DVVIDEO_DECODER */
1073

    
1074

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

    
1098
    uint8_t aspect = 0;
1099
    if((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1100
        aspect = 0x02;
1101

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

    
1147
#ifdef CONFIG_DVVIDEO_ENCODER
1148
static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1149
{
1150
    int chan, i, j, k;
1151

    
1152
    for (chan = 0; chan < c->sys->n_difchan; chan++) {
1153
        for (i = 0; i < c->sys->difseg_size; i++) {
1154
            memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1155

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

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

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

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

    
1197

    
1198
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1199
                                void *data)
1200
{
1201
    DVVideoContext *s = c->priv_data;
1202

    
1203
    s->sys = dv_codec_profile(c);
1204
    if (!s->sys)
1205
        return -1;
1206
    if(buf_size < s->sys->frame_size)
1207
        return -1;
1208

    
1209
    c->pix_fmt = s->sys->pix_fmt;
1210
    s->picture = *((AVFrame *)data);
1211
    s->picture.key_frame = 1;
1212
    s->picture.pict_type = FF_I_TYPE;
1213

    
1214
    s->buf = buf;
1215
    c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1216
               s->sys->n_difchan * s->sys->difseg_size * 27);
1217

    
1218
    emms_c();
1219

    
1220
    dv_format_frame(s, buf);
1221

    
1222
    return s->sys->frame_size;
1223
}
1224
#endif
1225

    
1226
static int dvvideo_close(AVCodecContext *c)
1227
{
1228
    DVVideoContext *s = c->priv_data;
1229

    
1230
    if(s->picture.data[0])
1231
        c->release_buffer(c, &s->picture);
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
    .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1246
    .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1247
};
1248
#endif // CONFIG_DVVIDEO_ENCODER
1249

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