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