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

696 lines
21KB
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. #include "avcodec.h"

  20. #include "dsputil.h"

  21. #include "mpegvideo.h"

  22. #include "simple_idct.h"

  23. 

  24. #define NTSC_FRAME_SIZE 120000

  25. #define PAL_FRAME_SIZE  144000

  26. 

  27. #define TEX_VLC_BITS 9

  28. 

  29. typedef struct DVVideoDecodeContext {

  30.     AVCodecContext *avctx;

  31.     GetBitContext gb;

  32.     VLC *vlc;

  33.     int sampling_411; /* 0 = 420, 1 = 411 */

  34.     int width, height;

  35.     UINT8 *current_picture[3]; /* picture structure */

  36.     int linesize[3];

  37.     DCTELEM block[5*6][64] __align8;

  38.     UINT8 dv_zigzag[2][64];

  39.     UINT8 idct_permutation[64];

  40.     /* XXX: move it to static storage ? */

  41.     UINT8 dv_shift[2][22][64];

  42.     void (*idct_put[2])(UINT8 *dest, int line_size, DCTELEM *block);

  43. } DVVideoDecodeContext;

  44. 

  45. #include "dvdata.h"

  46. 

  47. static VLC dv_vlc;

  48. /* XXX: also include quantization */

  49. static RL_VLC_ELEM *dv_rl_vlc[1];

  50. 

  51. static void dv_build_unquantize_tables(DVVideoDecodeContext *s)

  52. {

  53.     int i, q, j;

  54. 

  55.     /* NOTE: max left shift is 6 */

  56.     for(q = 0; q < 22; q++) {

  57.         /* 88 unquant */

  58.         for(i = 1; i < 64; i++) {

  59.             /* 88 table */

  60.             j = s->idct_permutation[i];

  61.             s->dv_shift[0][q][j] =

  62.                 dv_quant_shifts[q][dv_88_areas[i]] + 1;

  63.         }

  64.         

  65.         /* 248 unquant */

  66.         for(i = 1; i < 64; i++) {

  67.             /* 248 table */

  68.             s->dv_shift[1][q][i] =  

  69.                     dv_quant_shifts[q][dv_248_areas[i]] + 1;

  70.         }

  71.     }

  72. }

  73. 

  74. static int dvvideo_decode_init(AVCodecContext *avctx)

  75. {

  76.     DVVideoDecodeContext *s = avctx->priv_data;

  77.     MpegEncContext s2;

  78.     static int done;

  79. 

  80.     if (!done) {

  81.         int i;

  82. 

  83.         done = 1;

  84. 

  85.         /* NOTE: as a trick, we use the fact the no codes are unused

  86.            to accelerate the parsing of partial codes */

  87.         init_vlc(&dv_vlc, TEX_VLC_BITS, NB_DV_VLC, 

  88.                  dv_vlc_len, 1, 1, dv_vlc_bits, 2, 2);

  89. 

  90.         dv_rl_vlc[0] = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));

  91.         for(i = 0; i < dv_vlc.table_size; i++){

  92.             int code= dv_vlc.table[i][0];

  93.             int len = dv_vlc.table[i][1];

  94.             int level, run;

  95.         

  96.             if(len<0){ //more bits needed

  97.                 run= 0;

  98.                 level= code;

  99.             } else if (code == (NB_DV_VLC - 1)) {

  100.                 /* EOB */

  101.                 run = 0;

  102.                 level = 256;

  103.             } else {

  104.                 run=   dv_vlc_run[code] + 1;

  105.                 level= dv_vlc_level[code];

  106.             }

  107.             dv_rl_vlc[0][i].len = len;

  108.             dv_rl_vlc[0][i].level = level;

  109.             dv_rl_vlc[0][i].run = run;

  110.         }

  111.     }

  112. 

  113.     /* ugly way to get the idct & scantable */

  114.     /* XXX: fix it */

  115.     memset(&s2, 0, sizeof(MpegEncContext));

  116.     s2.avctx = avctx;

  117.     dsputil_init(&s2.dsp, avctx->dsp_mask);

  118.     if (DCT_common_init(&s2) < 0)

  119.        return -1;

  120. 

  121.     s->idct_put[0] = s2.idct_put;

  122.     memcpy(s->idct_permutation, s2.idct_permutation, 64);

  123.     memcpy(s->dv_zigzag[0], s2.intra_scantable.permutated, 64);

  124. 

  125.     /* XXX: use MMX also for idct248 */

  126.     s->idct_put[1] = simple_idct248_put;

  127.     memcpy(s->dv_zigzag[1], dv_248_zigzag, 64);

  128. 

  129.     /* XXX: do it only for constant case */

  130.     dv_build_unquantize_tables(s);

  131. 

  132.     return 0;

  133. }

  134. 

  135. //#define VLC_DEBUG

  136. 

  137. typedef struct BlockInfo {

  138.     const UINT8 *shift_table;

  139.     const UINT8 *scan_table;

  140.     UINT8 pos; /* position in block */

  141.     UINT8 eob_reached; /* true if EOB has been reached */

  142.     UINT8 dct_mode;

  143.     UINT8 partial_bit_count;

  144.     UINT16 partial_bit_buffer;

  145.     int shift_offset;

  146. } BlockInfo;

  147. 

  148. /* block size in bits */

  149. static const UINT16 block_sizes[6] = {

  150.     112, 112, 112, 112, 80, 80

  151. };

  152. 

  153. #ifndef ALT_BITSTREAM_READER

  154. #error only works with ALT_BITSTREAM_READER

  155. #endif

  156. 

  157. /* decode ac coefs */

  158. static void dv_decode_ac(DVVideoDecodeContext *s, 

  159.                          BlockInfo *mb, INT16 *block, int last_index)

  160. {

  161.     int last_re_index;

  162.     int shift_offset = mb->shift_offset;

  163.     const UINT8 *scan_table = mb->scan_table;

  164.     const UINT8 *shift_table = mb->shift_table;

  165.     int pos = mb->pos;

  166.     int level, pos1, sign, run;

  167.     int partial_bit_count;

  168. 

  169.     OPEN_READER(re, &s->gb);

  170.     

  171. #ifdef VLC_DEBUG

  172.     printf("start\n");

  173. #endif

  174. 

  175.     /* if we must parse a partial vlc, we do it here */

  176.     partial_bit_count = mb->partial_bit_count;

  177.     if (partial_bit_count > 0) {

  178.         UINT8 buf[4];

  179.         UINT32 v;

  180.         int l, l1;

  181.         GetBitContext gb1;

  182. 

  183.         /* build the dummy bit buffer */

  184.         l = 16 - partial_bit_count;

  185.         UPDATE_CACHE(re, &s->gb);

  186. #ifdef VLC_DEBUG

  187.         printf("show=%04x\n", SHOW_UBITS(re, &s->gb, 16));

  188. #endif

  189.         v = (mb->partial_bit_buffer << l) | SHOW_UBITS(re, &s->gb, l);

  190.         buf[0] = v >> 8;

  191.         buf[1] = v;

  192. #ifdef VLC_DEBUG

  193.         printf("v=%04x cnt=%d %04x\n", 

  194.                v, partial_bit_count, (mb->partial_bit_buffer << l));

  195. #endif

  196.         /* try to read the codeword */

  197.         init_get_bits(&gb1, buf, 4);

  198.         {

  199.             OPEN_READER(re1, &gb1);

  200.             UPDATE_CACHE(re1, &gb1);

  201.             GET_RL_VLC(level, run, re1, &gb1, dv_rl_vlc[0], 

  202.                        TEX_VLC_BITS, 2);

  203.             l = re1_index;

  204.             CLOSE_READER(re1, &gb1);

  205.         }

  206. #ifdef VLC_DEBUG

  207.         printf("****run=%d level=%d size=%d\n", run, level, l);

  208. #endif

  209.         /* compute codeword length */

  210.         l1 = (level != 256 && level != 0);

  211.         /* if too long, we cannot parse */

  212.         l -= partial_bit_count;

  213.         if ((re_index + l + l1) > last_index)

  214.             return;

  215.         /* skip read bits */

  216.         last_re_index = 0; /* avoid warning */

  217.         re_index += l;

  218.         /* by definition, if we can read the vlc, all partial bits

  219.            will be read (otherwise we could have read the vlc before) */

  220.         mb->partial_bit_count = 0;

  221.         UPDATE_CACHE(re, &s->gb);

  222.         goto handle_vlc;

  223.     }

  224. 

  225.     /* get the AC coefficients until last_index is reached */

  226.     for(;;) {

  227.         UPDATE_CACHE(re, &s->gb);

  228. #ifdef VLC_DEBUG

  229.         printf("%2d: bits=%04x index=%d\n", 

  230.                pos, SHOW_UBITS(re, &s->gb, 16), re_index);

  231. #endif

  232.         last_re_index = re_index;

  233.         GET_RL_VLC(level, run, re, &s->gb, dv_rl_vlc[0], 

  234.                    TEX_VLC_BITS, 2);

  235.     handle_vlc:

  236. #ifdef VLC_DEBUG

  237.         printf("run=%d level=%d\n", run, level);

  238. #endif

  239.         if (level == 256) {

  240.             if (re_index > last_index) {

  241.             cannot_read:

  242.                 /* put position before read code */

  243.                 re_index = last_re_index;

  244.                 mb->eob_reached = 0;

  245.                 break;

  246.             }

  247.             /* EOB */

  248.             mb->eob_reached = 1;

  249.             break;

  250.         } else if (level != 0) {

  251.             if ((re_index + 1) > last_index)

  252.                 goto cannot_read;

  253.             sign = SHOW_SBITS(re, &s->gb, 1);

  254.             level = (level ^ sign) - sign;

  255.             LAST_SKIP_BITS(re, &s->gb, 1);

  256.             pos += run;

  257.             /* error */

  258.             if (pos >= 64) {

  259.                 goto read_error;

  260.             }

  261.             pos1 = scan_table[pos];

  262.             level = level << (shift_table[pos1] + shift_offset);

  263.             block[pos1] = level;

  264.             //            printf("run=%d level=%d shift=%d\n", run, level, shift_table[pos1]);

  265.         } else {

  266.             if (re_index > last_index)

  267.                 goto cannot_read;

  268.             /* level is zero: means run without coding. No

  269.                sign is coded */

  270.             pos += run;

  271.             /* error */

  272.             if (pos >= 64) {

  273.             read_error:

  274. #if defined(VLC_DEBUG) || 1

  275.                 printf("error pos=%d\n", pos);

  276. #endif

  277.                 /* for errors, we consider the eob is reached */

  278.                 mb->eob_reached = 1;

  279.                 break;

  280.             }

  281.         }

  282.     }

  283.     CLOSE_READER(re, &s->gb);

  284.     mb->pos = pos;

  285. }

  286. 

  287. static inline void bit_copy(PutBitContext *pb, GetBitContext *gb, int bits_left)

  288. {

  289.     while (bits_left >= 16) {

  290.         put_bits(pb, 16, get_bits(gb, 16));

  291.         bits_left -= 16;

  292.     }

  293.     if (bits_left > 0) {

  294.         put_bits(pb, bits_left, get_bits(gb, bits_left));

  295.     }

  296. }

  297. 

  298. /* mb_x and mb_y are in units of 8 pixels */

  299. static inline void dv_decode_video_segment(DVVideoDecodeContext *s, 

  300.                                            UINT8 *buf_ptr1, 

  301.                                            const UINT16 *mb_pos_ptr)

  302. {

  303.     int quant, dc, dct_mode, class1, j;

  304.     int mb_index, mb_x, mb_y, v, last_index;

  305.     DCTELEM *block, *block1;

  306.     int c_offset, bits_left;

  307.     UINT8 *y_ptr;

  308.     BlockInfo mb_data[5 * 6], *mb, *mb1;

  309.     void (*idct_put)(UINT8 *dest, int line_size, DCTELEM *block);

  310.     UINT8 *buf_ptr;

  311.     PutBitContext pb, vs_pb;

  312.     UINT8 mb_bit_buffer[80 + 4]; /* allow some slack */

  313.     int mb_bit_count;

  314.     UINT8 vs_bit_buffer[5 * 80 + 4]; /* allow some slack */

  315.     int vs_bit_count;

  316.     

  317.     memset(s->block, 0, sizeof(s->block));

  318. 

  319.     /* pass 1 : read DC and AC coefficients in blocks */

  320.     buf_ptr = buf_ptr1;

  321.     block1 = &s->block[0][0];

  322.     mb1 = mb_data;

  323.     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80, NULL, NULL);

  324.     vs_bit_count = 0;

  325.     for(mb_index = 0; mb_index < 5; mb_index++) {

  326.         /* skip header */

  327.         quant = buf_ptr[3] & 0x0f;

  328.         buf_ptr += 4;

  329.         init_put_bits(&pb, mb_bit_buffer, 80, NULL, NULL);

  330.         mb_bit_count = 0;

  331.         mb = mb1;

  332.         block = block1;

  333.         for(j = 0;j < 6; j++) {

  334.             /* NOTE: size is not important here */

  335.             init_get_bits(&s->gb, buf_ptr, 14);

  336.             

  337.             /* get the dc */

  338.             dc = get_bits(&s->gb, 9);

  339.             dc = (dc << (32 - 9)) >> (32 - 9);

  340.             dct_mode = get_bits1(&s->gb);

  341.             mb->dct_mode = dct_mode;

  342.             mb->scan_table = s->dv_zigzag[dct_mode];

  343.             class1 = get_bits(&s->gb, 2);

  344.             mb->shift_offset = (class1 == 3);

  345.             mb->shift_table = s->dv_shift[dct_mode]

  346.                 [quant + dv_quant_offset[class1]];

  347.             dc = dc << 2;

  348.             /* convert to unsigned because 128 is not added in the

  349.                standard IDCT */

  350.             dc += 1024;

  351.             block[0] = dc;

  352.             last_index = block_sizes[j];

  353.             buf_ptr += last_index >> 3;

  354.             mb->pos = 0;

  355.             mb->partial_bit_count = 0;

  356. 

  357.             dv_decode_ac(s, mb, block, last_index);

  358. 

  359.             /* write the remaining bits  in a new buffer only if the

  360.                block is finished */

  361.             bits_left = last_index - s->gb.index;

  362.             if (mb->eob_reached) {

  363.                 mb->partial_bit_count = 0;

  364.                 mb_bit_count += bits_left;

  365.                 bit_copy(&pb, &s->gb, bits_left);

  366.             } else {

  367.                 /* should be < 16 bits otherwise a codeword could have

  368.                    been parsed */

  369.                 mb->partial_bit_count = bits_left;

  370.                 mb->partial_bit_buffer = get_bits(&s->gb, bits_left);

  371.             }

  372.             block += 64;

  373.             mb++;

  374.         }

  375.         

  376.         flush_put_bits(&pb);

  377. 

  378.         /* pass 2 : we can do it just after */

  379. #ifdef VLC_DEBUG

  380.         printf("***pass 2 size=%d\n", mb_bit_count);

  381. #endif

  382.         block = block1;

  383.         mb = mb1;

  384.         init_get_bits(&s->gb, mb_bit_buffer, 80);

  385.         for(j = 0;j < 6; j++) {

  386.             if (!mb->eob_reached && s->gb.index < mb_bit_count) {

  387.                 dv_decode_ac(s, mb, block, mb_bit_count);

  388.                 /* if still not finished, no need to parse other blocks */

  389.                 if (!mb->eob_reached) {

  390.                     /* we could not parse the current AC coefficient,

  391.                        so we add the remaining bytes */

  392.                     bits_left = mb_bit_count - s->gb.index;

  393.                     if (bits_left > 0) {

  394.                         mb->partial_bit_count += bits_left;

  395.                         mb->partial_bit_buffer = 

  396.                             (mb->partial_bit_buffer << bits_left) | 

  397.                             get_bits(&s->gb, bits_left);

  398.                     }

  399.                     goto next_mb;

  400.                 }

  401.             }

  402.             block += 64;

  403.             mb++;

  404.         }

  405.         /* all blocks are finished, so the extra bytes can be used at

  406.            the video segment level */

  407.         bits_left = mb_bit_count - s->gb.index;

  408.         vs_bit_count += bits_left;

  409.         bit_copy(&vs_pb, &s->gb, bits_left);

  410.     next_mb:

  411.         mb1 += 6;

  412.         block1 += 6 * 64;

  413.     }

  414. 

  415.     /* we need a pass other the whole video segment */

  416.     flush_put_bits(&vs_pb);

  417.         

  418. #ifdef VLC_DEBUG

  419.     printf("***pass 3 size=%d\n", vs_bit_count);

  420. #endif

  421.     block = &s->block[0][0];

  422.     mb = mb_data;

  423.     init_get_bits(&s->gb, vs_bit_buffer, 5 * 80);

  424.     for(mb_index = 0; mb_index < 5; mb_index++) {

  425.         for(j = 0;j < 6; j++) {

  426.             if (!mb->eob_reached) {

  427. #ifdef VLC_DEBUG

  428.                 printf("start %d:%d\n", mb_index, j);

  429. #endif

  430.                 dv_decode_ac(s, mb, block, vs_bit_count);

  431.             }

  432.             block += 64;

  433.             mb++;

  434.         }

  435.     }

  436.     

  437.     /* compute idct and place blocks */

  438.     block = &s->block[0][0];

  439.     mb = mb_data;

  440.     for(mb_index = 0; mb_index < 5; mb_index++) {

  441.         v = *mb_pos_ptr++;

  442.         mb_x = v & 0xff;

  443.         mb_y = v >> 8;

  444.         y_ptr = s->current_picture[0] + (mb_y * s->linesize[0] * 8) + (mb_x * 8);

  445.         if (s->sampling_411)

  446.             c_offset = (mb_y * s->linesize[1] * 8) + ((mb_x >> 2) * 8);

  447.         else

  448.             c_offset = ((mb_y >> 1) * s->linesize[1] * 8) + ((mb_x >> 1) * 8);

  449.         for(j = 0;j < 6; j++) {

  450.             idct_put = s->idct_put[mb->dct_mode];

  451.             if (j < 4) {

  452.                 if (s->sampling_411 && mb_x < (704 / 8)) {

  453.                     /* NOTE: at end of line, the macroblock is handled as 420 */

  454.                     idct_put(y_ptr + (j * 8), s->linesize[0], block);

  455.                 } else {

  456.                     idct_put(y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->linesize[0]),

  457.                              s->linesize[0], block);

  458.                 }

  459.             } else {

  460.                 if (s->sampling_411 && mb_x >= (704 / 8)) {

  461.                     uint8_t pixels[64], *c_ptr, *c_ptr1, *ptr;

  462.                     int y, linesize;

  463.                     /* NOTE: at end of line, the macroblock is handled as 420 */

  464.                     idct_put(pixels, 8, block);

  465.                     linesize = s->linesize[6 - j];

  466.                     c_ptr = s->current_picture[6 - j] + c_offset;

  467.                     ptr = pixels;

  468.                     for(y = 0;y < 8; y++) {

  469.                         /* convert to 411P */

  470.                         c_ptr1 = c_ptr + linesize;

  471.                         c_ptr1[0] = c_ptr[0] = (ptr[0] + ptr[1]) >> 1;

  472.                         c_ptr1[1] = c_ptr[1] = (ptr[2] + ptr[3]) >> 1;

  473.                         c_ptr1[2] = c_ptr[2] = (ptr[4] + ptr[5]) >> 1;

  474.                         c_ptr1[3] = c_ptr[3] = (ptr[6] + ptr[7]) >> 1;

  475.                         c_ptr += linesize * 2;

  476.                         ptr += 8;

  477.                     }

  478.                 } else {

  479.                     /* don't ask me why they inverted Cb and Cr ! */

  480.                     idct_put(s->current_picture[6 - j] + c_offset, 

  481.                              s->linesize[6 - j], block);

  482.                 }

  483.             }

  484.             block += 64;

  485.             mb++;

  486.         }

  487.     }

  488. }

  489. 

  490. 

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

  492.    144000 bytes for PAL) */

  493. static int dvvideo_decode_frame(AVCodecContext *avctx, 

  494.                                  void *data, int *data_size,

  495.                                  UINT8 *buf, int buf_size)

  496. {

  497.     DVVideoDecodeContext *s = avctx->priv_data;

  498.     int sct, dsf, apt, ds, nb_dif_segs, vs, width, height, i, packet_size;

  499.     unsigned size;

  500.     UINT8 *buf_ptr;

  501.     const UINT16 *mb_pos_ptr;

  502.     AVPicture *picture;

  503.     

  504.     /* parse id */

  505.     init_get_bits(&s->gb, buf, buf_size);

  506.     sct = get_bits(&s->gb, 3);

  507.     if (sct != 0)

  508.         return -1;

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

  510.     get_bits(&s->gb, 4); /* dsn (sequence number */

  511.     get_bits(&s->gb, 1); /* fsc (channel number) */

  512.     skip_bits(&s->gb, 3);

  513.     get_bits(&s->gb, 8); /* dbn (diff block number 0-134) */

  514. 

  515.     dsf = get_bits(&s->gb, 1); /* 0 = NTSC 1 = PAL */

  516.     if (get_bits(&s->gb, 1) != 0)

  517.         return -1;

  518.     skip_bits(&s->gb, 11);

  519.     apt = get_bits(&s->gb, 3); /* apt */

  520. 

  521.     get_bits(&s->gb, 1); /* tf1 */

  522.     skip_bits(&s->gb, 4);

  523.     get_bits(&s->gb, 3); /* ap1 */

  524. 

  525.     get_bits(&s->gb, 1); /* tf2 */

  526.     skip_bits(&s->gb, 4);

  527.     get_bits(&s->gb, 3); /* ap2 */

  528. 

  529.     get_bits(&s->gb, 1); /* tf3 */

  530.     skip_bits(&s->gb, 4);

  531.     get_bits(&s->gb, 3); /* ap3 */

  532.     

  533.     /* init size */

  534.     width = 720;

  535.     if (dsf) {

  536.         avctx->frame_rate = 25 * FRAME_RATE_BASE;

  537.         packet_size = PAL_FRAME_SIZE;

  538.         height = 576;

  539.         nb_dif_segs = 12;

  540.     } else {

  541.         avctx->frame_rate = 30 * FRAME_RATE_BASE;

  542.         packet_size = NTSC_FRAME_SIZE;

  543.         height = 480;

  544.         nb_dif_segs = 10;

  545.     }

  546.     /* NOTE: we only accept several full frames */

  547.     if (buf_size < packet_size)

  548.         return -1;

  549.     

  550.     /* XXX: is it correct to assume that 420 is always used in PAL

  551.        mode ? */

  552.     s->sampling_411 = !dsf;

  553.     if (s->sampling_411) {

  554.         mb_pos_ptr = dv_place_411;

  555.         avctx->pix_fmt = PIX_FMT_YUV411P;

  556.     } else {

  557.         mb_pos_ptr = dv_place_420;

  558.         avctx->pix_fmt = PIX_FMT_YUV420P;

  559.     }

  560. 

  561.     avctx->width = width;

  562.     avctx->height = height;

  563. 

  564.     if (avctx->flags & CODEC_FLAG_DR1)

  565.     {

  566. 	s->width = -1;

  567. 	avctx->dr_buffer[0] = avctx->dr_buffer[1] = avctx->dr_buffer[2] = 0;

  568. 	if(avctx->get_buffer_callback(avctx, width, height, I_TYPE) < 0

  569. 	   && avctx->flags & CODEC_FLAG_DR1) {

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

  571. 	    return -1;

  572. 	}

  573.     }

  574. 

  575.     /* (re)alloc picture if needed */

  576.     if (s->width != width || s->height != height) {

  577. 	if (!(avctx->flags & CODEC_FLAG_DR1))

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

  579. 		if (avctx->dr_buffer[i] != s->current_picture[i])

  580. 		    av_freep(&s->current_picture[i]);

  581. 		avctx->dr_buffer[i] = 0;

  582. 	    }

  583. 

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

  585. 	    if (avctx->dr_buffer[i]) {

  586. 		s->current_picture[i] = avctx->dr_buffer[i];

  587. 		s->linesize[i] = (i == 0) ? avctx->dr_stride : avctx->dr_uvstride;

  588. 	    } else {

  589. 		size = width * height;

  590. 		s->linesize[i] = width;

  591. 		if (i >= 1) {

  592. 		    size >>= 2;

  593. 		    s->linesize[i] >>= s->sampling_411 ? 2 : 1;

  594. 		}

  595. 		s->current_picture[i] = av_malloc(size);

  596. 	    }

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

  598.                 return -1;

  599.         }

  600.         s->width = width;

  601.         s->height = height;

  602.     }

  603. 

  604.     /* for each DIF segment */

  605.     buf_ptr = buf;

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

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

  608.         

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

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

  611.                 /* skip audio block */

  612.                 buf_ptr += 80;

  613.             }

  614.             dv_decode_video_segment(s, buf_ptr, mb_pos_ptr);

  615.             buf_ptr += 5 * 80;

  616.             mb_pos_ptr += 5;

  617.         }

  618.     }

  619. 

  620.     emms_c();

  621. 

  622.     /* return image */

  623.     *data_size = sizeof(AVPicture);

  624.     picture = data;

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

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

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

  628.     }

  629.     return packet_size;

  630. }

  631. 

  632. static int dvvideo_decode_end(AVCodecContext *avctx)

  633. {

  634.     DVVideoDecodeContext *s = avctx->priv_data;

  635.     int i;

  636. 

  637.     for(i=0;i<3;i++)

  638. 	if (avctx->dr_buffer[i] != s->current_picture[i])

  639.         av_freep(&s->current_picture[i]);

  640.     return 0;

  641. }

  642. 

  643. AVCodec dvvideo_decoder = {

  644.     "dvvideo",

  645.     CODEC_TYPE_VIDEO,

  646.     CODEC_ID_DVVIDEO,

  647.     sizeof(DVVideoDecodeContext),

  648.     dvvideo_decode_init,

  649.     NULL,

  650.     dvvideo_decode_end,

  651.     dvvideo_decode_frame,

  652.     CODEC_CAP_DR1,

  653.     NULL

  654. };

  655. 

  656. typedef struct DVAudioDecodeContext {

  657.     AVCodecContext *avctx;

  658.     GetBitContext gb;

  659. 

  660. } DVAudioDecodeContext;

  661. 

  662. static int dvaudio_decode_init(AVCodecContext *avctx)

  663. {

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

  665.     return 0;

  666. }

  667. 

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

  669.    144000 bytes for PAL) */

  670. static int dvaudio_decode_frame(AVCodecContext *avctx, 

  671.                                  void *data, int *data_size,

  672.                                  UINT8 *buf, int buf_size)

  673. {

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

  675.     return buf_size;

  676. }

  677. 

  678. static int dvaudio_decode_end(AVCodecContext *avctx)

  679. {

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

  681.     return 0;

  682. }

  683. 

  684. AVCodec dvaudio_decoder = {

  685.     "dvaudio",

  686.     CODEC_TYPE_AUDIO,

  687.     CODEC_ID_DVAUDIO,

  688.     sizeof(DVAudioDecodeContext),

  689.     dvaudio_decode_init,

  690.     NULL,

  691.     dvaudio_decode_end,

  692.     dvaudio_decode_frame,

  693.     0,

  694.     NULL

  695. };