falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2219 Commits
32 Branches
1.1GB
Tree: 2a250222e6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2a250222e6'
${ noResults }
FFmpeg/libavcodec/ffv1.c

919 lines
27KB
Raw Blame History 

  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 (a experimental lossless codec)

  25.  */

  26. 

  27. #include "common.h"

  28. #include "avcodec.h"

  29. #include "dsputil.h"

  30. #include "cabac.h"

  31. #include "golomb.h"

  32. 

  33. #define MAX_PLANES 4

  34. #define CONTEXT_SIZE 32

  35. 

  36. static const int8_t quant3[256]={

  37.  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

  38.  1, 1, 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, 0,

  53. };

  54. static const int8_t quant5[256]={

  55.  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  56.  2, 2, 2, 2, 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,-1,-1,-1,

  71. };

  72. static const int8_t quant7[256]={

  73.  0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  74.  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

  75.  2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,

  76.  3, 3, 3, 3, 3, 3, 3, 3, 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,-2,-2,-2,-2,-2,-2,-2,

  87. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,

  88. -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,

  89. };

  90. static const int8_t quant9[256]={

  91.  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,

  92.  3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

  93.  4, 4, 4, 4, 4, 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,-3,-3,-3,-3,

  106. -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,

  107. };

  108. static const int8_t quant11[256]={

  109.  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,

  110.  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

  111.  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

  112.  5, 5, 5, 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,-4,-4,

  123. -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,

  124. -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,

  125. };

  126. static const int8_t quant13[256]={

  127.  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,

  128.  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

  129.  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

  130.  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,

  131.  6, 6, 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,-5,

  140. -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,

  141. -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,

  142. -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,

  143. };

  144. 

  145. static const uint8_t log2_run[32]={

  146.  0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 

  147.  4, 4, 5, 5, 6, 6, 7, 7, 

  148.  8, 9,10,11,12,13,14,15,

  149. };

  150. 

  151. typedef struct VlcState{

  152.     int16_t drift;

  153.     uint16_t error_sum;

  154.     int8_t bias;

  155.     uint8_t count;

  156. } VlcState;

  157. 

  158. typedef struct PlaneContext{

  159.     int context_count;

  160.     uint8_t (*state)[CONTEXT_SIZE];

  161.     VlcState *vlc_state;

  162.     uint8_t interlace_bit_state[2];

  163. } PlaneContext;

  164. 

  165. typedef struct FFV1Context{

  166.     AVCodecContext *avctx;

  167.     CABACContext c;

  168.     GetBitContext gb;

  169.     PutBitContext pb;

  170.     int version;

  171.     int width, height;

  172.     int chroma_h_shift, chroma_v_shift;

  173.     int flags;

  174.     int picture_number;

  175.     AVFrame picture;

  176.     int plane_count;

  177.     int ac;                              ///< 1-> CABAC 0-> golomb rice

  178.     PlaneContext plane[MAX_PLANES];

  179.     int16_t quant_table[5][256];

  180.     

  181.     DSPContext dsp; 

  182. }FFV1Context;

  183. 

  184. static inline int predict(uint8_t *src, uint8_t *last){

  185.     const int LT= last[-1];

  186.     const int  T= last[ 0];

  187.     const int L =  src[-1];

  188.     uint8_t *cm = cropTbl + MAX_NEG_CROP;    

  189.     const int gradient= cm[L + T - LT];

  190. 

  191.     return mid_pred(L, gradient, T);

  192. }

  193. 

  194. static inline int get_context(FFV1Context *f, uint8_t *src, uint8_t *last, uint8_t *last2){

  195.     const int LT= last[-1];

  196.     const int  T= last[ 0];

  197.     const int RT= last[ 1];

  198.     const int L =  src[-1];

  199. 

  200.     if(f->quant_table[3][127]){

  201.         const int TT= last2[0];

  202.         const int LL=  src[-2];

  203.         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]

  204.               +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];

  205.     }else

  206.         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];

  207. }

  208. 

  209. /**

  210.  * put 

  211.  */

  212. static inline void put_symbol(CABACContext *c, uint8_t *state, int v, int is_signed){

  213.     int i;

  214. 

  215.     if(v){

  216.         const int a= ABS(v);

  217.         const int e= av_log2(a);

  218. 

  219.         put_cabac(c, state+0, 0);

  220.         put_cabac_u(c, state+1, e, 7, 6, 1); //1..7

  221.         if(e<7){

  222.             for(i=e-1; i>=0; i--){

  223.                 static const int offset[7]= {15+0, 15+0, 15+1, 15+3, 15+6, 15+10, 15+11};

  224.                 put_cabac(c, state+offset[e]+i, (a>>i)&1); //15..31

  225.             }

  226.             if(is_signed)

  227.                 put_cabac(c, state+8 + e, v < 0); //8..14

  228.         }

  229.     }else{

  230.         put_cabac(c, state+0, 1);

  231.     }

  232. }

  233. 

  234. static inline int get_symbol(CABACContext *c, uint8_t *state, int is_signed){

  235.     int i;

  236. 

  237.     if(get_cabac(c, state+0))

  238.         return 0;

  239.     else{

  240.         const int e= get_cabac_u(c, state+1, 7, 6, 1); //1..7

  241.         

  242.         if(e<7){

  243.             int a= 1<<e;

  244. 

  245.             for(i=e-1; i>=0; i--){

  246.                 static const int offset[7]= {15+0, 15+0, 15+1, 15+3, 15+6, 15+10, 15+11};

  247.                 a += get_cabac(c, state+offset[e]+i)<<i; //14..31

  248.             }

  249. 

  250.             if(is_signed && get_cabac(c, state+8 + e)) //8..14

  251.                 return -a;

  252.             else

  253.                 return a;

  254.         }else

  255.             return -128;

  256.     }

  257. }

  258. 

  259. static inline void update_vlc_state(VlcState * const state, const int v){

  260.     int drift= state->drift;

  261.     int count= state->count;

  262.     state->error_sum += ABS(v);

  263.     drift += v;

  264. 

  265.     if(count == 128){ //FIXME variable

  266.         count >>= 1;

  267.         drift >>= 1;

  268.         state->error_sum >>= 1;

  269.     }

  270.     count++;

  271. 

  272.     if(drift <= -count){

  273.         if(state->bias > -128) state->bias--;

  274.         

  275.         drift += count;

  276.         if(drift <= -count)

  277.             drift= -count + 1;

  278.     }else if(drift > 0){

  279.         if(state->bias <  127) state->bias++;

  280.         

  281.         drift -= count;

  282.         if(drift > 0) 

  283.             drift= 0;

  284.     }

  285. 

  286.     state->drift= drift;

  287.     state->count= count;

  288. }

  289. 

  290. static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v){

  291.     int i, k, code;

  292. //printf("final: %d ", v);

  293.     v = (int8_t)(v - state->bias);

  294.     

  295.     i= state->count;

  296.     k=0;

  297.     while(i < state->error_sum){ //FIXME optimize

  298.         k++;

  299.         i += i;

  300.     }

  301. #if 0 // JPEG LS

  302.     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);

  303.     else                                         code= v;

  304. #else

  305.      code= v ^ ((2*state->drift + state->count)>>31);

  306. #endif

  307.     

  308.     code = -2*code-1;

  309.     code^= (code>>31);

  310. //printf("v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code, state->bias, state->error_sum, state->drift, state->count, k);

  311.     set_ur_golomb(pb, code, k, 8, 8);

  312. 

  313.     update_vlc_state(state, v);

  314. }

  315. 

  316. static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state){

  317.     int k, i, v, ret;

  318. 

  319.     i= state->count;

  320.     k=0;

  321.     while(i < state->error_sum){ //FIXME optimize

  322.         k++;

  323.         i += i;

  324.     }

  325.     

  326.     v= get_ur_golomb(gb, k, 8, 8);

  327. //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);

  328.     

  329.     v++;

  330.     if(v&1) v=  (v>>1);

  331.     else    v= -(v>>1);

  332. 

  333. #if 0 // JPEG LS

  334.     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);

  335. #else

  336.      v ^= ((2*state->drift + state->count)>>31);

  337. #endif

  338. 

  339.     ret= (int8_t)(v + state->bias);

  340.     

  341.     update_vlc_state(state, v);

  342. //printf("final: %d\n", ret);

  343.     return ret;

  344. }

  345. 

  346. 

  347. 

  348. static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){

  349.     PlaneContext * const p= &s->plane[plane_index];

  350.     CABACContext * const c= &s->c;

  351.     int x,y;

  352.     uint8_t pred_diff_buffer[4][w+6]; //FIXME rema,e

  353.     uint8_t *pred_diff[4]= {pred_diff_buffer[0]+3, pred_diff_buffer[1]+3, pred_diff_buffer[2]+3, pred_diff_buffer[3]+3};

  354.     int run_index=0;

  355.     

  356.     memset(pred_diff_buffer, 0, sizeof(pred_diff_buffer));

  357.     

  358.     for(y=0; y<h; y++){

  359.         uint8_t *temp= pred_diff[0]; //FIXME try a normal buffer

  360.         int run_count=0;

  361.         int run_mode=0;

  362. 

  363.         pred_diff[0]= pred_diff[1];

  364.         pred_diff[1]= pred_diff[2];

  365.         pred_diff[2]= pred_diff[3];

  366.         pred_diff[3]= temp;

  367.         

  368.         pred_diff[3][-1]= pred_diff[2][0  ];

  369.         pred_diff[2][ w]= pred_diff[2][w-1];

  370. 

  371.         for(x=0; x<w; x++){

  372.             uint8_t *temp_src= src + x + stride*y;

  373.             int diff, context;

  374.             

  375.             context= get_context(s, pred_diff[3]+x, pred_diff[2]+x, pred_diff[1]+x);

  376.             diff= temp_src[0] - predict(pred_diff[3]+x, pred_diff[2]+x);

  377. 

  378.             if(context < 0){

  379.                 context = -context;

  380.                 diff= -diff;

  381.             }

  382. 

  383.             diff= (int8_t)diff;

  384. 

  385.             if(s->ac)

  386.                 put_symbol(c, p->state[context], diff, 1);

  387.             else{

  388.                 if(context == 0) run_mode=1;

  389.                 

  390.                 if(run_mode){

  391. 

  392.                     if(diff){

  393.                         while(run_count >= 1<<log2_run[run_index]){

  394.                             run_count -= 1<<log2_run[run_index];

  395.                             run_index++;

  396.                             put_bits(&s->pb, 1, 1);

  397.                         }

  398.                         

  399.                         put_bits(&s->pb, 1 + log2_run[run_index], run_count);

  400.                         if(run_index) run_index--;

  401.                         run_count=0;

  402.                         run_mode=0;

  403.                         if(diff>0) diff--;

  404.                     }else{

  405.                         run_count++;

  406.                     }

  407.                 }

  408.                 

  409. //                printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, (int)get_bit_count(&s->pb));

  410. 

  411.                 if(run_mode == 0)

  412.                     put_vlc_symbol(&s->pb, &p->vlc_state[context], diff);

  413.             }

  414. 

  415.             pred_diff[3][x]= temp_src[0];

  416.         }

  417.         if(run_mode){

  418.             while(run_count >= 1<<log2_run[run_index]){

  419.                 run_count -= 1<<log2_run[run_index];

  420.                 run_index++;

  421.                 put_bits(&s->pb, 1, 1);

  422.             }

  423. 

  424.             if(run_count)

  425.                 put_bits(&s->pb, 1, 1);

  426.         }

  427.     }

  428. }

  429. 

  430. static void write_quant_table(CABACContext *c, int16_t *quant_table){

  431.     int last=0;

  432.     int i;

  433.     uint8_t state[CONTEXT_SIZE]={0};

  434. 

  435.     for(i=1; i<128 ; i++){

  436.         if(quant_table[i] != quant_table[i-1]){

  437.             put_symbol(c, state, i-last-1, 0);

  438.             last= i;

  439.         }

  440.     }

  441.     put_symbol(c, state, i-last-1, 0);

  442. }

  443. 

  444. static void write_header(FFV1Context *f){

  445.     uint8_t state[CONTEXT_SIZE]={0};

  446.     int i;

  447.     CABACContext * const c= &f->c;

  448. 

  449.     put_symbol(c, state, f->version, 0);

  450.     put_symbol(c, state, f->avctx->coder_type, 0);

  451.     put_symbol(c, state, 0, 0); //YUV cs type 

  452.     put_cabac(c, state, 1); //chroma planes

  453.         put_symbol(c, state, f->chroma_h_shift, 0);

  454.         put_symbol(c, state, f->chroma_v_shift, 0);

  455.     put_cabac(c, state, 0); //no transparency plane

  456. 

  457.     for(i=0; i<5; i++)

  458.         write_quant_table(c, f->quant_table[i]);

  459. }

  460. 

  461. static int common_init(AVCodecContext *avctx){

  462.     FFV1Context *s = avctx->priv_data;

  463.     int width, height;

  464. 

  465.     s->avctx= avctx;

  466.     s->flags= avctx->flags;

  467.         

  468.     dsputil_init(&s->dsp, avctx);

  469.     

  470.     width= s->width= avctx->width;

  471.     height= s->height= avctx->height;

  472.     

  473.     assert(width && height);

  474. 

  475.     return 0;

  476. }

  477. 

  478. static int encode_init(AVCodecContext *avctx)

  479. {

  480.     FFV1Context *s = avctx->priv_data;

  481.     int i;

  482. 

  483.     common_init(avctx);

  484.  

  485.     s->version=0;

  486.     s->ac= avctx->coder_type;

  487.     

  488.     s->plane_count=3;

  489.     for(i=0; i<256; i++){

  490.         s->quant_table[0][i]=           quant11[i];

  491.         s->quant_table[1][i]=        11*quant11[i];

  492.         if(avctx->context_model==0){

  493.             s->quant_table[2][i]=     11*11*quant11[i];

  494.             s->quant_table[3][i]=

  495.             s->quant_table[4][i]=0;

  496.         }else{

  497.             s->quant_table[2][i]=     11*11*quant5 [i];

  498.             s->quant_table[3][i]=   5*11*11*quant5 [i];

  499.             s->quant_table[4][i]= 5*5*11*11*quant5 [i];

  500.         }

  501.     }

  502. 

  503.     for(i=0; i<s->plane_count; i++){

  504.         PlaneContext * const p= &s->plane[i];

  505.                

  506.         if(avctx->context_model==0){

  507.             p->context_count= (11*11*11+1)/2;

  508.         }else{        

  509.             p->context_count= (11*11*5*5*5+1)/2;

  510.         }

  511. 

  512.         if(s->ac){

  513.             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));

  514.         }else{

  515.             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));

  516.         }

  517.     }

  518. 

  519.     avctx->coded_frame= &s->picture;

  520.     switch(avctx->pix_fmt){

  521.     case PIX_FMT_YUV444P:

  522.     case PIX_FMT_YUV422P:

  523.     case PIX_FMT_YUV420P:

  524.     case PIX_FMT_YUV411P:

  525.     case PIX_FMT_YUV410P:

  526.         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);

  527.         break;

  528.     default:

  529.         fprintf(stderr, "format not supported\n");

  530.         return -1;

  531.     }

  532.     

  533.    

  534.     s->picture_number=0;

  535.     

  536.     return 0;

  537. }

  538. 

  539. 

  540. static void clear_state(FFV1Context *f){

  541.     int i, j;

  542. 

  543.     for(i=0; i<f->plane_count; i++){

  544.         PlaneContext *p= &f->plane[i];

  545. 

  546.         p->interlace_bit_state[0]= 0;

  547.         p->interlace_bit_state[1]= 0;

  548.         

  549.         for(j=0; j<p->context_count; j++){

  550.             if(f->ac){

  551.                 memset(p->state[j], 0, sizeof(uint8_t)*CONTEXT_SIZE);

  552.                 p->state[j][7] = 2*62;

  553.             }else{

  554.                 p->vlc_state[j].drift= 0;

  555.                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);

  556.                 p->vlc_state[j].bias= 0;

  557.                 p->vlc_state[j].count= 1;

  558.             }

  559.         }

  560.     }

  561. }

  562. 

  563. static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){

  564.     FFV1Context *f = avctx->priv_data;

  565.     CABACContext * const c= &f->c;

  566.     AVFrame *pict = data;

  567.     const int width= f->width;

  568.     const int height= f->height;

  569.     AVFrame * const p= &f->picture;

  570.     int used_count= 0;

  571. 

  572.     if(avctx->strict_std_compliance >= 0){

  573.         printf("this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"

  574.                "use vstrict=-1 to use it anyway\n");

  575.         return -1;

  576.     }

  577.         

  578.     ff_init_cabac_encoder(c, buf, buf_size);

  579.     ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);

  580.     

  581.     *p = *pict;

  582.     p->pict_type= FF_I_TYPE;

  583.     

  584.     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){

  585.         put_cabac_bypass(c, 1);

  586.         p->key_frame= 1;

  587.         write_header(f);

  588.         clear_state(f);

  589.     }else{

  590.         put_cabac_bypass(c, 0);

  591.         p->key_frame= 0;

  592.     }

  593. 

  594.     if(!f->ac){

  595.         used_count += put_cabac_terminate(c, 1);

  596. //printf("pos=%d\n", used_count);

  597.         init_put_bits(&f->pb, buf + used_count, buf_size - used_count, NULL, NULL);

  598.     }

  599.     

  600.     if(1){

  601.         const int chroma_width = -((-width )>>f->chroma_h_shift);

  602.         const int chroma_height= -((-height)>>f->chroma_v_shift);

  603. 

  604.         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);

  605. 

  606.         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);

  607.         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 2);

  608.     }

  609.     emms_c();

  610.     

  611.     f->picture_number++;

  612. 

  613.     if(f->ac){

  614.         return put_cabac_terminate(c, 1);

  615.     }else{

  616.         flush_put_bits(&f->pb); //nicer padding FIXME

  617.         return used_count + (get_bit_count(&f->pb)+7)/8;

  618.     }

  619. }

  620. 

  621. static void common_end(FFV1Context *s){

  622.     int i; 

  623. 

  624.     for(i=0; i<s->plane_count; i++){

  625.         PlaneContext *p= &s->plane[i];

  626. 

  627.         av_freep(&p->state);

  628.     }

  629. }

  630. 

  631. static int encode_end(AVCodecContext *avctx)

  632. {

  633.     FFV1Context *s = avctx->priv_data;

  634. 

  635.     common_end(s);

  636. 

  637.     return 0;

  638. }

  639. 

  640. static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){

  641.     PlaneContext * const p= &s->plane[plane_index];

  642.     CABACContext * const c= &s->c;

  643.     int x,y;

  644.     uint8_t pred_diff_buffer[4][w+6];

  645.     uint8_t *pred_diff[4]= {pred_diff_buffer[0]+3, pred_diff_buffer[1]+3, pred_diff_buffer[2]+3, pred_diff_buffer[3]+3};

  646.     int run_index=0;

  647.     

  648.     memset(pred_diff_buffer, 0, sizeof(pred_diff_buffer));

  649.     

  650.     for(y=0; y<h; y++){

  651.         uint8_t *temp= pred_diff[0]; //FIXME try a normal buffer

  652.         int run_count=0;

  653.         int run_mode=0;

  654. 

  655.         pred_diff[0]= pred_diff[1];

  656.         pred_diff[1]= pred_diff[2];

  657.         pred_diff[2]= pred_diff[3];

  658.         pred_diff[3]= temp;

  659. 

  660.         pred_diff[3][-1]= pred_diff[2][0  ];

  661.         pred_diff[2][ w]= pred_diff[2][w-1];

  662. 

  663.         for(x=0; x<w; x++){

  664.             uint8_t *temp_src= src + x + stride*y;

  665.             int diff, context, sign;

  666.              

  667.             context= get_context(s, pred_diff[3] + x, pred_diff[2] + x, pred_diff[1] + x);

  668.             if(context < 0){

  669.                 context= -context;

  670.                 sign=1;

  671.             }else

  672.                 sign=0;

  673.             

  674. 

  675.             if(s->ac)

  676.                 diff= get_symbol(c, p->state[context], 1);

  677.             else{

  678.                 if(context == 0 && run_mode==0) run_mode=1;

  679.                 

  680.                 if(run_mode){

  681.                     if(run_count==0 && run_mode==1){

  682.                         if(get_bits1(&s->gb)){

  683.                             run_count = 1<<log2_run[run_index];

  684.                             if(x + run_count <= w) run_index++;

  685.                         }else{

  686.                             if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);

  687.                             else run_count=0;

  688.                             if(run_index) run_index--;

  689.                             run_mode=2;

  690.                         }

  691.                     }

  692.                     run_count--;

  693.                     if(run_count < 0){

  694.                         run_mode=0;

  695.                         run_count=0;

  696.                         diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);

  697.                         if(diff>=0) diff++;

  698.                     }else

  699.                         diff=0;

  700.                 }else

  701.                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);

  702.                 

  703. //                printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, get_bits_count(&s->gb));

  704.             }

  705. 

  706.             if(sign) diff= (int8_t)(-diff); //FIXME remove cast

  707. 

  708.             pred_diff[3][x]=

  709.             temp_src[0] = predict(pred_diff[3] + x, pred_diff[2] + x) + diff;

  710.             

  711.             assert(diff>= -128 && diff <= 127);

  712.         }

  713.     }

  714. }

  715. 

  716. static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){

  717.     int v;

  718.     int i=0;

  719.     uint8_t state[CONTEXT_SIZE]={0};

  720. 

  721.     for(v=0; i<128 ; v++){

  722.         int len= get_symbol(c, state, 0) + 1;

  723. 

  724.         if(len + i > 128) return -1;

  725.         

  726.         while(len--){

  727.             quant_table[i] = scale*v;

  728.             i++;

  729. //printf("%2d ",v);

  730. //if(i%16==0) printf("\n");

  731.         }

  732.     }

  733. 

  734.     for(i=1; i<128; i++){

  735.         quant_table[256-i]= -quant_table[i];

  736.     }

  737.     quant_table[128]= -quant_table[127];

  738.     

  739.     return 2*v - 1;

  740. }

  741. 

  742. static int read_header(FFV1Context *f){

  743.     uint8_t state[CONTEXT_SIZE]={0};

  744.     int i, context_count;

  745.     CABACContext * const c= &f->c;

  746.     

  747.     f->version= get_symbol(c, state, 0);

  748.     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);

  749.     get_symbol(c, state, 0); //YUV cs type

  750.     get_cabac(c, state); //no chroma = false

  751.     f->chroma_h_shift= get_symbol(c, state, 0);

  752.     f->chroma_v_shift= get_symbol(c, state, 0);

  753.     get_cabac(c, state); //transparency plane

  754.     f->plane_count= 3;

  755.     

  756.     context_count=1;

  757.     for(i=0; i<5; i++){

  758.         context_count*= read_quant_table(c, f->quant_table[i], context_count);

  759.     }

  760.     context_count= (context_count+1)/2;

  761.     

  762.     for(i=0; i<f->plane_count; i++){

  763.         PlaneContext * const p= &f->plane[i];

  764. 

  765.         p->context_count= context_count;

  766. 

  767.         if(f->ac){

  768.             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));

  769.         }else{

  770.             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));

  771.         }

  772.     }

  773.     

  774.     return 0;

  775. }

  776. 

  777. static int decode_init(AVCodecContext *avctx)

  778. {

  779. //    FFV1Context *s = avctx->priv_data;

  780. 

  781.     common_init(avctx);

  782.     

  783. #if 0    

  784.     switch(s->bitstream_bpp){

  785.     case 12:

  786.         avctx->pix_fmt = PIX_FMT_YUV420P;

  787.         break;

  788.     case 16:

  789.         avctx->pix_fmt = PIX_FMT_YUV422P;

  790.         break;

  791.     case 24:

  792.     case 32:

  793.         if(s->bgr32){

  794.             avctx->pix_fmt = PIX_FMT_RGBA32;

  795.         }else{

  796.             avctx->pix_fmt = PIX_FMT_BGR24;

  797.         }

  798.         break;

  799.     default:

  800.         assert(0);

  801.     }

  802. #endif

  803.     

  804.     return 0;

  805. }

  806. 

  807. static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){

  808.     FFV1Context *f = avctx->priv_data;

  809.     CABACContext * const c= &f->c;

  810.     const int width= f->width;

  811.     const int height= f->height;

  812.     AVFrame * const p= &f->picture;

  813.     int bytes_read;

  814. 

  815.     AVFrame *picture = data;

  816. 

  817.     *data_size = 0;

  818. 

  819.     /* no supplementary picture */

  820.     if (buf_size == 0)

  821.         return 0;

  822. 

  823.     ff_init_cabac_decoder(c, buf, buf_size);

  824.     ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);

  825. 

  826.     p->reference= 0;

  827.     if(avctx->get_buffer(avctx, p) < 0){

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

  829.         return -1;

  830.     }

  831. 

  832.     p->pict_type= FF_I_TYPE; //FIXME I vs. P

  833.     if(get_cabac_bypass(c)){

  834.         p->key_frame= 1;

  835.         read_header(f);

  836.         clear_state(f);

  837.     }else{

  838.         p->key_frame= 0;

  839.     }

  840.     if(avctx->debug&FF_DEBUG_PICT_INFO)

  841.         printf("keyframe:%d\n", p->key_frame);

  842.     

  843.     if(!f->ac){

  844.         bytes_read = get_cabac_terminate(c);

  845.         if(bytes_read ==0) printf("error at end of AC stream\n");

  846. //printf("pos=%d\n", bytes_read);

  847.         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);

  848.     }

  849.     

  850.     if(1){

  851.         const int chroma_width = -((-width )>>f->chroma_h_shift);

  852.         const int chroma_height= -((-height)>>f->chroma_v_shift);

  853.         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);

  854.         

  855.         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);

  856.         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 2);

  857.     }

  858.         

  859.     emms_c();

  860. 

  861.     f->picture_number++;

  862. 

  863.     *picture= *p;

  864.     

  865.     avctx->release_buffer(avctx, p); //FIXME

  866. 

  867.     *data_size = sizeof(AVFrame);

  868.     

  869.     if(f->ac){

  870.         bytes_read= get_cabac_terminate(c);

  871.         if(bytes_read ==0) printf("error at end of frame\n");

  872.     }else{

  873.         bytes_read+= (get_bits_count(&f->gb)+7)/8;

  874.     }

  875. 

  876.     return bytes_read;

  877. }

  878. 

  879. static int decode_end(AVCodecContext *avctx)

  880. {

  881.     FFV1Context *s = avctx->priv_data;

  882.     int i;

  883.     

  884.     if(avctx->get_buffer == avcodec_default_get_buffer){

  885.         for(i=0; i<4; i++){

  886.             av_freep(&s->picture.base[i]);

  887.             s->picture.data[i]= NULL;

  888.         }

  889.         av_freep(&s->picture.opaque);

  890.     }

  891. 

  892.     return 0;

  893. }

  894. 

  895. AVCodec ffv1_decoder = {

  896.     "ffv1",

  897.     CODEC_TYPE_VIDEO,

  898.     CODEC_ID_FFV1,

  899.     sizeof(FFV1Context),

  900.     decode_init,

  901.     NULL,

  902.     decode_end,

  903.     decode_frame,

  904.     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,

  905.     NULL

  906. };

  907. 

  908. #ifdef CONFIG_ENCODERS

  909. AVCodec ffv1_encoder = {

  910.     "ffv1",

  911.     CODEC_TYPE_VIDEO,

  912.     CODEC_ID_FFV1,

  913.     sizeof(FFV1Context),

  914.     encode_init,

  915.     encode_frame,

  916.     encode_end,

  917. };

  918. #endif