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                 printf("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         packet_size = PAL_FRAME_SIZE;
 542         height = 576;
 543         nb_dif_segs = 12;
 544     } else {
 545         avctx->frame_rate = 30;
 546         packet_size = NTSC_FRAME_SIZE;
 547         height = 480;
 548         nb_dif_segs = 10;
 549     }
 550     avctx->frame_rate_base= 1;
 551     /* NOTE: we only accept several full frames */
 552     if (buf_size < packet_size)
 553         return -1;
 554
 555     /* NTSC[dsf == 0] is always 720x480, 4:1:1
 556      *  PAL[dsf == 1] is always 720x576, 4:2:0 for IEC 68134[apt == 0]
 557      *  but for the SMPTE 314M[apt == 1] it is 720x576, 4:1:1
 558      */
 559     s->sampling_411 = !dsf || apt;
 560     if (s->sampling_411) {
 561         mb_pos_ptr = dsf ? dv_place_411P : dv_place_411;
 562         avctx->pix_fmt = PIX_FMT_YUV411P;
 563     } else {
 564         mb_pos_ptr = dv_place_420;
 565         avctx->pix_fmt = PIX_FMT_YUV420P;
 566     }
 567
 568     avctx->width = width;
 569     avctx->height = height;
 570
 571     /* Once again, this is pretty complicated by the fact that the same
 572      * field is used differently by IEC 68134[apt == 0] and
 573      * SMPTE 314M[apt == 1].
 574      */
 575     if (buf[VAUX_TC61_OFFSET] == 0x61 &&
 576         ((apt == 0 && (buf[VAUX_TC61_OFFSET + 2] & 0x07) == 0x07) ||
 577          (apt == 1 && (buf[VAUX_TC61_OFFSET + 2] & 0x07) == 0x02)))
 578         avctx->aspect_ratio = 16.0 / 9.0;
 579     else
 580         avctx->aspect_ratio = 4.0 / 3.0;
 581
 582     s->picture.reference= 0;
 583     if(avctx->get_buffer(avctx, &s->picture) < 0) {
 584         fprintf(stderr, "get_buffer() failed\n");
 585         return -1;
 586     }
 587
 588     for(i=0;i<3;i++) {
 589         s->current_picture[i] = s->picture.data[i];
 590         s->linesize[i] = s->picture.linesize[i];
 591         if (!s->current_picture[i])
 592             return -1;
 593     }
 594     s->width = width;
 595     s->height = height;
 596
 597     /* for each DIF segment */
 598     buf_ptr = buf;
 599     for (ds = 0; ds < nb_dif_segs; ds++) {
 600         buf_ptr += 6 * 80; /* skip DIF segment header */
 601
 602         for(vs = 0; vs < 27; vs++) {
 603             if ((vs % 3) == 0) {
 604                 /* skip audio block */
 605                 buf_ptr += 80;
 606             }
 607             dv_decode_video_segment(s, buf_ptr, mb_pos_ptr);
 608             buf_ptr += 5 * 80;
 609             mb_pos_ptr += 5;
 610         }
 611     }
 612
 613     emms_c();
 614
 615     /* return image */
 616     *data_size = sizeof(AVFrame);
 617     *(AVFrame*)data= s->picture;
 618
 619     avctx->release_buffer(avctx, &s->picture);
 620
 621     return packet_size;
 622 }
 623
 624 static int dvvideo_decode_end(AVCodecContext *avctx)
 625 {
 626     DVVideoDecodeContext *s = avctx->priv_data;
 627     int i;
 628
 629     if(avctx->get_buffer == avcodec_default_get_buffer){
 630         for(i=0; i<4; i++){
 631             av_freep(&s->picture.base[i]);
 632             s->picture.data[i]= NULL;
 633         }
 634         av_freep(&s->picture.opaque);
 635     }
 636
 637     return 0;
 638 }
 639
 640 AVCodec dvvideo_decoder = {
 641     "dvvideo",
 642     CODEC_TYPE_VIDEO,
 643     CODEC_ID_DVVIDEO,
 644     sizeof(DVVideoDecodeContext),
 645     dvvideo_decode_init,
 646     NULL,
 647     dvvideo_decode_end,
 648     dvvideo_decode_frame,
 649     CODEC_CAP_DR1,
 650     NULL
 651 };
 652
 653 typedef struct DVAudioDecodeContext {
 654     AVCodecContext *avctx;
 655     GetBitContext gb;
 656 } DVAudioDecodeContext;
 657
 658 static int dvaudio_decode_init(AVCodecContext *avctx)
 659 {
 660     //    DVAudioDecodeContext *s = avctx->priv_data;
 661     return 0;
 662 }
 663
 664 static uint16_t dv_audio_12to16(uint16_t sample)
 665 {
 666     uint16_t shift, result;
 667
 668     sample = (sample < 0x800) ? sample : sample | 0xf000;
 669     shift = (sample & 0xf00) >> 8;
 670
 671     if (shift < 0x2 || shift > 0xd) {
 672         result = sample;
 673     } else if (shift < 0x8) {
 674         shift--;
 675         result = (sample - (256 * shift)) << shift;
 676     } else {
 677         shift = 0xe - shift;
 678         result = ((sample + ((256 * shift) + 1)) << shift) - 1;
 679     }
 680
 681     return result;
 682 }
 683
 684 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
 685    144000 bytes for PAL)
 686
 687    There's a couple of assumptions being made here:
 688          1. By default we silence erroneous (0x8000/16bit 0x800/12bit)
 689             audio samples. We can pass them upwards when ffmpeg will be ready
 690             to deal with them.
 691          2. We don't do software emphasis.
 692          3. Audio is always returned as 16bit linear samples: 12bit
 693             nonlinear samples are converted into 16bit linear ones.
 694 */
 695 static int dvaudio_decode_frame(AVCodecContext *avctx,
 696                                  void *data, int *data_size,
 697                                  uint8_t *buf, int buf_size)
 698 {
 699     DVVideoDecodeContext *s = avctx->priv_data;
 700     const uint16_t (*unshuffle)[9];
 701     int smpls, freq, quant, sys, stride, difseg, ad, dp, nb_dif_segs, i;
 702     uint16_t lc, rc;
 703     uint8_t *buf_ptr;
 704
 705     /* parse id */
 706     init_get_bits(&s->gb, &buf[AAUX_AS_OFFSET], 5*8);
 707     i = get_bits(&s->gb, 8);
 708     if (i != 0x50) { /* No audio ? */
 709         *data_size = 0;
 710         return buf_size;
 711     }
 712
 713     get_bits(&s->gb, 1); /* 0 - locked audio, 1 - unlocked audio */
 714     skip_bits(&s->gb, 1);
 715     smpls = get_bits(&s->gb, 6); /* samples in this frame - min. samples */
 716
 717     skip_bits(&s->gb, 8);
 718
 719     skip_bits(&s->gb, 2);
 720     sys = get_bits(&s->gb, 1); /* 0 - 60 fields, 1 = 50 fields */
 721     skip_bits(&s->gb, 5);
 722
 723     get_bits(&s->gb, 1); /* 0 - emphasis on, 1 - emphasis off */
 724     get_bits(&s->gb, 1); /* 0 - reserved, 1 - emphasis time constant 50/15us */
 725     freq = get_bits(&s->gb, 3); /* 0 - 48KHz, 1 - 44,1kHz, 2 - 32 kHz */
 726     quant = get_bits(&s->gb, 3); /* 0 - 16bit linear, 1 - 12bit nonlinear */
 727
 728     if (quant > 1)
 729         return -1; /* Unsupported quantization */
 730
 731     avctx->sample_rate = dv_audio_frequency[freq];
 732     avctx->channels = 2;
 733     // What about:
 734     // avctx->bit_rate =
 735     // avctx->frame_size =
 736
 737     *data_size = (dv_audio_min_samples[sys][freq] + smpls) *
 738                  avctx->channels * 2;
 739
 740     if (sys) {
 741         nb_dif_segs = 12;
 742         stride = 108;
 743         unshuffle = dv_place_audio50;
 744     } else {
 745         nb_dif_segs = 10;
 746         stride = 90;
 747         unshuffle = dv_place_audio60;
 748     }
 749
 750     /* for each DIF segment */
 751     buf_ptr = buf;
 752     for (difseg = 0; difseg < nb_dif_segs; difseg++) {
 753          buf_ptr += 6 * 80; /* skip DIF segment header */
 754          for (ad = 0; ad < 9; ad++) {
 755
 756               for (dp = 8; dp < 80; dp+=2) {
 757                    if (quant == 0) {  /* 16bit quantization */
 758                        i = unshuffle[difseg][ad] + (dp - 8)/2 * stride;
 759                        ((short *)data)[i] = (buf_ptr[dp] << 8) | buf_ptr[dp+1];
 760                        if (((unsigned short *)data)[i] == 0x8000)
 761                            ((short *)data)[i] = 0;
 762                    } else {           /* 12bit quantization */
 763                        if (difseg >= nb_dif_segs/2)
 764                            goto out;  /* We're not doing 4ch at this time */
 765
 766                        lc = ((uint16_t)buf_ptr[dp] << 4) |
 767                             ((uint16_t)buf_ptr[dp+2] >> 4);
 768                        rc = ((uint16_t)buf_ptr[dp+1] << 4) |
 769                             ((uint16_t)buf_ptr[dp+2] & 0x0f);
 770                        lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
 771                        rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
 772
 773                        i = unshuffle[difseg][ad] + (dp - 8)/3 * stride;
 774                        ((short *)data)[i] = lc;
 775                        i = unshuffle[difseg+nb_dif_segs/2][ad] + (dp - 8)/3 * stride;
 776                        ((short *)data)[i] = rc;
 777                        ++dp;
 778                    }
 779               }
 780
 781             buf_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
 782         }
 783     }
 784
 785 out:
 786     return buf_size;
 787 }
 788
 789 static int dvaudio_decode_end(AVCodecContext *avctx)
 790 {
 791     //    DVAudioDecodeContext *s = avctx->priv_data;
 792     return 0;
 793 }
 794
 795 AVCodec dvaudio_decoder = {
 796     "dvaudio",
 797     CODEC_TYPE_AUDIO,
 798     CODEC_ID_DVAUDIO,
 799     sizeof(DVAudioDecodeContext),
 800     dvaudio_decode_init,
 801     NULL,
 802     dvaudio_decode_end,
 803     dvaudio_decode_frame,
 804     0,
 805     NULL
 806 };