git.sesse.net Git - ffmpeg/blob - libavcodec/ffv1.c

   1 /*
   2  * FFV1 codec for libavcodec
   3  *
   4  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 /**
  24  * @file libavcodec/ffv1.c
  25  * FF Video Codec 1 (a lossless codec)
  26  */
  27
  28 #include "avcodec.h"
  29 #include "get_bits.h"
  30 #include "put_bits.h"
  31 #include "dsputil.h"
  32 #include "rangecoder.h"
  33 #include "golomb.h"
  34 #include "mathops.h"
  35
  36 #define MAX_PLANES 4
  37 #define CONTEXT_SIZE 32
  38
  39 extern const uint8_t ff_log2_run[32];
  40
  41 static const int8_t quant3[256]={
  42  0, 0, 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,-1,
  54 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  55 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  56 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  57 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
  58 };
  59
  60 static const int8_t quant5_10bit[256]={
  61  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
  62  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  63  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  64  1, 1, 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,-2,-2,-2,
  72 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  73 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,
  74 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  75 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  76 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
  77 };
  78
  79 static const int8_t quant5[256]={
  80  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  81  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  82  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  83  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  84  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  85  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  86  2, 2, 2, 2, 2, 2, 2, 2, 2, 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,-2,-2,
  89 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  90 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  91 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  92 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  93 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  94 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  95 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
  96 };
  97 static const int8_t quant7[256]={
  98  0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  99  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 100  2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
 101  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 102  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 103  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 104  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 105  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 106 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
 107 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
 108 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
 109 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
 110 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
 111 -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
 112 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
 113 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
 114 };
 115 static const int8_t quant9[256]={
 116  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 117  3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 118  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 119  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 120  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 121  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 122  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 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,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 125 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 126 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 127 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 128 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 129 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 130 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
 131 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
 132 };
 133 static const int8_t quant9_10bit[256]={
 134  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
 135  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
 136  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 137  3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
 138  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 139  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 140  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 141  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 142 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 143 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 144 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 145 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 146 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
 147 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
 148 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
 149 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
 150 };
 151
 152 static const int8_t quant11[256]={
 153  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
 154  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 155  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 156  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 157  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 158  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 159  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 160  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 161 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 162 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 163 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 164 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 165 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 166 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
 167 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 168 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
 169 };
 170 static const int8_t quant13[256]={
 171  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
 172  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 173  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 174  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 175  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 176  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 177  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 178  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 179 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 180 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 181 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 182 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 183 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
 184 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 185 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 186 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
 187 };
 188
 189 typedef struct VlcState{
 190     int16_t drift;
 191     uint16_t error_sum;
 192     int8_t bias;
 193     uint8_t count;
 194 } VlcState;
 195
 196 typedef struct PlaneContext{
 197     int context_count;
 198     uint8_t (*state)[CONTEXT_SIZE];
 199     VlcState *vlc_state;
 200     uint8_t interlace_bit_state[2];
 201 } PlaneContext;
 202
 203 typedef struct FFV1Context{
 204     AVCodecContext *avctx;
 205     RangeCoder c;
 206     GetBitContext gb;
 207     PutBitContext pb;
 208     int version;
 209     int width, height;
 210     int chroma_h_shift, chroma_v_shift;
 211     int flags;
 212     int picture_number;
 213     AVFrame picture;
 214     int plane_count;
 215     int ac;                              ///< 1=range coder <-> 0=golomb rice
 216     PlaneContext plane[MAX_PLANES];
 217     int16_t quant_table[5][256];
 218     int run_index;
 219     int colorspace;
 220
 221     DSPContext dsp;
 222 }FFV1Context;
 223
 224 static av_always_inline int fold(int diff, int bits){
 225     if(bits==8)
 226         diff= (int8_t)diff;
 227     else{
 228         diff+= 1<<(bits-1);
 229         diff&=(1<<bits)-1;
 230         diff-= 1<<(bits-1);
 231     }
 232
 233     return diff;
 234 }
 235
 236 static inline int predict(int_fast16_t *src, int_fast16_t *last){
 237     const int LT= last[-1];
 238     const int  T= last[ 0];
 239     const int L =  src[-1];
 240
 241     return mid_pred(L, L + T - LT, T);
 242 }
 243
 244 static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
 245     const int LT= last[-1];
 246     const int  T= last[ 0];
 247     const int RT= last[ 1];
 248     const int L =  src[-1];
 249
 250     if(f->quant_table[3][127]){
 251         const int TT= last2[0];
 252         const int LL=  src[-2];
 253         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
 254               +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
 255     }else
 256         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
 257 }
 258
 259 static inline void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed){
 260     int i;
 261
 262     if(v){
 263         const int a= FFABS(v);
 264         const int e= av_log2(a);
 265         put_rac(c, state+0, 0);
 266         if(e<=9){
 267             for(i=0; i<e; i++){
 268                 put_rac(c, state+1+i, 1);  //1..10
 269             }
 270             put_rac(c, state+1+i, 0);
 271
 272             for(i=e-1; i>=0; i--){
 273                 put_rac(c, state+22+i, (a>>i)&1); //22..31
 274             }
 275
 276             if(is_signed)
 277                 put_rac(c, state+11 + e, v < 0); //11..21
 278         }else{
 279             for(i=0; i<e; i++){
 280                 put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
 281             }
 282             put_rac(c, state+1+9, 0);
 283
 284             for(i=e-1; i>=0; i--){
 285                 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
 286             }
 287
 288             if(is_signed)
 289                 put_rac(c, state+11 + 10, v < 0); //11..21
 290         }
 291     }else{
 292         put_rac(c, state+0, 1);
 293     }
 294 }
 295
 296 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
 297     put_symbol_inline(c, state, v, is_signed);
 298 }
 299
 300 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
 301     if(get_rac(c, state+0))
 302         return 0;
 303     else{
 304         int i, e, a;
 305         e= 0;
 306         while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
 307             e++;
 308         }
 309
 310         a= 1;
 311         for(i=e-1; i>=0; i--){
 312             a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
 313         }
 314
 315         e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
 316         return (a^e)-e;
 317     }
 318 }
 319
 320 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
 321     return get_symbol_inline(c, state, is_signed);
 322 }
 323
 324 static inline void update_vlc_state(VlcState * const state, const int v){
 325     int drift= state->drift;
 326     int count= state->count;
 327     state->error_sum += FFABS(v);
 328     drift += v;
 329
 330     if(count == 128){ //FIXME variable
 331         count >>= 1;
 332         drift >>= 1;
 333         state->error_sum >>= 1;
 334     }
 335     count++;
 336
 337     if(drift <= -count){
 338         if(state->bias > -128) state->bias--;
 339
 340         drift += count;
 341         if(drift <= -count)
 342             drift= -count + 1;
 343     }else if(drift > 0){
 344         if(state->bias <  127) state->bias++;
 345
 346         drift -= count;
 347         if(drift > 0)
 348             drift= 0;
 349     }
 350
 351     state->drift= drift;
 352     state->count= count;
 353 }
 354
 355 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
 356     int i, k, code;
 357 //printf("final: %d ", v);
 358     v = fold(v - state->bias, bits);
 359
 360     i= state->count;
 361     k=0;
 362     while(i < state->error_sum){ //FIXME optimize
 363         k++;
 364         i += i;
 365     }
 366
 367     assert(k<=8);
 368
 369 #if 0 // JPEG LS
 370     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
 371     else                                         code= v;
 372 #else
 373      code= v ^ ((2*state->drift + state->count)>>31);
 374 #endif
 375
 376 //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);
 377     set_sr_golomb(pb, code, k, 12, bits);
 378
 379     update_vlc_state(state, v);
 380 }
 381
 382 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
 383     int k, i, v, ret;
 384
 385     i= state->count;
 386     k=0;
 387     while(i < state->error_sum){ //FIXME optimize
 388         k++;
 389         i += i;
 390     }
 391
 392     assert(k<=8);
 393
 394     v= get_sr_golomb(gb, k, 12, bits);
 395 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
 396
 397 #if 0 // JPEG LS
 398     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
 399 #else
 400      v ^= ((2*state->drift + state->count)>>31);
 401 #endif
 402
 403     ret= fold(v + state->bias, bits);
 404
 405     update_vlc_state(state, v);
 406 //printf("final: %d\n", ret);
 407     return ret;
 408 }
 409
 410 #if CONFIG_FFV1_ENCODER
 411 static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
 412     PlaneContext * const p= &s->plane[plane_index];
 413     RangeCoder * const c= &s->c;
 414     int x;
 415     int run_index= s->run_index;
 416     int run_count=0;
 417     int run_mode=0;
 418
 419     if(s->ac){
 420         if(c->bytestream_end - c->bytestream < w*20){
 421             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 422             return -1;
 423         }
 424     }else{
 425         if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
 426             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 427             return -1;
 428         }
 429     }
 430
 431     for(x=0; x<w; x++){
 432         int diff, context;
 433
 434         context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
 435         diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
 436
 437         if(context < 0){
 438             context = -context;
 439             diff= -diff;
 440         }
 441
 442         diff= fold(diff, bits);
 443
 444         if(s->ac){
 445             put_symbol_inline(c, p->state[context], diff, 1);
 446         }else{
 447             if(context == 0) run_mode=1;
 448
 449             if(run_mode){
 450
 451                 if(diff){
 452                     while(run_count >= 1<<ff_log2_run[run_index]){
 453                         run_count -= 1<<ff_log2_run[run_index];
 454                         run_index++;
 455                         put_bits(&s->pb, 1, 1);
 456                     }
 457
 458                     put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
 459                     if(run_index) run_index--;
 460                     run_count=0;
 461                     run_mode=0;
 462                     if(diff>0) diff--;
 463                 }else{
 464                     run_count++;
 465                 }
 466             }
 467
 468 //            printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, (int)put_bits_count(&s->pb));
 469
 470             if(run_mode == 0)
 471                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
 472         }
 473     }
 474     if(run_mode){
 475         while(run_count >= 1<<ff_log2_run[run_index]){
 476             run_count -= 1<<ff_log2_run[run_index];
 477             run_index++;
 478             put_bits(&s->pb, 1, 1);
 479         }
 480
 481         if(run_count)
 482             put_bits(&s->pb, 1, 1);
 483     }
 484     s->run_index= run_index;
 485
 486     return 0;
 487 }
 488
 489 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 490     int x,y,i;
 491     const int ring_size= s->avctx->context_model ? 3 : 2;
 492     int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
 493     s->run_index=0;
 494
 495     memset(sample_buffer, 0, sizeof(sample_buffer));
 496
 497     for(y=0; y<h; y++){
 498         for(i=0; i<ring_size; i++)
 499             sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
 500
 501         sample[0][-1]= sample[1][0  ];
 502         sample[1][ w]= sample[1][w-1];
 503 //{START_TIMER
 504         if(s->avctx->bits_per_raw_sample<=8){
 505             for(x=0; x<w; x++){
 506                 sample[0][x]= src[x + stride*y];
 507             }
 508             encode_line(s, w, sample, plane_index, 8);
 509         }else{
 510             for(x=0; x<w; x++){
 511                 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
 512             }
 513             encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
 514         }
 515 //STOP_TIMER("encode line")}
 516     }
 517 }
 518
 519 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 520     int x, y, p, i;
 521     const int ring_size= s->avctx->context_model ? 3 : 2;
 522     int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
 523     s->run_index=0;
 524
 525     memset(sample_buffer, 0, sizeof(sample_buffer));
 526
 527     for(y=0; y<h; y++){
 528         for(i=0; i<ring_size; i++)
 529             for(p=0; p<3; p++)
 530                 sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
 531
 532         for(x=0; x<w; x++){
 533             int v= src[x + stride*y];
 534             int b= v&0xFF;
 535             int g= (v>>8)&0xFF;
 536             int r= (v>>16)&0xFF;
 537
 538             b -= g;
 539             r -= g;
 540             g += (b + r)>>2;
 541             b += 0x100;
 542             r += 0x100;
 543
 544 //            assert(g>=0 && b>=0 && r>=0);
 545 //            assert(g<256 && b<512 && r<512);
 546             sample[0][0][x]= g;
 547             sample[1][0][x]= b;
 548             sample[2][0][x]= r;
 549         }
 550         for(p=0; p<3; p++){
 551             sample[p][0][-1]= sample[p][1][0  ];
 552             sample[p][1][ w]= sample[p][1][w-1];
 553             encode_line(s, w, sample[p], FFMIN(p, 1), 9);
 554         }
 555     }
 556 }
 557
 558 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
 559     int last=0;
 560     int i;
 561     uint8_t state[CONTEXT_SIZE];
 562     memset(state, 128, sizeof(state));
 563
 564     for(i=1; i<128 ; i++){
 565         if(quant_table[i] != quant_table[i-1]){
 566             put_symbol(c, state, i-last-1, 0);
 567             last= i;
 568         }
 569     }
 570     put_symbol(c, state, i-last-1, 0);
 571 }
 572
 573 static void write_header(FFV1Context *f){
 574     uint8_t state[CONTEXT_SIZE];
 575     int i;
 576     RangeCoder * const c= &f->c;
 577
 578     memset(state, 128, sizeof(state));
 579
 580     put_symbol(c, state, f->version, 0);
 581     put_symbol(c, state, f->avctx->coder_type, 0);
 582     put_symbol(c, state, f->colorspace, 0); //YUV cs type
 583     if(f->version>0)
 584         put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
 585     put_rac(c, state, 1); //chroma planes
 586         put_symbol(c, state, f->chroma_h_shift, 0);
 587         put_symbol(c, state, f->chroma_v_shift, 0);
 588     put_rac(c, state, 0); //no transparency plane
 589
 590     for(i=0; i<5; i++)
 591         write_quant_table(c, f->quant_table[i]);
 592 }
 593 #endif /* CONFIG_FFV1_ENCODER */
 594
 595 static av_cold int common_init(AVCodecContext *avctx){
 596     FFV1Context *s = avctx->priv_data;
 597
 598     s->avctx= avctx;
 599     s->flags= avctx->flags;
 600
 601     dsputil_init(&s->dsp, avctx);
 602
 603     s->width = avctx->width;
 604     s->height= avctx->height;
 605
 606     assert(s->width && s->height);
 607
 608     return 0;
 609 }
 610
 611 #if CONFIG_FFV1_ENCODER
 612 static av_cold int encode_init(AVCodecContext *avctx)
 613 {
 614     FFV1Context *s = avctx->priv_data;
 615     int i;
 616
 617     common_init(avctx);
 618
 619     s->version=0;
 620     s->ac= avctx->coder_type;
 621
 622     s->plane_count=2;
 623     for(i=0; i<256; i++){
 624         if(avctx->bits_per_raw_sample <=8){
 625             s->quant_table[0][i]=           quant11[i];
 626             s->quant_table[1][i]=        11*quant11[i];
 627             if(avctx->context_model==0){
 628                 s->quant_table[2][i]=     11*11*quant11[i];
 629                 s->quant_table[3][i]=
 630                 s->quant_table[4][i]=0;
 631             }else{
 632                 s->quant_table[2][i]=     11*11*quant5 [i];
 633                 s->quant_table[3][i]=   5*11*11*quant5 [i];
 634                 s->quant_table[4][i]= 5*5*11*11*quant5 [i];
 635             }
 636         }else{
 637             s->quant_table[0][i]=           quant9_10bit[i];
 638             s->quant_table[1][i]=        11*quant9_10bit[i];
 639             if(avctx->context_model==0){
 640                 s->quant_table[2][i]=     11*11*quant9_10bit[i];
 641                 s->quant_table[3][i]=
 642                 s->quant_table[4][i]=0;
 643             }else{
 644                 s->quant_table[2][i]=     11*11*quant5_10bit[i];
 645                 s->quant_table[3][i]=   5*11*11*quant5_10bit[i];
 646                 s->quant_table[4][i]= 5*5*11*11*quant5_10bit[i];
 647             }
 648         }
 649     }
 650
 651     for(i=0; i<s->plane_count; i++){
 652         PlaneContext * const p= &s->plane[i];
 653
 654         if(avctx->context_model==0){
 655             p->context_count= (11*11*11+1)/2;
 656         }else{
 657             p->context_count= (11*11*5*5*5+1)/2;
 658         }
 659
 660         if(s->ac){
 661             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 662         }else{
 663             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 664         }
 665     }
 666
 667     avctx->coded_frame= &s->picture;
 668     switch(avctx->pix_fmt){
 669     case PIX_FMT_YUV444P16:
 670     case PIX_FMT_YUV422P16:
 671     case PIX_FMT_YUV420P16:
 672         if(avctx->bits_per_raw_sample <=8){
 673             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 674             return -1;
 675         }
 676         if(!s->ac){
 677             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
 678             return -1;
 679         }
 680         s->version= 1;
 681     case PIX_FMT_YUV444P:
 682     case PIX_FMT_YUV422P:
 683     case PIX_FMT_YUV420P:
 684     case PIX_FMT_YUV411P:
 685     case PIX_FMT_YUV410P:
 686         s->colorspace= 0;
 687         break;
 688     case PIX_FMT_RGB32:
 689         s->colorspace= 1;
 690         break;
 691     default:
 692         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 693         return -1;
 694     }
 695     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 696
 697     s->picture_number=0;
 698
 699     return 0;
 700 }
 701 #endif /* CONFIG_FFV1_ENCODER */
 702
 703
 704 static void clear_state(FFV1Context *f){
 705     int i, j;
 706
 707     for(i=0; i<f->plane_count; i++){
 708         PlaneContext *p= &f->plane[i];
 709
 710         p->interlace_bit_state[0]= 128;
 711         p->interlace_bit_state[1]= 128;
 712
 713         for(j=0; j<p->context_count; j++){
 714             if(f->ac){
 715                 memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
 716             }else{
 717                 p->vlc_state[j].drift= 0;
 718                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
 719                 p->vlc_state[j].bias= 0;
 720                 p->vlc_state[j].count= 1;
 721             }
 722         }
 723     }
 724 }
 725
 726 #if CONFIG_FFV1_ENCODER
 727 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 728     FFV1Context *f = avctx->priv_data;
 729     RangeCoder * const c= &f->c;
 730     AVFrame *pict = data;
 731     const int width= f->width;
 732     const int height= f->height;
 733     AVFrame * const p= &f->picture;
 734     int used_count= 0;
 735     uint8_t keystate=128;
 736
 737     ff_init_range_encoder(c, buf, buf_size);
 738     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 739
 740     *p = *pict;
 741     p->pict_type= FF_I_TYPE;
 742
 743     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
 744         put_rac(c, &keystate, 1);
 745         p->key_frame= 1;
 746         write_header(f);
 747         clear_state(f);
 748     }else{
 749         put_rac(c, &keystate, 0);
 750         p->key_frame= 0;
 751     }
 752
 753     if(!f->ac){
 754         used_count += ff_rac_terminate(c);
 755 //printf("pos=%d\n", used_count);
 756         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
 757     }
 758
 759     if(f->colorspace==0){
 760         const int chroma_width = -((-width )>>f->chroma_h_shift);
 761         const int chroma_height= -((-height)>>f->chroma_v_shift);
 762
 763         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 764
 765         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 766         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 767     }else{
 768         encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
 769     }
 770     emms_c();
 771
 772     f->picture_number++;
 773
 774     if(f->ac){
 775         return ff_rac_terminate(c);
 776     }else{
 777         flush_put_bits(&f->pb); //nicer padding FIXME
 778         return used_count + (put_bits_count(&f->pb)+7)/8;
 779     }
 780 }
 781 #endif /* CONFIG_FFV1_ENCODER */
 782
 783 static av_cold int common_end(AVCodecContext *avctx){
 784     FFV1Context *s = avctx->priv_data;
 785     int i;
 786
 787     for(i=0; i<s->plane_count; i++){
 788         PlaneContext *p= &s->plane[i];
 789
 790         av_freep(&p->state);
 791         av_freep(&p->vlc_state);
 792     }
 793
 794     return 0;
 795 }
 796
 797 static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
 798     PlaneContext * const p= &s->plane[plane_index];
 799     RangeCoder * const c= &s->c;
 800     int x;
 801     int run_count=0;
 802     int run_mode=0;
 803     int run_index= s->run_index;
 804
 805     for(x=0; x<w; x++){
 806         int diff, context, sign;
 807
 808         context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
 809         if(context < 0){
 810             context= -context;
 811             sign=1;
 812         }else
 813             sign=0;
 814
 815
 816         if(s->ac){
 817             diff= get_symbol_inline(c, p->state[context], 1);
 818         }else{
 819             if(context == 0 && run_mode==0) run_mode=1;
 820
 821             if(run_mode){
 822                 if(run_count==0 && run_mode==1){
 823                     if(get_bits1(&s->gb)){
 824                         run_count = 1<<ff_log2_run[run_index];
 825                         if(x + run_count <= w) run_index++;
 826                     }else{
 827                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
 828                         else run_count=0;
 829                         if(run_index) run_index--;
 830                         run_mode=2;
 831                     }
 832                 }
 833                 run_count--;
 834                 if(run_count < 0){
 835                     run_mode=0;
 836                     run_count=0;
 837                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 838                     if(diff>=0) diff++;
 839                 }else
 840                     diff=0;
 841             }else
 842                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 843
 844 //            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));
 845         }
 846
 847         if(sign) diff= -diff;
 848
 849         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
 850     }
 851     s->run_index= run_index;
 852 }
 853
 854 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 855     int x, y;
 856     int_fast16_t sample_buffer[2][w+6];
 857     int_fast16_t *sample[2];
 858     sample[0]=sample_buffer[0]+3;
 859     sample[1]=sample_buffer[1]+3;
 860
 861     s->run_index=0;
 862
 863     memset(sample_buffer, 0, sizeof(sample_buffer));
 864
 865     for(y=0; y<h; y++){
 866         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
 867
 868         sample[0]= sample[1];
 869         sample[1]= temp;
 870
 871         sample[1][-1]= sample[0][0  ];
 872         sample[0][ w]= sample[0][w-1];
 873
 874 //{START_TIMER
 875         if(s->avctx->bits_per_raw_sample <= 8){
 876             decode_line(s, w, sample, plane_index, 8);
 877             for(x=0; x<w; x++){
 878                 src[x + stride*y]= sample[1][x];
 879             }
 880         }else{
 881             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
 882             for(x=0; x<w; x++){
 883                 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
 884             }
 885         }
 886 //STOP_TIMER("decode-line")}
 887     }
 888 }
 889
 890 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 891     int x, y, p;
 892     int_fast16_t sample_buffer[3][2][w+6];
 893     int_fast16_t *sample[3][2];
 894     for(x=0; x<3; x++){
 895         sample[x][0] = sample_buffer[x][0]+3;
 896         sample[x][1] = sample_buffer[x][1]+3;
 897     }
 898
 899     s->run_index=0;
 900
 901     memset(sample_buffer, 0, sizeof(sample_buffer));
 902
 903     for(y=0; y<h; y++){
 904         for(p=0; p<3; p++){
 905             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
 906
 907             sample[p][0]= sample[p][1];
 908             sample[p][1]= temp;
 909
 910             sample[p][1][-1]= sample[p][0][0  ];
 911             sample[p][0][ w]= sample[p][0][w-1];
 912             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
 913         }
 914         for(x=0; x<w; x++){
 915             int g= sample[0][1][x];
 916             int b= sample[1][1][x];
 917             int r= sample[2][1][x];
 918
 919 //            assert(g>=0 && b>=0 && r>=0);
 920 //            assert(g<256 && b<512 && r<512);
 921
 922             b -= 0x100;
 923             r -= 0x100;
 924             g -= (b + r)>>2;
 925             b += g;
 926             r += g;
 927
 928             src[x + stride*y]= b + (g<<8) + (r<<16);
 929         }
 930     }
 931 }
 932
 933 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
 934     int v;
 935     int i=0;
 936     uint8_t state[CONTEXT_SIZE];
 937
 938     memset(state, 128, sizeof(state));
 939
 940     for(v=0; i<128 ; v++){
 941         int len= get_symbol(c, state, 0) + 1;
 942
 943         if(len + i > 128) return -1;
 944
 945         while(len--){
 946             quant_table[i] = scale*v;
 947             i++;
 948 //printf("%2d ",v);
 949 //if(i%16==0) printf("\n");
 950         }
 951     }
 952
 953     for(i=1; i<128; i++){
 954         quant_table[256-i]= -quant_table[i];
 955     }
 956     quant_table[128]= -quant_table[127];
 957
 958     return 2*v - 1;
 959 }
 960
 961 static int read_header(FFV1Context *f){
 962     uint8_t state[CONTEXT_SIZE];
 963     int i, context_count;
 964     RangeCoder * const c= &f->c;
 965
 966     memset(state, 128, sizeof(state));
 967
 968     f->version= get_symbol(c, state, 0);
 969     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
 970     f->colorspace= get_symbol(c, state, 0); //YUV cs type
 971     if(f->version>0)
 972         f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
 973     get_rac(c, state); //no chroma = false
 974     f->chroma_h_shift= get_symbol(c, state, 0);
 975     f->chroma_v_shift= get_symbol(c, state, 0);
 976     get_rac(c, state); //transparency plane
 977     f->plane_count= 2;
 978
 979     if(f->colorspace==0){
 980         if(f->avctx->bits_per_raw_sample<=8){
 981             switch(16*f->chroma_h_shift + f->chroma_v_shift){
 982             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
 983             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
 984             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
 985             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
 986             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
 987             default:
 988                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 989                 return -1;
 990             }
 991         }else{
 992             switch(16*f->chroma_h_shift + f->chroma_v_shift){
 993             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
 994             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
 995             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
 996             default:
 997                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 998                 return -1;
 999             }
1000         }
1001     }else if(f->colorspace==1){
1002         if(f->chroma_h_shift || f->chroma_v_shift){
1003             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1004             return -1;
1005         }
1006         f->avctx->pix_fmt= PIX_FMT_RGB32;
1007     }else{
1008         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1009         return -1;
1010     }
1011
1012 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1013
1014     context_count=1;
1015     for(i=0; i<5; i++){
1016         context_count*= read_quant_table(c, f->quant_table[i], context_count);
1017         if(context_count < 0 || context_count > 32768){
1018             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1019             return -1;
1020         }
1021     }
1022     context_count= (context_count+1)/2;
1023
1024     for(i=0; i<f->plane_count; i++){
1025         PlaneContext * const p= &f->plane[i];
1026
1027         p->context_count= context_count;
1028
1029         if(f->ac){
1030             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
1031         }else{
1032             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
1033         }
1034     }
1035
1036     return 0;
1037 }
1038
1039 static av_cold int decode_init(AVCodecContext *avctx)
1040 {
1041 //    FFV1Context *s = avctx->priv_data;
1042
1043     common_init(avctx);
1044
1045     return 0;
1046 }
1047
1048 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1049     const uint8_t *buf = avpkt->data;
1050     int buf_size = avpkt->size;
1051     FFV1Context *f = avctx->priv_data;
1052     RangeCoder * const c= &f->c;
1053     const int width= f->width;
1054     const int height= f->height;
1055     AVFrame * const p= &f->picture;
1056     int bytes_read;
1057     uint8_t keystate= 128;
1058
1059     AVFrame *picture = data;
1060
1061     ff_init_range_decoder(c, buf, buf_size);
1062     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1063
1064
1065     p->pict_type= FF_I_TYPE; //FIXME I vs. P
1066     if(get_rac(c, &keystate)){
1067         p->key_frame= 1;
1068         if(read_header(f) < 0)
1069             return -1;
1070         clear_state(f);
1071     }else{
1072         p->key_frame= 0;
1073     }
1074     if(!f->plane[0].state && !f->plane[0].vlc_state)
1075         return -1;
1076
1077     p->reference= 0;
1078     if(avctx->get_buffer(avctx, p) < 0){
1079         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1080         return -1;
1081     }
1082
1083     if(avctx->debug&FF_DEBUG_PICT_INFO)
1084         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1085
1086     if(!f->ac){
1087         bytes_read = c->bytestream - c->bytestream_start - 1;
1088         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1089 //printf("pos=%d\n", bytes_read);
1090         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
1091     } else {
1092         bytes_read = 0; /* avoid warning */
1093     }
1094
1095     if(f->colorspace==0){
1096         const int chroma_width = -((-width )>>f->chroma_h_shift);
1097         const int chroma_height= -((-height)>>f->chroma_v_shift);
1098         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
1099
1100         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
1101         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
1102     }else{
1103         decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
1104     }
1105
1106     emms_c();
1107
1108     f->picture_number++;
1109
1110     *picture= *p;
1111
1112     avctx->release_buffer(avctx, p); //FIXME
1113
1114     *data_size = sizeof(AVFrame);
1115
1116     if(f->ac){
1117         bytes_read= c->bytestream - c->bytestream_start - 1;
1118         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1119     }else{
1120         bytes_read+= (get_bits_count(&f->gb)+7)/8;
1121     }
1122
1123     return bytes_read;
1124 }
1125
1126 AVCodec ffv1_decoder = {
1127     "ffv1",
1128     AVMEDIA_TYPE_VIDEO,
1129     CODEC_ID_FFV1,
1130     sizeof(FFV1Context),
1131     decode_init,
1132     NULL,
1133     common_end,
1134     decode_frame,
1135     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1136     NULL,
1137     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1138 };
1139
1140 #if CONFIG_FFV1_ENCODER
1141 AVCodec ffv1_encoder = {
1142     "ffv1",
1143     AVMEDIA_TYPE_VIDEO,
1144     CODEC_ID_FFV1,
1145     sizeof(FFV1Context),
1146     encode_init,
1147     encode_frame,
1148     common_end,
1149     .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_NONE},
1150     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1151 };
1152 #endif