Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ b2755007

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 "put_bits.h"
45
#include "simple_idct.h"
46
#include "dvdata.h"
47

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

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

    
57
    uint8_t  dv_zigzag[2][64];
58

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

    
65
#define TEX_VLC_BITS 9
66

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
266
    return 0;
267
}
268

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

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

    
283
        done = 1;
284

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

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

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

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

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

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

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

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

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

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

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

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

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

    
397
    return 0;
398
}
399

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
724
    return size;
725
}
726

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

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

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

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

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

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

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

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

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

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

    
822
    return 0;
823
}
824

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

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

    
849
    assert((((int)blk) & 15) == 0);
850

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

    
867
    zigzag_scan = bi->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct;
868
    weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
869

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

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

    
894
    bi->cno += bias;
895

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

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

    
916
    return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
917
}
918

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

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

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

    
970

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

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

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

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

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

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

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

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

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

    
1071
        dif[3] = *qnosp++;
1072
        dif += 4;
1073

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

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

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

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

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

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

    
1107
    return 0;
1108
}
1109

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

    
1121
    s->sys = dv_frame_profile(buf);
1122
    if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1123
        return -1; /* NOTE: we only accept several full frames */
1124

    
1125
    if (s->picture.data[0])
1126
        avctx->release_buffer(avctx, &s->picture);
1127

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

    
1141
    s->buf = buf;
1142
    avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1143
                   dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1144

    
1145
    emms_c();
1146

    
1147
    /* return image */
1148
    *data_size = sizeof(AVFrame);
1149
    *(AVFrame*)data = s->picture;
1150

    
1151
    return s->sys->frame_size;
1152
}
1153
#endif /* CONFIG_DVVIDEO_DECODER */
1154

    
1155

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

    
1179
    uint8_t aspect = 0;
1180
    if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1181
        aspect = 0x02;
1182

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

    
1228
#if CONFIG_DVVIDEO_ENCODER
1229
static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1230
{
1231
    int chan, i, j, k;
1232

    
1233
    for (chan = 0; chan < c->sys->n_difchan; chan++) {
1234
        for (i = 0; i < c->sys->difseg_size; i++) {
1235
            memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1236

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

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

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

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

    
1278

    
1279
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1280
                                void *data)
1281
{
1282
    DVVideoContext *s = c->priv_data;
1283

    
1284
    s->sys = dv_codec_profile(c);
1285
    if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1286
        return -1;
1287

    
1288
    c->pix_fmt           = s->sys->pix_fmt;
1289
    s->picture           = *((AVFrame *)data);
1290
    s->picture.key_frame = 1;
1291
    s->picture.pict_type = FF_I_TYPE;
1292

    
1293
    s->buf = buf;
1294
    c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1295
               dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1296

    
1297
    emms_c();
1298

    
1299
    dv_format_frame(s, buf);
1300

    
1301
    return s->sys->frame_size;
1302
}
1303
#endif
1304

    
1305
static int dvvideo_close(AVCodecContext *c)
1306
{
1307
    DVVideoContext *s = c->priv_data;
1308

    
1309
    if (s->picture.data[0])
1310
        c->release_buffer(c, &s->picture);
1311

    
1312
    return 0;
1313
}
1314

    
1315

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

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