Statistics
| Branch: | Revision:

ffmpeg / libavcodec / dv.c @ d2d230a7

History | View | Annotate | Download (32.9 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
 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
10
 * of DV technical info.
11
 *
12
 * This library is free software; you can redistribute it and/or
13
 * modify it under the terms of the GNU Lesser General Public
14
 * License as published by the Free Software Foundation; either
15
 * version 2 of the License, or (at your option) any later version.
16
 *
17
 * This library is distributed in the hope that it will be useful,
18
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20
 * Lesser General Public License for more details.
21
 *
22
 * You should have received a copy of the GNU Lesser General Public
23
 * License along with this library; if not, write to the Free Software
24
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25
 */
26

    
27
/**
28
 * @file dv.c
29
 * DV codec.
30
 */
31
#include "avcodec.h"
32
#include "dsputil.h"
33
#include "mpegvideo.h"
34
#include "simple_idct.h"
35
#include "dvdata.h"
36

    
37
//#undef NDEBUG
38
//#include <assert.h>
39

    
40
typedef struct DVVideoContext {
41
    const DVprofile* sys;
42
    AVFrame picture;
43
    AVCodecContext *avctx;
44
    uint8_t *buf;
45

    
46
    uint8_t dv_zigzag[2][64];
47
    uint8_t dv_idct_shift[2][2][22][64];
48

    
49
    void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
50
    void (*fdct[2])(DCTELEM *block);
51
    void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
52
} DVVideoContext;
53

    
54
/* MultiThreading - applies to entire DV codec, not just the avcontext */
55
uint8_t** dv_anchor;
56

    
57
#define TEX_VLC_BITS 9
58

    
59
#ifdef DV_CODEC_TINY_TARGET
60
#define DV_VLC_MAP_RUN_SIZE 15
61
#define DV_VLC_MAP_LEV_SIZE 23
62
#else
63
#define DV_VLC_MAP_RUN_SIZE  64
64
#define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
65
#endif
66

    
67
/* XXX: also include quantization */
68
static RL_VLC_ELEM *dv_rl_vlc;
69
/* VLC encoding lookup table */
70
static struct dv_vlc_pair {
71
   uint32_t vlc;
72
   uint8_t  size;
73
} (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;
74

    
75
static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
76
{
77
    int i, q, j;
78

    
79
    /* NOTE: max left shift is 6 */
80
    for(q = 0; q < 22; q++) {
81
        /* 88DCT */
82
        for(i = 1; i < 64; i++) {
83
            /* 88 table */
84
            j = perm[i];
85
            s->dv_idct_shift[0][0][q][j] =
86
                dv_quant_shifts[q][dv_88_areas[i]] + 1;
87
            s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
88
        }
89

    
90
        /* 248DCT */
91
        for(i = 1; i < 64; i++) {
92
            /* 248 table */
93
            s->dv_idct_shift[0][1][q][i] =
94
                dv_quant_shifts[q][dv_248_areas[i]] + 1;
95
            s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
96
        }
97
    }
98
}
99

    
100
static int dvvideo_init(AVCodecContext *avctx)
101
{
102
    DVVideoContext *s = avctx->priv_data;
103
    DSPContext dsp;
104
    static int done=0;
105
    int i, j;
106

    
107
    if (!done) {
108
        VLC dv_vlc;
109
        uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
110
        uint8_t new_dv_vlc_len[NB_DV_VLC*2];
111
        uint8_t new_dv_vlc_run[NB_DV_VLC*2];
112
        int16_t new_dv_vlc_level[NB_DV_VLC*2];
113

    
114
        done = 1;
115

    
116
        dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
117
        if (!dv_vlc_map)
118
            return -ENOMEM;
119

    
120
        /* dv_anchor lets each thread know its Id */
121
        dv_anchor = av_malloc(12*27*sizeof(void*));
122
        if (!dv_anchor) {
123
            return -ENOMEM;
124
        }
125
        for (i=0; i<12*27; i++)
126
            dv_anchor[i] = (void*)(size_t)i;
127

    
128
        /* it's faster to include sign bit in a generic VLC parsing scheme */
129
        for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
130
            new_dv_vlc_bits[j] = dv_vlc_bits[i];
131
            new_dv_vlc_len[j] = dv_vlc_len[i];
132
            new_dv_vlc_run[j] = dv_vlc_run[i];
133
            new_dv_vlc_level[j] = dv_vlc_level[i];
134

    
135
            if (dv_vlc_level[i]) {
136
                new_dv_vlc_bits[j] <<= 1;
137
                new_dv_vlc_len[j]++;
138

    
139
                j++;
140
                new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
141
                new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
142
                new_dv_vlc_run[j] = dv_vlc_run[i];
143
                new_dv_vlc_level[j] = -dv_vlc_level[i];
144
            }
145
        }
146

    
147
        /* NOTE: as a trick, we use the fact the no codes are unused
148
           to accelerate the parsing of partial codes */
149
        init_vlc(&dv_vlc, TEX_VLC_BITS, j,
150
                 new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
151

    
152
        dv_rl_vlc = av_mallocz_static(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
153
        if (!dv_rl_vlc)
154
            return -ENOMEM;
155

    
156
        for(i = 0; i < dv_vlc.table_size; i++){
157
            int code= dv_vlc.table[i][0];
158
            int len = dv_vlc.table[i][1];
159
            int level, run;
160

    
161
            if(len<0){ //more bits needed
162
                run= 0;
163
                level= code;
164
            } else {
165
                run=   new_dv_vlc_run[code] + 1;
166
                level= new_dv_vlc_level[code];
167
            }
168
            dv_rl_vlc[i].len = len;
169
            dv_rl_vlc[i].level = level;
170
            dv_rl_vlc[i].run = run;
171
        }
172
        free_vlc(&dv_vlc);
173

    
174
        for (i = 0; i < NB_DV_VLC - 1; i++) {
175
           if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
176
               continue;
177
#ifdef DV_CODEC_TINY_TARGET
178
           if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
179
               continue;
180
#endif
181

    
182
           if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
183
               continue;
184

    
185
           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
186
                                                            (!!dv_vlc_level[i]);
187
           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
188
                                                             (!!dv_vlc_level[i]);
189
        }
190
        for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
191
#ifdef DV_CODEC_TINY_TARGET
192
           for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
193
              if (dv_vlc_map[i][j].size == 0) {
194
                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
195
                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
196
                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
197
                                          dv_vlc_map[0][j].size;
198
              }
199
           }
200
#else
201
           for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
202
              if (dv_vlc_map[i][j].size == 0) {
203
                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
204
                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
205
                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
206
                                          dv_vlc_map[0][j].size;
207
              }
208
              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
209
                                            dv_vlc_map[i][j].vlc | 1;
210
              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
211
                                            dv_vlc_map[i][j].size;
212
           }
213
#endif
214
        }
215
    }
216

    
217
    /* Generic DSP setup */
218
    dsputil_init(&dsp, avctx);
219
    s->get_pixels = dsp.get_pixels;
220

    
221
    /* 88DCT setup */
222
    s->fdct[0] = dsp.fdct;
223
    s->idct_put[0] = dsp.idct_put;
224
    for (i=0; i<64; i++)
225
       s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
226

    
227
    /* 248DCT setup */
228
    s->fdct[1] = dsp.fdct248;
229
    s->idct_put[1] = simple_idct248_put;  // FIXME: need to add it to DSP
230
    if(avctx->lowres){
231
        for (i=0; i<64; i++){
232
            int j= ff_zigzag248_direct[i];
233
            s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
234
        }
235
    }else
236
        memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
237

    
238
    /* XXX: do it only for constant case */
239
    dv_build_unquantize_tables(s, dsp.idct_permutation);
240

    
241
    /* FIXME: I really don't think this should be here */
242
    if (dv_codec_profile(avctx))
243
        avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt;
244
    avctx->coded_frame = &s->picture;
245
    s->avctx= avctx;
246

    
247
    return 0;
248
}
249

    
250
// #define VLC_DEBUG
251
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
252

    
253
typedef struct BlockInfo {
254
    const uint8_t *shift_table;
255
    const uint8_t *scan_table;
256
    uint8_t pos; /* position in block */
257
    uint8_t dct_mode;
258
    uint8_t partial_bit_count;
259
    uint16_t partial_bit_buffer;
260
    int shift_offset;
261
} BlockInfo;
262

    
263
/* block size in bits */
264
static const uint16_t block_sizes[6] = {
265
    112, 112, 112, 112, 80, 80
266
};
267
/* bit budget for AC only in 5 MBs */
268
static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
269
/* see dv_88_areas and dv_248_areas for details */
270
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
271

    
272
#ifndef ALT_BITSTREAM_READER
273
#warning only works with ALT_BITSTREAM_READER
274
static int re_index; //Hack to make it compile
275
#endif
276

    
277
static inline int get_bits_left(GetBitContext *s)
278
{
279
    return s->size_in_bits - get_bits_count(s);
280
}
281

    
282
static inline int get_bits_size(GetBitContext *s)
283
{
284
    return s->size_in_bits;
285
}
286

    
287
static inline int put_bits_left(PutBitContext* s)
288
{
289
    return (s->buf_end - s->buf) * 8 - put_bits_count(s);
290
}
291

    
292
/* decode ac coefs */
293
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
294
{
295
    int last_index = get_bits_size(gb);
296
    const uint8_t *scan_table = mb->scan_table;
297
    const uint8_t *shift_table = mb->shift_table;
298
    int pos = mb->pos;
299
    int partial_bit_count = mb->partial_bit_count;
300
    int level, pos1, run, vlc_len, index;
301

    
302
    OPEN_READER(re, gb);
303
    UPDATE_CACHE(re, gb);
304

    
305
    /* if we must parse a partial vlc, we do it here */
306
    if (partial_bit_count > 0) {
307
        re_cache = ((unsigned)re_cache >> partial_bit_count) |
308
                   (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
309
        re_index -= partial_bit_count;
310
        mb->partial_bit_count = 0;
311
    }
312

    
313
    /* get the AC coefficients until last_index is reached */
314
    for(;;) {
315
#ifdef VLC_DEBUG
316
        printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
317
#endif
318
        /* our own optimized GET_RL_VLC */
319
        index = NEG_USR32(re_cache, TEX_VLC_BITS);
320
        vlc_len = dv_rl_vlc[index].len;
321
        if (vlc_len < 0) {
322
            index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
323
            vlc_len = TEX_VLC_BITS - vlc_len;
324
        }
325
        level = dv_rl_vlc[index].level;
326
        run = dv_rl_vlc[index].run;
327

    
328
        /* gotta check if we're still within gb boundaries */
329
        if (re_index + vlc_len > last_index) {
330
            /* should be < 16 bits otherwise a codeword could have been parsed */
331
            mb->partial_bit_count = last_index - re_index;
332
            mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
333
            re_index = last_index;
334
            break;
335
        }
336
        re_index += vlc_len;
337

    
338
#ifdef VLC_DEBUG
339
        printf("run=%d level=%d\n", run, level);
340
#endif
341
        pos += run;
342
        if (pos >= 64)
343
            break;
344

    
345
        assert(level);
346
        pos1 = scan_table[pos];
347
        block[pos1] = level << shift_table[pos1];
348

    
349
        UPDATE_CACHE(re, gb);
350
    }
351
    CLOSE_READER(re, gb);
352
    mb->pos = pos;
353
}
354

    
355
static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
356
{
357
    int bits_left = get_bits_left(gb);
358
    while (bits_left >= MIN_CACHE_BITS) {
359
        put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
360
        bits_left -= MIN_CACHE_BITS;
361
    }
362
    if (bits_left > 0) {
363
        put_bits(pb, bits_left, get_bits(gb, bits_left));
364
    }
365
}
366

    
367
/* mb_x and mb_y are in units of 8 pixels */
368
static inline void dv_decode_video_segment(DVVideoContext *s,
369
                                           uint8_t *buf_ptr1,
370
                                           const uint16_t *mb_pos_ptr)
371
{
372
    int quant, dc, dct_mode, class1, j;
373
    int mb_index, mb_x, mb_y, v, last_index;
374
    DCTELEM *block, *block1;
375
    int c_offset;
376
    uint8_t *y_ptr;
377
    void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
378
    uint8_t *buf_ptr;
379
    PutBitContext pb, vs_pb;
380
    GetBitContext gb;
381
    BlockInfo mb_data[5 * 6], *mb, *mb1;
382
    DECLARE_ALIGNED_8(DCTELEM, sblock[5*6][64]);
383
    DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
384
    DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
385
    const int log2_blocksize= 3-s->avctx->lowres;
386

    
387
    assert((((int)mb_bit_buffer)&7)==0);
388
    assert((((int)vs_bit_buffer)&7)==0);
389

    
390
    memset(sblock, 0, sizeof(sblock));
391

    
392
    /* pass 1 : read DC and AC coefficients in blocks */
393
    buf_ptr = buf_ptr1;
394
    block1 = &sblock[0][0];
395
    mb1 = mb_data;
396
    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
397
    for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
398
        /* skip header */
399
        quant = buf_ptr[3] & 0x0f;
400
        buf_ptr += 4;
401
        init_put_bits(&pb, mb_bit_buffer, 80);
402
        mb = mb1;
403
        block = block1;
404
        for(j = 0;j < 6; j++) {
405
            last_index = block_sizes[j];
406
            init_get_bits(&gb, buf_ptr, last_index);
407

    
408
            /* get the dc */
409
            dc = get_sbits(&gb, 9);
410
            dct_mode = get_bits1(&gb);
411
            mb->dct_mode = dct_mode;
412
            mb->scan_table = s->dv_zigzag[dct_mode];
413
            class1 = get_bits(&gb, 2);
414
            mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
415
                [quant + dv_quant_offset[class1]];
416
            dc = dc << 2;
417
            /* convert to unsigned because 128 is not added in the
418
               standard IDCT */
419
            dc += 1024;
420
            block[0] = dc;
421
            buf_ptr += last_index >> 3;
422
            mb->pos = 0;
423
            mb->partial_bit_count = 0;
424

    
425
#ifdef VLC_DEBUG
426
            printf("MB block: %d, %d ", mb_index, j);
427
#endif
428
            dv_decode_ac(&gb, mb, block);
429

    
430
            /* write the remaining bits  in a new buffer only if the
431
               block is finished */
432
            if (mb->pos >= 64)
433
                bit_copy(&pb, &gb);
434

    
435
            block += 64;
436
            mb++;
437
        }
438

    
439
        /* pass 2 : we can do it just after */
440
#ifdef VLC_DEBUG
441
        printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
442
#endif
443
        block = block1;
444
        mb = mb1;
445
        init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
446
        flush_put_bits(&pb);
447
        for(j = 0;j < 6; j++, block += 64, mb++) {
448
            if (mb->pos < 64 && get_bits_left(&gb) > 0) {
449
                dv_decode_ac(&gb, mb, block);
450
                /* if still not finished, no need to parse other blocks */
451
                if (mb->pos < 64)
452
                    break;
453
            }
454
        }
455
        /* all blocks are finished, so the extra bytes can be used at
456
           the video segment level */
457
        if (j >= 6)
458
            bit_copy(&vs_pb, &gb);
459
    }
460

    
461
    /* we need a pass other the whole video segment */
462
#ifdef VLC_DEBUG
463
    printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
464
#endif
465
    block = &sblock[0][0];
466
    mb = mb_data;
467
    init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
468
    flush_put_bits(&vs_pb);
469
    for(mb_index = 0; mb_index < 5; mb_index++) {
470
        for(j = 0;j < 6; j++) {
471
            if (mb->pos < 64) {
472
#ifdef VLC_DEBUG
473
                printf("start %d:%d\n", mb_index, j);
474
#endif
475
                dv_decode_ac(&gb, mb, block);
476
            }
477
            if (mb->pos >= 64 && mb->pos < 127)
478
                av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
479
            block += 64;
480
            mb++;
481
        }
482
    }
483

    
484
    /* compute idct and place blocks */
485
    block = &sblock[0][0];
486
    mb = mb_data;
487
    for(mb_index = 0; mb_index < 5; mb_index++) {
488
        v = *mb_pos_ptr++;
489
        mb_x = v & 0xff;
490
        mb_y = v >> 8;
491
        y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
492
        if (s->sys->pix_fmt == PIX_FMT_YUV411P)
493
            c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
494
        else
495
            c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);
496
        for(j = 0;j < 6; j++) {
497
            idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
498
            if (j < 4) {
499
                if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
500
                    /* NOTE: at end of line, the macroblock is handled as 420 */
501
                    idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
502
                } else {
503
                    idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
504
                             s->picture.linesize[0], block);
505
                }
506
            } else {
507
                if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
508
                    uint64_t aligned_pixels[64/8];
509
                    uint8_t *pixels= (uint8_t*)aligned_pixels;
510
                    uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
511
                    int x, y, linesize;
512
                    /* NOTE: at end of line, the macroblock is handled as 420 */
513
                    idct_put(pixels, 8, block);
514
                    linesize = s->picture.linesize[6 - j];
515
                    c_ptr = s->picture.data[6 - j] + c_offset;
516
                    ptr = pixels;
517
                    for(y = 0;y < (1<<log2_blocksize); y++) {
518
                        ptr1= ptr + (1<<(log2_blocksize-1));
519
                        c_ptr1 = c_ptr + (linesize<<log2_blocksize);
520
                        for(x=0; x < (1<<(log2_blocksize-1)); x++){
521
                            c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
522
                        }
523
                        c_ptr += linesize;
524
                        ptr += 8;
525
                    }
526
                } else {
527
                    /* don't ask me why they inverted Cb and Cr ! */
528
                    idct_put(s->picture.data[6 - j] + c_offset,
529
                             s->picture.linesize[6 - j], block);
530
                }
531
            }
532
            block += 64;
533
            mb++;
534
        }
535
    }
536
}
537

    
538
#ifdef DV_CODEC_TINY_TARGET
539
/* Converts run and level (where level != 0) pair into vlc, returning bit size */
540
static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
541
{
542
    int size;
543
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
544
        *vlc = dv_vlc_map[run][level].vlc | sign;
545
        size = dv_vlc_map[run][level].size;
546
    }
547
    else {
548
        if (level < DV_VLC_MAP_LEV_SIZE) {
549
            *vlc = dv_vlc_map[0][level].vlc | sign;
550
            size = dv_vlc_map[0][level].size;
551
        } else {
552
            *vlc = 0xfe00 | (level << 1) | sign;
553
            size = 16;
554
        }
555
        if (run) {
556
            *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
557
                                  (0x1f80 | (run - 1))) << size;
558
            size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
559
        }
560
    }
561

    
562
    return size;
563
}
564

    
565
static always_inline int dv_rl2vlc_size(int run, int level)
566
{
567
    int size;
568

    
569
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
570
        size = dv_vlc_map[run][level].size;
571
    }
572
    else {
573
        size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
574
        if (run) {
575
            size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
576
        }
577
    }
578
    return size;
579
}
580
#else
581
static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
582
{
583
    *vlc = dv_vlc_map[run][l].vlc | sign;
584
    return dv_vlc_map[run][l].size;
585
}
586

    
587
static always_inline int dv_rl2vlc_size(int run, int l)
588
{
589
    return dv_vlc_map[run][l].size;
590
}
591
#endif
592

    
593
typedef struct EncBlockInfo {
594
    int area_q[4];
595
    int bit_size[4];
596
    int prev[5];
597
    int cur_ac;
598
    int cno;
599
    int dct_mode;
600
    DCTELEM mb[64];
601
    uint8_t next[64];
602
    uint8_t sign[64];
603
    uint8_t partial_bit_count;
604
    uint32_t partial_bit_buffer; /* we can't use uint16_t here */
605
} EncBlockInfo;
606

    
607
static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
608
                                       PutBitContext* pb_end)
609
{
610
    int prev;
611
    int bits_left;
612
    PutBitContext* pb = pb_pool;
613
    int size = bi->partial_bit_count;
614
    uint32_t vlc = bi->partial_bit_buffer;
615

    
616
    bi->partial_bit_count = bi->partial_bit_buffer = 0;
617
    for(;;){
618
       /* Find suitable storage space */
619
       for (; size > (bits_left = put_bits_left(pb)); pb++) {
620
          if (bits_left) {
621
              size -= bits_left;
622
              put_bits(pb, bits_left, vlc >> size);
623
              vlc = vlc & ((1<<size)-1);
624
          }
625
          if (pb + 1 >= pb_end) {
626
              bi->partial_bit_count = size;
627
              bi->partial_bit_buffer = vlc;
628
              return pb;
629
          }
630
       }
631

    
632
       /* Store VLC */
633
       put_bits(pb, size, vlc);
634

    
635
       if(bi->cur_ac>=64)
636
           break;
637

    
638
       /* Construct the next VLC */
639
       prev= bi->cur_ac;
640
       bi->cur_ac = bi->next[prev];
641
       if(bi->cur_ac < 64){
642
           size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
643
       } else {
644
           size = 4; vlc = 6; /* End Of Block stamp */
645
       }
646
    }
647
    return pb;
648
}
649

    
650
static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
651
                                              const uint8_t* zigzag_scan, int bias)
652
{
653
    int i, area;
654
    static const int classes[] = {12, 24, 36, 0xffff};
655
    int max=12;
656
    int prev=0;
657

    
658
    bi->mb[0] = blk[0];
659

    
660
    for (area = 0; area < 4; area++) {
661
       bi->prev[area] = prev;
662
       bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
663
       for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
664
          int level = blk[zigzag_scan[i]];
665

    
666
          if (level+15 > 30U) {
667
              bi->sign[i] = (level>>31)&1;
668
              bi->mb[i] = level= ABS(level)>>4;
669
              if(level>max) max= level;
670
              bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
671
              bi->next[prev]= i;
672
              prev= i;
673
          }
674
       }
675
    }
676
    bi->next[prev]= i;
677
    for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
678

    
679
    bi->cno += bias;
680

    
681
    if (bi->cno >= 3) {
682
        bi->cno = 3;
683
        prev=0;
684
        i= bi->next[prev];
685
        for (area = 0; area < 4; area++) {
686
            bi->prev[area] = prev;
687
            bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
688
            for (; i<mb_area_start[area+1]; i= bi->next[i]) {
689
                bi->mb[i] >>=1;
690

    
691
                if (bi->mb[i]) {
692
                    bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
693
                    bi->next[prev]= i;
694
                    prev= i;
695
                }
696
            }
697
        }
698
        bi->next[prev]= i;
699
    }
700
}
701

    
702
//FIXME replace this by dsputil
703
#define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
704
static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
705
    DCTELEM *s;
706
    int score88 = 0;
707
    int score248 = 0;
708
    int i;
709

    
710
    /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
711
    s = blk;
712
    for(i=0; i<7; i++) {
713
        score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
714
                   SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
715
        s += 8;
716
    }
717
    /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
718
    s = blk;
719
    for(i=0; i<6; i++) {
720
        score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
721
                    SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
722
        s += 8;
723
    }
724

    
725
    return (score88 - score248 > -10);
726
}
727

    
728
static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
729
{
730
    int size[5];
731
    int i, j, k, a, prev, a2;
732
    EncBlockInfo* b;
733

    
734
    do {
735
       b = blks;
736
       for (i=0; i<5; i++) {
737
          if (!qnos[i])
738
              continue;
739

    
740
          qnos[i]--;
741
          size[i] = 0;
742
          for (j=0; j<6; j++, b++) {
743
             for (a=0; a<4; a++) {
744
                if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
745
                    b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
746
                    b->area_q[a]++;
747
                    prev= b->prev[a];
748
                    for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
749
                       b->mb[k] >>= 1;
750
                       if (b->mb[k]) {
751
                           b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
752
                           prev= k;
753
                       } else {
754
                           if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
755
                                for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++);
756
                                assert(a2<4);
757
                                assert(b->mb[b->next[k]]);
758
                                b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
759
                                                  -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
760
                           }
761
                           b->next[prev] = b->next[k];
762
                       }
763
                    }
764
                    b->prev[a+1]= prev;
765
                }
766
                size[i] += b->bit_size[a];
767
             }
768
          }
769
       }
770
       if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
771
            return;
772
    } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
773

    
774

    
775
    for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
776
        b = blks;
777
        size[0] = 0;
778
        for (j=0; j<6*5; j++, b++) {
779
            prev= b->prev[0];
780
            for (k= b->next[prev]; k<64; k= b->next[k]) {
781
                if(b->mb[k] < a && b->mb[k] > -a){
782
                    b->next[prev] = b->next[k];
783
                }else{
784
                    size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
785
                    prev= k;
786
                }
787
            }
788
        }
789
    }
790
}
791

    
792
/*
793
 * This is a very rough initial implementaion. The performance is
794
 * horrible and the weighting is missing. But it's missing from the
795
 * decoding step also -- so at least we're on the same page with decoder ;-)
796
 */
797
static inline void dv_encode_video_segment(DVVideoContext *s,
798
                                           uint8_t *dif,
799
                                           const uint16_t *mb_pos_ptr)
800
{
801
    int mb_index, i, j, v;
802
    int mb_x, mb_y, c_offset, linesize;
803
    uint8_t*  y_ptr;
804
    uint8_t*  data;
805
    uint8_t*  ptr;
806
    int       do_edge_wrap;
807
    DECLARE_ALIGNED_8(DCTELEM, block[64]);
808
    EncBlockInfo  enc_blks[5*6];
809
    PutBitContext pbs[5*6];
810
    PutBitContext* pb;
811
    EncBlockInfo* enc_blk;
812
    int       vs_bit_size = 0;
813
    int       qnos[5];
814

    
815
    assert((((int)block) & 7) == 0);
816

    
817
    enc_blk = &enc_blks[0];
818
    pb = &pbs[0];
819
    for(mb_index = 0; mb_index < 5; mb_index++) {
820
        v = *mb_pos_ptr++;
821
        mb_x = v & 0xff;
822
        mb_y = v >> 8;
823
        y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
824
        c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ?
825
                   ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) :
826
                   (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
827
        do_edge_wrap = 0;
828
        qnos[mb_index] = 15; /* No quantization */
829
        ptr = dif + mb_index*80 + 4;
830
        for(j = 0;j < 6; j++) {
831
            if (j < 4) {  /* Four Y blocks */
832
                /* NOTE: at end of line, the macroblock is handled as 420 */
833
                if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
834
                    data = y_ptr + (j * 8);
835
                } else {
836
                    data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
837
                }
838
                linesize = s->picture.linesize[0];
839
            } else {      /* Cr and Cb blocks */
840
                /* don't ask Fabrice why they inverted Cb and Cr ! */
841
                data = s->picture.data[6 - j] + c_offset;
842
                linesize = s->picture.linesize[6 - j];
843
                if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
844
                    do_edge_wrap = 1;
845
            }
846

    
847
            /* Everything is set up -- now just copy data -> DCT block */
848
            if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
849
                uint8_t* d;
850
                DCTELEM *b = block;
851
                for (i=0;i<8;i++) {
852
                   d = data + 8 * linesize;
853
                   b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
854
                   b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
855
                   data += linesize;
856
                   b += 8;
857
                }
858
            } else {             /* Simple copy: 8x8 -> 8x8 */
859
                s->get_pixels(block, data, linesize);
860
            }
861

    
862
            if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
863
                enc_blk->dct_mode = dv_guess_dct_mode(block);
864
            else
865
                enc_blk->dct_mode = 0;
866
            enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
867
            enc_blk->partial_bit_count = 0;
868
            enc_blk->partial_bit_buffer = 0;
869
            enc_blk->cur_ac = 0;
870

    
871
            s->fdct[enc_blk->dct_mode](block);
872

    
873
            dv_set_class_number(block, enc_blk,
874
                                enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4);
875

    
876
            init_put_bits(pb, ptr, block_sizes[j]/8);
877
            put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
878
            put_bits(pb, 1, enc_blk->dct_mode);
879
            put_bits(pb, 2, enc_blk->cno);
880

    
881
            vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
882
                           enc_blk->bit_size[2] + enc_blk->bit_size[3];
883
            ++enc_blk;
884
            ++pb;
885
            ptr += block_sizes[j]/8;
886
        }
887
    }
888

    
889
    if (vs_total_ac_bits < vs_bit_size)
890
        dv_guess_qnos(&enc_blks[0], &qnos[0]);
891

    
892
    for (i=0; i<5; i++) {
893
       dif[i*80 + 3] = qnos[i];
894
    }
895

    
896
    /* First pass over individual cells only */
897
    for (j=0; j<5*6; j++)
898
       dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
899

    
900
    /* Second pass over each MB space */
901
    for (j=0; j<5*6; j+=6) {
902
        pb= &pbs[j];
903
        for (i=0; i<6; i++) {
904
            if (enc_blks[i+j].partial_bit_count)
905
                pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
906
        }
907
    }
908

    
909
    /* Third and final pass over the whole vides segment space */
910
    pb= &pbs[0];
911
    for (j=0; j<5*6; j++) {
912
       if (enc_blks[j].partial_bit_count)
913
           pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
914
       if (enc_blks[j].partial_bit_count)
915
            av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
916
    }
917

    
918
    for (j=0; j<5*6; j++)
919
       flush_put_bits(&pbs[j]);
920
}
921

    
922
static int dv_decode_mt(AVCodecContext *avctx, void* sl)
923
{
924
    DVVideoContext *s = avctx->priv_data;
925
    int slice = (size_t)sl;
926
    dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
927
                            &s->sys->video_place[slice*5]);
928
    return 0;
929
}
930

    
931
static int dv_encode_mt(AVCodecContext *avctx, void* sl)
932
{
933
    DVVideoContext *s = avctx->priv_data;
934
    int slice = (size_t)sl;
935
    dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
936
                            &s->sys->video_place[slice*5]);
937
    return 0;
938
}
939

    
940
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
941
   144000 bytes for PAL) */
942
static int dvvideo_decode_frame(AVCodecContext *avctx,
943
                                 void *data, int *data_size,
944
                                 uint8_t *buf, int buf_size)
945
{
946
    DVVideoContext *s = avctx->priv_data;
947

    
948
    s->sys = dv_frame_profile(buf);
949
    if (!s->sys || buf_size < s->sys->frame_size)
950
        return -1; /* NOTE: we only accept several full frames */
951

    
952
    if(s->picture.data[0])
953
        avctx->release_buffer(avctx, &s->picture);
954

    
955
    s->picture.reference = 0;
956
    s->picture.key_frame = 1;
957
    s->picture.pict_type = FF_I_TYPE;
958
    avctx->pix_fmt = s->sys->pix_fmt;
959
    avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
960
    if(avctx->get_buffer(avctx, &s->picture) < 0) {
961
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
962
        return -1;
963
    }
964
    s->picture.interlaced_frame = 1;
965
    s->picture.top_field_first = 0;
966

    
967
    s->buf = buf;
968
    avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
969
                   s->sys->difseg_size * 27);
970

    
971
    emms_c();
972

    
973
    /* return image */
974
    *data_size = sizeof(AVFrame);
975
    *(AVFrame*)data= s->picture;
976

    
977
    return s->sys->frame_size;
978
}
979

    
980
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
981
                                void *data)
982
{
983
    DVVideoContext *s = c->priv_data;
984

    
985
    s->sys = dv_codec_profile(c);
986
    if (!s->sys)
987
        return -1;
988
    if(buf_size < s->sys->frame_size)
989
        return -1;
990

    
991
    c->pix_fmt = s->sys->pix_fmt;
992
    s->picture = *((AVFrame *)data);
993
    s->picture.key_frame = 1;
994
    s->picture.pict_type = FF_I_TYPE;
995

    
996
    s->buf = buf;
997
    c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
998
               s->sys->difseg_size * 27);
999

    
1000
    emms_c();
1001
    return s->sys->frame_size;
1002
}
1003

    
1004
static int dvvideo_close(AVCodecContext *c)
1005
{
1006

    
1007
    return 0;
1008
}
1009

    
1010

    
1011
#ifdef CONFIG_DVVIDEO_ENCODER
1012
AVCodec dvvideo_encoder = {
1013
    "dvvideo",
1014
    CODEC_TYPE_VIDEO,
1015
    CODEC_ID_DVVIDEO,
1016
    sizeof(DVVideoContext),
1017
    dvvideo_init,
1018
    dvvideo_encode_frame,
1019
    dvvideo_close,
1020
    NULL,
1021
    CODEC_CAP_DR1,
1022
    NULL
1023
};
1024
#endif // CONFIG_DVVIDEO_ENCODER
1025

    
1026
AVCodec dvvideo_decoder = {
1027
    "dvvideo",
1028
    CODEC_TYPE_VIDEO,
1029
    CODEC_ID_DVVIDEO,
1030
    sizeof(DVVideoContext),
1031
    dvvideo_init,
1032
    NULL,
1033
    dvvideo_close,
1034
    dvvideo_decode_frame,
1035
    CODEC_CAP_DR1,
1036
    NULL
1037
};