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