Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 94ed2a30

History | View | Annotate | Download (47.6 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 libavcodec/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

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

    
64
#define TEX_VLC_BITS 9
65

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

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

    
82
static inline int dv_work_pool_size(const DVprofile *d)
83
{
84
    int size = d->n_difchan*d->difseg_size*27;
85
    if (DV_PROFILE_IS_1080i50(d))
86
        size -= 3*27;
87
    if (DV_PROFILE_IS_720p50(d))
88
        size -= 4*27;
89
    return size;
90
}
91

    
92
static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
93
                                          uint16_t *tbl)
94
{
95
    static const uint8_t off[] = { 2, 6, 8, 0, 4 };
96
    static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
97
    static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
98
    static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
99

    
100
    static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
101
    static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
102

    
103
    static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
104
                                       0, 1, 2, 2, 1, 0,
105
                                       0, 1, 2, 2, 1, 0,
106
                                       0, 1, 2, 2, 1, 0,
107
                                       0, 1, 2};
108
    static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
109
                                       0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
110
                                       0, 1, 2, 3, 4, 5};
111

    
112
    static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
113
                                       { 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
114
                                       {10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
115
                                       {20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
116
                                       {30, 3}, {40, 0}, {40, 1}, {40, 2}, {40, 3},
117
                                       {50, 0}, {50, 1}, {50, 2}, {50, 3}, {60, 0},
118
                                       {60, 1}, {60, 2}, {60, 3}, {70, 0}, {70, 1},
119
                                       {70, 2}, {70, 3}, { 0,64}, { 0,65}, { 0,66},
120
                                       {10,64}, {10,65}, {10,66}, {20,64}, {20,65},
121
                                       {20,66}, {30,64}, {30,65}, {30,66}, {40,64},
122
                                       {40,65}, {40,66}, {50,64}, {50,65}, {50,66},
123
                                       {60,64}, {60,65}, {60,66}, {70,64}, {70,65},
124
                                       {70,66}, { 0,67}, {20,67}, {40,67}, {60,67}};
125

    
126
    int i, k, m;
127
    int x, y, blk;
128

    
129
    for (m=0; m<5; m++) {
130
         switch (d->width) {
131
         case 1440:
132
              blk = (chan*11+seq)*27+slot;
133

    
134
              if (chan == 0 && seq == 11) {
135
                  x = m*27+slot;
136
                  if (x<90) {
137
                      y = 0;
138
                  } else {
139
                      x = (x - 90)*2;
140
                      y = 67;
141
                  }
142
              } else {
143
                  i = (4*chan + blk + off[m])%11;
144
                  k = (blk/11)%27;
145

    
146
                  x = shuf1[m] + (chan&1)*9 + k%9;
147
                  y = (i*3+k/9)*2 + (chan>>1) + 1;
148
              }
149
              tbl[m] = (x<<1)|(y<<9);
150
              break;
151
         case 1280:
152
              blk = (chan*10+seq)*27+slot;
153

    
154
              i = (4*chan + (seq/5) + 2*blk + off[m])%10;
155
              k = (blk/5)%27;
156

    
157
              x = shuf1[m]+(chan&1)*9 + k%9;
158
              y = (i*3+k/9)*2 + (chan>>1) + 4;
159

    
160
              if (x >= 80) {
161
                  x = remap[y][0]+((x-80)<<(y>59));
162
                  y = remap[y][1];
163
              }
164
              tbl[m] = (x<<1)|(y<<9);
165
              break;
166
       case 960:
167
              blk = (chan*10+seq)*27+slot;
168

    
169
              i = (4*chan + (seq/5) + 2*blk + off[m])%10;
170
              k = (blk/5)%27 + (i&1)*3;
171

    
172
              x = shuf2[m] + k%6 + 6*(chan&1);
173
              y = l_start[i] + k/6 + 45*(chan>>1);
174
              tbl[m] = (x<<1)|(y<<9);
175
              break;
176
        case 720:
177
              switch (d->pix_fmt) {
178
              case PIX_FMT_YUV422P:
179
                   x = shuf3[m] + slot/3;
180
                   y = serpent1[slot] +
181
                       ((((seq + off[m]) % d->difseg_size)<<1) + chan)*3;
182
                   tbl[m] = (x<<1)|(y<<8);
183
                   break;
184
              case PIX_FMT_YUV420P:
185
                   x = shuf3[m] + slot/3;
186
                   y = serpent1[slot] +
187
                       ((seq + off[m]) % d->difseg_size)*3;
188
                   tbl[m] = (x<<1)|(y<<9);
189
                   break;
190
              case PIX_FMT_YUV411P:
191
                   i = (seq + off[m]) % d->difseg_size;
192
                   k = slot + ((m==1||m==2)?3:0);
193

    
194
                   x = l_start_shuffled[m] + k/6;
195
                   y = serpent2[k] + i*6;
196
                   if (x>21)
197
                       y = y*2 - i*6;
198
                   tbl[m] = (x<<2)|(y<<8);
199
                   break;
200
              }
201
        default:
202
              break;
203
        }
204
    }
205
}
206

    
207
static int dv_init_dynamic_tables(const DVprofile *d)
208
{
209
    int j,i,c,s,p;
210
    uint32_t *factor1, *factor2;
211
    const int *iweight1, *iweight2;
212

    
213
    if (!d->work_chunks[dv_work_pool_size(d)-1].buf_offset) {
214
        p = i = 0;
215
        for (c=0; c<d->n_difchan; c++) {
216
            for (s=0; s<d->difseg_size; s++) {
217
                p += 6;
218
                for (j=0; j<27; j++) {
219
                    p += !(j%3);
220
                    if (!(DV_PROFILE_IS_1080i50(d) && c != 0 && s == 11) &&
221
                        !(DV_PROFILE_IS_720p50(d) && s > 9)) {
222
                          dv_calc_mb_coordinates(d, c, s, j, &d->work_chunks[i].mb_coordinates[0]);
223
                          d->work_chunks[i++].buf_offset = p;
224
                    }
225
                    p += 5;
226
                }
227
            }
228
        }
229
    }
230

    
231
    if (!d->idct_factor[DV_PROFILE_IS_HD(d)?8191:5631]) {
232
        factor1 = &d->idct_factor[0];
233
        factor2 = &d->idct_factor[DV_PROFILE_IS_HD(d)?4096:2816];
234
        if (d->height == 720) {
235
            iweight1 = &dv_iweight_720_y[0];
236
            iweight2 = &dv_iweight_720_c[0];
237
        } else {
238
            iweight1 = &dv_iweight_1080_y[0];
239
            iweight2 = &dv_iweight_1080_c[0];
240
            }
241
        if (DV_PROFILE_IS_HD(d)) {
242
            for (c = 0; c < 4; c++) {
243
                for (s = 0; s < 16; s++) {
244
                    for (i = 0; i < 64; i++) {
245
                        *factor1++ = (dv100_qstep[s] << (c + 9)) * iweight1[i];
246
                        *factor2++ = (dv100_qstep[s] << (c + 9)) * iweight2[i];
247
                    }
248
                }
249
            }
250
        } else {
251
            iweight1 = &dv_iweight_88[0];
252
            for (j = 0; j < 2; j++, iweight1 = &dv_iweight_248[0]) {
253
                for (s = 0; s < 22; s++) {
254
                    for (i = c = 0; c < 4; c++) {
255
                        for (; i < dv_quant_areas[c]; i++) {
256
                            *factor1   = iweight1[i] << (dv_quant_shifts[s][c] + 1);
257
                            *factor2++ = (*factor1++) << 1;
258
        }
259
    }
260
            }
261
        }
262
    }
263
}
264

    
265
    return 0;
266
}
267

    
268
static av_cold int dvvideo_init(AVCodecContext *avctx)
269
{
270
    DVVideoContext *s = avctx->priv_data;
271
    DSPContext dsp;
272
    static int done = 0;
273
    int i, j;
274

    
275
    if (!done) {
276
        VLC dv_vlc;
277
        uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
278
        uint8_t  new_dv_vlc_len[NB_DV_VLC*2];
279
        uint8_t  new_dv_vlc_run[NB_DV_VLC*2];
280
        int16_t  new_dv_vlc_level[NB_DV_VLC*2];
281

    
282
        done = 1;
283

    
284
        /* it's faster to include sign bit in a generic VLC parsing scheme */
285
        for (i = 0, j = 0; i < NB_DV_VLC; i++, j++) {
286
            new_dv_vlc_bits[j]  = dv_vlc_bits[i];
287
            new_dv_vlc_len[j]   = dv_vlc_len[i];
288
            new_dv_vlc_run[j]   = dv_vlc_run[i];
289
            new_dv_vlc_level[j] = dv_vlc_level[i];
290

    
291
            if (dv_vlc_level[i]) {
292
                new_dv_vlc_bits[j] <<= 1;
293
                new_dv_vlc_len[j]++;
294

    
295
                j++;
296
                new_dv_vlc_bits[j]  = (dv_vlc_bits[i] << 1) | 1;
297
                new_dv_vlc_len[j]   =  dv_vlc_len[i] + 1;
298
                new_dv_vlc_run[j]   =  dv_vlc_run[i];
299
                new_dv_vlc_level[j] = -dv_vlc_level[i];
300
            }
301
        }
302

    
303
        /* NOTE: as a trick, we use the fact the no codes are unused
304
           to accelerate the parsing of partial codes */
305
        init_vlc(&dv_vlc, TEX_VLC_BITS, j,
306
                 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
307
        assert(dv_vlc.table_size == 1184);
308

    
309
        for (i = 0; i < dv_vlc.table_size; i++){
310
            int code = dv_vlc.table[i][0];
311
            int len  = dv_vlc.table[i][1];
312
            int level, run;
313

    
314
            if (len < 0){ //more bits needed
315
                run   = 0;
316
                level = code;
317
            } else {
318
                run   = new_dv_vlc_run  [code] + 1;
319
                level = new_dv_vlc_level[code];
320
            }
321
            dv_rl_vlc[i].len   = len;
322
            dv_rl_vlc[i].level = level;
323
            dv_rl_vlc[i].run   = run;
324
        }
325
        free_vlc(&dv_vlc);
326

    
327
        for (i = 0; i < NB_DV_VLC - 1; i++) {
328
           if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
329
               continue;
330
#if CONFIG_SMALL
331
           if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
332
               continue;
333
#endif
334

    
335
           if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
336
               continue;
337

    
338
           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc  =
339
               dv_vlc_bits[i] << (!!dv_vlc_level[i]);
340
           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size =
341
               dv_vlc_len[i] + (!!dv_vlc_level[i]);
342
        }
343
        for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
344
#if CONFIG_SMALL
345
           for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
346
              if (dv_vlc_map[i][j].size == 0) {
347
                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
348
                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
349
                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
350
                                          dv_vlc_map[0][j].size;
351
              }
352
           }
353
#else
354
           for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
355
              if (dv_vlc_map[i][j].size == 0) {
356
                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
357
                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
358
                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
359
                                          dv_vlc_map[0][j].size;
360
              }
361
              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
362
                                            dv_vlc_map[i][j].vlc | 1;
363
              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
364
                                            dv_vlc_map[i][j].size;
365
           }
366
#endif
367
        }
368
    }
369

    
370
    /* Generic DSP setup */
371
    dsputil_init(&dsp, avctx);
372
    ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
373
    s->get_pixels = dsp.get_pixels;
374
    s->ildct_cmp = dsp.ildct_cmp[5];
375

    
376
    /* 88DCT setup */
377
    s->fdct[0]     = dsp.fdct;
378
    s->idct_put[0] = dsp.idct_put;
379
    for (i = 0; i < 64; i++)
380
       s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
381

    
382
    /* 248DCT setup */
383
    s->fdct[1]     = dsp.fdct248;
384
    s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
385
    if (avctx->lowres){
386
        for (i = 0; i < 64; i++){
387
            int j = ff_zigzag248_direct[i];
388
            s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
389
        }
390
    }else
391
        memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
392

    
393
    avctx->coded_frame = &s->picture;
394
    s->avctx = avctx;
395

    
396
    return 0;
397
}
398

    
399
// #define VLC_DEBUG
400
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
401

    
402
typedef struct BlockInfo {
403
    const uint32_t *factor_table;
404
    const uint8_t *scan_table;
405
    uint8_t pos; /* position in block */
406
    void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
407
    uint8_t partial_bit_count;
408
    uint16_t partial_bit_buffer;
409
    int shift_offset;
410
} BlockInfo;
411

    
412
/* bit budget for AC only in 5 MBs */
413
static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
414
/* see dv_88_areas and dv_248_areas for details */
415
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
416

    
417
static inline int get_bits_left(GetBitContext *s)
418
{
419
    return s->size_in_bits - get_bits_count(s);
420
}
421

    
422
static inline int put_bits_left(PutBitContext* s)
423
{
424
    return (s->buf_end - s->buf) * 8 - put_bits_count(s);
425
}
426

    
427
/* decode ac coefficients */
428
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
429
{
430
    int last_index = gb->size_in_bits;
431
    const uint8_t  *scan_table   = mb->scan_table;
432
    const uint32_t *factor_table = mb->factor_table;
433
    int pos               = mb->pos;
434
    int partial_bit_count = mb->partial_bit_count;
435
    int level, run, vlc_len, index;
436

    
437
    OPEN_READER(re, gb);
438
    UPDATE_CACHE(re, gb);
439

    
440
    /* if we must parse a partial vlc, we do it here */
441
    if (partial_bit_count > 0) {
442
        re_cache = ((unsigned)re_cache >> partial_bit_count) |
443
                   (mb->partial_bit_buffer << (sizeof(re_cache) * 8 - partial_bit_count));
444
        re_index -= partial_bit_count;
445
        mb->partial_bit_count = 0;
446
    }
447

    
448
    /* get the AC coefficients until last_index is reached */
449
    for (;;) {
450
#ifdef VLC_DEBUG
451
        printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
452
#endif
453
        /* our own optimized GET_RL_VLC */
454
        index   = NEG_USR32(re_cache, TEX_VLC_BITS);
455
        vlc_len = dv_rl_vlc[index].len;
456
        if (vlc_len < 0) {
457
            index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
458
            vlc_len = TEX_VLC_BITS - vlc_len;
459
        }
460
        level = dv_rl_vlc[index].level;
461
        run   = dv_rl_vlc[index].run;
462

    
463
        /* gotta check if we're still within gb boundaries */
464
        if (re_index + vlc_len > last_index) {
465
            /* should be < 16 bits otherwise a codeword could have been parsed */
466
            mb->partial_bit_count = last_index - re_index;
467
            mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
468
            re_index = last_index;
469
            break;
470
        }
471
        re_index += vlc_len;
472

    
473
#ifdef VLC_DEBUG
474
        printf("run=%d level=%d\n", run, level);
475
#endif
476
        pos += run;
477
        if (pos >= 64)
478
            break;
479

    
480
        level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
481
        block[scan_table[pos]] = level;
482

    
483
        UPDATE_CACHE(re, gb);
484
    }
485
    CLOSE_READER(re, gb);
486
    mb->pos = pos;
487
}
488

    
489
static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
490
{
491
    int bits_left = get_bits_left(gb);
492
    while (bits_left >= MIN_CACHE_BITS) {
493
        put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
494
        bits_left -= MIN_CACHE_BITS;
495
    }
496
    if (bits_left > 0) {
497
        put_bits(pb, bits_left, get_bits(gb, bits_left));
498
    }
499
}
500

    
501
static inline void dv_calculate_mb_xy(DVVideoContext *s, DVwork_chunk *work_chunk, int m, int *mb_x, int *mb_y)
502
{
503
     *mb_x = work_chunk->mb_coordinates[m] & 0xff;
504
     *mb_y = work_chunk->mb_coordinates[m] >> 8;
505

    
506
     /* We work with 720p frames split in half. The odd half-frame (chan==2,3) is displaced :-( */
507
     if (s->sys->height == 720 && !(s->buf[1]&0x0C)) {
508
         *mb_y -= (*mb_y>17)?18:-72; /* shifting the Y coordinate down by 72/2 macro blocks */
509
     }
510
}
511

    
512
/* mb_x and mb_y are in units of 8 pixels */
513
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
514
{
515
    DVVideoContext *s = avctx->priv_data;
516
    DVwork_chunk *work_chunk = arg;
517
    int quant, dc, dct_mode, class1, j;
518
    int mb_index, mb_x, mb_y, last_index;
519
    int y_stride, linesize;
520
    DCTELEM *block, *block1;
521
    int c_offset;
522
    uint8_t *y_ptr;
523
    const uint8_t *buf_ptr;
524
    PutBitContext pb, vs_pb;
525
    GetBitContext gb;
526
    BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
527
    DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
528
    DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
529
    DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
530
    const int log2_blocksize = 3-s->avctx->lowres;
531
    int is_field_mode[5];
532

    
533
    assert((((int)mb_bit_buffer) & 7) == 0);
534
    assert((((int)vs_bit_buffer) & 7) == 0);
535

    
536
    memset(sblock, 0, sizeof(sblock));
537

    
538
    /* pass 1 : read DC and AC coefficients in blocks */
539
    buf_ptr = &s->buf[work_chunk->buf_offset*80];
540
    block1  = &sblock[0][0];
541
    mb1     = mb_data;
542
    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
543
    for (mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
544
        /* skip header */
545
        quant = buf_ptr[3] & 0x0f;
546
        buf_ptr += 4;
547
        init_put_bits(&pb, mb_bit_buffer, 80);
548
        mb    = mb1;
549
        block = block1;
550
        is_field_mode[mb_index] = 0;
551
        for (j = 0; j < s->sys->bpm; j++) {
552
            last_index = s->sys->block_sizes[j];
553
            init_get_bits(&gb, buf_ptr, last_index);
554

    
555
            /* get the dc */
556
            dc       = get_sbits(&gb, 9);
557
            dct_mode = get_bits1(&gb);
558
            class1   = get_bits(&gb, 2);
559
            if (DV_PROFILE_IS_HD(s->sys)) {
560
                mb->idct_put     = s->idct_put[0];
561
                mb->scan_table   = s->dv_zigzag[0];
562
                mb->factor_table = &s->sys->idct_factor[(j >= 4)*4*16*64 + class1*16*64 + quant*64];
563
                is_field_mode[mb_index] |= !j && dct_mode;
564
            } else {
565
                mb->idct_put     = s->idct_put[dct_mode && log2_blocksize == 3];
566
                mb->scan_table   = s->dv_zigzag[dct_mode];
567
                mb->factor_table = &s->sys->idct_factor[(class1 == 3)*2*22*64 + dct_mode*22*64 +
568
                                                        (quant + dv_quant_offset[class1])*64];
569
            }
570
            dc = dc << 2;
571
            /* convert to unsigned because 128 is not added in the
572
               standard IDCT */
573
            dc += 1024;
574
            block[0] = dc;
575
            buf_ptr += last_index >> 3;
576
            mb->pos               = 0;
577
            mb->partial_bit_count = 0;
578

    
579
#ifdef VLC_DEBUG
580
            printf("MB block: %d, %d ", mb_index, j);
581
#endif
582
            dv_decode_ac(&gb, mb, block);
583

    
584
            /* write the remaining bits  in a new buffer only if the
585
               block is finished */
586
            if (mb->pos >= 64)
587
                bit_copy(&pb, &gb);
588

    
589
            block += 64;
590
            mb++;
591
        }
592

    
593
        /* pass 2 : we can do it just after */
594
#ifdef VLC_DEBUG
595
        printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
596
#endif
597
        block = block1;
598
        mb    = mb1;
599
        init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
600
        flush_put_bits(&pb);
601
        for (j = 0; j < s->sys->bpm; j++, block += 64, mb++) {
602
            if (mb->pos < 64 && get_bits_left(&gb) > 0) {
603
                dv_decode_ac(&gb, mb, block);
604
                /* if still not finished, no need to parse other blocks */
605
                if (mb->pos < 64)
606
                    break;
607
            }
608
        }
609
        /* all blocks are finished, so the extra bytes can be used at
610
           the video segment level */
611
        if (j >= s->sys->bpm)
612
            bit_copy(&vs_pb, &gb);
613
    }
614

    
615
    /* we need a pass other the whole video segment */
616
#ifdef VLC_DEBUG
617
    printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
618
#endif
619
    block = &sblock[0][0];
620
    mb    = mb_data;
621
    init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
622
    flush_put_bits(&vs_pb);
623
    for (mb_index = 0; mb_index < 5; mb_index++) {
624
        for (j = 0; j < s->sys->bpm; j++) {
625
            if (mb->pos < 64) {
626
#ifdef VLC_DEBUG
627
                printf("start %d:%d\n", mb_index, j);
628
#endif
629
                dv_decode_ac(&gb, mb, block);
630
            }
631
            if (mb->pos >= 64 && mb->pos < 127)
632
                av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
633
            block += 64;
634
            mb++;
635
        }
636
    }
637

    
638
    /* compute idct and place blocks */
639
    block = &sblock[0][0];
640
    mb    = mb_data;
641
    for (mb_index = 0; mb_index < 5; mb_index++) {
642
        dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
643

    
644
        /* idct_put'ting luminance */
645
        if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
646
            (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
647
            (s->sys->height >= 720 && mb_y != 134)) {
648
            y_stride = (s->picture.linesize[0] << ((!is_field_mode[mb_index]) * log2_blocksize));
649
        } else {
650
            y_stride = (2 << log2_blocksize);
651
        }
652
        y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << log2_blocksize);
653
        linesize = s->picture.linesize[0] << is_field_mode[mb_index];
654
        mb[0]    .idct_put(y_ptr                                   , linesize, block + 0*64);
655
        if (s->sys->video_stype == 4) { /* SD 422 */
656
            mb[2].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 2*64);
657
        } else {
658
            mb[1].idct_put(y_ptr + (1 << log2_blocksize)           , linesize, block + 1*64);
659
            mb[2].idct_put(y_ptr                         + y_stride, linesize, block + 2*64);
660
            mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3*64);
661
        }
662
        mb += 4;
663
        block += 4*64;
664

    
665
        /* idct_put'ting chrominance */
666
        c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
667
                     (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << log2_blocksize);
668
        for (j = 2; j; j--) {
669
            uint8_t *c_ptr = s->picture.data[j] + c_offset;
670
            if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
671
                  uint64_t aligned_pixels[64/8];
672
                  uint8_t *pixels = (uint8_t*)aligned_pixels;
673
                  uint8_t *c_ptr1, *ptr1;
674
                  int x, y;
675
                  mb->idct_put(pixels, 8, block);
676
                  for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->picture.linesize[j], pixels += 8) {
677
                      ptr1   = pixels + (1 << (log2_blocksize - 1));
678
                      c_ptr1 = c_ptr + (s->picture.linesize[j] << log2_blocksize);
679
                      for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
680
                          c_ptr[x]  = pixels[x];
681
                          c_ptr1[x] = ptr1[x];
682
                      }
683
                  }
684
                  block += 64; mb++;
685
            } else {
686
                  y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
687
                                             s->picture.linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
688
                  linesize = s->picture.linesize[j] << is_field_mode[mb_index];
689
                  (mb++)->    idct_put(c_ptr           , linesize, block); block += 64;
690
                  if (s->sys->bpm == 8) {
691
                      (mb++)->idct_put(c_ptr + y_stride, linesize, block); block += 64;
692
                  }
693
            }
694
        }
695
    }
696
    return 0;
697
}
698

    
699
#if CONFIG_SMALL
700
/* Converts run and level (where level != 0) pair into vlc, returning bit size */
701
static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
702
{
703
    int size;
704
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
705
        *vlc = dv_vlc_map[run][level].vlc | sign;
706
        size = dv_vlc_map[run][level].size;
707
    }
708
    else {
709
        if (level < DV_VLC_MAP_LEV_SIZE) {
710
            *vlc = dv_vlc_map[0][level].vlc | sign;
711
            size = dv_vlc_map[0][level].size;
712
        } else {
713
            *vlc = 0xfe00 | (level << 1) | sign;
714
            size = 16;
715
        }
716
        if (run) {
717
            *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
718
                                  (0x1f80 | (run - 1))) << size;
719
            size +=  (run < 16) ? dv_vlc_map[run-1][0].size : 13;
720
        }
721
    }
722

    
723
    return size;
724
}
725

    
726
static av_always_inline int dv_rl2vlc_size(int run, int level)
727
{
728
    int size;
729

    
730
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
731
        size = dv_vlc_map[run][level].size;
732
    }
733
    else {
734
        size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
735
        if (run) {
736
            size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
737
        }
738
    }
739
    return size;
740
}
741
#else
742
static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
743
{
744
    *vlc = dv_vlc_map[run][l].vlc | sign;
745
    return dv_vlc_map[run][l].size;
746
}
747

    
748
static av_always_inline int dv_rl2vlc_size(int run, int l)
749
{
750
    return dv_vlc_map[run][l].size;
751
}
752
#endif
753

    
754
typedef struct EncBlockInfo {
755
    int      area_q[4];
756
    int      bit_size[4];
757
    int      prev[5];
758
    int      cur_ac;
759
    int      cno;
760
    int      dct_mode;
761
    DCTELEM  mb[64];
762
    uint8_t  next[64];
763
    uint8_t  sign[64];
764
    uint8_t  partial_bit_count;
765
    uint32_t partial_bit_buffer; /* we can't use uint16_t here */
766
} EncBlockInfo;
767

    
768
static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
769
                                                    PutBitContext* pb_pool,
770
                                                    PutBitContext* pb_end)
771
{
772
    int prev, bits_left;
773
    PutBitContext* pb = pb_pool;
774
    int size = bi->partial_bit_count;
775
    uint32_t vlc = bi->partial_bit_buffer;
776

    
777
    bi->partial_bit_count = bi->partial_bit_buffer = 0;
778
    for (;;){
779
       /* Find suitable storage space */
780
       for (; size > (bits_left = put_bits_left(pb)); pb++) {
781
          if (bits_left) {
782
              size -= bits_left;
783
              put_bits(pb, bits_left, vlc >> size);
784
              vlc = vlc & ((1 << size) - 1);
785
          }
786
          if (pb + 1 >= pb_end) {
787
              bi->partial_bit_count  = size;
788
              bi->partial_bit_buffer = vlc;
789
              return pb;
790
          }
791
       }
792

    
793
       /* Store VLC */
794
       put_bits(pb, size, vlc);
795

    
796
       if (bi->cur_ac >= 64)
797
           break;
798

    
799
       /* Construct the next VLC */
800
       prev       = bi->cur_ac;
801
       bi->cur_ac = bi->next[prev];
802
       if (bi->cur_ac < 64){
803
           size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
804
       } else {
805
           size = 4; vlc = 6; /* End Of Block stamp */
806
       }
807
    }
808
    return pb;
809
}
810

    
811
static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
812
    if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
813
        int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
814
        if (ps > 0) {
815
            int is = s->ildct_cmp(NULL, data           , NULL, linesize<<1, 4) +
816
                     s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
817
            return (ps > is);
818
        }
819
    } else
820
        return 0;
821
}
822

    
823
static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
824
{
825
    const int *weight;
826
    const uint8_t* zigzag_scan;
827
    DECLARE_ALIGNED_16(DCTELEM, blk[64]);
828
    int i, area;
829
    /* We offer two different methods for class number assignment: the
830
       method suggested in SMPTE 314M Table 22, and an improved
831
       method. The SMPTE method is very conservative; it assigns class
832
       3 (i.e. severe quantization) to any block where the largest AC
833
       component is greater than 36. FFmpeg's DV encoder tracks AC bit
834
       consumption precisely, so there is no need to bias most blocks
835
       towards strongly lossy compression. Instead, we assign class 2
836
       to most blocks, and use class 3 only when strictly necessary
837
       (for blocks whose largest AC component exceeds 255). */
838

    
839
#if 0 /* SMPTE spec method */
840
    static const int classes[] = {12, 24, 36, 0xffff};
841
#else /* improved FFmpeg method */
842
    static const int classes[] = {-1, -1, 255, 0xffff};
843
#endif
844
    int max  = classes[0];
845
    int prev = 0;
846

    
847
    assert((((int)blk) & 15) == 0);
848

    
849
    bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
850
    bi->partial_bit_count = 0;
851
    bi->partial_bit_buffer = 0;
852
    bi->cur_ac = 0;
853
    if (data) {
854
        bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
855
        s->get_pixels(blk, data, linesize);
856
        s->fdct[bi->dct_mode](blk);
857
    } else {
858
        /* We rely on the fact that encoding all zeros leads to an immediate EOB,
859
           which is precisely what the spec calls for in the "dummy" blocks. */
860
        memset(blk, 0, sizeof(blk));
861
        bi->dct_mode = 0;
862
    }
863
    bi->mb[0] = blk[0];
864

    
865
    zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
866
    weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
867

    
868
    for (area = 0; area < 4; area++) {
869
       bi->prev[area]     = prev;
870
       bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
871
       for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
872
          int level = blk[zigzag_scan[i]];
873

    
874
          if (level + 15 > 30U) {
875
              bi->sign[i] = (level >> 31) & 1;
876
              /* weigh it and and shift down into range, adding for rounding */
877
              /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
878
                 AND the 2x doubling of the weights */
879
              level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
880
              bi->mb[i] = level;
881
              if (level > max)
882
                  max = level;
883
              bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
884
              bi->next[prev]= i;
885
              prev = i;
886
          }
887
       }
888
    }
889
    bi->next[prev]= i;
890
    for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
891

    
892
    bi->cno += bias;
893

    
894
    if (bi->cno >= 3) {
895
        bi->cno = 3;
896
        prev    = 0;
897
        i       = bi->next[prev];
898
        for (area = 0; area < 4; area++) {
899
            bi->prev[area]     = prev;
900
            bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
901
            for (; i < mb_area_start[area+1]; i = bi->next[i]) {
902
                bi->mb[i] >>= 1;
903

    
904
                if (bi->mb[i]) {
905
                    bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
906
                    bi->next[prev]= i;
907
                    prev = i;
908
                }
909
            }
910
        }
911
        bi->next[prev]= i;
912
    }
913

    
914
    return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
915
}
916

    
917
static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
918
{
919
    int size[5];
920
    int i, j, k, a, prev, a2;
921
    EncBlockInfo* b;
922

    
923
    size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
924
    do {
925
       b = blks;
926
       for (i = 0; i < 5; i++) {
927
          if (!qnos[i])
928
              continue;
929

    
930
          qnos[i]--;
931
          size[i] = 0;
932
          for (j = 0; j < 6; j++, b++) {
933
             for (a = 0; a < 4; a++) {
934
                if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
935
                    b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
936
                    b->area_q[a]++;
937
                    prev = b->prev[a];
938
                    assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
939
                    for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
940
                       b->mb[k] >>= 1;
941
                       if (b->mb[k]) {
942
                           b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
943
                           prev = k;
944
                       } else {
945
                           if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
946
                                for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
947
                                    b->prev[a2] = prev;
948
                                assert(a2 < 4);
949
                                assert(b->mb[b->next[k]]);
950
                                b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
951
                                                  -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
952
                                assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
953
                                b->prev[a2] = prev;
954
                           }
955
                           b->next[prev] = b->next[k];
956
                       }
957
                    }
958
                    b->prev[a+1]= prev;
959
                }
960
                size[i] += b->bit_size[a];
961
             }
962
          }
963
          if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
964
                return;
965
       }
966
    } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
967

    
968

    
969
    for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
970
        b = blks;
971
        size[0] = 5 * 6 * 4; //EOB
972
        for (j = 0; j < 6 *5; j++, b++) {
973
            prev = b->prev[0];
974
            for (k = b->next[prev]; k < 64; k = b->next[k]) {
975
                if (b->mb[k] < a && b->mb[k] > -a){
976
                    b->next[prev] = b->next[k];
977
                }else{
978
                    size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
979
                    prev = k;
980
                }
981
            }
982
        }
983
    }
984
}
985

    
986
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
987
{
988
    DVVideoContext *s = avctx->priv_data;
989
    DVwork_chunk *work_chunk = arg;
990
    int mb_index, i, j;
991
    int mb_x, mb_y, c_offset, linesize, y_stride;
992
    uint8_t*  y_ptr;
993
    uint8_t*  dif;
994
    uint8_t   scratch[64];
995
    EncBlockInfo  enc_blks[5*DV_MAX_BPM];
996
    PutBitContext pbs[5*DV_MAX_BPM];
997
    PutBitContext* pb;
998
    EncBlockInfo* enc_blk;
999
    int       vs_bit_size = 0;
1000
    int       qnos[5] = {15, 15, 15, 15, 15}; /* No quantization */
1001
    int*      qnosp = &qnos[0];
1002

    
1003
    dif = &s->buf[work_chunk->buf_offset*80];
1004
    enc_blk = &enc_blks[0];
1005
    for (mb_index = 0; mb_index < 5; mb_index++) {
1006
        dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
1007

    
1008
        /* initializing luminance blocks */
1009
        if ((s->sys->pix_fmt == PIX_FMT_YUV420P) ||
1010
            (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
1011
            (s->sys->height >= 720 && mb_y != 134)) {
1012
            y_stride = s->picture.linesize[0] << 3;
1013
        } else {
1014
            y_stride = 16;
1015
        }
1016
        y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1017
        linesize = s->picture.linesize[0];
1018

    
1019
        if (s->sys->video_stype == 4) { /* SD 422 */
1020
            vs_bit_size +=
1021
            dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1022
            dv_init_enc_block(enc_blk+1, NULL                , linesize, s, 0) +
1023
            dv_init_enc_block(enc_blk+2, y_ptr + 8           , linesize, s, 0) +
1024
            dv_init_enc_block(enc_blk+3, NULL                , linesize, s, 0);
1025
        } else {
1026
            vs_bit_size +=
1027
            dv_init_enc_block(enc_blk+0, y_ptr               , linesize, s, 0) +
1028
            dv_init_enc_block(enc_blk+1, y_ptr + 8           , linesize, s, 0) +
1029
            dv_init_enc_block(enc_blk+2, y_ptr     + y_stride, linesize, s, 0) +
1030
            dv_init_enc_block(enc_blk+3, y_ptr + 8 + y_stride, linesize, s, 0);
1031
        }
1032
        enc_blk += 4;
1033

    
1034
        /* initializing chrominance blocks */
1035
        c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1036
                     (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1037
        for (j = 2; j; j--) {
1038
            uint8_t *c_ptr = s->picture.data[j] + c_offset;
1039
            linesize = s->picture.linesize[j];
1040
            y_stride = (mb_y == 134) ? 8 : (s->picture.linesize[j] << 3);
1041
            if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
1042
                uint8_t* d;
1043
                uint8_t* b = scratch;
1044
                for (i = 0; i < 8; i++) {
1045
                    d = c_ptr + (linesize << 3);
1046
                    b[0] = c_ptr[0]; b[1] = c_ptr[1]; b[2] = c_ptr[2]; b[3] = c_ptr[3];
1047
                    b[4] =     d[0]; b[5] =     d[1]; b[6] =     d[2]; b[7] =     d[3];
1048
                    c_ptr += linesize;
1049
                    b += 8;
1050
                }
1051
                c_ptr = scratch;
1052
                linesize = 8;
1053
            }
1054

    
1055
            vs_bit_size += dv_init_enc_block(    enc_blk++, c_ptr           , linesize, s, 1);
1056
            if (s->sys->bpm == 8) {
1057
                vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride, linesize, s, 1);
1058
            }
1059
        }
1060
    }
1061

    
1062
    if (vs_total_ac_bits < vs_bit_size)
1063
        dv_guess_qnos(&enc_blks[0], qnosp);
1064

    
1065
    /* DIF encoding process */
1066
    for (j=0; j<5*s->sys->bpm;) {
1067
        int start_mb = j;
1068

    
1069
        dif[3] = *qnosp++;
1070
        dif += 4;
1071

    
1072
        /* First pass over individual cells only */
1073
        for (i=0; i<s->sys->bpm; i++, j++) {
1074
            int sz = s->sys->block_sizes[i]>>3;
1075

    
1076
            init_put_bits(&pbs[j], dif, sz);
1077
            put_bits(&pbs[j], 9, (uint16_t)(((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2));
1078
            put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
1079
            put_bits(&pbs[j], 2, enc_blks[j].cno);
1080

    
1081
            dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1082
            dif += sz;
1083
        }
1084

    
1085
        /* Second pass over each MB space */
1086
        pb = &pbs[start_mb];
1087
        for (i=0; i<s->sys->bpm; i++) {
1088
            if (enc_blks[start_mb+i].partial_bit_count)
1089
                pb = dv_encode_ac(&enc_blks[start_mb+i], pb, &pbs[start_mb+s->sys->bpm]);
1090
        }
1091
    }
1092

    
1093
    /* Third and final pass over the whole video segment space */
1094
    pb = &pbs[0];
1095
    for (j=0; j<5*s->sys->bpm; j++) {
1096
       if (enc_blks[j].partial_bit_count)
1097
           pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1098
       if (enc_blks[j].partial_bit_count)
1099
            av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1100
    }
1101

    
1102
    for (j=0; j<5*s->sys->bpm; j++)
1103
       flush_put_bits(&pbs[j]);
1104

    
1105
    return 0;
1106
}
1107

    
1108
#if CONFIG_DVVIDEO_DECODER
1109
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1110
   144000 bytes for PAL - or twice those for 50Mbps) */
1111
static int dvvideo_decode_frame(AVCodecContext *avctx,
1112
                                 void *data, int *data_size,
1113
                                 const uint8_t *buf, int buf_size)
1114
{
1115
    DVVideoContext *s = avctx->priv_data;
1116

    
1117
    s->sys = dv_frame_profile(buf);
1118
    if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1119
        return -1; /* NOTE: we only accept several full frames */
1120

    
1121
    if (s->picture.data[0])
1122
        avctx->release_buffer(avctx, &s->picture);
1123

    
1124
    s->picture.reference = 0;
1125
    s->picture.key_frame = 1;
1126
    s->picture.pict_type = FF_I_TYPE;
1127
    avctx->pix_fmt   = s->sys->pix_fmt;
1128
    avctx->time_base = s->sys->time_base;
1129
    avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1130
    if (avctx->get_buffer(avctx, &s->picture) < 0) {
1131
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1132
        return -1;
1133
    }
1134
    s->picture.interlaced_frame = 1;
1135
    s->picture.top_field_first  = 0;
1136

    
1137
    s->buf = buf;
1138
    avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1139
                   dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1140

    
1141
    emms_c();
1142

    
1143
    /* return image */
1144
    *data_size = sizeof(AVFrame);
1145
    *(AVFrame*)data = s->picture;
1146

    
1147
    return s->sys->frame_size;
1148
}
1149
#endif /* CONFIG_DVVIDEO_DECODER */
1150

    
1151

    
1152
static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1153
                                uint8_t* buf)
1154
{
1155
    /*
1156
     * Here's what SMPTE314M says about these two:
1157
     *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1158
     *             as track application IDs (APTn = 001, AP1n =
1159
     *             001, AP2n = 001, AP3n = 001), if the source signal
1160
     *             comes from a digital VCR. If the signal source is
1161
     *             unknown, all bits for these data shall be set to 1.
1162
     *    (page 12) STYPE: STYPE defines a signal type of video signal
1163
     *                     00000b = 4:1:1 compression
1164
     *                     00100b = 4:2:2 compression
1165
     *                     XXXXXX = Reserved
1166
     * Now, I've got two problems with these statements:
1167
     *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1168
     *      It seems that for PAL as defined in IEC 61834 we have to set
1169
     *      APT to 000 and for SMPTE314M to 001.
1170
     *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1171
     *      compression scheme (if any).
1172
     */
1173
    int apt   = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1174

    
1175
    uint8_t aspect = 0;
1176
    if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1177
        aspect = 0x02;
1178

    
1179
    buf[0] = (uint8_t)pack_id;
1180
    switch (pack_id) {
1181
    case dv_header525: /* I can't imagine why these two weren't defined as real */
1182
    case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1183
          buf[1] = 0xf8 |        /* reserved -- always 1 */
1184
                   (apt & 0x07); /* APT: Track application ID */
1185
          buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1186
                   (0x0f << 3) | /* reserved -- always 1 */
1187
                   (apt & 0x07); /* AP1: Audio application ID */
1188
          buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1189
                   (0x0f << 3) | /* reserved -- always 1 */
1190
                   (apt & 0x07); /* AP2: Video application ID */
1191
          buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1192
                   (0x0f << 3) | /* reserved -- always 1 */
1193
                   (apt & 0x07); /* AP3: Subcode application ID */
1194
          break;
1195
    case dv_video_source:
1196
          buf[1] = 0xff;      /* reserved -- always 1 */
1197
          buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1198
                   (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1199
                   (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1200
                   0xf;       /* reserved -- always 1 */
1201
          buf[3] = (3 << 6) | /* reserved -- always 1 */
1202
                   (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1203
                   c->sys->video_stype; /* signal type video compression */
1204
          buf[4] = 0xff;      /* VISC: 0xff -- no information */
1205
          break;
1206
    case dv_video_control:
1207
          buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1208
                   0x3f;      /* reserved -- always 1 */
1209
          buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
1210
                   aspect;
1211
          buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1212
                   (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1213
                   (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1214
                   (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1215
                   0xc;       /* reserved -- always b1100 */
1216
          buf[4] = 0xff;      /* reserved -- always 1 */
1217
          break;
1218
    default:
1219
          buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1220
    }
1221
    return 5;
1222
}
1223

    
1224
#if CONFIG_DVVIDEO_ENCODER
1225
static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1226
{
1227
    int chan, i, j, k;
1228

    
1229
    for (chan = 0; chan < c->sys->n_difchan; chan++) {
1230
        for (i = 0; i < c->sys->difseg_size; i++) {
1231
            memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1232

    
1233
            /* DV header: 1DIF */
1234
            buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1235
            buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1236
            buf += 72; /* unused bytes */
1237

    
1238
            /* DV subcode: 2DIFs */
1239
            for (j = 0; j < 2; j++) {
1240
                buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1241
                for (k = 0; k < 6; k++)
1242
                     buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1243
                buf += 29; /* unused bytes */
1244
            }
1245

    
1246
            /* DV VAUX: 3DIFS */
1247
            for (j = 0; j < 3; j++) {
1248
                buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1249
                buf += dv_write_pack(dv_video_source,  c, buf);
1250
                buf += dv_write_pack(dv_video_control, c, buf);
1251
                buf += 7*5;
1252
                buf += dv_write_pack(dv_video_source,  c, buf);
1253
                buf += dv_write_pack(dv_video_control, c, buf);
1254
                buf += 4*5 + 2; /* unused bytes */
1255
            }
1256

    
1257
            /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1258
            for (j = 0; j < 135; j++) {
1259
                if (j%15 == 0) {
1260
                    memset(buf, 0xff, 80);
1261
                    buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1262
                    buf += 77; /* audio control & shuffled PCM audio */
1263
                }
1264
                buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1265
                buf += 77; /* 1 video macroblock: 1 bytes control
1266
                              4 * 14 bytes Y 8x8 data
1267
                              10 bytes Cr 8x8 data
1268
                              10 bytes Cb 8x8 data */
1269
            }
1270
        }
1271
    }
1272
}
1273

    
1274

    
1275
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1276
                                void *data)
1277
{
1278
    DVVideoContext *s = c->priv_data;
1279

    
1280
    s->sys = dv_codec_profile(c);
1281
    if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1282
        return -1;
1283

    
1284
    c->pix_fmt           = s->sys->pix_fmt;
1285
    s->picture           = *((AVFrame *)data);
1286
    s->picture.key_frame = 1;
1287
    s->picture.pict_type = FF_I_TYPE;
1288

    
1289
    s->buf = buf;
1290
    c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1291
               dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1292

    
1293
    emms_c();
1294

    
1295
    dv_format_frame(s, buf);
1296

    
1297
    return s->sys->frame_size;
1298
}
1299
#endif
1300

    
1301
static int dvvideo_close(AVCodecContext *c)
1302
{
1303
    DVVideoContext *s = c->priv_data;
1304

    
1305
    if (s->picture.data[0])
1306
        c->release_buffer(c, &s->picture);
1307

    
1308
    return 0;
1309
}
1310

    
1311

    
1312
#if CONFIG_DVVIDEO_ENCODER
1313
AVCodec dvvideo_encoder = {
1314
    "dvvideo",
1315
    CODEC_TYPE_VIDEO,
1316
    CODEC_ID_DVVIDEO,
1317
    sizeof(DVVideoContext),
1318
    dvvideo_init,
1319
    dvvideo_encode_frame,
1320
    .pix_fmts  = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1321
    .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1322
};
1323
#endif // CONFIG_DVVIDEO_ENCODER
1324

    
1325
#if CONFIG_DVVIDEO_DECODER
1326
AVCodec dvvideo_decoder = {
1327
    "dvvideo",
1328
    CODEC_TYPE_VIDEO,
1329
    CODEC_ID_DVVIDEO,
1330
    sizeof(DVVideoContext),
1331
    dvvideo_init,
1332
    NULL,
1333
    dvvideo_close,
1334
    dvvideo_decode_frame,
1335
    CODEC_CAP_DR1,
1336
    NULL,
1337
    .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1338
};
1339
#endif