git.sesse.net Git - ffmpeg/blob - libavcodec/dv.c

   1 /*
   2  * DV decoder
   3  * Copyright (c) 2002 Fabrice Bellard.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19
  20 /**
  21  * @file dv.c
  22  * DV decoder.
  23  */
  24 #include "avcodec.h"
  25 #include "dsputil.h"
  26 #include "mpegvideo.h"
  27 #include "simple_idct.h"
  28
  29 #define NTSC_FRAME_SIZE 120000
  30 #define PAL_FRAME_SIZE  144000
  31
  32 #define TEX_VLC_BITS 9
  33
  34 typedef struct DVVideoDecodeContext {
  35     AVCodecContext *avctx;
  36     GetBitContext gb;
  37     VLC *vlc;
  38     int sampling_411; /* 0 = 420, 1 = 411 */
  39     int width, height;
  40     uint8_t *current_picture[3]; /* picture structure */
  41     AVFrame picture;
  42     int linesize[3];
  43     DCTELEM block[5*6][64] __align8;
  44     uint8_t dv_zigzag[2][64];
  45     uint8_t idct_permutation[64];
  46     /* XXX: move it to static storage ? */
  47     uint8_t dv_shift[2][22][64];
  48     void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
  49 } DVVideoDecodeContext;
  50
  51 #include "dvdata.h"
  52
  53 static VLC dv_vlc;
  54 /* XXX: also include quantization */
  55 static RL_VLC_ELEM *dv_rl_vlc[1];
  56
  57 static void dv_build_unquantize_tables(DVVideoDecodeContext *s)
  58 {
  59     int i, q, j;
  60
  61     /* NOTE: max left shift is 6 */
  62     for(q = 0; q < 22; q++) {
  63         /* 88 unquant */
  64         for(i = 1; i < 64; i++) {
  65             /* 88 table */
  66             j = s->idct_permutation[i];
  67             s->dv_shift[0][q][j] =
  68                 dv_quant_shifts[q][dv_88_areas[i]] + 1;
  69         }
  70
  71         /* 248 unquant */
  72         for(i = 1; i < 64; i++) {
  73             /* 248 table */
  74             s->dv_shift[1][q][i] =
  75                     dv_quant_shifts[q][dv_248_areas[i]] + 1;
  76         }
  77     }
  78 }
  79
  80 static int dvvideo_decode_init(AVCodecContext *avctx)
  81 {
  82     DVVideoDecodeContext *s = avctx->priv_data;
  83     MpegEncContext s2;
  84     static int done=0;
  85
  86     if (!done) {
  87         int i;
  88
  89         done = 1;
  90
  91         /* NOTE: as a trick, we use the fact the no codes are unused
  92            to accelerate the parsing of partial codes */
  93         init_vlc(&dv_vlc, TEX_VLC_BITS, NB_DV_VLC,
  94                  dv_vlc_len, 1, 1, dv_vlc_bits, 2, 2);
  95
  96         dv_rl_vlc[0] = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
  97         for(i = 0; i < dv_vlc.table_size; i++){
  98             int code= dv_vlc.table[i][0];
  99             int len = dv_vlc.table[i][1];
 100             int level, run;
 101
 102             if(len<0){ //more bits needed
 103                 run= 0;
 104                 level= code;
 105             } else if (code == (NB_DV_VLC - 1)) {
 106                 /* EOB */
 107                 run = 0;
 108                 level = 256;
 109             } else {
 110                 run=   dv_vlc_run[code] + 1;
 111                 level= dv_vlc_level[code];
 112             }
 113             dv_rl_vlc[0][i].len = len;
 114             dv_rl_vlc[0][i].level = level;
 115             dv_rl_vlc[0][i].run = run;
 116         }
 117     }
 118
 119     /* ugly way to get the idct & scantable */
 120     /* XXX: fix it */
 121     memset(&s2, 0, sizeof(MpegEncContext));
 122     s2.avctx = avctx;
 123     dsputil_init(&s2.dsp, avctx);
 124     if (DCT_common_init(&s2) < 0)
 125        return -1;
 126
 127     s->idct_put[0] = s2.dsp.idct_put;
 128     memcpy(s->idct_permutation, s2.dsp.idct_permutation, 64);
 129     memcpy(s->dv_zigzag[0], s2.intra_scantable.permutated, 64);
 130
 131     /* XXX: use MMX also for idct248 */
 132     s->idct_put[1] = simple_idct248_put;
 133     memcpy(s->dv_zigzag[1], dv_248_zigzag, 64);
 134
 135     /* XXX: do it only for constant case */
 136     dv_build_unquantize_tables(s);
 137
 138     return 0;
 139 }
 140
 141 //#define VLC_DEBUG
 142
 143 typedef struct BlockInfo {
 144     const uint8_t *shift_table;
 145     const uint8_t *scan_table;
 146     uint8_t pos; /* position in block */
 147     uint8_t eob_reached; /* true if EOB has been reached */
 148     uint8_t dct_mode;
 149     uint8_t partial_bit_count;
 150     uint16_t partial_bit_buffer;
 151     int shift_offset;
 152 } BlockInfo;
 153
 154 /* block size in bits */
 155 static const uint16_t block_sizes[6] = {
 156     112, 112, 112, 112, 80, 80
 157 };
 158
 159 #ifndef ALT_BITSTREAM_READER
 160 #error only works with ALT_BITSTREAM_READER
 161 #endif
 162
 163 /* decode ac coefs */
 164 static void dv_decode_ac(DVVideoDecodeContext *s,
 165                          BlockInfo *mb, DCTELEM *block, int last_index)
 166 {
 167     int last_re_index;
 168     int shift_offset = mb->shift_offset;
 169     const uint8_t *scan_table = mb->scan_table;
 170     const uint8_t *shift_table = mb->shift_table;
 171     int pos = mb->pos;
 172     int level, pos1, sign, run;
 173     int partial_bit_count;
 174
 175     OPEN_READER(re, &s->gb);
 176
 177 #ifdef VLC_DEBUG
 178     printf("start\n");
 179 #endif
 180
 181     /* if we must parse a partial vlc, we do it here */
 182     partial_bit_count = mb->partial_bit_count;
 183     if (partial_bit_count > 0) {
 184         uint8_t buf[4];
 185         uint32_t v;
 186         int l, l1;
 187         GetBitContext gb1;
 188
 189         /* build the dummy bit buffer */
 190         l = 16 - partial_bit_count;
 191         UPDATE_CACHE(re, &s->gb);
 192 #ifdef VLC_DEBUG
 193         printf("show=%04x\n", SHOW_UBITS(re, &s->gb, 16));
 194 #endif
 195         v = (mb->partial_bit_buffer << l) | SHOW_UBITS(re, &s->gb, l);
 196         buf[0] = v >> 8;
 197         buf[1] = v;
 198 #ifdef VLC_DEBUG
 199         printf("v=%04x cnt=%d %04x\n",
 200                v, partial_bit_count, (mb->partial_bit_buffer << l));
 201 #endif
 202         /* try to read the codeword */
 203         init_get_bits(&gb1, buf, 4*8);
 204         {
 205             OPEN_READER(re1, &gb1);
 206             UPDATE_CACHE(re1, &gb1);
 207             GET_RL_VLC(level, run, re1, &gb1, dv_rl_vlc[0],
 208                        TEX_VLC_BITS, 2);
 209             l = re1_index;
 210             CLOSE_READER(re1, &gb1);
 211         }
 212 #ifdef VLC_DEBUG
 213         printf("****run=%d level=%d size=%d\n", run, level, l);
 214 #endif
 215         /* compute codeword length */
 216         l1 = (level != 256 && level != 0);
 217         /* if too long, we cannot parse */
 218         l -= partial_bit_count;
 219         if ((re_index + l + l1) > last_index)
 220             return;
 221         /* skip read bits */
 222         last_re_index = 0; /* avoid warning */
 223         re_index += l;
 224         /* by definition, if we can read the vlc, all partial bits
 225            will be read (otherwise we could have read the vlc before) */
 226         mb->partial_bit_count = 0;
 227         UPDATE_CACHE(re, &s->gb);
 228         goto handle_vlc;
 229     }
 230
 231     /* get the AC coefficients until last_index is reached */
 232     for(;;) {
 233         UPDATE_CACHE(re, &s->gb);
 234 #ifdef VLC_DEBUG
 235         printf("%2d: bits=%04x index=%d\n",
 236                pos, SHOW_UBITS(re, &s->gb, 16), re_index);
 237 #endif
 238         last_re_index = re_index;
 239         GET_RL_VLC(level, run, re, &s->gb, dv_rl_vlc[0],
 240                    TEX_VLC_BITS, 2);
 241     handle_vlc:
 242 #ifdef VLC_DEBUG
 243         printf("run=%d level=%d\n", run, level);
 244 #endif
 245         if (level == 256) {
 246             if (re_index > last_index) {
 247             cannot_read:
 248                 /* put position before read code */
 249                 re_index = last_re_index;
 250                 mb->eob_reached = 0;
 251                 break;
 252             }
 253             /* EOB */
 254             mb->eob_reached = 1;
 255             break;
 256         } else if (level != 0) {
 257             if ((re_index + 1) > last_index)
 258                 goto cannot_read;
 259             sign = SHOW_SBITS(re, &s->gb, 1);
 260             level = (level ^ sign) - sign;
 261             LAST_SKIP_BITS(re, &s->gb, 1);
 262             pos += run;
 263             /* error */
 264             if (pos >= 64) {
 265                 goto read_error;
 266             }
 267             pos1 = scan_table[pos];
 268             level = level << (shift_table[pos1] + shift_offset);
 269             block[pos1] = level;
 270             //            printf("run=%d level=%d shift=%d\n", run, level, shift_table[pos1]);
 271         } else {
 272             if (re_index > last_index)
 273                 goto cannot_read;
 274             /* level is zero: means run without coding. No
 275                sign is coded */
 276             pos += run;
 277             /* error */
 278             if (pos >= 64) {
 279             read_error:
 280 #if defined(VLC_DEBUG) || 1
 281                 fprintf(stderr, "error pos=%d\n", pos);
 282 #endif
 283                 /* for errors, we consider the eob is reached */
 284                 mb->eob_reached = 1;
 285                 break;
 286             }
 287         }
 288     }
 289     CLOSE_READER(re, &s->gb);
 290     mb->pos = pos;
 291 }
 292
 293 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb, int bits_left)
 294 {
 295     while (bits_left >= 16) {
 296         put_bits(pb, 16, get_bits(gb, 16));
 297         bits_left -= 16;
 298     }
 299     if (bits_left > 0) {
 300         put_bits(pb, bits_left, get_bits(gb, bits_left));
 301     }
 302 }
 303
 304 /* mb_x and mb_y are in units of 8 pixels */
 305 static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
 306                                            uint8_t *buf_ptr1,
 307                                            const uint16_t *mb_pos_ptr)
 308 {
 309     int quant, dc, dct_mode, class1, j;
 310     int mb_index, mb_x, mb_y, v, last_index;
 311     DCTELEM *block, *block1;
 312     int c_offset, bits_left;
 313     uint8_t *y_ptr;
 314     BlockInfo mb_data[5 * 6], *mb, *mb1;
 315     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
 316     uint8_t *buf_ptr;
 317     PutBitContext pb, vs_pb;
 318     uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */
 319     int mb_bit_count;
 320     uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
 321     int vs_bit_count;
 322
 323     memset(s->block, 0, sizeof(s->block));
 324
 325     /* pass 1 : read DC and AC coefficients in blocks */
 326     buf_ptr = buf_ptr1;
 327     block1 = &s->block[0][0];
 328     mb1 = mb_data;
 329     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80, NULL, NULL);
 330     vs_bit_count = 0;
 331     for(mb_index = 0; mb_index < 5; mb_index++) {
 332         /* skip header */
 333         quant = buf_ptr[3] & 0x0f;
 334         buf_ptr += 4;
 335         init_put_bits(&pb, mb_bit_buffer, 80, NULL, NULL);
 336         mb_bit_count = 0;
 337         mb = mb1;
 338         block = block1;
 339         for(j = 0;j < 6; j++) {
 340             /* NOTE: size is not important here */
 341             init_get_bits(&s->gb, buf_ptr, 14*8);
 342
 343             /* get the dc */
 344             dc = get_bits(&s->gb, 9);
 345             dc = (dc << (32 - 9)) >> (32 - 9);
 346             dct_mode = get_bits1(&s->gb);
 347             mb->dct_mode = dct_mode;
 348             mb->scan_table = s->dv_zigzag[dct_mode];
 349             class1 = get_bits(&s->gb, 2);
 350             mb->shift_offset = (class1 == 3);
 351             mb->shift_table = s->dv_shift[dct_mode]
 352                 [quant + dv_quant_offset[class1]];
 353             dc = dc << 2;
 354             /* convert to unsigned because 128 is not added in the
 355                standard IDCT */
 356             dc += 1024;
 357             block[0] = dc;
 358             last_index = block_sizes[j];
 359             buf_ptr += last_index >> 3;
 360             mb->pos = 0;
 361             mb->partial_bit_count = 0;
 362
 363             dv_decode_ac(s, mb, block, last_index);
 364
 365             /* write the remaining bits  in a new buffer only if the
 366                block is finished */
 367             bits_left = last_index - s->gb.index;
 368             if (mb->eob_reached) {
 369                 mb->partial_bit_count = 0;
 370                 mb_bit_count += bits_left;
 371                 bit_copy(&pb, &s->gb, bits_left);
 372             } else {
 373                 /* should be < 16 bits otherwise a codeword could have
 374                    been parsed */
 375                 mb->partial_bit_count = bits_left;
 376                 mb->partial_bit_buffer = get_bits(&s->gb, bits_left);
 377             }
 378             block += 64;
 379             mb++;
 380         }
 381
 382         flush_put_bits(&pb);
 383
 384         /* pass 2 : we can do it just after */
 385 #ifdef VLC_DEBUG
 386         printf("***pass 2 size=%d\n", mb_bit_count);
 387 #endif
 388         block = block1;
 389         mb = mb1;
 390         init_get_bits(&s->gb, mb_bit_buffer, 80*8);
 391         for(j = 0;j < 6; j++) {
 392             if (!mb->eob_reached && s->gb.index < mb_bit_count) {
 393                 dv_decode_ac(s, mb, block, mb_bit_count);
 394                 /* if still not finished, no need to parse other blocks */
 395                 if (!mb->eob_reached) {
 396                     /* we could not parse the current AC coefficient,
 397                        so we add the remaining bytes */
 398                     bits_left = mb_bit_count - s->gb.index;
 399                     if (bits_left > 0) {
 400                         mb->partial_bit_count += bits_left;
 401                         mb->partial_bit_buffer =
 402                             (mb->partial_bit_buffer << bits_left) |
 403                             get_bits(&s->gb, bits_left);
 404                     }
 405                     goto next_mb;
 406                 }
 407             }
 408             block += 64;
 409             mb++;
 410         }
 411         /* all blocks are finished, so the extra bytes can be used at
 412            the video segment level */
 413         bits_left = mb_bit_count - s->gb.index;
 414         vs_bit_count += bits_left;
 415         bit_copy(&vs_pb, &s->gb, bits_left);
 416     next_mb:
 417         mb1 += 6;
 418         block1 += 6 * 64;
 419     }
 420
 421     /* we need a pass other the whole video segment */
 422     flush_put_bits(&vs_pb);
 423
 424 #ifdef VLC_DEBUG
 425     printf("***pass 3 size=%d\n", vs_bit_count);
 426 #endif
 427     block = &s->block[0][0];
 428     mb = mb_data;
 429     init_get_bits(&s->gb, vs_bit_buffer, 5 * 80*8);
 430     for(mb_index = 0; mb_index < 5; mb_index++) {
 431         for(j = 0;j < 6; j++) {
 432             if (!mb->eob_reached) {
 433 #ifdef VLC_DEBUG
 434                 printf("start %d:%d\n", mb_index, j);
 435 #endif
 436                 dv_decode_ac(s, mb, block, vs_bit_count);
 437             }
 438             block += 64;
 439             mb++;
 440         }
 441     }
 442
 443     /* compute idct and place blocks */
 444     block = &s->block[0][0];
 445     mb = mb_data;
 446     for(mb_index = 0; mb_index < 5; mb_index++) {
 447         v = *mb_pos_ptr++;
 448         mb_x = v & 0xff;
 449         mb_y = v >> 8;
 450         y_ptr = s->current_picture[0] + (mb_y * s->linesize[0] * 8) + (mb_x * 8);
 451         if (s->sampling_411)
 452             c_offset = (mb_y * s->linesize[1] * 8) + ((mb_x >> 2) * 8);
 453         else
 454             c_offset = ((mb_y >> 1) * s->linesize[1] * 8) + ((mb_x >> 1) * 8);
 455         for(j = 0;j < 6; j++) {
 456             idct_put = s->idct_put[mb->dct_mode];
 457             if (j < 4) {
 458                 if (s->sampling_411 && mb_x < (704 / 8)) {
 459                     /* NOTE: at end of line, the macroblock is handled as 420 */
 460                     idct_put(y_ptr + (j * 8), s->linesize[0], block);
 461                 } else {
 462                     idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->linesize[0]),
 463                              s->linesize[0], block);
 464                 }
 465             } else {
 466                 if (s->sampling_411 && mb_x >= (704 / 8)) {
 467                     uint8_t pixels[64], *c_ptr, *c_ptr1, *ptr;
 468                     int y, linesize;
 469                     /* NOTE: at end of line, the macroblock is handled as 420 */
 470                     idct_put(pixels, 8, block);
 471                     linesize = s->linesize[6 - j];
 472                     c_ptr = s->current_picture[6 - j] + c_offset;
 473                     ptr = pixels;
 474                     for(y = 0;y < 8; y++) {
 475                         /* convert to 411P */
 476                         c_ptr1 = c_ptr + linesize;
 477                         c_ptr1[0] = c_ptr[0] = (ptr[0] + ptr[1]) >> 1;
 478                         c_ptr1[1] = c_ptr[1] = (ptr[2] + ptr[3]) >> 1;
 479                         c_ptr1[2] = c_ptr[2] = (ptr[4] + ptr[5]) >> 1;
 480                         c_ptr1[3] = c_ptr[3] = (ptr[6] + ptr[7]) >> 1;
 481                         c_ptr += linesize * 2;
 482                         ptr += 8;
 483                     }
 484                 } else {
 485                     /* don't ask me why they inverted Cb and Cr ! */
 486                     idct_put(s->current_picture[6 - j] + c_offset,
 487                              s->linesize[6 - j], block);
 488                 }
 489             }
 490             block += 64;
 491             mb++;
 492         }
 493     }
 494 }
 495
 496
 497 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
 498    144000 bytes for PAL) */
 499 static int dvvideo_decode_frame(AVCodecContext *avctx,
 500                                  void *data, int *data_size,
 501                                  uint8_t *buf, int buf_size)
 502 {
 503     DVVideoDecodeContext *s = avctx->priv_data;
 504     int sct, dsf, apt, ds, nb_dif_segs, vs, width, height, i, packet_size;
 505     uint8_t *buf_ptr;
 506     const uint16_t *mb_pos_ptr;
 507
 508     /* parse id */
 509     init_get_bits(&s->gb, buf, buf_size*8);
 510     sct = get_bits(&s->gb, 3);
 511     if (sct != 0)
 512         return -1;
 513     skip_bits(&s->gb, 5);
 514     get_bits(&s->gb, 4); /* dsn (sequence number */
 515     get_bits(&s->gb, 1); /* fsc (channel number) */
 516     skip_bits(&s->gb, 3);
 517     get_bits(&s->gb, 8); /* dbn (diff block number 0-134) */
 518
 519     dsf = get_bits(&s->gb, 1); /* 0 = NTSC 1 = PAL */
 520     if (get_bits(&s->gb, 1) != 0)
 521         return -1;
 522     skip_bits(&s->gb, 11);
 523     apt = get_bits(&s->gb, 3); /* apt */
 524
 525     get_bits(&s->gb, 1); /* tf1 */
 526     skip_bits(&s->gb, 4);
 527     get_bits(&s->gb, 3); /* ap1 */
 528
 529     get_bits(&s->gb, 1); /* tf2 */
 530     skip_bits(&s->gb, 4);
 531     get_bits(&s->gb, 3); /* ap2 */
 532
 533     get_bits(&s->gb, 1); /* tf3 */
 534     skip_bits(&s->gb, 4);
 535     get_bits(&s->gb, 3); /* ap3 */
 536
 537     /* init size */
 538     width = 720;
 539     if (dsf) {
 540         avctx->frame_rate = 25;
 541         avctx->frame_rate_base = 1;
 542         packet_size = PAL_FRAME_SIZE;
 543         height = 576;
 544         nb_dif_segs = 12;
 545     } else {
 546         avctx->frame_rate = 30000;
 547         avctx->frame_rate_base = 1001;
 548         packet_size = NTSC_FRAME_SIZE;
 549         height = 480;
 550         nb_dif_segs = 10;
 551     }
 552     /* NOTE: we only accept several full frames */
 553     if (buf_size < packet_size)
 554         return -1;
 555
 556     /* NTSC[dsf == 0] is always 720x480, 4:1:1
 557      *  PAL[dsf == 1] is always 720x576, 4:2:0 for IEC 68134[apt == 0]
 558      *  but for the SMPTE 314M[apt == 1] it is 720x576, 4:1:1
 559      */
 560     s->sampling_411 = !dsf || apt;
 561     if (s->sampling_411) {
 562         mb_pos_ptr = dsf ? dv_place_411P : dv_place_411;
 563         avctx->pix_fmt = PIX_FMT_YUV411P;
 564     } else {
 565         mb_pos_ptr = dv_place_420;
 566         avctx->pix_fmt = PIX_FMT_YUV420P;
 567     }
 568
 569     avctx->width = width;
 570     avctx->height = height;
 571
 572     /* Once again, this is pretty complicated by the fact that the same
 573      * field is used differently by IEC 68134[apt == 0] and
 574      * SMPTE 314M[apt == 1].
 575      */
 576     if (buf[VAUX_TC61_OFFSET] == 0x61 &&
 577         ((apt == 0 && (buf[VAUX_TC61_OFFSET + 2] & 0x07) == 0x07) ||
 578          (apt == 1 && (buf[VAUX_TC61_OFFSET + 2] & 0x07) == 0x02)))
 579         avctx->aspect_ratio = 16.0 / 9.0;
 580     else
 581         avctx->aspect_ratio = 4.0 / 3.0;
 582
 583     if(s->picture.data[0])
 584         avctx->release_buffer(avctx, &s->picture);
 585
 586     s->picture.reference= 0;
 587     if(avctx->get_buffer(avctx, &s->picture) < 0) {
 588         fprintf(stderr, "get_buffer() failed\n");
 589         return -1;
 590     }
 591
 592     for(i=0;i<3;i++) {
 593         s->current_picture[i] = s->picture.data[i];
 594         s->linesize[i] = s->picture.linesize[i];
 595         if (!s->current_picture[i])
 596             return -1;
 597     }
 598     s->width = width;
 599     s->height = height;
 600
 601     /* for each DIF segment */
 602     buf_ptr = buf;
 603     for (ds = 0; ds < nb_dif_segs; ds++) {
 604         buf_ptr += 6 * 80; /* skip DIF segment header */
 605
 606         for(vs = 0; vs < 27; vs++) {
 607             if ((vs % 3) == 0) {
 608                 /* skip audio block */
 609                 buf_ptr += 80;
 610             }
 611             dv_decode_video_segment(s, buf_ptr, mb_pos_ptr);
 612             buf_ptr += 5 * 80;
 613             mb_pos_ptr += 5;
 614         }
 615     }
 616
 617     emms_c();
 618
 619     /* return image */
 620     *data_size = sizeof(AVFrame);
 621     *(AVFrame*)data= s->picture;
 622
 623     return packet_size;
 624 }
 625
 626 static int dvvideo_decode_end(AVCodecContext *avctx)
 627 {
 628     DVVideoDecodeContext *s = avctx->priv_data;
 629
 630     avcodec_default_free_buffers(avctx);
 631
 632     return 0;
 633 }
 634
 635 AVCodec dvvideo_decoder = {
 636     "dvvideo",
 637     CODEC_TYPE_VIDEO,
 638     CODEC_ID_DVVIDEO,
 639     sizeof(DVVideoDecodeContext),
 640     dvvideo_decode_init,
 641     NULL,
 642     dvvideo_decode_end,
 643     dvvideo_decode_frame,
 644     CODEC_CAP_DR1,
 645     NULL
 646 };
 647
 648 typedef struct DVAudioDecodeContext {
 649     AVCodecContext *avctx;
 650     GetBitContext gb;
 651 } DVAudioDecodeContext;
 652
 653 static int dvaudio_decode_init(AVCodecContext *avctx)
 654 {
 655     //    DVAudioDecodeContext *s = avctx->priv_data;
 656     return 0;
 657 }
 658
 659 static uint16_t dv_audio_12to16(uint16_t sample)
 660 {
 661     uint16_t shift, result;
 662
 663     sample = (sample < 0x800) ? sample : sample | 0xf000;
 664     shift = (sample & 0xf00) >> 8;
 665
 666     if (shift < 0x2 || shift > 0xd) {
 667         result = sample;
 668     } else if (shift < 0x8) {
 669         shift--;
 670         result = (sample - (256 * shift)) << shift;
 671     } else {
 672         shift = 0xe - shift;
 673         result = ((sample + ((256 * shift) + 1)) << shift) - 1;
 674     }
 675
 676     return result;
 677 }
 678
 679 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
 680    144000 bytes for PAL)
 681
 682    There's a couple of assumptions being made here:
 683          1. By default we silence erroneous (0x8000/16bit 0x800/12bit)
 684             audio samples. We can pass them upwards when ffmpeg will be ready
 685             to deal with them.
 686          2. We don't do software emphasis.
 687          3. Audio is always returned as 16bit linear samples: 12bit
 688             nonlinear samples are converted into 16bit linear ones.
 689 */
 690 static int dvaudio_decode_frame(AVCodecContext *avctx,
 691                                  void *data, int *data_size,
 692                                  uint8_t *buf, int buf_size)
 693 {
 694     DVVideoDecodeContext *s = avctx->priv_data;
 695     const uint16_t (*unshuffle)[9];
 696     int smpls, freq, quant, sys, stride, difseg, ad, dp, nb_dif_segs, i;
 697     uint16_t lc, rc;
 698     uint8_t *buf_ptr;
 699
 700     /* parse id */
 701     init_get_bits(&s->gb, &buf[AAUX_AS_OFFSET], 5*8);
 702     i = get_bits(&s->gb, 8);
 703     if (i != 0x50) { /* No audio ? */
 704         *data_size = 0;
 705         return buf_size;
 706     }
 707
 708     get_bits(&s->gb, 1); /* 0 - locked audio, 1 - unlocked audio */
 709     skip_bits(&s->gb, 1);
 710     smpls = get_bits(&s->gb, 6); /* samples in this frame - min. samples */
 711
 712     skip_bits(&s->gb, 8);
 713
 714     skip_bits(&s->gb, 2);
 715     sys = get_bits(&s->gb, 1); /* 0 - 60 fields, 1 = 50 fields */
 716     skip_bits(&s->gb, 5);
 717
 718     get_bits(&s->gb, 1); /* 0 - emphasis on, 1 - emphasis off */
 719     get_bits(&s->gb, 1); /* 0 - reserved, 1 - emphasis time constant 50/15us */
 720     freq = get_bits(&s->gb, 3); /* 0 - 48KHz, 1 - 44,1kHz, 2 - 32 kHz */
 721     quant = get_bits(&s->gb, 3); /* 0 - 16bit linear, 1 - 12bit nonlinear */
 722
 723     if (quant > 1)
 724         return -1; /* Unsupported quantization */
 725
 726     avctx->sample_rate = dv_audio_frequency[freq];
 727     avctx->channels = 2;
 728     avctx->bit_rate = avctx->channels * avctx->sample_rate * 16;
 729     // What about:
 730     // avctx->frame_size =
 731
 732     *data_size = (dv_audio_min_samples[sys][freq] + smpls) *
 733                  avctx->channels * 2;
 734
 735     if (sys) {
 736         nb_dif_segs = 12;
 737         stride = 108;
 738         unshuffle = dv_place_audio50;
 739     } else {
 740         nb_dif_segs = 10;
 741         stride = 90;
 742         unshuffle = dv_place_audio60;
 743     }
 744
 745     /* for each DIF segment */
 746     buf_ptr = buf;
 747     for (difseg = 0; difseg < nb_dif_segs; difseg++) {
 748          buf_ptr += 6 * 80; /* skip DIF segment header */
 749          for (ad = 0; ad < 9; ad++) {
 750
 751               for (dp = 8; dp < 80; dp+=2) {
 752                    if (quant == 0) {  /* 16bit quantization */
 753                        i = unshuffle[difseg][ad] + (dp - 8)/2 * stride;
 754                        ((short *)data)[i] = (buf_ptr[dp] << 8) | buf_ptr[dp+1];
 755                        if (((unsigned short *)data)[i] == 0x8000)
 756                            ((short *)data)[i] = 0;
 757                    } else {           /* 12bit quantization */
 758                        if (difseg >= nb_dif_segs/2)
 759                            goto out;  /* We're not doing 4ch at this time */
 760
 761                        lc = ((uint16_t)buf_ptr[dp] << 4) |
 762                             ((uint16_t)buf_ptr[dp+2] >> 4);
 763                        rc = ((uint16_t)buf_ptr[dp+1] << 4) |
 764                             ((uint16_t)buf_ptr[dp+2] & 0x0f);
 765                        lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
 766                        rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
 767
 768                        i = unshuffle[difseg][ad] + (dp - 8)/3 * stride;
 769                        ((short *)data)[i] = lc;
 770                        i = unshuffle[difseg+nb_dif_segs/2][ad] + (dp - 8)/3 * stride;
 771                        ((short *)data)[i] = rc;
 772                        ++dp;
 773                    }
 774               }
 775
 776             buf_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
 777         }
 778     }
 779
 780 out:
 781     return buf_size;
 782 }
 783
 784 static int dvaudio_decode_end(AVCodecContext *avctx)
 785 {
 786     //    DVAudioDecodeContext *s = avctx->priv_data;
 787     return 0;
 788 }
 789
 790 AVCodec dvaudio_decoder = {
 791     "dvaudio",
 792     CODEC_TYPE_AUDIO,
 793     CODEC_ID_DVAUDIO,
 794     sizeof(DVAudioDecodeContext),
 795     dvaudio_decode_init,
 796     NULL,
 797     dvaudio_decode_end,
 798     dvaudio_decode_frame,
 799     0,
 800     NULL
 801 };