Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ ce83d2bd

History | View | Annotate | Download (47.6 KB)

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

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

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

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

    
56
    uint8_t  dv_zigzag[2][64];
57

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

    
64
#define TEX_VLC_BITS 9
65

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
265
    return 0;
266
}
267

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

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

    
282
        done = 1;
283

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

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

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

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

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

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

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

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

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

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

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

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

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

    
396
    return 0;
397
}
398

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
723
    return size;
724
}
725

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

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

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

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

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

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

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

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

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

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

    
821
    return 0;
822
}
823

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

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

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

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

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

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

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

    
893
    bi->cno += bias;
894

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

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

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

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

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

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

    
969

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1106
    return 0;
1107
}
1108

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

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

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

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

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

    
1142
    emms_c();
1143

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

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

    
1152

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

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

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

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

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

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

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

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

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

    
1275

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

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

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

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

    
1294
    emms_c();
1295

    
1296
    dv_format_frame(s, buf);
1297

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

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

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

    
1309
    return 0;
1310
}
1311

    
1312

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

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