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