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.
2014 Commits
32 Branches
283MB
Tree: 15e654b17b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '15e654b17b'
${ noResults }
FFmpeg/libavcodec/dv.c

807 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.     /* 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. };