dv.c 31.4 KB
Newer Older
1 2 3 4
/*
 * DV decoder
 * Copyright (c) 2002 Fabrice Bellard.
 *
5 6 7 8 9 10
 * DV encoder 
 * Copyright (c) 2003 Roman Shaposhnik.
 *
 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
 * of DV technical info.
 *
11 12 13 14 15 16 17 18 19 20 21 22 23 24
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
Michael Niedermayer's avatar
Michael Niedermayer committed
25 26 27

/**
 * @file dv.c
28
 * DV codec.
Michael Niedermayer's avatar
Michael Niedermayer committed
29
 */
30 31 32 33
#include "avcodec.h"
#include "dsputil.h"
#include "mpegvideo.h"
#include "simple_idct.h"
34
#include "dvdata.h"
35 36

typedef struct DVVideoDecodeContext {
37
    const DVprofile* sys;
38
    AVFrame picture;
39
    
40
    uint8_t dv_zigzag[2][64];
41 42
    uint8_t dv_idct_shift[2][22][64];
  
43
    void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
44
    void (*fdct[2])(DCTELEM *block);
45
    void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
46 47 48
    
    GetBitContext gb;
    DCTELEM block[5*6][64] __align8;
49 50
} DVVideoDecodeContext;

51
#define TEX_VLC_BITS 9
52 53 54 55 56 57 58 59 60

#ifdef DV_CODEC_TINY_TARGET
#define DV_VLC_MAP_RUN_SIZE 15
#define DV_VLC_MAP_LEV_SIZE 23
#else
#define DV_VLC_MAP_RUN_SIZE  64 
#define DV_VLC_MAP_LEV_SIZE 512
#endif

61 62
/* XXX: also include quantization */
static RL_VLC_ELEM *dv_rl_vlc[1];
63 64 65 66 67
/* VLC encoding lookup table */
static struct dv_vlc_pair {
   uint32_t vlc;
   uint8_t  size;
} (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;
68

69
static void dv_build_unquantize_tables(DVVideoDecodeContext *s, uint8_t* perm)
70
{
71
    int i, q, j;
72 73

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

92
static int dvvideo_init(AVCodecContext *avctx)
93 94
{
    DVVideoDecodeContext *s = avctx->priv_data;
95
    DSPContext dsp;
96
    static int done=0;
97
    int i, j;
98 99 100

    if (!done) {
        int i;
101
        VLC dv_vlc;
102 103 104

        done = 1;

105 106 107 108
        dv_vlc_map = av_mallocz(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
	if (!dv_vlc_map)
	    return -ENOMEM;

109 110 111 112 113 114
        /* NOTE: as a trick, we use the fact the no codes are unused
           to accelerate the parsing of partial codes */
        init_vlc(&dv_vlc, TEX_VLC_BITS, NB_DV_VLC, 
                 dv_vlc_len, 1, 1, dv_vlc_bits, 2, 2);

        dv_rl_vlc[0] = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
115 116 117 118
	if (!dv_rl_vlc[0]) {
	    av_free(dv_vlc_map);
	    return -ENOMEM;
	}
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
        for(i = 0; i < dv_vlc.table_size; i++){
            int code= dv_vlc.table[i][0];
            int len = dv_vlc.table[i][1];
            int level, run;
        
            if(len<0){ //more bits needed
                run= 0;
                level= code;
            } else if (code == (NB_DV_VLC - 1)) {
                /* EOB */
                run = 0;
                level = 256;
            } else {
                run=   dv_vlc_run[code] + 1;
                level= dv_vlc_level[code];
            }
            dv_rl_vlc[0][i].len = len;
            dv_rl_vlc[0][i].level = level;
            dv_rl_vlc[0][i].run = run;
        }
139 140

	for (i = 0; i < NB_DV_VLC - 1; i++) {
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
           if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE || dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
	       continue;
	   
	   if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
	       continue;
	       
	   dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << 
	                                                    (!!dv_vlc_level[i]);
	   dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + 
	                                                     (!!dv_vlc_level[i]);
	}
	for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
#ifdef DV_CODEC_TINY_TARGET
	   for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
	      if (dv_vlc_map[i][j].size == 0) {
	          dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
		            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
	          dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + 
		                          dv_vlc_map[0][j].size;
	      }
	   }
#else
	   for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
	      if (dv_vlc_map[i][j].size == 0) {
	          dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
		            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
	          dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + 
		                          dv_vlc_map[0][j].size;
	      }
	      dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = 
	                                    dv_vlc_map[i][j].vlc | 1;
	      dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = 
	                                    dv_vlc_map[i][j].size;
	   }
#endif
176
	}
177
    }
178

179 180 181
    /* Generic DSP setup */
    dsputil_init(&dsp, avctx);
    s->get_pixels = dsp.get_pixels;
182

183 184 185 186 187
    /* 88DCT setup */
    s->fdct[0] = dsp.fdct;
    s->idct_put[0] = dsp.idct_put;
    for (i=0; i<64; i++)
       s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
188

189 190 191 192
    /* 248DCT setup */
    s->fdct[1] = dsp.fdct248;
    s->idct_put[1] = simple_idct248_put;  // FIXME: need to add it to DSP
    memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
193

194
    /* XXX: do it only for constant case */
195
    dv_build_unquantize_tables(s, dsp.idct_permutation);
196

197 198 199
    /* FIXME: I really don't think this should be here */
    if (dv_codec_profile(avctx))
	avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt; 
200
    avctx->coded_frame = &s->picture;
201
    
202 203 204
    return 0;
}

205
// #define VLC_DEBUG
206

207
typedef struct BlockInfo {
208 209 210 211 212 213 214
    const uint8_t *shift_table;
    const uint8_t *scan_table;
    uint8_t pos; /* position in block */
    uint8_t eob_reached; /* true if EOB has been reached */
    uint8_t dct_mode;
    uint8_t partial_bit_count;
    uint16_t partial_bit_buffer;
215 216
    int shift_offset;
} BlockInfo;
217 218

/* block size in bits */
219
static const uint16_t block_sizes[6] = {
220 221
    112, 112, 112, 112, 80, 80
};
222 223 224 225
/* bit budget for AC only in 5 MBs */
static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
/* see dv_88_areas and dv_248_areas for details */
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; 
226 227

#ifndef ALT_BITSTREAM_READER
228
#warning only works with ALT_BITSTREAM_READER
229 230 231 232
#endif

/* decode ac coefs */
static void dv_decode_ac(DVVideoDecodeContext *s, 
233
                         BlockInfo *mb, DCTELEM *block, int last_index)
234 235
{
    int last_re_index;
236
    int shift_offset = mb->shift_offset;
237 238
    const uint8_t *scan_table = mb->scan_table;
    const uint8_t *shift_table = mb->shift_table;
239
    int pos = mb->pos;
240 241
    int level, pos1, sign, run;
    int partial_bit_count;
242 243 244 245
#ifndef ALT_BITSTREAM_READER //FIXME
    int re_index=0; 
    int re1_index=0;
#endif
246 247 248
    OPEN_READER(re, &s->gb);
    
#ifdef VLC_DEBUG
249
    printf("start\n");
250 251 252
#endif

    /* if we must parse a partial vlc, we do it here */
253
    partial_bit_count = mb->partial_bit_count;
254
    if (partial_bit_count > 0) {
255 256
        uint8_t buf[4];
        uint32_t v;
257 258 259 260 261 262 263 264 265
        int l, l1;
        GetBitContext gb1;

        /* build the dummy bit buffer */
        l = 16 - partial_bit_count;
        UPDATE_CACHE(re, &s->gb);
#ifdef VLC_DEBUG
        printf("show=%04x\n", SHOW_UBITS(re, &s->gb, 16));
#endif
266
        v = (mb->partial_bit_buffer << l) | SHOW_UBITS(re, &s->gb, l);
267 268 269 270
        buf[0] = v >> 8;
        buf[1] = v;
#ifdef VLC_DEBUG
        printf("v=%04x cnt=%d %04x\n", 
271
               v, partial_bit_count, (mb->partial_bit_buffer << l));
272 273
#endif
        /* try to read the codeword */
274
        init_get_bits(&gb1, buf, 4*8);
275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294
        {
            OPEN_READER(re1, &gb1);
            UPDATE_CACHE(re1, &gb1);
            GET_RL_VLC(level, run, re1, &gb1, dv_rl_vlc[0], 
                       TEX_VLC_BITS, 2);
            l = re1_index;
            CLOSE_READER(re1, &gb1);
        }
#ifdef VLC_DEBUG
        printf("****run=%d level=%d size=%d\n", run, level, l);
#endif
        /* compute codeword length */
        l1 = (level != 256 && level != 0);
        /* if too long, we cannot parse */
        l -= partial_bit_count;
        if ((re_index + l + l1) > last_index)
            return;
        /* skip read bits */
        last_re_index = 0; /* avoid warning */
        re_index += l;
295
        /* by definition, if we can read the vlc, all partial bits
296
           will be read (otherwise we could have read the vlc before) */
297
        mb->partial_bit_count = 0;
298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
        UPDATE_CACHE(re, &s->gb);
        goto handle_vlc;
    }

    /* get the AC coefficients until last_index is reached */
    for(;;) {
        UPDATE_CACHE(re, &s->gb);
#ifdef VLC_DEBUG
        printf("%2d: bits=%04x index=%d\n", 
               pos, SHOW_UBITS(re, &s->gb, 16), re_index);
#endif
        last_re_index = re_index;
        GET_RL_VLC(level, run, re, &s->gb, dv_rl_vlc[0], 
                   TEX_VLC_BITS, 2);
    handle_vlc:
#ifdef VLC_DEBUG
        printf("run=%d level=%d\n", run, level);
#endif
        if (level == 256) {
            if (re_index > last_index) {
            cannot_read:
                /* put position before read code */
                re_index = last_re_index;
321
                mb->eob_reached = 0;
322 323 324
                break;
            }
            /* EOB */
325
            mb->eob_reached = 1;
326 327 328 329 330 331 332 333 334 335 336 337 338
            break;
        } else if (level != 0) {
            if ((re_index + 1) > last_index)
                goto cannot_read;
            sign = SHOW_SBITS(re, &s->gb, 1);
            level = (level ^ sign) - sign;
            LAST_SKIP_BITS(re, &s->gb, 1);
            pos += run;
            /* error */
            if (pos >= 64) {
                goto read_error;
            }
            pos1 = scan_table[pos];
339
            level = level << (shift_table[pos1] + shift_offset);
340 341 342 343 344 345 346 347 348 349 350 351
            block[pos1] = level;
            //            printf("run=%d level=%d shift=%d\n", run, level, shift_table[pos1]);
        } else {
            if (re_index > last_index)
                goto cannot_read;
            /* level is zero: means run without coding. No
               sign is coded */
            pos += run;
            /* error */
            if (pos >= 64) {
            read_error:
#if defined(VLC_DEBUG) || 1
352
                av_log(NULL, AV_LOG_ERROR, "error pos=%d\n", pos);
353 354
#endif
                /* for errors, we consider the eob is reached */
355
                mb->eob_reached = 1;
356 357 358 359 360
                break;
            }
        }
    }
    CLOSE_READER(re, &s->gb);
361
    mb->pos = pos;
362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
}

static inline void bit_copy(PutBitContext *pb, GetBitContext *gb, int bits_left)
{
    while (bits_left >= 16) {
        put_bits(pb, 16, get_bits(gb, 16));
        bits_left -= 16;
    }
    if (bits_left > 0) {
        put_bits(pb, bits_left, get_bits(gb, bits_left));
    }
}

/* mb_x and mb_y are in units of 8 pixels */
static inline void dv_decode_video_segment(DVVideoDecodeContext *s, 
377 378
                                           uint8_t *buf_ptr1, 
                                           const uint16_t *mb_pos_ptr)
379 380 381 382 383
{
    int quant, dc, dct_mode, class1, j;
    int mb_index, mb_x, mb_y, v, last_index;
    DCTELEM *block, *block1;
    int c_offset, bits_left;
384
    uint8_t *y_ptr;
385
    BlockInfo mb_data[5 * 6], *mb, *mb1;
386 387
    void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
    uint8_t *buf_ptr;
388
    PutBitContext pb, vs_pb;
389
    uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */
390
    int mb_bit_count;
391
    uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
392 393 394 395 396 397 398
    int vs_bit_count;
    
    memset(s->block, 0, sizeof(s->block));

    /* pass 1 : read DC and AC coefficients in blocks */
    buf_ptr = buf_ptr1;
    block1 = &s->block[0][0];
399
    mb1 = mb_data;
400
    init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
401 402 403 404 405
    vs_bit_count = 0;
    for(mb_index = 0; mb_index < 5; mb_index++) {
        /* skip header */
        quant = buf_ptr[3] & 0x0f;
        buf_ptr += 4;
406
        init_put_bits(&pb, mb_bit_buffer, 80);
407 408
        mb_bit_count = 0;
        mb = mb1;
409 410 411
        block = block1;
        for(j = 0;j < 6; j++) {
            /* NOTE: size is not important here */
412
            init_get_bits(&s->gb, buf_ptr, 14*8);
413 414 415 416 417
            
            /* get the dc */
            dc = get_bits(&s->gb, 9);
            dc = (dc << (32 - 9)) >> (32 - 9);
            dct_mode = get_bits1(&s->gb);
418 419
            mb->dct_mode = dct_mode;
            mb->scan_table = s->dv_zigzag[dct_mode];
420
            class1 = get_bits(&s->gb, 2);
421
            mb->shift_offset = (class1 == 3);
422
            mb->shift_table = s->dv_idct_shift[dct_mode]
423 424 425 426 427 428 429 430
                [quant + dv_quant_offset[class1]];
            dc = dc << 2;
            /* convert to unsigned because 128 is not added in the
               standard IDCT */
            dc += 1024;
            block[0] = dc;
            last_index = block_sizes[j];
            buf_ptr += last_index >> 3;
431 432
            mb->pos = 0;
            mb->partial_bit_count = 0;
433

434 435 436
#ifdef VLC_DEBUG
            printf("MB block: %d, %d ", mb_index, j);
#endif
437
            dv_decode_ac(s, mb, block, last_index);
438 439 440

            /* write the remaining bits  in a new buffer only if the
               block is finished */
441
            bits_left = last_index - get_bits_count(&s->gb);
442 443 444
            if (mb->eob_reached) {
                mb->partial_bit_count = 0;
                mb_bit_count += bits_left;
445 446 447 448
                bit_copy(&pb, &s->gb, bits_left);
            } else {
                /* should be < 16 bits otherwise a codeword could have
                   been parsed */
449 450
                mb->partial_bit_count = bits_left;
                mb->partial_bit_buffer = get_bits(&s->gb, bits_left);
451 452
            }
            block += 64;
453
            mb++;
454 455 456 457 458 459
        }
        
        flush_put_bits(&pb);

        /* pass 2 : we can do it just after */
#ifdef VLC_DEBUG
460
        printf("***pass 2 size=%d MB#=%d\n", mb_bit_count, mb_index);
461 462
#endif
        block = block1;
463
        mb = mb1;
464
        init_get_bits(&s->gb, mb_bit_buffer, 80*8);
465
        for(j = 0;j < 6; j++) {
466
            if (!mb->eob_reached && get_bits_count(&s->gb) < mb_bit_count) {
467
                dv_decode_ac(s, mb, block, mb_bit_count);
468
                /* if still not finished, no need to parse other blocks */
469
                if (!mb->eob_reached) {
470 471
                    /* we could not parse the current AC coefficient,
                       so we add the remaining bytes */
472
                    bits_left = mb_bit_count - get_bits_count(&s->gb);
473
                    if (bits_left > 0) {
474 475 476
                        mb->partial_bit_count += bits_left;
                        mb->partial_bit_buffer = 
                            (mb->partial_bit_buffer << bits_left) | 
477 478 479 480 481 482
                            get_bits(&s->gb, bits_left);
                    }
                    goto next_mb;
                }
            }
            block += 64;
483
            mb++;
484 485 486
        }
        /* all blocks are finished, so the extra bytes can be used at
           the video segment level */
487
        bits_left = mb_bit_count - get_bits_count(&s->gb);
488 489 490
        vs_bit_count += bits_left;
        bit_copy(&vs_pb, &s->gb, bits_left);
    next_mb:
491
        mb1 += 6;
492 493 494 495 496 497 498 499 500 501 502
        block1 += 6 * 64;
    }

    /* we need a pass other the whole video segment */
    flush_put_bits(&vs_pb);
        
#ifdef VLC_DEBUG
    printf("***pass 3 size=%d\n", vs_bit_count);
#endif
    block = &s->block[0][0];
    mb = mb_data;
503
    init_get_bits(&s->gb, vs_bit_buffer, 5 * 80*8);
504 505
    for(mb_index = 0; mb_index < 5; mb_index++) {
        for(j = 0;j < 6; j++) {
506
            if (!mb->eob_reached) {
507 508 509
#ifdef VLC_DEBUG
                printf("start %d:%d\n", mb_index, j);
#endif
510
                dv_decode_ac(s, mb, block, vs_bit_count);
511 512
            }
            block += 64;
513
            mb++;
514 515 516 517 518 519 520 521 522 523
        }
    }
    
    /* compute idct and place blocks */
    block = &s->block[0][0];
    mb = mb_data;
    for(mb_index = 0; mb_index < 5; mb_index++) {
        v = *mb_pos_ptr++;
        mb_x = v & 0xff;
        mb_y = v >> 8;
524 525 526
        y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
        if (s->sys->pix_fmt == PIX_FMT_YUV411P)
            c_offset = (mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8);
527
        else
528
            c_offset = ((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8);
529
        for(j = 0;j < 6; j++) {
530
            idct_put = s->idct_put[mb->dct_mode];
531
            if (j < 4) {
532
                if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
533
                    /* NOTE: at end of line, the macroblock is handled as 420 */
534
                    idct_put(y_ptr + (j * 8), s->picture.linesize[0], block);
535
                } else {
536 537
                    idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]),
                             s->picture.linesize[0], block);
538 539
                }
            } else {
540
                if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
541
                    uint64_t aligned_pixels[64/8];
Michael Niedermayer's avatar
Michael Niedermayer committed
542
                    uint8_t *pixels= (uint8_t*)aligned_pixels;
543
		    uint8_t *c_ptr, *c_ptr1, *ptr;
544 545 546
                    int y, linesize;
                    /* NOTE: at end of line, the macroblock is handled as 420 */
                    idct_put(pixels, 8, block);
547 548
                    linesize = s->picture.linesize[6 - j];
                    c_ptr = s->picture.data[6 - j] + c_offset;
549 550 551
                    ptr = pixels;
                    for(y = 0;y < 8; y++) {
                        /* convert to 411P */
552 553 554 555 556 557
                        c_ptr1 = c_ptr + 8*linesize;
                        c_ptr[0]= ptr[0]; c_ptr1[0]= ptr[4];
                        c_ptr[1]= ptr[1]; c_ptr1[1]= ptr[5];
                        c_ptr[2]= ptr[2]; c_ptr1[2]= ptr[6];
                        c_ptr[3]= ptr[3]; c_ptr1[3]= ptr[7];
                        c_ptr += linesize;
558 559 560 561
                        ptr += 8;
                    }
                } else {
                    /* don't ask me why they inverted Cb and Cr ! */
562 563
                    idct_put(s->picture.data[6 - j] + c_offset, 
                             s->picture.linesize[6 - j], block);
564
                }
565 566
            }
            block += 64;
567
            mb++;
568 569 570 571
        }
    }
}

572
#ifdef DV_CODEC_TINY_TARGET
573
/* Converts run and level (where level != 0) pair into vlc, returning bit size */
574
static always_inline int dv_rl2vlc(int run, int l, uint32_t* vlc)
575 576 577 578 579 580 581
{
    int sign = l >> 8;
    int level = (l ^ sign) - sign;
    int size;
    
    sign = (sign & 1);

582 583 584
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
        *vlc = dv_vlc_map[run][level].vlc | sign;
	size = dv_vlc_map[run][level].size;
585 586
    }
    else { 
587 588 589
        if (level < DV_VLC_MAP_LEV_SIZE) {
	    *vlc = dv_vlc_map[0][level].vlc | sign;
	    size = dv_vlc_map[0][level].size;
590
	} else {
591
            *vlc = 0xfe00 | (level << 1) | sign;
592 593
	    size = 16;
	}
594 595 596 597
	if (run) {
	    *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : 
	                          (0x1f80 | (run - 1))) << size;
	    size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
598 599 600 601 602 603
	}
    }
    
    return size;
}

604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632
static always_inline int dv_rl2vlc_size(int run, int l)
{
    int level = (l ^ (l >> 8)) - (l >> 8);
    int size;
    
    if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
	size = dv_vlc_map[run][level].size; 
    }
    else { 
	size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
	if (run) {
	    size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
	}
    }
    return size;
}
#else
static always_inline int dv_rl2vlc(int run, int l, uint32_t* vlc)
{
    *vlc = dv_vlc_map[run][((uint16_t)l)&0x1ff].vlc;
    return dv_vlc_map[run][((uint16_t)l)&0x1ff].size;
}

static always_inline int dv_rl2vlc_size(int run, int l)
{
    return dv_vlc_map[run][((uint16_t)l)&0x1ff].size;
}
#endif

633
typedef struct EncBlockInfo {
634 635 636 637
    int area_q[4];
    int bit_size[4];
    int prev_run[4];
    int cur_ac;
638 639 640
    int cno;
    int dct_mode;
    DCTELEM *mb;
641 642
    uint8_t partial_bit_count;
    uint32_t partial_bit_buffer; /* we can't use uint16_t here */
643 644
} EncBlockInfo;

645
static always_inline int dv_bits_left(PutBitContext* s)
646
{
647
    return (s->buf_end - s->buf) * 8 - 
648
           ((s->buf_ptr - s->buf) * 8 + 32 - (int64_t)s->bit_left);
649 650
}

651 652
static always_inline void dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool, 
                                       int pb_size)
653
{
654 655 656 657 658
    int run;
    int bits_left;
    PutBitContext* pb = pb_pool;
    int size = bi->partial_bit_count;
    uint32_t vlc = bi->partial_bit_buffer;
659
    
660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
    bi->partial_bit_count = bi->partial_bit_buffer = 0;
vlc_loop:
       /* Find suitable storage space */
       for (; size > (bits_left = dv_bits_left(pb)); pb++) {
          if (bits_left) {
              size -= bits_left;
	      put_bits(pb, bits_left, vlc >> size);
	      vlc = vlc & ((1<<size)-1);
	  }
	  if (pb_size == 1) {
	      bi->partial_bit_count = size;
	      bi->partial_bit_buffer = vlc;
	      return;
	  }
	  --pb_size;
       }
       
       /* Store VLC */
       put_bits(pb, size, vlc);
       
       /* Construct the next VLC */
       run = 0;
       for (; bi->cur_ac < 64; bi->cur_ac++, run++) {
           if (bi->mb[bi->cur_ac]) {
	       size = dv_rl2vlc(run, bi->mb[bi->cur_ac], &vlc);
	       bi->cur_ac++;
	       goto vlc_loop;
687
	   }
688
       }
689
   
690 691 692 693 694
       if (bi->cur_ac == 64) {
           size = 4; vlc = 6; /* End Of Block stamp */
	   bi->cur_ac++;
	   goto vlc_loop;
       }
695 696
}

697 698
static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, 
                                              const uint8_t* zigzag_scan, int bias)
699
{
700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720
    int i, area;
    int run;
    int classes[] = {12, 24, 36, 0xffff};

    run = 0;
    bi->mb[0] = blk[0]; 
    bi->cno = 0;
    for (area = 0; area < 4; area++) {
       bi->prev_run[area] = run;
       bi->bit_size[area] = 0;
       for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
          bi->mb[i] = (blk[zigzag_scan[i]] / 16);
          while ((bi->mb[i] ^ (bi->mb[i] >> 8)) > classes[bi->cno])
              bi->cno++;
       
          if (bi->mb[i]) {
              bi->bit_size[area] += dv_rl2vlc_size(run, bi->mb[i]);
	      run = 0;
          } else
              ++run;
       }
721
    }
722 723
    bi->bit_size[3] += 4; /* EOB marker */
    bi->cno += bias;
724
    
725
    if (bi->cno >= 3) { /* FIXME: we have to recreate bit_size[], prev_run[] */
726
        bi->cno = 3;
727 728 729
	for (i=1; i<64; i++)
	   bi->mb[i] /= 2;
    }
730 731
}

732 733 734 735 736 737
#define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
    DCTELEM *s;
    int score88 = 0;
    int score248 = 0;
    int i;
738
    
739 740 741 742 743 744 745 746 747 748 749 750 751
    /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
    s = blk;
    for(i=0; i<7; i++) {
        score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + 
	           SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
        s += 8;
    }
    /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
    s = blk;
    for(i=0; i<6; i++) {
        score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
	            SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
        s += 8;
752
    }
753 754 755 756 757 758 759 760 761

    return (score88 - score248 > -10);
}

static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
{
    int size[5];
    int i, j, k, a, run;
    EncBlockInfo* b;
762
    
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
    do {
       b = blks;
       for (i=0; i<5; i++) {
          if (!qnos[i])
	      continue;
	  
	  qnos[i]--;
	  size[i] = 0;
          for (j=0; j<6; j++, b++) {
	     for (a=0; a<4; a++) {
	        if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
		    b->bit_size[a] = (a==3)?4:0;
		    b->area_q[a]++;
		    run = b->prev_run[a];
		    for (k=mb_area_start[a]; k<mb_area_start[a+1]; k++) {
		       b->mb[k] /= 2;
		       if (b->mb[k]) {
                           b->bit_size[a] += dv_rl2vlc_size(run, b->mb[k]);
	                   run = 0;
                       } else
                           ++run;
		    }
		}
		size[i] += b->bit_size[a];
	     }
	  }
       }
    } while ((vs_total_ac_bits < size[0] + size[1] + size[2] + size[3] + size[4]) && 
             (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]));
792 793
}

794 795
/*
 * This is a very rough initial implementaion. The performance is
796 797
 * horrible and the weighting is missing. But it's missing from the 
 * decoding step also -- so at least we're on the same page with decoder ;-)
798 799 800 801 802 803 804 805 806
 */
static inline void dv_encode_video_segment(DVVideoDecodeContext *s, 
                                           uint8_t *dif, 
                                           const uint16_t *mb_pos_ptr)
{
    int mb_index, i, j, v;
    int mb_x, mb_y, c_offset, linesize; 
    uint8_t*  y_ptr;
    uint8_t*  data;
807
    uint8_t*  ptr;
808
    int       do_edge_wrap;
809
    DCTELEM   block[64] __align8;
810
    EncBlockInfo  enc_blks[5*6];
811 812
    PutBitContext pbs[5*6];
    PutBitContext* pb; 
813
    EncBlockInfo* enc_blk;
814 815
    int       vs_bit_size = 0;
    int       qnos[5];
816
   
817
    enc_blk = &enc_blks[0];
818
    pb = &pbs[0];
819 820 821 822 823 824 825 826 827
    for(mb_index = 0; mb_index < 5; mb_index++) {
        v = *mb_pos_ptr++;
        mb_x = v & 0xff;
        mb_y = v >> 8;
        y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
	c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ?
	           ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) :
		   (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
	do_edge_wrap = 0;
828 829
	qnos[mb_index] = 15; /* No quantization */
        ptr = dif + mb_index*80 + 4;
830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860
        for(j = 0;j < 6; j++) {
            if (j < 4) {  /* Four Y blocks */
		/* NOTE: at end of line, the macroblock is handled as 420 */
		if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
                    data = y_ptr + (j * 8);
                } else {
                    data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
                }
		linesize = s->picture.linesize[0];
            } else {      /* Cr and Cb blocks */
	        /* don't ask Fabrice why they inverted Cb and Cr ! */
	        data = s->picture.data[6 - j] + c_offset;
		linesize = s->picture.linesize[6 - j];
		if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
		    do_edge_wrap = 1;
	    }	
            
	    /* Everything is set up -- now just copy data -> DCT block */
	    if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
		uint8_t* d;
		DCTELEM *b = block;
	        for (i=0;i<8;i++) {
		   d = data + 8 * linesize;
		   b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
                   b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
		   data += linesize;
		   b += 8;
		}
	    } else {             /* Simple copy: 8x8 -> 8x8 */
	        s->get_pixels(block, data, linesize);
	    }
861
	  
862 863 864 865 866 867
            enc_blk->dct_mode = dv_guess_dct_mode(block);
	    enc_blk->mb = &s->block[mb_index*6+j][0];
	    enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
	    enc_blk->partial_bit_count = 0;
	    enc_blk->partial_bit_buffer = 0;
	    enc_blk->cur_ac = 1;
868 869
	    
	    s->fdct[enc_blk->dct_mode](block);
870
	    
871 872 873 874 875 876 877 878 879 880 881 882 883 884
	    dv_set_class_number(block, enc_blk, 
	                        enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
				j/4*(j%2));
           
            init_put_bits(pb, ptr, block_sizes[j]/8);
	    put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024) >> 2));
	    put_bits(pb, 1, enc_blk->dct_mode);
	    put_bits(pb, 2, enc_blk->cno);
	    
	    vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
	                   enc_blk->bit_size[2] + enc_blk->bit_size[3];
	    ++enc_blk;
	    ++pb;
	    ptr += block_sizes[j]/8;
885 886 887
        }
    }

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

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

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

899 900 901 902
    /* Second pass over each MB space */
    for (j=0; j<5*6; j++) {
       if (enc_blks[j].cur_ac < 65 || enc_blks[j].partial_bit_count)
           dv_encode_ac(&enc_blks[j], &pbs[(j/6)*6], 6);
903 904
    }

905 906 907 908
    /* Third and final pass over the whole vides segment space */
    for (j=0; j<5*6; j++) {
       if (enc_blks[j].cur_ac < 65 || enc_blks[j].partial_bit_count)
           dv_encode_ac(&enc_blks[j], &pbs[0], 6*5);
909
    }
910 911 912

    for (j=0; j<5*6; j++)
       flush_put_bits(&pbs[j]);
913 914
}

915 916 917 918
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
   144000 bytes for PAL) */
static int dvvideo_decode_frame(AVCodecContext *avctx, 
                                 void *data, int *data_size,
919
                                 uint8_t *buf, int buf_size)
920 921
{
    DVVideoDecodeContext *s = avctx->priv_data;
922
    int ds, vs;
923
    const uint16_t *mb_pos_ptr;
Michael Niedermayer's avatar
Michael Niedermayer committed
924 925 926 927 928
  
    *data_size=0;
    /* special case for last picture */
    if(buf_size==0)
        return 0;
929
    
930 931 932
    s->sys = dv_frame_profile(buf);
    if (!s->sys || buf_size < s->sys->frame_size)
        return -1; /* NOTE: we only accept several full frames */
933

934
	
935 936 937
    if(s->picture.data[0])
        avctx->release_buffer(avctx, &s->picture);
    
938 939
    s->picture.reference = 0;
    avctx->pix_fmt = s->sys->pix_fmt;
940 941
    avctx->width = s->sys->width;
    avctx->height = s->sys->height;
Michael Niedermayer's avatar
Michael Niedermayer committed
942
    if(avctx->get_buffer(avctx, &s->picture) < 0) {
943
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
Michael Niedermayer's avatar
Michael Niedermayer committed
944
        return -1;
Zdenek Kabelac's avatar
Zdenek Kabelac committed
945
    }
946
    s->picture.interlaced_frame = 1;
947
    s->picture.top_field_first = 0;
Zdenek Kabelac's avatar
Zdenek Kabelac committed
948

949
    /* for each DIF segment */
950 951 952
    mb_pos_ptr = s->sys->video_place;
    for (ds = 0; ds < s->sys->difseg_size; ds++) {
        buf += 6 * 80; /* skip DIF segment header */
953 954
        
        for(vs = 0; vs < 27; vs++) {
955 956 957
            if ((vs % 3) == 0)
	        buf += 80; /* skip audio block */
            
958 959 960
#ifdef VLC_DEBUG
            printf("********************* %d, %d **********************\n", ds, vs);
#endif
961 962
	    dv_decode_video_segment(s, buf, mb_pos_ptr);
            buf += 5 * 80;
963 964 965 966
            mb_pos_ptr += 5;
        }
    }

967 968
    emms_c();

969
    /* return image */
970 971
    *data_size = sizeof(AVFrame);
    *(AVFrame*)data= s->picture;
Michael Niedermayer's avatar
Michael Niedermayer committed
972
    
973
    return s->sys->frame_size;
974 975
}

976 977
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, 
                                void *data)
978
{
979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
    DVVideoDecodeContext *s = c->priv_data;
    const uint16_t *mb_pos_ptr;
    int ds, vs;

    s->sys = dv_codec_profile(c);
    if (!s->sys)
	return -1;
    
    c->pix_fmt = s->sys->pix_fmt;
    s->picture = *((AVFrame *)data);

    /* for each DIF segment */
    mb_pos_ptr = s->sys->video_place;
    for (ds = 0; ds < s->sys->difseg_size; ds++) {
        buf += 6 * 80; /* skip DIF segment header */
        
        for(vs = 0; vs < 27; vs++) {
            if ((vs % 3) == 0)
	        buf += 80; /* skip audio block */

#ifdef VLC_DEBUG
            printf("********************* %d, %d **********************\n", ds, vs);
#endif
	    dv_encode_video_segment(s, buf, mb_pos_ptr);
            buf += 5 * 80;
            mb_pos_ptr += 5;
        }
    }
1007

1008 1009 1010 1011 1012 1013 1014
    emms_c();
    return s->sys->frame_size;
}

static int dvvideo_end(AVCodecContext *avctx)
{
    avcodec_default_free_buffers(avctx);    
1015 1016 1017 1018 1019 1020 1021 1022
    return 0;
}

AVCodec dvvideo_decoder = {
    "dvvideo",
    CODEC_TYPE_VIDEO,
    CODEC_ID_DVVIDEO,
    sizeof(DVVideoDecodeContext),
1023 1024 1025
    dvvideo_init,
    dvvideo_encode_frame,
    dvvideo_end,
1026
    dvvideo_decode_frame,
Zdenek Kabelac's avatar
Zdenek Kabelac committed
1027
    CODEC_CAP_DR1,
1028 1029
    NULL
};