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