falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1892 Commits
32 Branches
498MB
Tree: f99963b016
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f99963b016'
${ noResults }
FFmpeg/libavcodec/dv.c

794 lines
24KB
Raw Blame History 

  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.     s->picture.reference= 0;

  572.     if(avctx->get_buffer(avctx, &s->picture) < 0) {

  573.         fprintf(stderr, "get_buffer() failed\n");

  574.         return -1;

  575.     }

  576. 

  577.     for(i=0;i<3;i++) {

  578.         s->current_picture[i] = s->picture.data[i];

  579.         s->linesize[i] = s->picture.linesize[i];

  580.         if (!s->current_picture[i])

  581.             return -1;

  582.     }

  583.     s->width = width;

  584.     s->height = height;

  585. 

  586.     /* for each DIF segment */

  587.     buf_ptr = buf;

  588.     for (ds = 0; ds < nb_dif_segs; ds++) {

  589.         buf_ptr += 6 * 80; /* skip DIF segment header */

  590.         

  591.         for(vs = 0; vs < 27; vs++) {

  592.             if ((vs % 3) == 0) {

  593.                 /* skip audio block */

  594.                 buf_ptr += 80;

  595.             }

  596.             dv_decode_video_segment(s, buf_ptr, mb_pos_ptr);

  597.             buf_ptr += 5 * 80;

  598.             mb_pos_ptr += 5;

  599.         }

  600.     }

  601. 

  602.     emms_c();

  603. 

  604.     /* return image */

  605.     *data_size = sizeof(AVFrame);

  606.     *(AVFrame*)data= s->picture;

  607.     

  608.     avctx->release_buffer(avctx, &s->picture);

  609.     

  610.     return packet_size;

  611. }

  612. 

  613. static int dvvideo_decode_end(AVCodecContext *avctx)

  614. {

  615.     DVVideoDecodeContext *s = avctx->priv_data;

  616.     int i;

  617.     

  618.     if(avctx->get_buffer == avcodec_default_get_buffer){

  619.         for(i=0; i<4; i++){

  620.             av_freep(&s->picture.base[i]);

  621.             s->picture.data[i]= NULL;

  622.         }

  623.         av_freep(&s->picture.opaque);

  624.     }

  625. 

  626.     return 0;

  627. }

  628. 

  629. AVCodec dvvideo_decoder = {

  630.     "dvvideo",

  631.     CODEC_TYPE_VIDEO,

  632.     CODEC_ID_DVVIDEO,

  633.     sizeof(DVVideoDecodeContext),

  634.     dvvideo_decode_init,

  635.     NULL,

  636.     dvvideo_decode_end,

  637.     dvvideo_decode_frame,

  638.     CODEC_CAP_DR1,

  639.     NULL

  640. };

  641. 

  642. typedef struct DVAudioDecodeContext {

  643.     AVCodecContext *avctx;

  644.     GetBitContext gb;

  645. } DVAudioDecodeContext;

  646. 

  647. static int dvaudio_decode_init(AVCodecContext *avctx)

  648. {

  649.     //    DVAudioDecodeContext *s = avctx->priv_data;

  650.     return 0;

  651. }

  652. 

  653. static uint16_t dv_audio_12to16(uint16_t sample)

  654. {

  655.     uint16_t shift, result;

  656.     

  657.     sample = (sample < 0x800) ? sample : sample | 0xf000;

  658.     shift = (sample & 0xf00) >> 8;

  659. 

  660.     if (shift < 0x2 || shift > 0xd) {

  661. 	result = sample;

  662.     } else if (shift < 0x8) {

  663.         shift--;

  664. 	result = (sample - (256 * shift)) << shift;

  665.     } else {

  666. 	shift = 0xe - shift;

  667. 	result = ((sample + ((256 * shift) + 1)) << shift) - 1;

  668.     }

  669. 

  670.     return result;

  671. }

  672. 

  673. /* NOTE: exactly one frame must be given (120000 bytes for NTSC,

  674.    144000 bytes for PAL) 

  675. 

  676.    There's a couple of assumptions being made here:

  677.          1. We don't do any kind of audio error correction. It means,

  678. 	    that erroneous samples 0x8000 are being passed upwards.

  679.             Do we need to silence erroneous samples ? Average them ?

  680. 	 2. We don't do software emphasis.

  681. 	 3. We are not checking for 'speed' argument being valid.

  682. 	 4. Audio is always returned as 16bit linear samples: 12bit

  683. 	    nonlinear samples are converted into 16bit linear ones.

  684. */

  685. static int dvaudio_decode_frame(AVCodecContext *avctx, 

  686.                                  void *data, int *data_size,

  687.                                  uint8_t *buf, int buf_size)

  688. {

  689.     DVVideoDecodeContext *s = avctx->priv_data;

  690.     const uint16_t (*unshuffle)[9];

  691.     int smpls, freq, quant, sys, stride, difseg, ad, dp, nb_dif_segs, i;

  692.     uint16_t lc, rc;

  693.     uint8_t *buf_ptr;

  694.     

  695.     /* parse id */

  696.     init_get_bits(&s->gb, &buf[AAUX_OFFSET], 5*8);

  697.     i = get_bits(&s->gb, 8);

  698.     if (i != 0x50) { /* No audio ? */

  699. 	*data_size = 0;

  700. 	return buf_size;

  701.     }

  702.     

  703.     get_bits(&s->gb, 1); /* 0 - locked audio, 1 - unlocked audio */

  704.     skip_bits(&s->gb, 1);

  705.     smpls = get_bits(&s->gb, 6); /* samples in this frame - min. samples */

  706. 

  707.     skip_bits(&s->gb, 8);

  708. 

  709.     skip_bits(&s->gb, 2);

  710.     sys = get_bits(&s->gb, 1); /* 0 - 60 fields, 1 = 50 fields */

  711.     skip_bits(&s->gb, 5);

  712. 

  713.     get_bits(&s->gb, 1); /* 0 - emphasis on, 1 - emphasis off */

  714.     get_bits(&s->gb, 1); /* 0 - reserved, 1 - emphasis time constant 50/15us */

  715.     freq = get_bits(&s->gb, 3); /* 0 - 48KHz, 1 - 44,1kHz, 2 - 32 kHz */

  716.     quant = get_bits(&s->gb, 3); /* 0 - 16bit linear, 1 - 12bit nonlinear */

  717. 

  718.     if (quant > 1)

  719. 	return -1; /* Unsupported quantization */

  720. 

  721.     avctx->sample_rate = dv_audio_frequency[freq];

  722.     // What about:

  723.     // avctx->bit_rate = 

  724.     // avctx->frame_size =

  725.    

  726.     *data_size = (dv_audio_min_samples[sys][freq] + smpls) * 

  727. 	         avctx->channels * 2;

  728. 

  729.     if (sys) {

  730. 	nb_dif_segs = 12;

  731. 	stride = 108;

  732. 	unshuffle = dv_place_audio50;

  733.     } else {

  734. 	nb_dif_segs = 10;

  735. 	stride = 90;

  736. 	unshuffle = dv_place_audio60;

  737.     }

  738.     

  739.     /* for each DIF segment */

  740.     buf_ptr = buf;

  741.     for (difseg = 0; difseg < nb_dif_segs; difseg++) {

  742.          buf_ptr += 6 * 80; /* skip DIF segment header */

  743.          for (ad = 0; ad < 9; ad++) {

  744.               

  745.               for (dp = 8; dp < 80; dp+=2) {

  746. 		   if (quant == 0) {  /* 16bit quantization */

  747. 		       i = unshuffle[difseg][ad] + (dp - 8)/2 * stride;

  748. 		       ((short *)data)[i] = (buf_ptr[dp] << 8) | buf_ptr[dp+1]; 

  749. 		   } else {           /* 12bit quantization */

  750. 		       if (difseg >= nb_dif_segs/2)

  751. 			   goto out;  /* We're not doing 4ch at this time */

  752. 		       

  753. 		       lc = ((uint16_t)buf_ptr[dp] << 4) | 

  754. 			    ((uint16_t)buf_ptr[dp+2] >> 4);

  755. 		       rc = ((uint16_t)buf_ptr[dp+1] << 4) |

  756. 			    ((uint16_t)buf_ptr[dp+2] & 0x0f);

  757. 		       lc = dv_audio_12to16(lc);

  758. 		       rc = dv_audio_12to16(rc);

  759. 

  760. 		       i = unshuffle[difseg][ad] + (dp - 8)/3 * stride;

  761. 		       ((short *)data)[i] = lc;

  762. 		       i = unshuffle[difseg+nb_dif_segs/2][ad] + (dp - 8)/3 * stride;

  763. 		       ((short *)data)[i] = rc;

  764. 		       ++dp;

  765. 		   }

  766. 	      }

  767. 		

  768. 	    buf_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */

  769.         }

  770.     }

  771. 

  772. out:

  773.     return buf_size;

  774. }

  775. 

  776. static int dvaudio_decode_end(AVCodecContext *avctx)

  777. {

  778.     //    DVAudioDecodeContext *s = avctx->priv_data;

  779.     return 0;

  780. }

  781. 

  782. AVCodec dvaudio_decoder = {

  783.     "dvaudio",

  784.     CODEC_TYPE_AUDIO,

  785.     CODEC_ID_DVAUDIO,

  786.     sizeof(DVAudioDecodeContext),

  787.     dvaudio_decode_init,

  788.     NULL,

  789.     dvaudio_decode_end,

  790.     dvaudio_decode_frame,

  791.     0,

  792.     NULL

  793. };