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

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

Windows CE

开发平台：

C/C++

asv1.c：源码内容
  1. /*
  2.  * ASUS V1/V2 codec
  3.  * Copyright (c) 2003 Michael Niedermayer
  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 asv1.c
  22.  * ASUS V1/V2 codec.
  23.  */
  24.  
  25. #include "avcodec.h"
  26. #include "dsputil.h"
  27. #include "mpegvideo.h"
  29. //#undef NDEBUG
  30. //#include <assert.h>
  32. #define VLC_BITS 6
  33. #define ASV2_LEVEL_VLC_BITS 10
  34.  
  35. typedef struct ASV1Context{
  36.     AVCodecContext *avctx;
  37.     DSPContext dsp;
  38.     AVFrame picture;
  39.     PutBitContext pb;
  40.     GetBitContext gb;
  41.     ScanTable scantable;
  42.     int inv_qscale;
  43.     int mb_width;
  44.     int mb_height;
  45.     int mb_width2;
  46.     int mb_height2;
  47.     DCTELEM __align8 block[6][64];
  48.     uint16_t __align8 intra_matrix[64];
  49.     int __align8 q_intra_matrix[64];
  50.     uint8_t *bitstream_buffer;
  51.     int bitstream_buffer_size;
  52. } ASV1Context;
  54. static const uint8_t scantab[64]={
  55.     0x00,0x08,0x01,0x09,0x10,0x18,0x11,0x19,
  56.     0x02,0x0A,0x03,0x0B,0x12,0x1A,0x13,0x1B,
  57.     0x04,0x0C,0x05,0x0D,0x20,0x28,0x21,0x29,
  58.     0x06,0x0E,0x07,0x0F,0x14,0x1C,0x15,0x1D,
  59.     0x22,0x2A,0x23,0x2B,0x30,0x38,0x31,0x39,
  60.     0x16,0x1E,0x17,0x1F,0x24,0x2C,0x25,0x2D,
  61.     0x32,0x3A,0x33,0x3B,0x26,0x2E,0x27,0x2F,
  62.     0x34,0x3C,0x35,0x3D,0x36,0x3E,0x37,0x3F,
  63. };
  66. static const uint8_t ccp_tab[17][2]={
  67.     {0x2,2}, {0x7,5}, {0xB,5}, {0x3,5},
  68.     {0xD,5}, {0x5,5}, {0x9,5}, {0x1,5},
  69.     {0xE,5}, {0x6,5}, {0xA,5}, {0x2,5}, 
  70.     {0xC,5}, {0x4,5}, {0x8,5}, {0x3,2},
  71.     {0xF,5}, //EOB
  72. };
  74. static const uint8_t level_tab[7][2]={
  75.     {3,4}, {3,3}, {3,2}, {0,3}, {2,2}, {2,3}, {2,4}
  76. };
  78. static const uint8_t dc_ccp_tab[8][2]={
  79.     {0x1,2}, {0xD,4}, {0xF,4}, {0xC,4},
  80.     {0x5,3}, {0xE,4}, {0x4,3}, {0x0,2},
  81. };
  83. static const uint8_t ac_ccp_tab[16][2]={
  84.     {0x00,2}, {0x3B,6}, {0x0A,4}, {0x3A,6},
  85.     {0x02,3}, {0x39,6}, {0x3C,6}, {0x38,6},
  86.     {0x03,3}, {0x3D,6}, {0x08,4}, {0x1F,5},
  87.     {0x09,4}, {0x0B,4}, {0x0D,4}, {0x0C,4},
  88. };
  90. static const uint8_t asv2_level_tab[63][2]={
  91.     {0x3F,10},{0x2F,10},{0x37,10},{0x27,10},{0x3B,10},{0x2B,10},{0x33,10},{0x23,10},
  92.     {0x3D,10},{0x2D,10},{0x35,10},{0x25,10},{0x39,10},{0x29,10},{0x31,10},{0x21,10},
  93.     {0x1F, 8},{0x17, 8},{0x1B, 8},{0x13, 8},{0x1D, 8},{0x15, 8},{0x19, 8},{0x11, 8},
  94.     {0x0F, 6},{0x0B, 6},{0x0D, 6},{0x09, 6},
  95.     {0x07, 4},{0x05, 4},
  96.     {0x03, 2},
  97.     {0x00, 5},
  98.     {0x02, 2},
  99.     {0x04, 4},{0x06, 4},
  100.     {0x08, 6},{0x0C, 6},{0x0A, 6},{0x0E, 6},
  101.     {0x10, 8},{0x18, 8},{0x14, 8},{0x1C, 8},{0x12, 8},{0x1A, 8},{0x16, 8},{0x1E, 8},
  102.     {0x20,10},{0x30,10},{0x28,10},{0x38,10},{0x24,10},{0x34,10},{0x2C,10},{0x3C,10},
  103.     {0x22,10},{0x32,10},{0x2A,10},{0x3A,10},{0x26,10},{0x36,10},{0x2E,10},{0x3E,10},
  104. };
  107. static VLC ccp_vlc;
  108. static VLC level_vlc;
  109. static VLC dc_ccp_vlc;
  110. static VLC ac_ccp_vlc;
  111. static VLC asv2_level_vlc;
  113. static void init_vlcs(ASV1Context *a){
  114.     static int done = 0;
  116.     if (!done) {
  117.         done = 1;
  119.         init_vlc(&ccp_vlc, VLC_BITS, 17, 
  120.                  &ccp_tab[0][1], 2, 1,
  121.                  &ccp_tab[0][0], 2, 1, 1);
  122.         init_vlc(&dc_ccp_vlc, VLC_BITS, 8, 
  123.                  &dc_ccp_tab[0][1], 2, 1,
  124.                  &dc_ccp_tab[0][0], 2, 1, 1);
  125.         init_vlc(&ac_ccp_vlc, VLC_BITS, 16, 
  126.                  &ac_ccp_tab[0][1], 2, 1,
  127.                  &ac_ccp_tab[0][0], 2, 1, 1);
  128.         init_vlc(&level_vlc,  VLC_BITS, 7, 
  129.                  &level_tab[0][1], 2, 1,
  130.                  &level_tab[0][0], 2, 1, 1);
  131.         init_vlc(&asv2_level_vlc, ASV2_LEVEL_VLC_BITS, 63, 
  132.                  &asv2_level_tab[0][1], 2, 1,
  133.                  &asv2_level_tab[0][0], 2, 1, 1);
  134.     }
  135. }
  137. //FIXME write a reversed bitstream reader to avoid the double reverse
  138. static inline int asv2_get_bits(GetBitContext *gb, int n){
  139.     return ff_reverse[ get_bits(gb, n) << (8-n) ];
  140. }
  142. static inline void asv2_put_bits(PutBitContext *pb, int n, int v){
  143.     put_bits(pb, n, ff_reverse[ v << (8-n) ]);
  144. }
  146. static inline int asv1_get_level(GetBitContext *gb){
  147.     int code= get_vlc2(gb, level_vlc.table, VLC_BITS, 1);
  149.     if(code==3) return get_sbits(gb, 8);
  150.     else        return code - 3;
  151. }
  153. static inline int asv2_get_level(GetBitContext *gb){
  154.     int code= get_vlc2(gb, asv2_level_vlc.table, ASV2_LEVEL_VLC_BITS, 1);
  156.     if(code==31) return (int8_t)asv2_get_bits(gb, 8);
  157.     else         return code - 31;
  158. }
  160. static inline void asv1_put_level(PutBitContext *pb, int level){
  161.     unsigned int index= level + 3;
  163.     if(index <= 6) put_bits(pb, level_tab[index][1], level_tab[index][0]);
  164.     else{
  165.         put_bits(pb, level_tab[3][1], level_tab[3][0]);
  166.         put_bits(pb, 8, level&0xFF);
  167.     }
  168. }
  170. static inline void asv2_put_level(PutBitContext *pb, int level){
  171.     unsigned int index= level + 31;
  173.     if(index <= 62) put_bits(pb, asv2_level_tab[index][1], asv2_level_tab[index][0]);
  174.     else{
  175.         put_bits(pb, asv2_level_tab[31][1], asv2_level_tab[31][0]);
  176.         asv2_put_bits(pb, 8, level&0xFF);
  177.     }
  178. }
  180. static inline int asv1_decode_block(ASV1Context *a, DCTELEM block[64]){
  181.     int i;
  183.     block[0]= 8*get_bits(&a->gb, 8);
  184.     
  185.     for(i=0; i<11; i++){
  186.         const int ccp= get_vlc2(&a->gb, ccp_vlc.table, VLC_BITS, 1);
  188.         if(ccp){
  189.             if(ccp == 16) break;
  190.             if(ccp < 0 || i>=10){
  191.                 av_log(a->avctx, AV_LOG_ERROR, "coded coeff pattern damagedn");
  192.                 return -1;
  193.             }
  195.             if(ccp&8) block[a->scantable.permutated[4*i+0]]= (asv1_get_level(&a->gb) * a->intra_matrix[4*i+0])>>4;
  196.             if(ccp&4) block[a->scantable.permutated[4*i+1]]= (asv1_get_level(&a->gb) * a->intra_matrix[4*i+1])>>4;
  197.             if(ccp&2) block[a->scantable.permutated[4*i+2]]= (asv1_get_level(&a->gb) * a->intra_matrix[4*i+2])>>4;
  198.             if(ccp&1) block[a->scantable.permutated[4*i+3]]= (asv1_get_level(&a->gb) * a->intra_matrix[4*i+3])>>4;
  199.         }
  200.     }
  202.     return 0;
  203. }
  205. static inline int asv2_decode_block(ASV1Context *a, DCTELEM block[64]){
  206.     int i, count, ccp;
  208.     count= asv2_get_bits(&a->gb, 4);
  209.     
  210.     block[0]= 8*asv2_get_bits(&a->gb, 8);
  211.     
  212.     ccp= get_vlc2(&a->gb, dc_ccp_vlc.table, VLC_BITS, 1);
  213.     if(ccp){
  214.         if(ccp&4) block[a->scantable.permutated[1]]= (asv2_get_level(&a->gb) * a->intra_matrix[1])>>4;
  215.         if(ccp&2) block[a->scantable.permutated[2]]= (asv2_get_level(&a->gb) * a->intra_matrix[2])>>4;
  216.         if(ccp&1) block[a->scantable.permutated[3]]= (asv2_get_level(&a->gb) * a->intra_matrix[3])>>4;
  217.     }
  219.     for(i=1; i<count+1; i++){
  220.         const int ccp= get_vlc2(&a->gb, ac_ccp_vlc.table, VLC_BITS, 1);
  222.         if(ccp){
  223.             if(ccp&8) block[a->scantable.permutated[4*i+0]]= (asv2_get_level(&a->gb) * a->intra_matrix[4*i+0])>>4;
  224.             if(ccp&4) block[a->scantable.permutated[4*i+1]]= (asv2_get_level(&a->gb) * a->intra_matrix[4*i+1])>>4;
  225.             if(ccp&2) block[a->scantable.permutated[4*i+2]]= (asv2_get_level(&a->gb) * a->intra_matrix[4*i+2])>>4;
  226.             if(ccp&1) block[a->scantable.permutated[4*i+3]]= (asv2_get_level(&a->gb) * a->intra_matrix[4*i+3])>>4;
  227.         }
  228.     }
  229.     
  230.     return 0;
  231. }
  233. static inline void asv1_encode_block(ASV1Context *a, DCTELEM block[64]){
  234.     int i;
  235.     int nc_count=0;
  236.     
  237.     put_bits(&a->pb, 8, (block[0] + 32)>>6);
  238.     block[0]= 0;
  239.     
  240.     for(i=0; i<10; i++){
  241.         const int index= scantab[4*i];
  242.         int ccp=0;
  244.         if( (block[index + 0] = (block[index + 0]*a->q_intra_matrix[index + 0] + (1<<15))>>16) ) ccp |= 8;
  245.         if( (block[index + 8] = (block[index + 8]*a->q_intra_matrix[index + 8] + (1<<15))>>16) ) ccp |= 4;
  246.         if( (block[index + 1] = (block[index + 1]*a->q_intra_matrix[index + 1] + (1<<15))>>16) ) ccp |= 2;
  247.         if( (block[index + 9] = (block[index + 9]*a->q_intra_matrix[index + 9] + (1<<15))>>16) ) ccp |= 1;
  249.         if(ccp){
  250.             for(;nc_count; nc_count--) 
  251.                 put_bits(&a->pb, ccp_tab[0][1], ccp_tab[0][0]);
  253.             put_bits(&a->pb, ccp_tab[ccp][1], ccp_tab[ccp][0]);
  254.             
  255.             if(ccp&8) asv1_put_level(&a->pb, block[index + 0]);
  256.             if(ccp&4) asv1_put_level(&a->pb, block[index + 8]);
  257.             if(ccp&2) asv1_put_level(&a->pb, block[index + 1]);
  258.             if(ccp&1) asv1_put_level(&a->pb, block[index + 9]);
  259.         }else{
  260.             nc_count++;
  261.         }
  262.     }
  263.     put_bits(&a->pb, ccp_tab[16][1], ccp_tab[16][0]);
  264. }
  266. static inline void asv2_encode_block(ASV1Context *a, DCTELEM block[64]){
  267.     int i;
  268.     int count=0;
  269.     
  270.     for(count=63; count>3; count--){
  271.         const int index= scantab[count];
  273.         if( (block[index]*a->q_intra_matrix[index] + (1<<15))>>16 ) 
  274.             break;
  275.     }
  276.     
  277.     count >>= 2;
  279.     asv2_put_bits(&a->pb, 4, count);
  280.     asv2_put_bits(&a->pb, 8, (block[0] + 32)>>6);
  281.     block[0]= 0;
  282.     
  283.     for(i=0; i<=count; i++){
  284.         const int index= scantab[4*i];
  285.         int ccp=0;
  287.         if( (block[index + 0] = (block[index + 0]*a->q_intra_matrix[index + 0] + (1<<15))>>16) ) ccp |= 8;
  288.         if( (block[index + 8] = (block[index + 8]*a->q_intra_matrix[index + 8] + (1<<15))>>16) ) ccp |= 4;
  289.         if( (block[index + 1] = (block[index + 1]*a->q_intra_matrix[index + 1] + (1<<15))>>16) ) ccp |= 2;
  290.         if( (block[index + 9] = (block[index + 9]*a->q_intra_matrix[index + 9] + (1<<15))>>16) ) ccp |= 1;
  292.         if(i) put_bits(&a->pb, ac_ccp_tab[ccp][1], ac_ccp_tab[ccp][0]);
  293.         else  put_bits(&a->pb, dc_ccp_tab[ccp][1], dc_ccp_tab[ccp][0]);
  295.         if(ccp){
  296.             if(ccp&8) asv2_put_level(&a->pb, block[index + 0]);
  297.             if(ccp&4) asv2_put_level(&a->pb, block[index + 8]);
  298.             if(ccp&2) asv2_put_level(&a->pb, block[index + 1]);
  299.             if(ccp&1) asv2_put_level(&a->pb, block[index + 9]);
  300.         }
  301.     }
  302. }
  304. static inline int decode_mb(ASV1Context *a, DCTELEM block[6][64]){
  305.     int i;
  307.     a->dsp.clear_blocks(block[0]);
  308.     
  309.     if(a->avctx->codec_id == CODEC_ID_ASV1){
  310.         for(i=0; i<6; i++){
  311.             if( asv1_decode_block(a, block[i]) < 0) 
  312.                 return -1;
  313.         }
  314.     }else{
  315.         for(i=0; i<6; i++){
  316.             if( asv2_decode_block(a, block[i]) < 0) 
  317.                 return -1;
  318.         }
  319.     }
  320.     return 0;
  321. }
  323. static inline int encode_mb(ASV1Context *a, DCTELEM block[6][64]){
  324.     int i;
  325.     
  326.     if(a->pb.buf_end - a->pb.buf - (put_bits_count(&a->pb)>>3) < 30*16*16*3/2/8){
  327.         av_log(a->avctx, AV_LOG_ERROR, "encoded frame too largen");
  328.         return -1;
  329.     }
  331.     if(a->avctx->codec_id == CODEC_ID_ASV1){
  332.         for(i=0; i<6; i++)
  333.             asv1_encode_block(a, block[i]);
  334.     }else{
  335.         for(i=0; i<6; i++)
  336.             asv2_encode_block(a, block[i]);
  337.     }
  338.     return 0;
  339. }
  341. static inline void idct_put(ASV1Context *a, int mb_x, int mb_y){
  342.     DCTELEM (*block)[64]= a->block;
  343.     int linesize= a->picture.linesize[0];
  344.     
  345.     uint8_t *dest_y  = a->picture.data[0] + (mb_y * 16* linesize              ) + mb_x * 16;
  346.     uint8_t *dest_cb = a->picture.data[1] + (mb_y * 8 * a->picture.linesize[1]) + mb_x * 8;
  347.     uint8_t *dest_cr = a->picture.data[2] + (mb_y * 8 * a->picture.linesize[2]) + mb_x * 8;
  349.     a->dsp.idct_put(dest_y                 , linesize, block[0]);
  350.     a->dsp.idct_put(dest_y              + 8, linesize, block[1]);
  351.     a->dsp.idct_put(dest_y + 8*linesize    , linesize, block[2]);
  352.     a->dsp.idct_put(dest_y + 8*linesize + 8, linesize, block[3]);
  354.     if(!(a->avctx->flags&CODEC_FLAG_GRAY)){
  355.         a->dsp.idct_put(dest_cb, a->picture.linesize[1], block[4]);
  356.         a->dsp.idct_put(dest_cr, a->picture.linesize[2], block[5]);
  357.     }
  358. }
  360. static inline void dct_get(ASV1Context *a, int mb_x, int mb_y){
  361.     DCTELEM (*block)[64]= a->block;
  362.     int linesize= a->picture.linesize[0];
  363.     int i;
  364.     
  365.     uint8_t *ptr_y  = a->picture.data[0] + (mb_y * 16* linesize              ) + mb_x * 16;
  366.     uint8_t *ptr_cb = a->picture.data[1] + (mb_y * 8 * a->picture.linesize[1]) + mb_x * 8;
  367.     uint8_t *ptr_cr = a->picture.data[2] + (mb_y * 8 * a->picture.linesize[2]) + mb_x * 8;
  369.     a->dsp.get_pixels(block[0], ptr_y                 , linesize);
  370.     a->dsp.get_pixels(block[1], ptr_y              + 8, linesize);
  371.     a->dsp.get_pixels(block[2], ptr_y + 8*linesize    , linesize);
  372.     a->dsp.get_pixels(block[3], ptr_y + 8*linesize + 8, linesize);
  373.     for(i=0; i<4; i++)
  374.         a->dsp.fdct(block[i]);
  375.     
  376.     if(!(a->avctx->flags&CODEC_FLAG_GRAY)){
  377.         a->dsp.get_pixels(block[4], ptr_cb, a->picture.linesize[1]);
  378.         a->dsp.get_pixels(block[5], ptr_cr, a->picture.linesize[2]);
  379.         for(i=4; i<6; i++)
  380.             a->dsp.fdct(block[i]);
  381.     }
  382. }
  384. static int decode_frame(AVCodecContext *avctx, 
  385.                         void *data, int *data_size,
  386.                         uint8_t *buf, int buf_size)
  387. {
  388.     ASV1Context * const a = avctx->priv_data;
  389.     AVFrame *picture = data;
  390.     AVFrame * const p= (AVFrame*)&a->picture;
  391.     int mb_x, mb_y;
  393.     if(p->data[0])
  394.         avctx->release_buffer(avctx, p);
  396.     p->reference= 0;
  397.     if(avctx->get_buffer(avctx, p) < 0){
  398.         av_log(avctx, AV_LOG_ERROR, "get_buffer() failedn");
  399.         return -1;
  400.     }
  401.     p->pict_type= I_TYPE;
  402.     p->key_frame= 1;
  404.     a->bitstream_buffer= av_fast_realloc(a->bitstream_buffer, &a->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
  405.     
  406.     if(avctx->codec_id == CODEC_ID_ASV1)
  407.         a->dsp.bswap_buf((uint32_t*)a->bitstream_buffer, (uint32_t*)buf, buf_size/4);
  408.     else{
  409.         int i;
  410.         for(i=0; i<buf_size; i++)
  411.             a->bitstream_buffer[i]= ff_reverse[ buf[i] ];
  412.     }
  414.     init_get_bits(&a->gb, a->bitstream_buffer, buf_size*8);
  416.     for(mb_y=0; mb_y<a->mb_height2; mb_y++){
  417.         for(mb_x=0; mb_x<a->mb_width2; mb_x++){
  418.             if( decode_mb(a, a->block) <0)
  419.                 return -1;
  420.              
  421.             idct_put(a, mb_x, mb_y);
  422.         }
  423.     }
  425.     if(a->mb_width2 != a->mb_width){
  426.         mb_x= a->mb_width2;
  427.         for(mb_y=0; mb_y<a->mb_height2; mb_y++){
  428.             if( decode_mb(a, a->block) <0)
  429.                 return -1;
  430.              
  431.             idct_put(a, mb_x, mb_y);
  432.         }
  433.     }
  435.     if(a->mb_height2 != a->mb_height){
  436.         mb_y= a->mb_height2;
  437.         for(mb_x=0; mb_x<a->mb_width; mb_x++){
  438.             if( decode_mb(a, a->block) <0)
  439.                 return -1;
  440.              
  441.             idct_put(a, mb_x, mb_y);
  442.         }
  443.     }
  444. #if 0    
  445. int i;
  446. printf("%d %dn", 8*buf_size, get_bits_count(&a->gb));
  447. for(i=get_bits_count(&a->gb); i<8*buf_size; i++){
  448.     printf("%d", get_bits1(&a->gb));
  449. }
  451. for(i=0; i<s->avctx->extradata_size; i++){
  452.     printf("%cn", ((uint8_t*)s->avctx->extradata)[i]);
  453. }
  454. #endif
  456.     *picture= *(AVFrame*)&a->picture;
  457.     *data_size = sizeof(AVPicture);
  459.     emms_c();
  460.     
  461.     return (get_bits_count(&a->gb)+31)/32*4;
  462. }
  464. static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
  465.     ASV1Context * const a = avctx->priv_data;
  466.     AVFrame *pict = data;
  467.     AVFrame * const p= (AVFrame*)&a->picture;
  468.     int size;
  469.     int mb_x, mb_y;
  471.     init_put_bits(&a->pb, buf, buf_size);
  472.     
  473.     *p = *pict;
  474.     p->pict_type= I_TYPE;
  475.     p->key_frame= 1;
  477.     for(mb_y=0; mb_y<a->mb_height2; mb_y++){
  478.         for(mb_x=0; mb_x<a->mb_width2; mb_x++){
  479.             dct_get(a, mb_x, mb_y);
  480.             encode_mb(a, a->block);
  481.         }
  482.     }
  484.     if(a->mb_width2 != a->mb_width){
  485.         mb_x= a->mb_width2;
  486.         for(mb_y=0; mb_y<a->mb_height2; mb_y++){
  487.             dct_get(a, mb_x, mb_y);
  488.             encode_mb(a, a->block);
  489.         }
  490.     }
  492.     if(a->mb_height2 != a->mb_height){
  493.         mb_y= a->mb_height2;
  494.         for(mb_x=0; mb_x<a->mb_width; mb_x++){
  495.             dct_get(a, mb_x, mb_y);
  496.             encode_mb(a, a->block);
  497.         }
  498.     }
  499.     emms_c();
  500.     
  501.     align_put_bits(&a->pb);
  502.     while(put_bits_count(&a->pb)&31)
  503.         put_bits(&a->pb, 8, 0);
  504.     
  505.     size= put_bits_count(&a->pb)/32;
  506.     
  507.     if(avctx->codec_id == CODEC_ID_ASV1)
  508.         a->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
  509.     else{
  510.         int i;
  511.         for(i=0; i<4*size; i++)
  512.             buf[i]= ff_reverse[ buf[i] ];
  513.     }
  514.     
  515.     return size*4;
  516. }
  518. static void common_init(AVCodecContext *avctx){
  519.     ASV1Context * const a = avctx->priv_data;
  521.     dsputil_init(&a->dsp, avctx);
  523.     a->mb_width   = (avctx->width  + 15) / 16;
  524.     a->mb_height  = (avctx->height + 15) / 16;
  525.     a->mb_width2  = (avctx->width  + 0) / 16;
  526.     a->mb_height2 = (avctx->height + 0) / 16;
  528.     avctx->coded_frame= (AVFrame*)&a->picture;
  529.     a->avctx= avctx;
  530. }
  532. static int decode_init(AVCodecContext *avctx){
  533.     ASV1Context * const a = avctx->priv_data;
  534.     AVFrame *p= (AVFrame*)&a->picture;
  535.     int i;
  536.     const int scale= avctx->codec_id == CODEC_ID_ASV1 ? 1 : 2;
  537.  
  538.     common_init(avctx);
  539.     init_vlcs(a);
  540.     ff_init_scantable(a->dsp.idct_permutation, &a->scantable, scantab);
  541.     avctx->pix_fmt= PIX_FMT_YUV420P;
  543.     a->inv_qscale= ((uint8_t*)avctx->extradata)[0];
  544.     if(a->inv_qscale == 0){
  545.         av_log(avctx, AV_LOG_ERROR, "illegal qscale 0n");
  546.         if(avctx->codec_id == CODEC_ID_ASV1)
  547.             a->inv_qscale= 6;
  548.         else
  549.             a->inv_qscale= 10;
  550.     }
  552.     for(i=0; i<64; i++){
  553.         int index= scantab[i];
  555.         a->intra_matrix[i]= 64*scale*ff_mpeg1_default_intra_matrix[index] / a->inv_qscale;
  556.     }
  558.     p->qstride= a->mb_width;
  559.     p->qscale_table= av_malloc( p->qstride * a->mb_height);
  560.     p->quality= (32*scale + a->inv_qscale/2)/a->inv_qscale;
  561.     memset(p->qscale_table, p->quality, p->qstride*a->mb_height);
  563.     return 0;
  564. }
  566. static int encode_init(AVCodecContext *avctx){
  567.     ASV1Context * const a = avctx->priv_data;
  568.     int i;
  569.     const int scale= avctx->codec_id == CODEC_ID_ASV1 ? 1 : 2;
  571.     common_init(avctx);
  572.     
  573.     if(avctx->global_quality == 0) avctx->global_quality= 4*FF_QUALITY_SCALE;
  575.     a->inv_qscale= (32*scale*FF_QUALITY_SCALE +  avctx->global_quality/2) / avctx->global_quality;
  576.     
  577.     avctx->extradata= av_mallocz(8);
  578.     avctx->extradata_size=8;
  579.     ((uint32_t*)avctx->extradata)[0]= le2me_32(a->inv_qscale);
  580.     ((uint32_t*)avctx->extradata)[1]= le2me_32(ff_get_fourcc("ASUS"));
  581.     
  582.     for(i=0; i<64; i++){
  583.         int q= 32*scale*ff_mpeg1_default_intra_matrix[i];
  584.         a->q_intra_matrix[i]= ((a->inv_qscale<<16) + q/2) / q;
  585.     }
  587.     return 0;
  588. }
  590. static int decode_end(AVCodecContext *avctx){
  591.     ASV1Context * const a = avctx->priv_data;
  593.     av_freep(&a->bitstream_buffer);
  594.     av_freep(&a->picture.qscale_table);
  595.     a->bitstream_buffer_size=0;
  596.     
  597.     return 0;
  598. }
  600. AVCodec asv1_decoder = {
  601.     "asv1",
  602.     CODEC_TYPE_VIDEO,
  603.     CODEC_ID_ASV1,
  604.     sizeof(ASV1Context),
  605.     decode_init,
  606.     NULL,
  607.     decode_end,
  608.     decode_frame,
  609.     CODEC_CAP_DR1,
  610. };
  612. AVCodec asv2_decoder = {
  613.     "asv2",
  614.     CODEC_TYPE_VIDEO,
  615.     CODEC_ID_ASV2,
  616.     sizeof(ASV1Context),
  617.     decode_init,
  618.     NULL,
  619.     decode_end,
  620.     decode_frame,
  621.     CODEC_CAP_DR1,
  622. };
  624. #ifdef CONFIG_ENCODERS
  626. AVCodec asv1_encoder = {
  627.     "asv1",
  628.     CODEC_TYPE_VIDEO,
  629.     CODEC_ID_ASV1,
  630.     sizeof(ASV1Context),
  631.     encode_init,
  632.     encode_frame,
  633.     //encode_end,
  634. };
  636. AVCodec asv2_encoder = {
  637.     "asv2",
  638.     CODEC_TYPE_VIDEO,
  639.     CODEC_ID_ASV2,
  640.     sizeof(ASV1Context),
  641.     encode_init,
  642.     encode_frame,
  643.     //encode_end,
  644. };
  646. #endif //CONFIG_ENCODERS