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 (an experimental 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-> CABAC 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->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
 673             av_log(avctx, AV_LOG_ERROR, "More than 8 bit per component is still experimental and no gurantee is yet made for future compatibility\n"
 674                "Use vstrict=-2 / -strict -2 to use it anyway.\n");
 675             return -1;
 676         }
 677         if(avctx->bits_per_raw_sample <=8){
 678             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample inavlid\n");
 679             return -1;
 680         }
 681         s->version= 1;
 682     case PIX_FMT_YUV444P:
 683     case PIX_FMT_YUV422P:
 684     case PIX_FMT_YUV420P:
 685     case PIX_FMT_YUV411P:
 686     case PIX_FMT_YUV410P:
 687         s->colorspace= 0;
 688         break;
 689     case PIX_FMT_RGB32:
 690         s->colorspace= 1;
 691         break;
 692     default:
 693         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 694         return -1;
 695     }
 696     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 697
 698     s->picture_number=0;
 699
 700     return 0;
 701 }
 702 #endif /* CONFIG_FFV1_ENCODER */
 703
 704
 705 static void clear_state(FFV1Context *f){
 706     int i, j;
 707
 708     for(i=0; i<f->plane_count; i++){
 709         PlaneContext *p= &f->plane[i];
 710
 711         p->interlace_bit_state[0]= 128;
 712         p->interlace_bit_state[1]= 128;
 713
 714         for(j=0; j<p->context_count; j++){
 715             if(f->ac){
 716                 memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
 717             }else{
 718                 p->vlc_state[j].drift= 0;
 719                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
 720                 p->vlc_state[j].bias= 0;
 721                 p->vlc_state[j].count= 1;
 722             }
 723         }
 724     }
 725 }
 726
 727 #if CONFIG_FFV1_ENCODER
 728 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 729     FFV1Context *f = avctx->priv_data;
 730     RangeCoder * const c= &f->c;
 731     AVFrame *pict = data;
 732     const int width= f->width;
 733     const int height= f->height;
 734     AVFrame * const p= &f->picture;
 735     int used_count= 0;
 736     uint8_t keystate=128;
 737
 738     ff_init_range_encoder(c, buf, buf_size);
 739 //    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
 740     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 741
 742     *p = *pict;
 743     p->pict_type= FF_I_TYPE;
 744
 745     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
 746         put_rac(c, &keystate, 1);
 747         p->key_frame= 1;
 748         write_header(f);
 749         clear_state(f);
 750     }else{
 751         put_rac(c, &keystate, 0);
 752         p->key_frame= 0;
 753     }
 754
 755     if(!f->ac){
 756         used_count += ff_rac_terminate(c);
 757 //printf("pos=%d\n", used_count);
 758         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
 759     }
 760
 761     if(f->colorspace==0){
 762         const int chroma_width = -((-width )>>f->chroma_h_shift);
 763         const int chroma_height= -((-height)>>f->chroma_v_shift);
 764
 765         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 766
 767         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 768         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 769     }else{
 770         encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
 771     }
 772     emms_c();
 773
 774     f->picture_number++;
 775
 776     if(f->ac){
 777         return ff_rac_terminate(c);
 778     }else{
 779         flush_put_bits(&f->pb); //nicer padding FIXME
 780         return used_count + (put_bits_count(&f->pb)+7)/8;
 781     }
 782 }
 783 #endif /* CONFIG_FFV1_ENCODER */
 784
 785 static av_cold int common_end(AVCodecContext *avctx){
 786     FFV1Context *s = avctx->priv_data;
 787     int i;
 788
 789     for(i=0; i<s->plane_count; i++){
 790         PlaneContext *p= &s->plane[i];
 791
 792         av_freep(&p->state);
 793         av_freep(&p->vlc_state);
 794     }
 795
 796     return 0;
 797 }
 798
 799 static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
 800     PlaneContext * const p= &s->plane[plane_index];
 801     RangeCoder * const c= &s->c;
 802     int x;
 803     int run_count=0;
 804     int run_mode=0;
 805     int run_index= s->run_index;
 806
 807     for(x=0; x<w; x++){
 808         int diff, context, sign;
 809
 810         context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
 811         if(context < 0){
 812             context= -context;
 813             sign=1;
 814         }else
 815             sign=0;
 816
 817
 818         if(s->ac){
 819             diff= get_symbol_inline(c, p->state[context], 1);
 820         }else{
 821             if(context == 0 && run_mode==0) run_mode=1;
 822
 823             if(run_mode){
 824                 if(run_count==0 && run_mode==1){
 825                     if(get_bits1(&s->gb)){
 826                         run_count = 1<<ff_log2_run[run_index];
 827                         if(x + run_count <= w) run_index++;
 828                     }else{
 829                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
 830                         else run_count=0;
 831                         if(run_index) run_index--;
 832                         run_mode=2;
 833                     }
 834                 }
 835                 run_count--;
 836                 if(run_count < 0){
 837                     run_mode=0;
 838                     run_count=0;
 839                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 840                     if(diff>=0) diff++;
 841                 }else
 842                     diff=0;
 843             }else
 844                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 845
 846 //            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));
 847         }
 848
 849         if(sign) diff= -diff;
 850
 851         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
 852     }
 853     s->run_index= run_index;
 854 }
 855
 856 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 857     int x, y;
 858     int_fast16_t sample_buffer[2][w+6];
 859     int_fast16_t *sample[2];
 860     sample[0]=sample_buffer[0]+3;
 861     sample[1]=sample_buffer[1]+3;
 862
 863     s->run_index=0;
 864
 865     memset(sample_buffer, 0, sizeof(sample_buffer));
 866
 867     for(y=0; y<h; y++){
 868         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
 869
 870         sample[0]= sample[1];
 871         sample[1]= temp;
 872
 873         sample[1][-1]= sample[0][0  ];
 874         sample[0][ w]= sample[0][w-1];
 875
 876 //{START_TIMER
 877         if(s->avctx->bits_per_raw_sample <= 8){
 878             decode_line(s, w, sample, plane_index, 8);
 879             for(x=0; x<w; x++){
 880                 src[x + stride*y]= sample[1][x];
 881             }
 882         }else{
 883             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
 884             for(x=0; x<w; x++){
 885                 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
 886             }
 887         }
 888 //STOP_TIMER("decode-line")}
 889     }
 890 }
 891
 892 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 893     int x, y, p;
 894     int_fast16_t sample_buffer[3][2][w+6];
 895     int_fast16_t *sample[3][2];
 896     for(x=0; x<3; x++){
 897         sample[x][0] = sample_buffer[x][0]+3;
 898         sample[x][1] = sample_buffer[x][1]+3;
 899     }
 900
 901     s->run_index=0;
 902
 903     memset(sample_buffer, 0, sizeof(sample_buffer));
 904
 905     for(y=0; y<h; y++){
 906         for(p=0; p<3; p++){
 907             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
 908
 909             sample[p][0]= sample[p][1];
 910             sample[p][1]= temp;
 911
 912             sample[p][1][-1]= sample[p][0][0  ];
 913             sample[p][0][ w]= sample[p][0][w-1];
 914             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
 915         }
 916         for(x=0; x<w; x++){
 917             int g= sample[0][1][x];
 918             int b= sample[1][1][x];
 919             int r= sample[2][1][x];
 920
 921 //            assert(g>=0 && b>=0 && r>=0);
 922 //            assert(g<256 && b<512 && r<512);
 923
 924             b -= 0x100;
 925             r -= 0x100;
 926             g -= (b + r)>>2;
 927             b += g;
 928             r += g;
 929
 930             src[x + stride*y]= b + (g<<8) + (r<<16);
 931         }
 932     }
 933 }
 934
 935 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
 936     int v;
 937     int i=0;
 938     uint8_t state[CONTEXT_SIZE];
 939
 940     memset(state, 128, sizeof(state));
 941
 942     for(v=0; i<128 ; v++){
 943         int len= get_symbol(c, state, 0) + 1;
 944
 945         if(len + i > 128) return -1;
 946
 947         while(len--){
 948             quant_table[i] = scale*v;
 949             i++;
 950 //printf("%2d ",v);
 951 //if(i%16==0) printf("\n");
 952         }
 953     }
 954
 955     for(i=1; i<128; i++){
 956         quant_table[256-i]= -quant_table[i];
 957     }
 958     quant_table[128]= -quant_table[127];
 959
 960     return 2*v - 1;
 961 }
 962
 963 static int read_header(FFV1Context *f){
 964     uint8_t state[CONTEXT_SIZE];
 965     int i, context_count;
 966     RangeCoder * const c= &f->c;
 967
 968     memset(state, 128, sizeof(state));
 969
 970     f->version= get_symbol(c, state, 0);
 971     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
 972     f->colorspace= get_symbol(c, state, 0); //YUV cs type
 973     if(f->version>0)
 974         f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
 975     get_rac(c, state); //no chroma = false
 976     f->chroma_h_shift= get_symbol(c, state, 0);
 977     f->chroma_v_shift= get_symbol(c, state, 0);
 978     get_rac(c, state); //transparency plane
 979     f->plane_count= 2;
 980
 981     if(f->colorspace==0){
 982         if(f->avctx->bits_per_raw_sample<=8){
 983             switch(16*f->chroma_h_shift + f->chroma_v_shift){
 984             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
 985             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
 986             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
 987             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
 988             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
 989             default:
 990                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 991                 return -1;
 992             }
 993         }else{
 994             switch(16*f->chroma_h_shift + f->chroma_v_shift){
 995             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
 996             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
 997             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
 998             default:
 999                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1000                 return -1;
1001             }
1002         }
1003     }else if(f->colorspace==1){
1004         if(f->chroma_h_shift || f->chroma_v_shift){
1005             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1006             return -1;
1007         }
1008         f->avctx->pix_fmt= PIX_FMT_RGB32;
1009     }else{
1010         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1011         return -1;
1012     }
1013
1014 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1015
1016     context_count=1;
1017     for(i=0; i<5; i++){
1018         context_count*= read_quant_table(c, f->quant_table[i], context_count);
1019         if(context_count < 0 || context_count > 32768){
1020             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1021             return -1;
1022         }
1023     }
1024     context_count= (context_count+1)/2;
1025
1026     for(i=0; i<f->plane_count; i++){
1027         PlaneContext * const p= &f->plane[i];
1028
1029         p->context_count= context_count;
1030
1031         if(f->ac){
1032             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
1033         }else{
1034             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
1035         }
1036     }
1037
1038     return 0;
1039 }
1040
1041 static av_cold int decode_init(AVCodecContext *avctx)
1042 {
1043 //    FFV1Context *s = avctx->priv_data;
1044
1045     common_init(avctx);
1046
1047     return 0;
1048 }
1049
1050 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1051     const uint8_t *buf = avpkt->data;
1052     int buf_size = avpkt->size;
1053     FFV1Context *f = avctx->priv_data;
1054     RangeCoder * const c= &f->c;
1055     const int width= f->width;
1056     const int height= f->height;
1057     AVFrame * const p= &f->picture;
1058     int bytes_read;
1059     uint8_t keystate= 128;
1060
1061     AVFrame *picture = data;
1062
1063     ff_init_range_decoder(c, buf, buf_size);
1064     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1065
1066
1067     p->pict_type= FF_I_TYPE; //FIXME I vs. P
1068     if(get_rac(c, &keystate)){
1069         p->key_frame= 1;
1070         if(read_header(f) < 0)
1071             return -1;
1072         clear_state(f);
1073     }else{
1074         p->key_frame= 0;
1075     }
1076     if(!f->plane[0].state && !f->plane[0].vlc_state)
1077         return -1;
1078
1079     p->reference= 0;
1080     if(avctx->get_buffer(avctx, p) < 0){
1081         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1082         return -1;
1083     }
1084
1085     if(avctx->debug&FF_DEBUG_PICT_INFO)
1086         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1087
1088     if(!f->ac){
1089         bytes_read = c->bytestream - c->bytestream_start - 1;
1090         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1091 //printf("pos=%d\n", bytes_read);
1092         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
1093     } else {
1094         bytes_read = 0; /* avoid warning */
1095     }
1096
1097     if(f->colorspace==0){
1098         const int chroma_width = -((-width )>>f->chroma_h_shift);
1099         const int chroma_height= -((-height)>>f->chroma_v_shift);
1100         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
1101
1102         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
1103         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
1104     }else{
1105         decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
1106     }
1107
1108     emms_c();
1109
1110     f->picture_number++;
1111
1112     *picture= *p;
1113
1114     avctx->release_buffer(avctx, p); //FIXME
1115
1116     *data_size = sizeof(AVFrame);
1117
1118     if(f->ac){
1119         bytes_read= c->bytestream - c->bytestream_start - 1;
1120         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1121     }else{
1122         bytes_read+= (get_bits_count(&f->gb)+7)/8;
1123     }
1124
1125     return bytes_read;
1126 }
1127
1128 AVCodec ffv1_decoder = {
1129     "ffv1",
1130     CODEC_TYPE_VIDEO,
1131     CODEC_ID_FFV1,
1132     sizeof(FFV1Context),
1133     decode_init,
1134     NULL,
1135     common_end,
1136     decode_frame,
1137     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1138     NULL,
1139     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
1140 };
1141
1142 #if CONFIG_FFV1_ENCODER
1143 AVCodec ffv1_encoder = {
1144     "ffv1",
1145     CODEC_TYPE_VIDEO,
1146     CODEC_ID_FFV1,
1147     sizeof(FFV1Context),
1148     encode_init,
1149     encode_frame,
1150     common_end,
1151     .pix_fmts= (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},
1152     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
1153 };
1154 #endif