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