开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
dv.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：31k
源码类别：

Windows CE

开发平台：

C/C++

dv.c：源码内容
  1. /*
  2.  * DV decoder
  3.  * Copyright (c) 2002 Fabrice Bellard.
  4.  * Copyright (c) 2004 Roman Shaposhnik.
  5.  *
  6.  * DV encoder 
  7.  * Copyright (c) 2003 Roman Shaposhnik.
  8.  *
  9.  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
  10.  * of DV technical info.
  11.  *
  12.  * This library is free software; you can redistribute it and/or
  13.  * modify it under the terms of the GNU Lesser General Public
  14.  * License as published by the Free Software Foundation; either
  15.  * version 2 of the License, or (at your option) any later version.
  16.  *
  17.  * This library is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20.  * Lesser General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU Lesser General Public
  23.  * License along with this library; if not, write to the Free Software
  24.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25.  */
  27. /**
  28.  * @file dv.c
  29.  * DV codec.
  30.  */
  31. #include "avcodec.h"
  32. #include "dsputil.h"
  33. #include "mpegvideo.h"
  34. #include "simple_idct.h"
  35. #include "dvdata.h"
  37. //#undef NDEBUG
  38. //#include <assert.h>
  40. typedef struct DVVideoContext {
  41.     const DVprofile* sys;
  42.     AVFrame picture;
  43.     AVCodecContext *avctx;
  44.     uint8_t *buf;
  45.     
  46.     uint8_t dv_zigzag[2][64];
  47.     uint8_t dv_idct_shift[2][2][22][64];
  48.   
  49.     void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
  50.     void (*fdct[2])(DCTELEM *block);
  51.     void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
  52. } DVVideoContext;
  54. #define TEX_VLC_BITS 9
  56. #ifdef DV_CODEC_TINY_TARGET
  57. #define DV_VLC_MAP_RUN_SIZE 15
  58. #define DV_VLC_MAP_LEV_SIZE 23
  59. #else
  60. #define DV_VLC_MAP_RUN_SIZE  64 
  61. #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
  62. #endif
  64. /* MultiThreading */
  65. static uint8_t** dv_anchor;
  67. /* XXX: also include quantization */
  68. static RL_VLC_ELEM *dv_rl_vlc;
  69. /* VLC encoding lookup table */
  70. static struct dv_vlc_pair {
  71.    uint32_t vlc;
  72.    uint8_t  size;
  73. } (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;
  75. static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
  76. {
  77.     int i, q, j;
  79.     /* NOTE: max left shift is 6 */
  80.     for(q = 0; q < 22; q++) {
  81.         /* 88DCT */
  82.         for(i = 1; i < 64; i++) {
  83.             /* 88 table */
  84.             j = perm[i];
  85.             s->dv_idct_shift[0][0][q][j] =
  86.                 dv_quant_shifts[q][dv_88_areas[i]] + 1;
  87.     s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
  88.         }
  89.         
  90.         /* 248DCT */
  91.         for(i = 1; i < 64; i++) {
  92.             /* 248 table */
  93.             s->dv_idct_shift[0][1][q][i] =  
  94.                 dv_quant_shifts[q][dv_248_areas[i]] + 1;
  95.     s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
  96.         }
  97.     }
  98. }
  100. static int dvvideo_init(AVCodecContext *avctx)
  101. {
  102.     DVVideoContext *s = avctx->priv_data;
  103.     DSPContext dsp;
  104.     static int done=0;
  105.     int i, j;
  107.     if (!done) {
  108.         VLC dv_vlc;
  109.         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
  110.         uint8_t new_dv_vlc_len[NB_DV_VLC*2];
  111.         uint8_t new_dv_vlc_run[NB_DV_VLC*2];
  112.         int16_t new_dv_vlc_level[NB_DV_VLC*2];
  114.         done = 1;
  116.         dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
  117. if (!dv_vlc_map)
  118.     return -ENOMEM;
  120. /* dv_anchor lets each thread know its Id */
  121. dv_anchor = av_malloc(12*27*sizeof(void*));
  122. if (!dv_anchor) {
  123.     return -ENOMEM;
  124. }
  125. for (i=0; i<12*27; i++)
  126.     dv_anchor[i] = (void*)(size_t)i;
  128. /* it's faster to include sign bit in a generic VLC parsing scheme */
  129. for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
  130.     new_dv_vlc_bits[j] = dv_vlc_bits[i];
  131.     new_dv_vlc_len[j] = dv_vlc_len[i];
  132.     new_dv_vlc_run[j] = dv_vlc_run[i];
  133.     new_dv_vlc_level[j] = dv_vlc_level[i];
  134.     
  135.     if (dv_vlc_level[i]) {
  136.         new_dv_vlc_bits[j] <<= 1;
  137. new_dv_vlc_len[j]++;
  139. j++;
  140. new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
  141. new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
  142. new_dv_vlc_run[j] = dv_vlc_run[i];
  143. new_dv_vlc_level[j] = -dv_vlc_level[i];
  144.     }
  145. }
  146.              
  147.         /* NOTE: as a trick, we use the fact the no codes are unused
  148.            to accelerate the parsing of partial codes */
  149.         init_vlc(&dv_vlc, TEX_VLC_BITS, j, 
  150.                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
  152.         dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
  153. if (!dv_rl_vlc) {
  154.     av_free(dv_anchor);
  155.     return -ENOMEM;
  156. }
  157.         for(i = 0; i < dv_vlc.table_size; i++){
  158.             int code= dv_vlc.table[i][0];
  159.             int len = dv_vlc.table[i][1];
  160.             int level, run;
  161.         
  162.             if(len<0){ //more bits needed
  163.                 run= 0;
  164.                 level= code;
  165.             } else {
  166.                 run=   new_dv_vlc_run[code] + 1;
  167.                 level= new_dv_vlc_level[code];
  168.             }
  169.             dv_rl_vlc[i].len = len;
  170.             dv_rl_vlc[i].level = level;
  171.             dv_rl_vlc[i].run = run;
  172.         }
  173. free_vlc(&dv_vlc);
  175. for (i = 0; i < NB_DV_VLC - 1; i++) {
  176.            if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
  177.        continue;
  178. #ifdef DV_CODEC_TINY_TARGET
  179.            if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
  180.        continue;
  181. #endif
  182.    
  183.    if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
  184.        continue;
  185.        
  186.    dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] << 
  187.                                                     (!!dv_vlc_level[i]);
  188.    dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] + 
  189.                                                      (!!dv_vlc_level[i]);
  190. }
  191. for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
  192. #ifdef DV_CODEC_TINY_TARGET
  193.    for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
  194.       if (dv_vlc_map[i][j].size == 0) {
  195.           dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
  196.             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
  197.           dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + 
  198.                           dv_vlc_map[0][j].size;
  199.       }
  200.    }
  201. #else
  202.    for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
  203.       if (dv_vlc_map[i][j].size == 0) {
  204.           dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
  205.             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
  206.           dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size + 
  207.                           dv_vlc_map[0][j].size;
  208.       }
  209.       dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc = 
  210.                                     dv_vlc_map[i][j].vlc | 1;
  211.       dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size = 
  212.                                     dv_vlc_map[i][j].size;
  213.    }
  214. #endif
  215. }
  216.     }
  218.     /* Generic DSP setup */
  219.     dsputil_init(&dsp, avctx);
  220.     s->get_pixels = dsp.get_pixels;
  222.     /* 88DCT setup */
  223.     s->fdct[0] = dsp.fdct;
  224.     s->idct_put[0] = dsp.idct_put;
  225.     for (i=0; i<64; i++)
  226.        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
  228.     /* 248DCT setup */
  229.     s->fdct[1] = dsp.fdct248;
  230.     s->idct_put[1] = simple_idct248_put;  // FIXME: need to add it to DSP
  231.     if(avctx->lowres){
  232.         for (i=0; i<64; i++){
  233.             int j= ff_zigzag248_direct[i];
  234.             s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
  235.         }
  236.     }else
  237.         memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
  239.     /* XXX: do it only for constant case */
  240.     dv_build_unquantize_tables(s, dsp.idct_permutation);
  242.     /* FIXME: I really don't think this should be here */
  243.     if (dv_codec_profile(avctx))
  244. avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt; 
  245.     avctx->coded_frame = &s->picture;
  246.     s->avctx= avctx;
  247.     
  248.     return 0;
  249. }
  251. // #define VLC_DEBUG
  252. // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
  254. typedef struct BlockInfo {
  255.     const uint8_t *shift_table;
  256.     const uint8_t *scan_table;
  257.     uint8_t pos; /* position in block */
  258.     uint8_t dct_mode;
  259.     uint8_t partial_bit_count;
  260.     uint16_t partial_bit_buffer;
  261.     int shift_offset;
  262. } BlockInfo;
  264. /* block size in bits */
  265. static const uint16_t block_sizes[6] = {
  266.     112, 112, 112, 112, 80, 80
  267. };
  268. /* bit budget for AC only in 5 MBs */
  269. static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
  270. /* see dv_88_areas and dv_248_areas for details */
  271. static const int mb_area_start[5] = { 1, 6, 21, 43, 64 }; 
  273. #ifndef ALT_BITSTREAM_READER
  274. #warning only works with ALT_BITSTREAM_READER
  275. static int re_index; //Hack to make it compile
  276. #endif
  278. static inline int get_bits_left(GetBitContext *s)
  279. {
  280.     return s->size_in_bits - get_bits_count(s);
  281. }
  283. static inline int get_bits_size(GetBitContext *s)
  284. {
  285.     return s->size_in_bits;
  286. }
  288. static inline int put_bits_left(PutBitContext* s)
  289. {
  290.     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
  291. }
  293. /* decode ac coefs */
  294. static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
  295. {
  296.     int last_index = get_bits_size(gb);
  297.     const uint8_t *scan_table = mb->scan_table;
  298.     const uint8_t *shift_table = mb->shift_table;
  299.     int pos = mb->pos;
  300.     int partial_bit_count = mb->partial_bit_count;
  301.     int level, pos1, run, vlc_len, index;
  302.     
  303.     OPEN_READER(re, gb);
  304.     UPDATE_CACHE(re, gb);
  305.     
  306.     /* if we must parse a partial vlc, we do it here */
  307.     if (partial_bit_count > 0) {
  308.         re_cache = ((unsigned)re_cache >> partial_bit_count) |
  309.            (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
  310. re_index -= partial_bit_count;
  311. mb->partial_bit_count = 0;
  312.     }
  314.     /* get the AC coefficients until last_index is reached */
  315.     for(;;) {
  316. #ifdef VLC_DEBUG
  317.         printf("%2d: bits=%04x index=%dn", pos, SHOW_UBITS(re, gb, 16), re_index);
  318. #endif
  319.         /* our own optimized GET_RL_VLC */
  320.         index = NEG_USR32(re_cache, TEX_VLC_BITS);
  321. vlc_len = dv_rl_vlc[index].len;
  322.         if (vlc_len < 0) {
  323.             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
  324.             vlc_len = TEX_VLC_BITS - vlc_len;
  325.         }
  326.         level = dv_rl_vlc[index].level;
  327. run = dv_rl_vlc[index].run;
  329. /* gotta check if we're still within gb boundaries */
  330. if (re_index + vlc_len > last_index) {
  331.     /* should be < 16 bits otherwise a codeword could have been parsed */
  332.     mb->partial_bit_count = last_index - re_index;
  333.     mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
  334.     re_index = last_index;
  335.     break;
  336. }
  337. re_index += vlc_len;
  339. #ifdef VLC_DEBUG
  340. printf("run=%d level=%dn", run, level);
  341. #endif
  342. pos += run; 
  343. if (pos >= 64)
  344.     break;
  345.         
  346.         assert(level);
  347.         pos1 = scan_table[pos];
  348.         block[pos1] = level << shift_table[pos1];
  350.         UPDATE_CACHE(re, gb);
  351.     }
  352.     CLOSE_READER(re, gb);
  353.     mb->pos = pos;
  354. }
  356. static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
  357. {
  358.     int bits_left = get_bits_left(gb);
  359.     while (bits_left >= MIN_CACHE_BITS) {
  360.         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
  361.         bits_left -= MIN_CACHE_BITS;
  362.     }
  363.     if (bits_left > 0) {
  364.         put_bits(pb, bits_left, get_bits(gb, bits_left));
  365.     }
  366. }
  368. /* mb_x and mb_y are in units of 8 pixels */
  369. static inline void dv_decode_video_segment(DVVideoContext *s, 
  370.                                            uint8_t *buf_ptr1, 
  371.                                            const uint16_t *mb_pos_ptr)
  372. {
  373.     int quant, dc, dct_mode, class1, j;
  374.     int mb_index, mb_x, mb_y, v, last_index;
  375.     DCTELEM *block, *block1;
  376.     int c_offset;
  377.     uint8_t *y_ptr;
  378.     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
  379.     uint8_t *buf_ptr;
  380.     PutBitContext pb, vs_pb;
  381.     GetBitContext gb;
  382.     BlockInfo mb_data[5 * 6], *mb, *mb1;
  383.     DCTELEM sblock[5*6][64] __align8;
  384.     uint8_t mb_bit_buffer[80 + 4] __align8; /* allow some slack */
  385.     uint8_t vs_bit_buffer[5 * 80 + 4] __align8; /* allow some slack */
  386.     const int log2_blocksize= 3-s->avctx->lowres;
  387.     
  388.     assert((((int)mb_bit_buffer)&7)==0);
  389.     assert((((int)vs_bit_buffer)&7)==0);
  390.     
  391.     memset(sblock, 0, sizeof(sblock));
  393.     /* pass 1 : read DC and AC coefficients in blocks */
  394.     buf_ptr = buf_ptr1;
  395.     block1 = &sblock[0][0];
  396.     mb1 = mb_data;
  397.     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
  398.     for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
  399.         /* skip header */
  400.         quant = buf_ptr[3] & 0x0f;
  401.         buf_ptr += 4;
  402.         init_put_bits(&pb, mb_bit_buffer, 80);
  403.         mb = mb1;
  404.         block = block1;
  405.         for(j = 0;j < 6; j++) {
  406.             last_index = block_sizes[j];
  407.     init_get_bits(&gb, buf_ptr, last_index);
  408.             
  409.             /* get the dc */
  410.             dc = get_sbits(&gb, 9);
  411.             dct_mode = get_bits1(&gb);
  412.             mb->dct_mode = dct_mode;
  413.             mb->scan_table = s->dv_zigzag[dct_mode];
  414.             class1 = get_bits(&gb, 2);
  415.             mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
  416.                 [quant + dv_quant_offset[class1]];
  417.             dc = dc << 2;
  418.             /* convert to unsigned because 128 is not added in the
  419.                standard IDCT */
  420.             dc += 1024;
  421.             block[0] = dc;
  422.             buf_ptr += last_index >> 3;
  423.             mb->pos = 0;
  424.             mb->partial_bit_count = 0;
  426. #ifdef VLC_DEBUG
  427.             printf("MB block: %d, %d ", mb_index, j);
  428. #endif
  429.             dv_decode_ac(&gb, mb, block);
  431.             /* write the remaining bits  in a new buffer only if the
  432.                block is finished */
  433.             if (mb->pos >= 64)
  434.                 bit_copy(&pb, &gb);
  435.             
  436.             block += 64;
  437.             mb++;
  438.         }
  439.         
  440.         /* pass 2 : we can do it just after */
  441. #ifdef VLC_DEBUG
  442.         printf("***pass 2 size=%d MB#=%dn", put_bits_count(&pb), mb_index);
  443. #endif
  444.         block = block1;
  445.         mb = mb1;
  446.         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
  447. flush_put_bits(&pb);
  448.         for(j = 0;j < 6; j++, block += 64, mb++) {
  449.             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
  450.                 dv_decode_ac(&gb, mb, block);
  451.                 /* if still not finished, no need to parse other blocks */
  452.                 if (mb->pos < 64)
  453.                     break;
  454.             }
  455.         }
  456.         /* all blocks are finished, so the extra bytes can be used at
  457.            the video segment level */
  458.         if (j >= 6)
  459.     bit_copy(&vs_pb, &gb);
  460.     }
  462.     /* we need a pass other the whole video segment */
  463. #ifdef VLC_DEBUG
  464.     printf("***pass 3 size=%dn", put_bits_count(&vs_pb));
  465. #endif
  466.     block = &sblock[0][0];
  467.     mb = mb_data;
  468.     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
  469.     flush_put_bits(&vs_pb);
  470.     for(mb_index = 0; mb_index < 5; mb_index++) {
  471.         for(j = 0;j < 6; j++) {
  472.             if (mb->pos < 64) {
  473. #ifdef VLC_DEBUG
  474.                 printf("start %d:%dn", mb_index, j);
  475. #endif
  476.                 dv_decode_ac(&gb, mb, block);
  477.             }
  478.     if (mb->pos >= 64 && mb->pos < 127)
  479. av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%dn", mb->pos);
  480.             block += 64;
  481.             mb++;
  482.         }
  483.     }
  484.     
  485.     /* compute idct and place blocks */
  486.     block = &sblock[0][0];
  487.     mb = mb_data;
  488.     for(mb_index = 0; mb_index < 5; mb_index++) {
  489.         v = *mb_pos_ptr++;
  490.         mb_x = v & 0xff;
  491.         mb_y = v >> 8;
  492.         y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
  493.         if (s->sys->pix_fmt == PIX_FMT_YUV411P)
  494.             c_offset = ((mb_y * s->picture.linesize[1] + (mb_x >> 2))<<log2_blocksize);
  495.         else
  496.             c_offset = (((mb_y >> 1) * s->picture.linesize[1] + (mb_x >> 1))<<log2_blocksize);
  497.         for(j = 0;j < 6; j++) {
  498.             idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
  499.             if (j < 4) {
  500.                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
  501.                     /* NOTE: at end of line, the macroblock is handled as 420 */
  502.                     idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
  503.                 } else {
  504.                     idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
  505.                              s->picture.linesize[0], block);
  506.                 }
  507.             } else {
  508.                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
  509.                     uint64_t aligned_pixels[64/8];
  510.                     uint8_t *pixels= (uint8_t*)aligned_pixels;
  511.     uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
  512.                     int x, y, linesize;
  513.                     /* NOTE: at end of line, the macroblock is handled as 420 */
  514.                     idct_put(pixels, 8, block);
  515.                     linesize = s->picture.linesize[6 - j];
  516.                     c_ptr = s->picture.data[6 - j] + c_offset;
  517.                     ptr = pixels;
  518.                     for(y = 0;y < (1<<log2_blocksize); y++) {
  519.                         ptr1= ptr + (1<<(log2_blocksize-1));
  520.                         c_ptr1 = c_ptr + (linesize<<log2_blocksize);
  521.                         for(x=0; x < (1<<(log2_blocksize-1)); x++){
  522.                             c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
  523.                         }
  524.                         c_ptr += linesize;
  525.                         ptr += 8;
  526.                     }
  527.                 } else {
  528.                     /* don't ask me why they inverted Cb and Cr ! */
  529.                     idct_put(s->picture.data[6 - j] + c_offset, 
  530.                              s->picture.linesize[6 - j], block);
  531.                 }
  532.             }
  533.             block += 64;
  534.             mb++;
  535.         }
  536.     }
  537. }
  539. #ifdef DV_CODEC_TINY_TARGET
  540. /* Converts run and level (where level != 0) pair into vlc, returning bit size */
  541. static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
  542. {
  543.     int size;
  544.     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
  545.         *vlc = dv_vlc_map[run][level].vlc | sign;
  546. size = dv_vlc_map[run][level].size;
  547.     }
  548.     else { 
  549.         if (level < DV_VLC_MAP_LEV_SIZE) {
  550.     *vlc = dv_vlc_map[0][level].vlc | sign;
  551.     size = dv_vlc_map[0][level].size;
  552. } else {
  553.             *vlc = 0xfe00 | (level << 1) | sign;
  554.     size = 16;
  555. }
  556. if (run) {
  557.     *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc : 
  558.                           (0x1f80 | (run - 1))) << size;
  559.     size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
  560. }
  561.     }
  562.     
  563.     return size;
  564. }
  566. static always_inline int dv_rl2vlc_size(int run, int level)
  567. {
  568.     int size;
  569.     
  570.     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
  571. size = dv_vlc_map[run][level].size; 
  572.     }
  573.     else { 
  574. size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
  575. if (run) {
  576.     size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
  577. }
  578.     }
  579.     return size;
  580. }
  581. #else
  582. static always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
  583. {
  584.     *vlc = dv_vlc_map[run][l].vlc | sign;
  585.     return dv_vlc_map[run][l].size;
  586. }
  588. static always_inline int dv_rl2vlc_size(int run, int l)
  589. {
  590.     return dv_vlc_map[run][l].size;
  591. }
  592. #endif
  594. typedef struct EncBlockInfo {
  595.     int area_q[4];
  596.     int bit_size[4];
  597.     int prev[5];
  598.     int cur_ac;
  599.     int cno;
  600.     int dct_mode;
  601.     DCTELEM mb[64];
  602.     uint8_t next[64];
  603.     uint8_t sign[64];
  604.     uint8_t partial_bit_count;
  605.     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
  606. } EncBlockInfo;
  608. static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool, 
  609.                                        PutBitContext* pb_end)
  610. {
  611.     int prev;
  612.     int bits_left;
  613.     PutBitContext* pb = pb_pool;
  614.     int size = bi->partial_bit_count;
  615.     uint32_t vlc = bi->partial_bit_buffer;
  617.     bi->partial_bit_count = bi->partial_bit_buffer = 0;
  618.     for(;;){
  619.        /* Find suitable storage space */
  620.        for (; size > (bits_left = put_bits_left(pb)); pb++) {
  621.           if (bits_left) {
  622.               size -= bits_left;
  623.       put_bits(pb, bits_left, vlc >> size);
  624.       vlc = vlc & ((1<<size)-1);
  625.   }
  626.   if (pb + 1 >= pb_end) {
  627.       bi->partial_bit_count = size;
  628.       bi->partial_bit_buffer = vlc;
  629.       return pb;
  630.   }
  631.        }
  632.        
  633.        /* Store VLC */
  634.        put_bits(pb, size, vlc);
  635.        
  636.        if(bi->cur_ac>=64)
  637.            break;
  638.        
  639.        /* Construct the next VLC */
  640.        prev= bi->cur_ac;
  641.        bi->cur_ac = bi->next[prev];
  642.        if(bi->cur_ac < 64){
  643.            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
  644.        } else {
  645.            size = 4; vlc = 6; /* End Of Block stamp */
  646.        }
  647.     }
  648.     return pb;
  649. }
  651. static always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi, 
  652.                                               const uint8_t* zigzag_scan, int bias)
  653. {
  654.     int i, area;
  655.     static const int classes[] = {12, 24, 36, 0xffff};
  656.     int max=12;
  657.     int prev=0;
  659.     bi->mb[0] = blk[0]; 
  660.     
  661.     for (area = 0; area < 4; area++) {
  662.        bi->prev[area] = prev;
  663.        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
  664.        for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
  665.           int level = blk[zigzag_scan[i]];
  666.        
  667.           if (level+15 > 30U) {
  668.               bi->sign[i] = (level>>31)&1;
  669.               bi->mb[i] = level= ABS(level)>>4;
  670.               if(level>max) max= level;
  671.               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
  672.               bi->next[prev]= i;
  673.               prev= i;
  674.           }
  675.        }
  676.     }
  677.     bi->next[prev]= i;
  678.     for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
  680.     bi->cno += bias;
  681.     
  682.     if (bi->cno >= 3) {
  683.         bi->cno = 3;
  684.         prev=0;
  685.         i= bi->next[prev];
  686.         for (area = 0; area < 4; area++) {
  687.             bi->prev[area] = prev;
  688.             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
  689.             for (; i<mb_area_start[area+1]; i= bi->next[i]) {
  690.                 bi->mb[i] >>=1;
  691.             
  692.                 if (bi->mb[i]) {
  693.                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
  694.                     bi->next[prev]= i;
  695.                     prev= i;
  696.                 }
  697.             }
  698.         }
  699.         bi->next[prev]= i;
  700.     }
  701. }
  703. //FIXME replace this by dsputil
  704. #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
  705. static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
  706.     DCTELEM *s;
  707.     int score88 = 0;
  708.     int score248 = 0;
  709.     int i;
  710.     
  711.     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
  712.     s = blk;
  713.     for(i=0; i<7; i++) {
  714.         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) + 
  715.            SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
  716.         s += 8;
  717.     }
  718.     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
  719.     s = blk;
  720.     for(i=0; i<6; i++) {
  721.         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
  722.             SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
  723.         s += 8;
  724.     }
  726.     return (score88 - score248 > -10);
  727. }
  729. static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
  730. {
  731.     int size[5];
  732.     int i, j, k, a, prev;
  733.     EncBlockInfo* b;
  735.     do {
  736.        b = blks;
  737.        for (i=0; i<5; i++) {
  738.           if (!qnos[i])
  739.       continue;
  740.   
  741.   qnos[i]--;
  742.   size[i] = 0;
  743.           for (j=0; j<6; j++, b++) {
  744.      for (a=0; a<4; a++) {
  745.         if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
  746.     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
  747.     b->area_q[a]++;
  748.                     prev= b->prev[a];
  749.                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
  750.        b->mb[k] >>= 1;
  751.        if (b->mb[k]) {
  752.                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
  753.                    prev= k;
  754.                        } else {
  755.                            b->next[prev] = b->next[k];
  756.                        }
  757.     }
  758.                     b->prev[a+1]= prev;
  759. }
  760. size[i] += b->bit_size[a];
  761.      }
  762.   }
  763.        }
  764.     } while ((vs_total_ac_bits < size[0] + size[1] + size[2] + size[3] + size[4]) && 
  765.              (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]));
  766. }
  768. /*
  769.  * This is a very rough initial implementaion. The performance is
  770.  * horrible and the weighting is missing. But it's missing from the 
  771.  * decoding step also -- so at least we're on the same page with decoder ;-)
  772.  */
  773. static inline void dv_encode_video_segment(DVVideoContext *s, 
  774.                                            uint8_t *dif, 
  775.                                            const uint16_t *mb_pos_ptr)
  776. {
  777.     int mb_index, i, j, v;
  778.     int mb_x, mb_y, c_offset, linesize; 
  779.     uint8_t*  y_ptr;
  780.     uint8_t*  data;
  781.     uint8_t*  ptr;
  782.     int       do_edge_wrap;
  783.     DCTELEM   block[64] __align8;
  784.     EncBlockInfo  enc_blks[5*6];
  785.     PutBitContext pbs[5*6];
  786.     PutBitContext* pb; 
  787.     EncBlockInfo* enc_blk;
  788.     int       vs_bit_size = 0;
  789.     int       qnos[5];
  790.     
  791.     assert((((int)block) & 7) == 0);
  792.    
  793.     enc_blk = &enc_blks[0];
  794.     pb = &pbs[0];
  795.     for(mb_index = 0; mb_index < 5; mb_index++) {
  796.         v = *mb_pos_ptr++;
  797.         mb_x = v & 0xff;
  798.         mb_y = v >> 8;
  799.         y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
  800. c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ?
  801.            ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) :
  802.    (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
  803. do_edge_wrap = 0;
  804. qnos[mb_index] = 15; /* No quantization */
  805.         ptr = dif + mb_index*80 + 4;
  806.         for(j = 0;j < 6; j++) {
  807.             if (j < 4) {  /* Four Y blocks */
  808. /* NOTE: at end of line, the macroblock is handled as 420 */
  809. if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
  810.                     data = y_ptr + (j * 8);
  811.                 } else {
  812.                     data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
  813.                 }
  814. linesize = s->picture.linesize[0];
  815.             } else {      /* Cr and Cb blocks */
  816.         /* don't ask Fabrice why they inverted Cb and Cr ! */
  817.         data = s->picture.data[6 - j] + c_offset;
  818. linesize = s->picture.linesize[6 - j];
  819. if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
  820.     do_edge_wrap = 1;
  821.     }
  822.             
  823.     /* Everything is set up -- now just copy data -> DCT block */
  824.     if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
  825. uint8_t* d;
  826. DCTELEM *b = block;
  827.         for (i=0;i<8;i++) {
  828.    d = data + 8 * linesize;
  829.    b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
  830.                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
  831.    data += linesize;
  832.    b += 8;
  833. }
  834.     } else {             /* Simple copy: 8x8 -> 8x8 */
  835.         s->get_pixels(block, data, linesize);
  836.     }
  837.   
  838.             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
  839.                 enc_blk->dct_mode = dv_guess_dct_mode(block);
  840.             else
  841.                 enc_blk->dct_mode = 0;
  842.     enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
  843.     enc_blk->partial_bit_count = 0;
  844.     enc_blk->partial_bit_buffer = 0;
  845.     enc_blk->cur_ac = 0;
  846.     
  847.     s->fdct[enc_blk->dct_mode](block);
  848.     
  849.     dv_set_class_number(block, enc_blk, 
  850.                         enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4);
  851.            
  852.             init_put_bits(pb, ptr, block_sizes[j]/8);
  853.     put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
  854.     put_bits(pb, 1, enc_blk->dct_mode);
  855.     put_bits(pb, 2, enc_blk->cno);
  856.     
  857.     vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
  858.                    enc_blk->bit_size[2] + enc_blk->bit_size[3];
  859.     ++enc_blk;
  860.     ++pb;
  861.     ptr += block_sizes[j]/8;
  862.         }
  863.     }
  865.     if (vs_total_ac_bits < vs_bit_size)
  866.         dv_guess_qnos(&enc_blks[0], &qnos[0]);
  868.     for (i=0; i<5; i++) {
  869.        dif[i*80 + 3] = qnos[i];
  870.     }
  872.     /* First pass over individual cells only */
  873.     for (j=0; j<5*6; j++)
  874.        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
  876.     /* Second pass over each MB space */
  877.     for (j=0; j<5*6; j+=6) {
  878.         pb= &pbs[j];
  879.         for (i=0; i<6; i++) {
  880.             if (enc_blks[i+j].partial_bit_count)
  881.                 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
  882.         }
  883.     }
  885.     /* Third and final pass over the whole vides segment space */
  886.     pb= &pbs[0];
  887.     for (j=0; j<5*6; j++) {
  888.        if (enc_blks[j].partial_bit_count)
  889.            pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
  890.     }
  892.     for (j=0; j<5*6; j++)
  893.        flush_put_bits(&pbs[j]);
  894. }
  896. static int dv_decode_mt(AVCodecContext *avctx, void* sl)
  897. {
  898.     DVVideoContext *s = avctx->priv_data;
  899.     int slice = (size_t)sl;
  900.     dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
  901.                     &s->sys->video_place[slice*5]);
  902.     return 0;
  903. }
  905. static int dv_encode_mt(AVCodecContext *avctx, void* sl)
  906. {
  907.     DVVideoContext *s = avctx->priv_data;
  908.     int slice = (size_t)sl;
  909.     dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
  910.                     &s->sys->video_place[slice*5]);
  911.     return 0;
  912. }
  914. /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
  915.    144000 bytes for PAL) */
  916. static int dvvideo_decode_frame(AVCodecContext *avctx, 
  917.                                  void *data, int *data_size,
  918.                                  uint8_t *buf, int buf_size)
  919. {
  920.     DVVideoContext *s = avctx->priv_data;
  921.   
  922.     s->sys = dv_frame_profile(buf);
  923.     if (!s->sys || buf_size < s->sys->frame_size)
  924.         return -1; /* NOTE: we only accept several full frames */
  926.     if(s->picture.data[0])
  927.         avctx->release_buffer(avctx, &s->picture);
  928.     
  929.     s->picture.reference = 0;
  930.     s->picture.key_frame = 1;
  931.     s->picture.pict_type = FF_I_TYPE;
  932.     avctx->pix_fmt = s->sys->pix_fmt;
  933.     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
  934.     if(avctx->get_buffer(avctx, &s->picture) < 0) {
  935.         av_log(avctx, AV_LOG_ERROR, "get_buffer() failedn");
  936.         return -1;
  937.     }
  938.     s->picture.interlaced_frame = 1;
  939.     s->picture.top_field_first = 0;
  941.     s->buf = buf;
  942.     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL, 
  943.            s->sys->difseg_size * 27);
  944.     
  945.     emms_c();
  947.     /* return image */
  948.     *data_size = sizeof(AVFrame);
  949.     *(AVFrame*)data= s->picture;
  950.     
  951.     return s->sys->frame_size;
  952. }
  954. static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size, 
  955.                                 void *data)
  956. {
  957.     DVVideoContext *s = c->priv_data;
  959.     s->sys = dv_codec_profile(c);
  960.     if (!s->sys)
  961. return -1;
  962.     if(buf_size < s->sys->frame_size)
  963.         return -1;
  965.     c->pix_fmt = s->sys->pix_fmt;
  966.     s->picture = *((AVFrame *)data);
  967.     s->picture.key_frame = 1;
  968.     s->picture.pict_type = FF_I_TYPE;
  970.     s->buf = buf;
  971.     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL, 
  972.        s->sys->difseg_size * 27);
  974.     emms_c();
  975.     return s->sys->frame_size;
  976. }
  978. #ifdef CONFIG_DVVIDEO_ENCODER
  979. AVCodec dvvideo_encoder = {
  980.     "dvvideo",
  981.     CODEC_TYPE_VIDEO,
  982.     CODEC_ID_DVVIDEO,
  983.     sizeof(DVVideoContext),
  984.     dvvideo_init,
  985.     dvvideo_encode_frame,
  986.     NULL,
  987.     NULL,
  988.     CODEC_CAP_DR1,
  989.     NULL
  990. };
  991. #endif // CONFIG_DVVIDEO_ENCODER
  993. AVCodec dvvideo_decoder = {
  994.     "dvvideo",
  995.     CODEC_TYPE_VIDEO,
  996.     CODEC_ID_DVVIDEO,
  997.     sizeof(DVVideoContext),
  998.     dvvideo_init,
  999.     NULL,
  1000.     NULL,
  1001.     dvvideo_decode_frame,
  1002.     CODEC_CAP_DR1,
  1003.     NULL
  1004. };