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

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

Windows CE

开发平台：

C/C++

ffv1.c：源码内容
  1. /*
  2.  * FFV1 codec for libavcodec
  3.  *
  4.  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
  5.  *
  6.  * This library is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2 of the License, or (at your option) any later version.
  10.  *
  11.  * This library is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with this library; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19.  *
  20.  */
  21.  
  22. /**
  23.  * @file ffv1.c
  24.  * FF Video Codec 1 (an experimental lossless codec)
  25.  */
  27. #include "common.h"
  28. #include "bitstream.h"
  29. #include "avcodec.h"
  30. #include "dsputil.h"
  31. #include "rangecoder.h"
  32. #include "golomb.h"
  34. #define MAX_PLANES 4
  35. #define CONTEXT_SIZE 32
  37. static const int8_t quant3[256]={
  38.  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  39.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  40.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  41.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  42.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  43.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  44.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  45.  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  46. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  47. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  48. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  49. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  50. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  51. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  52. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  53. -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
  54. };
  55. static const int8_t quant5[256]={
  56.  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  57.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  58.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  59.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  60.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  61.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  62.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  63.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  64. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  65. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  66. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  67. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  68. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  69. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  70. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  71. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
  72. };
  73. static const int8_t quant7[256]={
  74.  0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  75.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  76.  2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
  77.  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  78.  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  79.  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  80.  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  81.  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  82. -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  83. -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  84. -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  85. -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  86. -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  87. -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
  88. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  89. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
  90. };
  91. static const int8_t quant9[256]={
  92.  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  93.  3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  94.  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  95.  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  96.  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  97.  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  98.  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  99.  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  100. -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
  101. -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
  102. -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
  103. -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
  104. -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
  105. -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
  106. -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
  107. -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
  108. };
  109. static const int8_t quant11[256]={
  110.  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
  111.  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  112.  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  113.  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  114.  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  115.  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  116.  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  117.  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  118. -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
  119. -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
  120. -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
  121. -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
  122. -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
  123. -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
  124. -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
  125. -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
  126. };
  127. static const int8_t quant13[256]={
  128.  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
  129.  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  130.  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  131.  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  132.  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  133.  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  134.  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  135.  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  136. -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
  137. -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
  138. -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
  139. -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
  140. -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
  141. -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
  142. -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
  143. -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
  144. };
  146. static const uint8_t log2_run[32]={
  147.  0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 
  148.  4, 4, 5, 5, 6, 6, 7, 7, 
  149.  8, 9,10,11,12,13,14,15,
  150. };
  152. typedef struct VlcState{
  153.     int16_t drift;
  154.     uint16_t error_sum;
  155.     int8_t bias;
  156.     uint8_t count;
  157. } VlcState;
  159. typedef struct PlaneContext{
  160.     int context_count;
  161.     uint8_t (*state)[CONTEXT_SIZE];
  162.     VlcState *vlc_state;
  163.     uint8_t interlace_bit_state[2];
  164. } PlaneContext;
  166. typedef struct FFV1Context{
  167.     AVCodecContext *avctx;
  168.     RangeCoder c;
  169.     GetBitContext gb;
  170.     PutBitContext pb;
  171.     int version;
  172.     int width, height;
  173.     int chroma_h_shift, chroma_v_shift;
  174.     int flags;
  175.     int picture_number;
  176.     AVFrame picture;
  177.     int plane_count;
  178.     int ac;                              ///< 1-> CABAC 0-> golomb rice
  179.     PlaneContext plane[MAX_PLANES];
  180.     int16_t quant_table[5][256];
  181.     int run_index;
  182.     int colorspace;
  183.     
  184.     DSPContext dsp; 
  185. }FFV1Context;
  187. static always_inline int fold(int diff, int bits){
  188.     if(bits==8)
  189.         diff= (int8_t)diff;
  190.     else{
  191.         diff+= 1<<(bits-1);
  192.         diff&=(1<<bits)-1;
  193.         diff-= 1<<(bits-1);
  194.     }
  196.     return diff;
  197. }
  199. static inline int predict(int_fast16_t *src, int_fast16_t *last){
  200.     const int LT= last[-1];
  201.     const int  T= last[ 0];
  202.     const int L =  src[-1];
  204.     return mid_pred(L, L + T - LT, T);
  205. }
  207. static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
  208.     const int LT= last[-1];
  209.     const int  T= last[ 0];
  210.     const int RT= last[ 1];
  211.     const int L =  src[-1];
  213.     if(f->quant_table[3][127]){
  214.         const int TT= last2[0];
  215.         const int LL=  src[-2];
  216.         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
  217.               +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
  218.     }else
  219.         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
  220. }
  222. static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
  223.     int i;
  225.     if(v){
  226.         const int a= ABS(v);
  227.         const int e= av_log2(a);
  228.         put_rac(c, state+0, 0);
  229.         
  230.         assert(e<=9);
  232.         for(i=0; i<e; i++){
  233.             put_rac(c, state+1+i, 1);  //1..10
  234.         }
  235.         put_rac(c, state+1+i, 0);
  237.         for(i=e-1; i>=0; i--){
  238.             put_rac(c, state+22+i, (a>>i)&1); //22..31
  239.         }
  241.         if(is_signed)
  242.             put_rac(c, state+11 + e, v < 0); //11..21
  243.     }else{
  244.         put_rac(c, state+0, 1);
  245.     }
  246. }
  248. static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
  249.     if(get_rac(c, state+0))
  250.         return 0;
  251.     else{
  252.         int i, e, a;
  253.         e= 0;
  254.         while(get_rac(c, state+1 + e)){ //1..10
  255.             e++;
  256.         }
  257.         assert(e<=9);
  259.         a= 1;
  260.         for(i=e-1; i>=0; i--){
  261.             a += a + get_rac(c, state+22 + i); //22..31
  262.         }
  264.         if(is_signed && get_rac(c, state+11 + e)) //11..21
  265.             return -a;
  266.         else
  267.             return a;
  268.     }
  269. }
  271. static inline void update_vlc_state(VlcState * const state, const int v){
  272.     int drift= state->drift;
  273.     int count= state->count;
  274.     state->error_sum += ABS(v);
  275.     drift += v;
  277.     if(count == 128){ //FIXME variable
  278.         count >>= 1;
  279.         drift >>= 1;
  280.         state->error_sum >>= 1;
  281.     }
  282.     count++;
  284.     if(drift <= -count){
  285.         if(state->bias > -128) state->bias--;
  286.         
  287.         drift += count;
  288.         if(drift <= -count)
  289.             drift= -count + 1;
  290.     }else if(drift > 0){
  291.         if(state->bias <  127) state->bias++;
  292.         
  293.         drift -= count;
  294.         if(drift > 0) 
  295.             drift= 0;
  296.     }
  298.     state->drift= drift;
  299.     state->count= count;
  300. }
  302. static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
  303.     int i, k, code;
  304. //printf("final: %d ", v);
  305.     v = fold(v - state->bias, bits);
  307.     i= state->count;
  308.     k=0;
  309.     while(i < state->error_sum){ //FIXME optimize
  310.         k++;
  311.         i += i;
  312.     }
  314.     assert(k<=8);
  316. #if 0 // JPEG LS
  317.     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
  318.     else                                         code= v;
  319. #else
  320.      code= v ^ ((2*state->drift + state->count)>>31);
  321. #endif
  322.     
  323. //printf("v:%d/%d bias:%d error:%d drift:%d count:%d k:%dn", v, code, state->bias, state->error_sum, state->drift, state->count, k);
  324.     set_sr_golomb(pb, code, k, 12, bits);
  326.     update_vlc_state(state, v);
  327. }
  329. static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
  330.     int k, i, v, ret;
  332.     i= state->count;
  333.     k=0;
  334.     while(i < state->error_sum){ //FIXME optimize
  335.         k++;
  336.         i += i;
  337.     }
  339.     assert(k<=8);
  341.     v= get_sr_golomb(gb, k, 12, bits);
  342. //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
  344. #if 0 // JPEG LS
  345.     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
  346. #else
  347.      v ^= ((2*state->drift + state->count)>>31);
  348. #endif
  350.     ret= fold(v + state->bias, bits);
  351.     
  352.     update_vlc_state(state, v);
  353. //printf("final: %dn", ret);
  354.     return ret;
  355. }
  357. static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
  358.     PlaneContext * const p= &s->plane[plane_index];
  359.     RangeCoder * const c= &s->c;
  360.     int x;
  361.     int run_index= s->run_index;
  362.     int run_count=0;
  363.     int run_mode=0;
  365.     if(s->ac){
  366.         if(c->bytestream_end - c->bytestream < w*20){
  367.             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too largen");
  368.             return -1;
  369.         }
  370.     }else{
  371.         if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
  372.             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too largen");
  373.             return -1;
  374.         }
  375.     }
  377.     for(x=0; x<w; x++){
  378.         int diff, context;
  379.         
  380.         context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
  381.         diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
  383.         if(context < 0){
  384.             context = -context;
  385.             diff= -diff;
  386.         }
  388.         diff= fold(diff, bits);
  389.         
  390.         if(s->ac){
  391.             put_symbol(c, p->state[context], diff, 1);
  392.         }else{
  393.             if(context == 0) run_mode=1;
  394.             
  395.             if(run_mode){
  397.                 if(diff){
  398.                     while(run_count >= 1<<log2_run[run_index]){
  399.                         run_count -= 1<<log2_run[run_index];
  400.                         run_index++;
  401.                         put_bits(&s->pb, 1, 1);
  402.                     }
  403.                     
  404.                     put_bits(&s->pb, 1 + log2_run[run_index], run_count);
  405.                     if(run_index) run_index--;
  406.                     run_count=0;
  407.                     run_mode=0;
  408.                     if(diff>0) diff--;
  409.                 }else{
  410.                     run_count++;
  411.                 }
  412.             }
  413.             
  414. //            printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%dn", run_count, run_index, run_mode, x, y, (int)put_bits_count(&s->pb));
  416.             if(run_mode == 0)
  417.                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
  418.         }
  419.     }
  420.     if(run_mode){
  421.         while(run_count >= 1<<log2_run[run_index]){
  422.             run_count -= 1<<log2_run[run_index];
  423.             run_index++;
  424.             put_bits(&s->pb, 1, 1);
  425.         }
  427.         if(run_count)
  428.             put_bits(&s->pb, 1, 1);
  429.     }
  430.     s->run_index= run_index;
  431.     
  432.     return 0;
  433. }
  435. static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
  436.     int x,y,i;
  437.     const int ring_size= s->avctx->context_model ? 3 : 2;
  438.     int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
  439.     s->run_index=0;
  440.     
  441.     memset(sample_buffer, 0, sizeof(sample_buffer));
  442.     
  443.     for(y=0; y<h; y++){
  444.         for(i=0; i<ring_size; i++)
  445.             sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
  446.         
  447.         sample[0][-1]= sample[1][0  ];
  448.         sample[1][ w]= sample[1][w-1];
  449. //{START_TIMER
  450.         for(x=0; x<w; x++){
  451.             sample[0][x]= src[x + stride*y];
  452.         }
  453.         encode_line(s, w, sample, plane_index, 8);
  454. //STOP_TIMER("encode line")}
  455.     }
  456. }
  458. static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
  459.     int x, y, p, i;
  460.     const int ring_size= s->avctx->context_model ? 3 : 2;
  461.     int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
  462.     s->run_index=0;
  463.     
  464.     memset(sample_buffer, 0, sizeof(sample_buffer));
  465.     
  466.     for(y=0; y<h; y++){
  467.         for(i=0; i<ring_size; i++)
  468.             for(p=0; p<3; p++)
  469.                 sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
  471.         for(x=0; x<w; x++){
  472.             int v= src[x + stride*y];
  473.             int b= v&0xFF;
  474.             int g= (v>>8)&0xFF;
  475.             int r= (v>>16)&0xFF;
  476.             
  477.             b -= g;
  478.             r -= g;
  479.             g += (b + r)>>2;
  480.             b += 0x100;
  481.             r += 0x100;
  482.             
  483. //            assert(g>=0 && b>=0 && r>=0);
  484. //            assert(g<256 && b<512 && r<512);
  485.             sample[0][0][x]= g;
  486.             sample[1][0][x]= b;
  487.             sample[2][0][x]= r;
  488.         }
  489.         for(p=0; p<3; p++){
  490.             sample[p][0][-1]= sample[p][1][0  ];
  491.             sample[p][1][ w]= sample[p][1][w-1];
  492.             encode_line(s, w, sample[p], FFMIN(p, 1), 9);
  493.         }
  494.     }
  495. }
  497. static void write_quant_table(RangeCoder *c, int16_t *quant_table){
  498.     int last=0;
  499.     int i;
  500.     uint8_t state[CONTEXT_SIZE];
  501.     memset(state, 128, sizeof(state));
  503.     for(i=1; i<128 ; i++){
  504.         if(quant_table[i] != quant_table[i-1]){
  505.             put_symbol(c, state, i-last-1, 0);
  506.             last= i;
  507.         }
  508.     }
  509.     put_symbol(c, state, i-last-1, 0);
  510. }
  512. static void write_header(FFV1Context *f){
  513.     uint8_t state[CONTEXT_SIZE];
  514.     int i;
  515.     RangeCoder * const c= &f->c;
  517.     memset(state, 128, sizeof(state));
  518.     
  519.     put_symbol(c, state, f->version, 0);
  520.     put_symbol(c, state, f->avctx->coder_type, 0);
  521.     put_symbol(c, state, f->colorspace, 0); //YUV cs type 
  522.     put_rac(c, state, 1); //chroma planes
  523.         put_symbol(c, state, f->chroma_h_shift, 0);
  524.         put_symbol(c, state, f->chroma_v_shift, 0);
  525.     put_rac(c, state, 0); //no transparency plane
  527.     for(i=0; i<5; i++)
  528.         write_quant_table(c, f->quant_table[i]);
  529. }
  531. static int common_init(AVCodecContext *avctx){
  532.     FFV1Context *s = avctx->priv_data;
  533.     int width, height;
  535.     s->avctx= avctx;
  536.     s->flags= avctx->flags;
  537.         
  538.     dsputil_init(&s->dsp, avctx);
  539.     
  540.     width= s->width= avctx->width;
  541.     height= s->height= avctx->height;
  542.     
  543.     assert(width && height);
  545.     return 0;
  546. }
  548. static int encode_init(AVCodecContext *avctx)
  549. {
  550.     FFV1Context *s = avctx->priv_data;
  551.     int i;
  553.     if(avctx->strict_std_compliance >FF_COMPLIANCE_EXPERIMENTAL){
  554.         av_log(avctx, AV_LOG_ERROR, "this codec is under development, files encoded with it may not be decodeable with future versions!!!n"
  555.                "use vstrict=-2 / -strict -2 to use it anywayn");
  556.         return -1;
  557.     }
  558.         
  559.     common_init(avctx);
  560.  
  561.     s->version=0;
  562.     s->ac= avctx->coder_type;
  563.     
  564.     s->plane_count=2;
  565.     for(i=0; i<256; i++){
  566.         s->quant_table[0][i]=           quant11[i];
  567.         s->quant_table[1][i]=        11*quant11[i];
  568.         if(avctx->context_model==0){
  569.             s->quant_table[2][i]=     11*11*quant11[i];
  570.             s->quant_table[3][i]=
  571.             s->quant_table[4][i]=0;
  572.         }else{
  573.             s->quant_table[2][i]=     11*11*quant5 [i];
  574.             s->quant_table[3][i]=   5*11*11*quant5 [i];
  575.             s->quant_table[4][i]= 5*5*11*11*quant5 [i];
  576.         }
  577.     }
  579.     for(i=0; i<s->plane_count; i++){
  580.         PlaneContext * const p= &s->plane[i];
  581.                
  582.         if(avctx->context_model==0){
  583.             p->context_count= (11*11*11+1)/2;
  584.         }else{        
  585.             p->context_count= (11*11*5*5*5+1)/2;
  586.         }
  588.         if(s->ac){
  589.             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
  590.         }else{
  591.             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
  592.         }
  593.     }
  595.     avctx->coded_frame= &s->picture;
  596.     switch(avctx->pix_fmt){
  597.     case PIX_FMT_YUV444P:
  598.     case PIX_FMT_YUV422P:
  599.     case PIX_FMT_YUV420P:
  600.     case PIX_FMT_YUV411P:
  601.     case PIX_FMT_YUV410P:
  602.         s->colorspace= 0;
  603.         break;
  604.     case PIX_FMT_RGBA32:
  605.         s->colorspace= 1;
  606.         break;
  607.     default:
  608.         av_log(avctx, AV_LOG_ERROR, "format not supportedn");
  609.         return -1;
  610.     }
  611.     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
  613.     s->picture_number=0;
  614.     
  615.     return 0;
  616. }
  619. static void clear_state(FFV1Context *f){
  620.     int i, j;
  622.     for(i=0; i<f->plane_count; i++){
  623.         PlaneContext *p= &f->plane[i];
  625.         p->interlace_bit_state[0]= 128;
  626.         p->interlace_bit_state[1]= 128;
  627.         
  628.         for(j=0; j<p->context_count; j++){
  629.             if(f->ac){
  630.                 memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
  631.             }else{
  632.                 p->vlc_state[j].drift= 0;
  633.                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
  634.                 p->vlc_state[j].bias= 0;
  635.                 p->vlc_state[j].count= 1;
  636.             }
  637.         }
  638.     }
  639. }
  641. static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
  642.     FFV1Context *f = avctx->priv_data;
  643.     RangeCoder * const c= &f->c;
  644.     AVFrame *pict = data;
  645.     const int width= f->width;
  646.     const int height= f->height;
  647.     AVFrame * const p= &f->picture;
  648.     int used_count= 0;
  649.     uint8_t keystate=128;
  651.     ff_init_range_encoder(c, buf, buf_size);
  652. //    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
  653.     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
  655.     *p = *pict;
  656.     p->pict_type= FF_I_TYPE;
  657.     
  658.     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
  659.         put_rac(c, &keystate, 1);
  660.         p->key_frame= 1;
  661.         write_header(f);
  662.         clear_state(f);
  663.     }else{
  664.         put_rac(c, &keystate, 0);
  665.         p->key_frame= 0;
  666.     }
  668.     if(!f->ac){
  669.         used_count += ff_rac_terminate(c);
  670. //printf("pos=%dn", used_count);
  671.         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
  672.     }
  673.     
  674.     if(f->colorspace==0){
  675.         const int chroma_width = -((-width )>>f->chroma_h_shift);
  676.         const int chroma_height= -((-height)>>f->chroma_v_shift);
  678.         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
  680.         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
  681.         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
  682.     }else{
  683.         encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
  684.     }
  685.     emms_c();
  686.     
  687.     f->picture_number++;
  689.     if(f->ac){
  690.         return ff_rac_terminate(c);
  691.     }else{
  692.         flush_put_bits(&f->pb); //nicer padding FIXME
  693.         return used_count + (put_bits_count(&f->pb)+7)/8;
  694.     }
  695. }
  697. static void common_end(FFV1Context *s){
  698.     int i; 
  700.     for(i=0; i<s->plane_count; i++){
  701.         PlaneContext *p= &s->plane[i];
  703.         av_freep(&p->state);
  704.     }
  705. }
  707. static int encode_end(AVCodecContext *avctx)
  708. {
  709.     FFV1Context *s = avctx->priv_data;
  711.     common_end(s);
  713.     return 0;
  714. }
  716. static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
  717.     PlaneContext * const p= &s->plane[plane_index];
  718.     RangeCoder * const c= &s->c;
  719.     int x;
  720.     int run_count=0;
  721.     int run_mode=0;
  722.     int run_index= s->run_index;
  724.     for(x=0; x<w; x++){
  725.         int diff, context, sign;
  726.          
  727.         context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
  728.         if(context < 0){
  729.             context= -context;
  730.             sign=1;
  731.         }else
  732.             sign=0;
  733.         
  735.         if(s->ac){
  736.             diff= get_symbol(c, p->state[context], 1);
  737.         }else{
  738.             if(context == 0 && run_mode==0) run_mode=1;
  739.             
  740.             if(run_mode){
  741.                 if(run_count==0 && run_mode==1){
  742.                     if(get_bits1(&s->gb)){
  743.                         run_count = 1<<log2_run[run_index];
  744.                         if(x + run_count <= w) run_index++;
  745.                     }else{
  746.                         if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
  747.                         else run_count=0;
  748.                         if(run_index) run_index--;
  749.                         run_mode=2;
  750.                     }
  751.                 }
  752.                 run_count--;
  753.                 if(run_count < 0){
  754.                     run_mode=0;
  755.                     run_count=0;
  756.                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
  757.                     if(diff>=0) diff++;
  758.                 }else
  759.                     diff=0;
  760.             }else
  761.                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
  762.             
  763. //            printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%dn", run_count, run_index, run_mode, x, y, get_bits_count(&s->gb));
  764.         }
  766.         if(sign) diff= -diff;
  768.         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
  769.     }
  770.     s->run_index= run_index;        
  771. }
  773. static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
  774.     int x, y;
  775.     int_fast16_t sample_buffer[2][w+6];
  776.     int_fast16_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
  778.     s->run_index=0;
  779.     
  780.     memset(sample_buffer, 0, sizeof(sample_buffer));
  781.     
  782.     for(y=0; y<h; y++){
  783.         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
  785.         sample[0]= sample[1];
  786.         sample[1]= temp;
  788.         sample[1][-1]= sample[0][0  ];
  789.         sample[0][ w]= sample[0][w-1];
  790.         
  791. //{START_TIMER
  792.         decode_line(s, w, sample, plane_index, 8);
  793.         for(x=0; x<w; x++){
  794.             src[x + stride*y]= sample[1][x];
  795.         }
  796. //STOP_TIMER("decode-line")}
  797.     }
  798. }
  800. static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
  801.     int x, y, p;
  802.     int_fast16_t sample_buffer[3][2][w+6];
  803.     int_fast16_t *sample[3][2]= {
  804.         {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
  805.         {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
  806.         {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
  808.     s->run_index=0;
  809.     
  810.     memset(sample_buffer, 0, sizeof(sample_buffer));
  811.     
  812.     for(y=0; y<h; y++){
  813.         for(p=0; p<3; p++){
  814.             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
  816.             sample[p][0]= sample[p][1];
  817.             sample[p][1]= temp;
  819.             sample[p][1][-1]= sample[p][0][0  ];
  820.             sample[p][0][ w]= sample[p][0][w-1];
  821.             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
  822.         }
  823.         for(x=0; x<w; x++){
  824.             int g= sample[0][1][x];
  825.             int b= sample[1][1][x];
  826.             int r= sample[2][1][x];
  828. //            assert(g>=0 && b>=0 && r>=0);
  829. //            assert(g<256 && b<512 && r<512);
  830.             
  831.             b -= 0x100;
  832.             r -= 0x100;
  833.             g -= (b + r)>>2;
  834.             b += g;
  835.             r += g;
  836.             
  837.             src[x + stride*y]= b + (g<<8) + (r<<16);
  838.         }
  839.     }
  840. }
  842. static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
  843.     int v;
  844.     int i=0;
  845.     uint8_t state[CONTEXT_SIZE];
  847.     memset(state, 128, sizeof(state));
  849.     for(v=0; i<128 ; v++){
  850.         int len= get_symbol(c, state, 0) + 1;
  852.         if(len + i > 128) return -1;
  853.         
  854.         while(len--){
  855.             quant_table[i] = scale*v;
  856.             i++;
  857. //printf("%2d ",v);
  858. //if(i%16==0) printf("n");
  859.         }
  860.     }
  862.     for(i=1; i<128; i++){
  863.         quant_table[256-i]= -quant_table[i];
  864.     }
  865.     quant_table[128]= -quant_table[127];
  866.     
  867.     return 2*v - 1;
  868. }
  870. static int read_header(FFV1Context *f){
  871.     uint8_t state[CONTEXT_SIZE];
  872.     int i, context_count;
  873.     RangeCoder * const c= &f->c;
  874.     
  875.     memset(state, 128, sizeof(state));
  877.     f->version= get_symbol(c, state, 0);
  878.     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
  879.     f->colorspace= get_symbol(c, state, 0); //YUV cs type
  880.     get_rac(c, state); //no chroma = false
  881.     f->chroma_h_shift= get_symbol(c, state, 0);
  882.     f->chroma_v_shift= get_symbol(c, state, 0);
  883.     get_rac(c, state); //transparency plane
  884.     f->plane_count= 2;
  886.     if(f->colorspace==0){
  887.         switch(16*f->chroma_h_shift + f->chroma_v_shift){
  888.         case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
  889.         case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
  890.         case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
  891.         case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
  892.         case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
  893.         default:
  894.             av_log(f->avctx, AV_LOG_ERROR, "format not supportedn");
  895.             return -1;
  896.         }
  897.     }else if(f->colorspace==1){
  898.         if(f->chroma_h_shift || f->chroma_v_shift){
  899.             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspacen");
  900.             return -1;
  901.         }
  902.         f->avctx->pix_fmt= PIX_FMT_RGBA32;
  903.     }else{
  904.         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supportedn");
  905.         return -1;
  906.     }
  908. //printf("%d %d %dn", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
  910.     context_count=1;
  911.     for(i=0; i<5; i++){
  912.         context_count*= read_quant_table(c, f->quant_table[i], context_count);
  913.         if(context_count < 0 || context_count > 32768){
  914.             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table errorn");
  915.             return -1;
  916.         }
  917.     }
  918.     context_count= (context_count+1)/2;
  919.     
  920.     for(i=0; i<f->plane_count; i++){
  921.         PlaneContext * const p= &f->plane[i];
  923.         p->context_count= context_count;
  925.         if(f->ac){
  926.             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
  927.         }else{
  928.             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
  929.         }
  930.     }
  931.     
  932.     return 0;
  933. }
  935. static int decode_init(AVCodecContext *avctx)
  936. {
  937. //    FFV1Context *s = avctx->priv_data;
  939.     common_init(avctx);
  940.     
  941.     return 0;
  942. }
  944. static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
  945.     FFV1Context *f = avctx->priv_data;
  946.     RangeCoder * const c= &f->c;
  947.     const int width= f->width;
  948.     const int height= f->height;
  949.     AVFrame * const p= &f->picture;
  950.     int bytes_read;
  951.     uint8_t keystate= 128;
  953.     AVFrame *picture = data;
  955.     ff_init_range_decoder(c, buf, buf_size);
  956.     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
  959.     p->pict_type= FF_I_TYPE; //FIXME I vs. P
  960.     if(get_rac(c, &keystate)){
  961.         p->key_frame= 1;
  962.         read_header(f);
  963.         clear_state(f);
  964.     }else{
  965.         p->key_frame= 0;
  966.     }
  968.     p->reference= 0;
  969.     if(avctx->get_buffer(avctx, p) < 0){
  970.         av_log(avctx, AV_LOG_ERROR, "get_buffer() failedn");
  971.         return -1;
  972.     }
  974.     if(avctx->debug&FF_DEBUG_PICT_INFO)
  975.         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%dn", p->key_frame, f->ac);
  976.     
  977.     if(!f->ac){
  978.         bytes_read = c->bytestream - c->bytestream_start - 1;
  979.         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC streamn"); //FIXME
  980. //printf("pos=%dn", bytes_read);
  981.         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
  982.     } else {
  983.         bytes_read = 0; /* avoid warning */
  984.     }
  985.     
  986.     if(f->colorspace==0){
  987.         const int chroma_width = -((-width )>>f->chroma_h_shift);
  988.         const int chroma_height= -((-height)>>f->chroma_v_shift);
  989.         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
  990.         
  991.         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
  992.         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
  993.     }else{
  994.         decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
  995.     }
  996.         
  997.     emms_c();
  999.     f->picture_number++;
  1001.     *picture= *p;
  1002.     
  1003.     avctx->release_buffer(avctx, p); //FIXME
  1005.     *data_size = sizeof(AVFrame);
  1006.     
  1007.     if(f->ac){
  1008.         bytes_read= c->bytestream - c->bytestream_start - 1;
  1009.         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of framen");
  1010.     }else{
  1011.         bytes_read+= (get_bits_count(&f->gb)+7)/8;
  1012.     }
  1014.     return bytes_read;
  1015. }
  1017. AVCodec ffv1_decoder = {
  1018.     "ffv1",
  1019.     CODEC_TYPE_VIDEO,
  1020.     CODEC_ID_FFV1,
  1021.     sizeof(FFV1Context),
  1022.     decode_init,
  1023.     NULL,
  1024.     NULL,
  1025.     decode_frame,
  1026.     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
  1027.     NULL
  1028. };
  1030. #ifdef CONFIG_ENCODERS
  1031. AVCodec ffv1_encoder = {
  1032.     "ffv1",
  1033.     CODEC_TYPE_VIDEO,
  1034.     CODEC_ID_FFV1,
  1035.     sizeof(FFV1Context),
  1036.     encode_init,
  1037.     encode_frame,
  1038.     encode_end,
  1039. };
  1040. #endif