Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 8f1e203a

History | View | Annotate | Download (48 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 "get_bits.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
    avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
397

    
398
    return 0;
399
}
400

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
725
    return size;
726
}
727

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

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

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

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

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

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

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

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

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

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

    
823
    return 0;
824
}
825

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

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

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

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

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

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

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

    
895
    bi->cno += bias;
896

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

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

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

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

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

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

    
971

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1105
    for (j=0; j<5*s->sys->bpm; j++) {
1106
       int pos;
1107
       int size = pbs[j].size_in_bits >> 3;
1108
       flush_put_bits(&pbs[j]);
1109
       pos = put_bits_count(&pbs[j]) >> 3;
1110
       if (pos > size) {
1111
           av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
1112
           return -1;
1113
       }
1114
       memset(pbs[j].buf + pos, 0xff, size - pos);
1115
    }
1116

    
1117
    return 0;
1118
}
1119

    
1120
#if CONFIG_DVVIDEO_DECODER
1121
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
1122
   144000 bytes for PAL - or twice those for 50Mbps) */
1123
static int dvvideo_decode_frame(AVCodecContext *avctx,
1124
                                 void *data, int *data_size,
1125
                                 AVPacket *avpkt)
1126
{
1127
    const uint8_t *buf = avpkt->data;
1128
    int buf_size = avpkt->size;
1129
    DVVideoContext *s = avctx->priv_data;
1130

    
1131
    s->sys = dv_frame_profile(s->sys, buf, buf_size);
1132
    if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
1133
        av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
1134
        return -1; /* NOTE: we only accept several full frames */
1135
    }
1136

    
1137
    if (s->picture.data[0])
1138
        avctx->release_buffer(avctx, &s->picture);
1139

    
1140
    s->picture.reference = 0;
1141
    s->picture.key_frame = 1;
1142
    s->picture.pict_type = FF_I_TYPE;
1143
    avctx->pix_fmt   = s->sys->pix_fmt;
1144
    avctx->time_base = s->sys->time_base;
1145
    avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1146
    if (avctx->get_buffer(avctx, &s->picture) < 0) {
1147
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1148
        return -1;
1149
    }
1150
    s->picture.interlaced_frame = 1;
1151
    s->picture.top_field_first  = 0;
1152

    
1153
    s->buf = buf;
1154
    avctx->execute(avctx, dv_decode_video_segment, s->sys->work_chunks, NULL,
1155
                   dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1156

    
1157
    emms_c();
1158

    
1159
    /* return image */
1160
    *data_size = sizeof(AVFrame);
1161
    *(AVFrame*)data = s->picture;
1162

    
1163
    return s->sys->frame_size;
1164
}
1165
#endif /* CONFIG_DVVIDEO_DECODER */
1166

    
1167

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

    
1191
    uint8_t aspect = 0;
1192
    if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
1193
        aspect = 0x02;
1194

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

    
1240
#if CONFIG_DVVIDEO_ENCODER
1241
static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1242
{
1243
    int chan, i, j, k;
1244

    
1245
    for (chan = 0; chan < c->sys->n_difchan; chan++) {
1246
        for (i = 0; i < c->sys->difseg_size; i++) {
1247
            memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1248

    
1249
            /* DV header: 1DIF */
1250
            buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1251
            buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1252
            buf += 72; /* unused bytes */
1253

    
1254
            /* DV subcode: 2DIFs */
1255
            for (j = 0; j < 2; j++) {
1256
                buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1257
                for (k = 0; k < 6; k++)
1258
                     buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1259
                buf += 29; /* unused bytes */
1260
            }
1261

    
1262
            /* DV VAUX: 3DIFS */
1263
            for (j = 0; j < 3; j++) {
1264
                buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1265
                buf += dv_write_pack(dv_video_source,  c, buf);
1266
                buf += dv_write_pack(dv_video_control, c, buf);
1267
                buf += 7*5;
1268
                buf += dv_write_pack(dv_video_source,  c, buf);
1269
                buf += dv_write_pack(dv_video_control, c, buf);
1270
                buf += 4*5 + 2; /* unused bytes */
1271
            }
1272

    
1273
            /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1274
            for (j = 0; j < 135; j++) {
1275
                if (j%15 == 0) {
1276
                    memset(buf, 0xff, 80);
1277
                    buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1278
                    buf += 77; /* audio control & shuffled PCM audio */
1279
                }
1280
                buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1281
                buf += 77; /* 1 video macroblock: 1 bytes control
1282
                              4 * 14 bytes Y 8x8 data
1283
                              10 bytes Cr 8x8 data
1284
                              10 bytes Cb 8x8 data */
1285
            }
1286
        }
1287
    }
1288
}
1289

    
1290

    
1291
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1292
                                void *data)
1293
{
1294
    DVVideoContext *s = c->priv_data;
1295

    
1296
    s->sys = dv_codec_profile(c);
1297
    if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1298
        return -1;
1299

    
1300
    c->pix_fmt           = s->sys->pix_fmt;
1301
    s->picture           = *((AVFrame *)data);
1302
    s->picture.key_frame = 1;
1303
    s->picture.pict_type = FF_I_TYPE;
1304

    
1305
    s->buf = buf;
1306
    c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1307
               dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1308

    
1309
    emms_c();
1310

    
1311
    dv_format_frame(s, buf);
1312

    
1313
    return s->sys->frame_size;
1314
}
1315
#endif
1316

    
1317
static int dvvideo_close(AVCodecContext *c)
1318
{
1319
    DVVideoContext *s = c->priv_data;
1320

    
1321
    if (s->picture.data[0])
1322
        c->release_buffer(c, &s->picture);
1323

    
1324
    return 0;
1325
}
1326

    
1327

    
1328
#if CONFIG_DVVIDEO_ENCODER
1329
AVCodec dvvideo_encoder = {
1330
    "dvvideo",
1331
    CODEC_TYPE_VIDEO,
1332
    CODEC_ID_DVVIDEO,
1333
    sizeof(DVVideoContext),
1334
    dvvideo_init,
1335
    dvvideo_encode_frame,
1336
    .pix_fmts  = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1337
    .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1338
};
1339
#endif // CONFIG_DVVIDEO_ENCODER
1340

    
1341
#if CONFIG_DVVIDEO_DECODER
1342
AVCodec dvvideo_decoder = {
1343
    "dvvideo",
1344
    CODEC_TYPE_VIDEO,
1345
    CODEC_ID_DVVIDEO,
1346
    sizeof(DVVideoContext),
1347
    dvvideo_init,
1348
    NULL,
1349
    dvvideo_close,
1350
    dvvideo_decode_frame,
1351
    CODEC_CAP_DR1,
1352
    NULL,
1353
    .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1354
};
1355
#endif