Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ 5c2a9dd6

History | View | Annotate | Download (48.3 KB)

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

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

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

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

    
56
    uint8_t  dv_zigzag[2][64];
57

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

    
63
#define TEX_VLC_BITS 9
64

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
264
    return 0;
265
}
266

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

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

    
281
        done = 1;
282

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

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

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

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

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

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

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

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

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

    
369
    /* Generic DSP setup */
370
    dsputil_init(&dsp, avctx);
371
    s->get_pixels = dsp.get_pixels;
372

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

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

    
390
    avctx->coded_frame = &s->picture;
391
    s->avctx = avctx;
392

    
393
    return 0;
394
}
395

    
396
// #define VLC_DEBUG
397
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
398

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

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

    
414
static inline int get_bits_left(GetBitContext *s)
415
{
416
    return s->size_in_bits - get_bits_count(s);
417
}
418

    
419
static inline int put_bits_left(PutBitContext* s)
420
{
421
    return (s->buf_end - s->buf) * 8 - put_bits_count(s);
422
}
423

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

    
434
    OPEN_READER(re, gb);
435
    UPDATE_CACHE(re, gb);
436

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

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

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

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

    
477
        level = (level * factor_table[pos] + (1 << (dv_iweight_bits - 1))) >> dv_iweight_bits;
478
        block[scan_table[pos]] = level;
479

    
480
        UPDATE_CACHE(re, gb);
481
    }
482
    CLOSE_READER(re, gb);
483
    mb->pos = pos;
484
}
485

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

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

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

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

    
529
    assert((((int)mb_bit_buffer) & 7) == 0);
530
    assert((((int)vs_bit_buffer) & 7) == 0);
531

    
532
    memset(sblock, 0, sizeof(sblock));
533

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

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

    
575
#ifdef VLC_DEBUG
576
            printf("MB block: %d, %d ", mb_index, j);
577
#endif
578
            dv_decode_ac(&gb, mb, block);
579

    
580
            /* write the remaining bits  in a new buffer only if the
581
               block is finished */
582
            if (mb->pos >= 64)
583
                bit_copy(&pb, &gb);
584

    
585
            block += 64;
586
            mb++;
587
        }
588

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

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

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

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

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

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

    
719
    return size;
720
}
721

    
722
static av_always_inline int dv_rl2vlc_size(int run, int level)
723
{
724
    int size;
725

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

    
744
static av_always_inline int dv_rl2vlc_size(int run, int l)
745
{
746
    return dv_vlc_map[run][l].size;
747
}
748
#endif
749

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

    
764
static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi,
765
                                                    PutBitContext* pb_pool,
766
                                                    PutBitContext* pb_end)
767
{
768
    int prev, bits_left;
769
    PutBitContext* pb = pb_pool;
770
    int size = bi->partial_bit_count;
771
    uint32_t vlc = bi->partial_bit_buffer;
772

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

    
789
       /* Store VLC */
790
       put_bits(pb, size, vlc);
791

    
792
       if (bi->cur_ac >= 64)
793
           break;
794

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

    
807
//FIXME replace this by dsputil
808
#define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
809
static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
810
    DCTELEM *s;
811
    int score88  = 0;
812
    int score248 = 0;
813
    int i;
814

    
815
    /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
816
    s = blk;
817
    for (i = 0; i < 7; i++) {
818
        score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
819
                   SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
820
        s += 8;
821
    }
822
    /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
823
    s = blk;
824
    for (i = 0; i < 6; i++) {
825
        score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
826
                    SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
827
        s += 8;
828
    }
829

    
830
    return (score88 - score248 > -10);
831
}
832

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

    
848
#if 0 /* SMPTE spec method */
849
    static const int classes[] = {12, 24, 36, 0xffff};
850
#else /* improved FFmpeg method */
851
    static const int classes[] = {-1, -1, 255, 0xffff};
852
#endif
853
    int max  = classes[0];
854
    int prev = 0;
855

    
856
    bi->mb[0] = blk[0];
857

    
858
    for (area = 0; area < 4; area++) {
859
       bi->prev[area]     = prev;
860
       bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
861
       for (i = mb_area_start[area]; i < mb_area_start[area+1]; i++) {
862
          int level = blk[zigzag_scan[i]];
863

    
864
          if (level + 15 > 30U) {
865
              bi->sign[i] = (level >> 31) & 1;
866
              /* weigh it and and shift down into range, adding for rounding */
867
              /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
868
                 AND the 2x doubling of the weights */
869
              level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
870
              bi->mb[i] = level;
871
              if (level > max)
872
                  max = level;
873
              bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
874
              bi->next[prev]= i;
875
              prev = i;
876
          }
877
       }
878
    }
879
    bi->next[prev]= i;
880
    for (bi->cno = 0; max > classes[bi->cno]; bi->cno++);
881

    
882
    bi->cno += bias;
883

    
884
    if (bi->cno >= 3) {
885
        bi->cno = 3;
886
        prev    = 0;
887
        i       = bi->next[prev];
888
        for (area = 0; area < 4; area++) {
889
            bi->prev[area]     = prev;
890
            bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
891
            for (; i < mb_area_start[area+1]; i = bi->next[i]) {
892
                bi->mb[i] >>= 1;
893

    
894
                if (bi->mb[i]) {
895
                    bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
896
                    bi->next[prev]= i;
897
                    prev = i;
898
                }
899
            }
900
        }
901
        bi->next[prev]= i;
902
    }
903
}
904

    
905
static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
906
{
907
    int size[5];
908
    int i, j, k, a, prev, a2;
909
    EncBlockInfo* b;
910

    
911
    size[0] = size[1] = size[2] = size[3] = size[4] = 1 << 24;
912
    do {
913
       b = blks;
914
       for (i = 0; i < 5; i++) {
915
          if (!qnos[i])
916
              continue;
917

    
918
          qnos[i]--;
919
          size[i] = 0;
920
          for (j = 0; j < 6; j++, b++) {
921
             for (a = 0; a < 4; a++) {
922
                if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
923
                    b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
924
                    b->area_q[a]++;
925
                    prev = b->prev[a];
926
                    assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
927
                    for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
928
                       b->mb[k] >>= 1;
929
                       if (b->mb[k]) {
930
                           b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
931
                           prev = k;
932
                       } else {
933
                           if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
934
                                for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
935
                                    b->prev[a2] = prev;
936
                                assert(a2 < 4);
937
                                assert(b->mb[b->next[k]]);
938
                                b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
939
                                                  -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
940
                                assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
941
                                b->prev[a2] = prev;
942
                           }
943
                           b->next[prev] = b->next[k];
944
                       }
945
                    }
946
                    b->prev[a+1]= prev;
947
                }
948
                size[i] += b->bit_size[a];
949
             }
950
          }
951
          if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
952
                return;
953
       }
954
    } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
955

    
956

    
957
    for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a){
958
        b = blks;
959
        size[0] = 5 * 6 * 4; //EOB
960
        for (j = 0; j < 6 *5; j++, b++) {
961
            prev = b->prev[0];
962
            for (k = b->next[prev]; k < 64; k = b->next[k]) {
963
                if (b->mb[k] < a && b->mb[k] > -a){
964
                    b->next[prev] = b->next[k];
965
                }else{
966
                    size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
967
                    prev = k;
968
                }
969
            }
970
        }
971
    }
972
}
973

    
974
static int dv_encode_video_segment(AVCodecContext *avctx, DVwork_chunk *work_chunk)
975
{
976
    DVVideoContext *s = avctx->priv_data;
977
    int mb_index, i, j;
978
    int mb_x, mb_y, c_offset, linesize;
979
    uint8_t*  y_ptr;
980
    uint8_t*  data;
981
    uint8_t*  ptr;
982
    uint8_t*  dif;
983
    int       do_edge_wrap;
984
    DECLARE_ALIGNED_16(DCTELEM, block[64]);
985
    EncBlockInfo  enc_blks[5*DV_MAX_BPM];
986
    PutBitContext pbs[5*DV_MAX_BPM];
987
    PutBitContext* pb;
988
    EncBlockInfo* enc_blk;
989
    int       vs_bit_size = 0;
990
    int       qnos[5];
991

    
992
    assert((((int)block) & 15) == 0);
993

    
994
    dif = &s->buf[work_chunk->buf_offset*80];
995
    enc_blk = &enc_blks[0];
996
    pb = &pbs[0];
997
    for (mb_index = 0; mb_index < 5; mb_index++) {
998
        dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
999
        y_ptr    = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x) << 3);
1000
        c_offset = (((mb_y >>  (s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
1001
                     (mb_x >> ((s->sys->pix_fmt == PIX_FMT_YUV411P) ? 2 : 1))) << 3);
1002
        do_edge_wrap   = 0;
1003
        qnos[mb_index] = 15; /* No quantization */
1004
        ptr = dif + mb_index*80 + 4;
1005
        for (j = 0; j < 6; j++) {
1006
            int dummy = 0;
1007
            if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
1008
                if (j == 0 || j == 2) {
1009
                    /* Y0 Y1 */
1010
                    data     = y_ptr + ((j >> 1) * 8);
1011
                    linesize = s->picture.linesize[0];
1012
                } else if (j > 3) {
1013
                    /* Cr Cb */
1014
                    data     = s->picture.data[6 - j] + c_offset;
1015
                    linesize = s->picture.linesize[6 - j];
1016
                } else {
1017
                    /* j=1 and j=3 are "dummy" blocks, used for AC data only */
1018
                    data     = NULL;
1019
                    linesize = 0;
1020
                    dummy    = 1;
1021
                }
1022
            } else { /* 4:1:1 or 4:2:0 */
1023
                if (j < 4) {  /* Four Y blocks */
1024
                    /* NOTE: at end of line, the macroblock is handled as 420 */
1025
                    if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
1026
                        data = y_ptr + (j * 8);
1027
                    } else {
1028
                        data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
1029
                    }
1030
                    linesize = s->picture.linesize[0];
1031
                } else {      /* Cr and Cb blocks */
1032
                    /* don't ask Fabrice why they inverted Cb and Cr ! */
1033
                    data     = s->picture.data    [6 - j] + c_offset;
1034
                    linesize = s->picture.linesize[6 - j];
1035
                    if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
1036
                        do_edge_wrap = 1;
1037
                }
1038
            }
1039

    
1040
            /* Everything is set up -- now just copy data -> DCT block */
1041
            if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
1042
                uint8_t* d;
1043
                DCTELEM *b = block;
1044
                for (i = 0; i < 8; i++) {
1045
                   d = data + 8 * linesize;
1046
                   b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
1047
                   b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
1048
                   data += linesize;
1049
                   b += 8;
1050
                }
1051
            } else {             /* Simple copy: 8x8 -> 8x8 */
1052
                if (!dummy)
1053
                    s->get_pixels(block, data, linesize);
1054
            }
1055

    
1056
            if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
1057
                enc_blk->dct_mode = dv_guess_dct_mode(block);
1058
            else
1059
                enc_blk->dct_mode = 0;
1060
            enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
1061
            enc_blk->partial_bit_count = 0;
1062
            enc_blk->partial_bit_buffer = 0;
1063
            enc_blk->cur_ac = 0;
1064

    
1065
            if (dummy) {
1066
                /* We rely on the fact that encoding all zeros leads to an immediate EOB,
1067
                   which is precisely what the spec calls for in the "dummy" blocks. */
1068
                memset(block, 0, sizeof(block));
1069
            } else {
1070
                s->fdct[enc_blk->dct_mode](block);
1071
            }
1072

    
1073
            dv_set_class_number(block, enc_blk,
1074
                                enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
1075
                                enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
1076
                                j/4);
1077

    
1078
            init_put_bits(pb, ptr, s->sys->block_sizes[j]/8);
1079
            put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
1080
            put_bits(pb, 1, enc_blk->dct_mode);
1081
            put_bits(pb, 2, enc_blk->cno);
1082

    
1083
            vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
1084
                           enc_blk->bit_size[2] + enc_blk->bit_size[3];
1085
            ++enc_blk;
1086
            ++pb;
1087
            ptr += s->sys->block_sizes[j]/8;
1088
        }
1089
    }
1090

    
1091
    if (vs_total_ac_bits < vs_bit_size)
1092
        dv_guess_qnos(&enc_blks[0], &qnos[0]);
1093

    
1094
    for (i = 0; i < 5; i++) {
1095
       dif[i*80 + 3] = qnos[i];
1096
    }
1097

    
1098
    /* First pass over individual cells only */
1099
    for (j = 0; j < 5 * s->sys->bpm; j++)
1100
       dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
1101

    
1102
    /* Second pass over each MB space */
1103
    for (j=0; j<5*s->sys->bpm; j+=s->sys->bpm) {
1104
        pb = &pbs[j];
1105
        for (i=0; i<s->sys->bpm; i++) {
1106
            if (enc_blks[i+j].partial_bit_count)
1107
                pb = dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+s->sys->bpm]);
1108
        }
1109
    }
1110

    
1111
    /* Third and final pass over the whole video segment space */
1112
    pb = &pbs[0];
1113
    for (j=0; j<5*s->sys->bpm; j++) {
1114
       if (enc_blks[j].partial_bit_count)
1115
           pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
1116
       if (enc_blks[j].partial_bit_count)
1117
            av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
1118
    }
1119

    
1120
    for (j=0; j<5*s->sys->bpm; j++)
1121
       flush_put_bits(&pbs[j]);
1122

    
1123
    return 0;
1124
}
1125

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

    
1135
    s->sys = dv_frame_profile(buf);
1136
    if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1137
        return -1; /* NOTE: we only accept several full frames */
1138

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

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

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

    
1159
    emms_c();
1160

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

    
1165
    return s->sys->frame_size;
1166
}
1167
#endif /* CONFIG_DVVIDEO_DECODER */
1168

    
1169

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

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

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

    
1243
#if CONFIG_DVVIDEO_ENCODER
1244
static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1245
{
1246
    int chan, i, j, k;
1247

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

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

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

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

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

    
1293

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

    
1299
    s->sys = dv_codec_profile(c);
1300
    if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
1301
        return -1;
1302

    
1303
    c->pix_fmt           = s->sys->pix_fmt;
1304
    s->picture           = *((AVFrame *)data);
1305
    s->picture.key_frame = 1;
1306
    s->picture.pict_type = FF_I_TYPE;
1307

    
1308
    s->buf = buf;
1309
    c->execute(c, dv_encode_video_segment, s->sys->work_chunks, NULL,
1310
               dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1311

    
1312
    emms_c();
1313

    
1314
    dv_format_frame(s, buf);
1315

    
1316
    return s->sys->frame_size;
1317
}
1318
#endif
1319

    
1320
static int dvvideo_close(AVCodecContext *c)
1321
{
1322
    DVVideoContext *s = c->priv_data;
1323

    
1324
    if (s->picture.data[0])
1325
        c->release_buffer(c, &s->picture);
1326

    
1327
    return 0;
1328
}
1329

    
1330

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

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