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 #include "libavutil/avassert.h"
  36
  37 #define MAX_PLANES 4
  38 #define CONTEXT_SIZE 32
  39
  40 #define MAX_QUANT_TABLES 8
  41 #define MAX_CONTEXT_INPUTS 5
  42
  43 extern const uint8_t ff_log2_run[32];
  44
  45 static const int8_t quant3[256]={
  46  0, 0, 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,-1,
  58 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  59 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  60 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  61 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
  62 };
  63
  64 static const int8_t quant5_10bit[256]={
  65  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
  66  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  67  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  68  1, 1, 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,-2,
  74 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  75 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  76 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  77 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,
  78 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  79 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  80 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
  81 };
  82
  83 static const int8_t quant5[256]={
  84  0, 1, 1, 1, 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,-2,-2,-2,
  96 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  97 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  98 -2,-2,-2,-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,-1,-1,-1,
 100 };
 101 static const int8_t quant7[256]={
 102  0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 103  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 104  2, 2, 2, 2, 2, 2, 2, 2, 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,-3,-3,-3,-3,-3,-3,-3,
 112 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
 113 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
 114 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
 115 -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
 116 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
 117 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
 118 };
 119 static const int8_t quant9[256]={
 120  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 121  3, 3, 3, 3, 3, 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,-4,-4,-4,-4,
 131 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 132 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 133 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 134 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
 135 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
 136 };
 137 static const int8_t quant9_10bit[256]={
 138  0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
 139  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
 140  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
 141  3, 3, 3, 3, 3, 3, 3, 3, 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,-4,-4,-4,-4,-4,-4,-4,
 147 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 148 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 149 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 150 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
 151 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
 152 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
 153 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
 154 };
 155
 156 static const int8_t quant11[256]={
 157  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
 158  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 159  4, 4, 4, 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,-5,-5,
 167 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 168 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 169 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 170 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
 171 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 172 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
 173 };
 174 static const int8_t quant13[256]={
 175  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
 176  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 177  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 178  5, 5, 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,-6,
 184 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 185 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 186 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 187 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
 188 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 189 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 190 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
 191 };
 192
 193 static const uint8_t ver2_state[256]= {
 194    0,  10,  10,  10,  10,  16,  16,  16,  28,  16,  16,  29,  42,  49,  20,  49,
 195   59,  25,  26,  26,  27,  31,  33,  33,  33,  34,  34,  37,  67,  38,  39,  39,
 196   40,  40,  41,  79,  43,  44,  45,  45,  48,  48,  64,  50,  51,  52,  88,  52,
 197   53,  74,  55,  57,  58,  58,  74,  60, 101,  61,  62,  84,  66,  66,  68,  69,
 198   87,  82,  71,  97,  73,  73,  82,  75, 111,  77,  94,  78,  87,  81,  83,  97,
 199   85,  83,  94,  86,  99,  89,  90,  99, 111,  92,  93, 134,  95,  98, 105,  98,
 200  105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
 201  115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
 202  165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
 203  147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
 204  172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
 205  175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
 206  197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
 207  209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
 208  226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
 209  241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
 210 };
 211
 212 typedef struct VlcState{
 213     int16_t drift;
 214     uint16_t error_sum;
 215     int8_t bias;
 216     uint8_t count;
 217 } VlcState;
 218
 219 typedef struct PlaneContext{
 220     int16_t quant_table[MAX_CONTEXT_INPUTS][256];
 221     int quant_table_index;
 222     int context_count;
 223     uint8_t (*state)[CONTEXT_SIZE];
 224     VlcState *vlc_state;
 225     uint8_t interlace_bit_state[2];
 226 } PlaneContext;
 227
 228 #define MAX_SLICES 256
 229
 230 typedef struct FFV1Context{
 231     AVCodecContext *avctx;
 232     RangeCoder c;
 233     GetBitContext gb;
 234     PutBitContext pb;
 235     uint64_t rc_stat[256][2];
 236     uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
 237     int version;
 238     int width, height;
 239     int chroma_h_shift, chroma_v_shift;
 240     int flags;
 241     int picture_number;
 242     AVFrame picture;
 243     int plane_count;
 244     int ac;                              ///< 1=range coder <-> 0=golomb rice
 245     PlaneContext plane[MAX_PLANES];
 246     int16_t quant_table[MAX_CONTEXT_INPUTS][256];
 247     int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
 248     int context_count[MAX_QUANT_TABLES];
 249     uint8_t state_transition[256];
 250     uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
 251     int run_index;
 252     int colorspace;
 253     int_fast16_t *sample_buffer;
 254
 255     int quant_table_count;
 256
 257     DSPContext dsp;
 258
 259     struct FFV1Context *slice_context[MAX_SLICES];
 260     int slice_count;
 261     int num_v_slices;
 262     int num_h_slices;
 263     int slice_width;
 264     int slice_height;
 265     int slice_x;
 266     int slice_y;
 267 }FFV1Context;
 268
 269 static av_always_inline int fold(int diff, int bits){
 270     if(bits==8)
 271         diff= (int8_t)diff;
 272     else{
 273         diff+= 1<<(bits-1);
 274         diff&=(1<<bits)-1;
 275         diff-= 1<<(bits-1);
 276     }
 277
 278     return diff;
 279 }
 280
 281 static inline int predict(int_fast16_t *src, int_fast16_t *last){
 282     const int LT= last[-1];
 283     const int  T= last[ 0];
 284     const int L =  src[-1];
 285
 286     return mid_pred(L, L + T - LT, T);
 287 }
 288
 289 static inline int get_context(PlaneContext *p, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
 290     const int LT= last[-1];
 291     const int  T= last[ 0];
 292     const int RT= last[ 1];
 293     const int L =  src[-1];
 294
 295     if(p->quant_table[3][127]){
 296         const int TT= last2[0];
 297         const int LL=  src[-2];
 298         return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
 299               +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
 300     }else
 301         return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
 302 }
 303
 304 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2]){
 305     int i;
 306
 307 #define put_rac(C,S,B) \
 308 do{\
 309     if(rc_stat){\
 310     rc_stat[*(S)][B]++;\
 311         rc_stat2[(S)-state][B]++;\
 312     }\
 313     put_rac(C,S,B);\
 314 }while(0)
 315
 316     if(v){
 317         const int a= FFABS(v);
 318         const int e= av_log2(a);
 319         put_rac(c, state+0, 0);
 320         if(e<=9){
 321             for(i=0; i<e; i++){
 322                 put_rac(c, state+1+i, 1);  //1..10
 323             }
 324             put_rac(c, state+1+i, 0);
 325
 326             for(i=e-1; i>=0; i--){
 327                 put_rac(c, state+22+i, (a>>i)&1); //22..31
 328             }
 329
 330             if(is_signed)
 331                 put_rac(c, state+11 + e, v < 0); //11..21
 332         }else{
 333             for(i=0; i<e; i++){
 334                 put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
 335             }
 336             put_rac(c, state+1+9, 0);
 337
 338             for(i=e-1; i>=0; i--){
 339                 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
 340             }
 341
 342             if(is_signed)
 343                 put_rac(c, state+11 + 10, v < 0); //11..21
 344         }
 345     }else{
 346         put_rac(c, state+0, 1);
 347     }
 348 #undef put_rac
 349 }
 350
 351 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
 352     put_symbol_inline(c, state, v, is_signed, NULL, NULL);
 353 }
 354
 355 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
 356     if(get_rac(c, state+0))
 357         return 0;
 358     else{
 359         int i, e, a;
 360         e= 0;
 361         while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
 362             e++;
 363         }
 364
 365         a= 1;
 366         for(i=e-1; i>=0; i--){
 367             a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
 368         }
 369
 370         e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
 371         return (a^e)-e;
 372     }
 373 }
 374
 375 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
 376     return get_symbol_inline(c, state, is_signed);
 377 }
 378
 379 static inline void update_vlc_state(VlcState * const state, const int v){
 380     int drift= state->drift;
 381     int count= state->count;
 382     state->error_sum += FFABS(v);
 383     drift += v;
 384
 385     if(count == 128){ //FIXME variable
 386         count >>= 1;
 387         drift >>= 1;
 388         state->error_sum >>= 1;
 389     }
 390     count++;
 391
 392     if(drift <= -count){
 393         if(state->bias > -128) state->bias--;
 394
 395         drift += count;
 396         if(drift <= -count)
 397             drift= -count + 1;
 398     }else if(drift > 0){
 399         if(state->bias <  127) state->bias++;
 400
 401         drift -= count;
 402         if(drift > 0)
 403             drift= 0;
 404     }
 405
 406     state->drift= drift;
 407     state->count= count;
 408 }
 409
 410 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
 411     int i, k, code;
 412 //printf("final: %d ", v);
 413     v = fold(v - state->bias, bits);
 414
 415     i= state->count;
 416     k=0;
 417     while(i < state->error_sum){ //FIXME optimize
 418         k++;
 419         i += i;
 420     }
 421
 422     assert(k<=8);
 423
 424 #if 0 // JPEG LS
 425     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
 426     else                                         code= v;
 427 #else
 428      code= v ^ ((2*state->drift + state->count)>>31);
 429 #endif
 430
 431 //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);
 432     set_sr_golomb(pb, code, k, 12, bits);
 433
 434     update_vlc_state(state, v);
 435 }
 436
 437 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
 438     int k, i, v, ret;
 439
 440     i= state->count;
 441     k=0;
 442     while(i < state->error_sum){ //FIXME optimize
 443         k++;
 444         i += i;
 445     }
 446
 447     assert(k<=8);
 448
 449     v= get_sr_golomb(gb, k, 12, bits);
 450 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
 451
 452 #if 0 // JPEG LS
 453     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
 454 #else
 455      v ^= ((2*state->drift + state->count)>>31);
 456 #endif
 457
 458     ret= fold(v + state->bias, bits);
 459
 460     update_vlc_state(state, v);
 461 //printf("final: %d\n", ret);
 462     return ret;
 463 }
 464
 465 #if CONFIG_FFV1_ENCODER
 466 static av_always_inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
 467     PlaneContext * const p= &s->plane[plane_index];
 468     RangeCoder * const c= &s->c;
 469     int x;
 470     int run_index= s->run_index;
 471     int run_count=0;
 472     int run_mode=0;
 473
 474     if(s->ac){
 475         if(c->bytestream_end - c->bytestream < w*20){
 476             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 477             return -1;
 478         }
 479     }else{
 480         if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
 481             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 482             return -1;
 483         }
 484     }
 485
 486     for(x=0; x<w; x++){
 487         int diff, context;
 488
 489         context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
 490         diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
 491
 492         if(context < 0){
 493             context = -context;
 494             diff= -diff;
 495         }
 496
 497         diff= fold(diff, bits);
 498
 499         if(s->ac){
 500             if(s->flags & CODEC_FLAG_PASS1){
 501                 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
 502             }else{
 503                 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
 504             }
 505         }else{
 506             if(context == 0) run_mode=1;
 507
 508             if(run_mode){
 509
 510                 if(diff){
 511                     while(run_count >= 1<<ff_log2_run[run_index]){
 512                         run_count -= 1<<ff_log2_run[run_index];
 513                         run_index++;
 514                         put_bits(&s->pb, 1, 1);
 515                     }
 516
 517                     put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
 518                     if(run_index) run_index--;
 519                     run_count=0;
 520                     run_mode=0;
 521                     if(diff>0) diff--;
 522                 }else{
 523                     run_count++;
 524                 }
 525             }
 526
 527 //            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));
 528
 529             if(run_mode == 0)
 530                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
 531         }
 532     }
 533     if(run_mode){
 534         while(run_count >= 1<<ff_log2_run[run_index]){
 535             run_count -= 1<<ff_log2_run[run_index];
 536             run_index++;
 537             put_bits(&s->pb, 1, 1);
 538         }
 539
 540         if(run_count)
 541             put_bits(&s->pb, 1, 1);
 542     }
 543     s->run_index= run_index;
 544
 545     return 0;
 546 }
 547
 548 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 549     int x,y,i;
 550     const int ring_size= s->avctx->context_model ? 3 : 2;
 551     int_fast16_t *sample[3];
 552     s->run_index=0;
 553
 554     memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
 555
 556     for(y=0; y<h; y++){
 557         for(i=0; i<ring_size; i++)
 558             sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
 559
 560         sample[0][-1]= sample[1][0  ];
 561         sample[1][ w]= sample[1][w-1];
 562 //{START_TIMER
 563         if(s->avctx->bits_per_raw_sample<=8){
 564             for(x=0; x<w; x++){
 565                 sample[0][x]= src[x + stride*y];
 566             }
 567             encode_line(s, w, sample, plane_index, 8);
 568         }else{
 569             for(x=0; x<w; x++){
 570                 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
 571             }
 572             encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
 573         }
 574 //STOP_TIMER("encode line")}
 575     }
 576 }
 577
 578 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 579     int x, y, p, i;
 580     const int ring_size= s->avctx->context_model ? 3 : 2;
 581     int_fast16_t *sample[3][3];
 582     s->run_index=0;
 583
 584     memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
 585
 586     for(y=0; y<h; y++){
 587         for(i=0; i<ring_size; i++)
 588             for(p=0; p<3; p++)
 589                 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
 590
 591         for(x=0; x<w; x++){
 592             int v= src[x + stride*y];
 593             int b= v&0xFF;
 594             int g= (v>>8)&0xFF;
 595             int r= (v>>16)&0xFF;
 596
 597             b -= g;
 598             r -= g;
 599             g += (b + r)>>2;
 600             b += 0x100;
 601             r += 0x100;
 602
 603 //            assert(g>=0 && b>=0 && r>=0);
 604 //            assert(g<256 && b<512 && r<512);
 605             sample[0][0][x]= g;
 606             sample[1][0][x]= b;
 607             sample[2][0][x]= r;
 608         }
 609         for(p=0; p<3; p++){
 610             sample[p][0][-1]= sample[p][1][0  ];
 611             sample[p][1][ w]= sample[p][1][w-1];
 612             encode_line(s, w, sample[p], FFMIN(p, 1), 9);
 613         }
 614     }
 615 }
 616
 617 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
 618     int last=0;
 619     int i;
 620     uint8_t state[CONTEXT_SIZE];
 621     memset(state, 128, sizeof(state));
 622
 623     for(i=1; i<128 ; i++){
 624         if(quant_table[i] != quant_table[i-1]){
 625             put_symbol(c, state, i-last-1, 0);
 626             last= i;
 627         }
 628     }
 629     put_symbol(c, state, i-last-1, 0);
 630 }
 631
 632 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
 633     int i;
 634     for(i=0; i<5; i++)
 635         write_quant_table(c, quant_table[i]);
 636 }
 637
 638 static void write_header(FFV1Context *f){
 639     uint8_t state[CONTEXT_SIZE];
 640     int i, j;
 641     RangeCoder * const c= &f->slice_context[0]->c;
 642
 643     memset(state, 128, sizeof(state));
 644
 645     if(f->version < 2){
 646         put_symbol(c, state, f->version, 0);
 647         put_symbol(c, state, f->ac, 0);
 648         if(f->ac>1){
 649             for(i=1; i<256; i++){
 650                 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 651             }
 652         }
 653         put_symbol(c, state, f->colorspace, 0); //YUV cs type
 654         if(f->version>0)
 655             put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
 656         put_rac(c, state, 1); //chroma planes
 657             put_symbol(c, state, f->chroma_h_shift, 0);
 658             put_symbol(c, state, f->chroma_v_shift, 0);
 659         put_rac(c, state, 0); //no transparency plane
 660
 661         write_quant_tables(c, f->quant_table);
 662     }else{
 663         put_symbol(c, state, f->slice_count, 0);
 664         for(i=0; i<f->slice_count; i++){
 665             FFV1Context *fs= f->slice_context[i];
 666             put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
 667             put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
 668             put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
 669             put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
 670             for(j=0; j<f->plane_count; j++){
 671                 put_symbol(c, state, f->plane[j].quant_table_index, 0);
 672                 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
 673             }
 674         }
 675     }
 676 }
 677 #endif /* CONFIG_FFV1_ENCODER */
 678
 679 static av_cold int common_init(AVCodecContext *avctx){
 680     FFV1Context *s = avctx->priv_data;
 681
 682     s->avctx= avctx;
 683     s->flags= avctx->flags;
 684
 685     dsputil_init(&s->dsp, avctx);
 686
 687     s->width = avctx->width;
 688     s->height= avctx->height;
 689
 690     assert(s->width && s->height);
 691     //defaults
 692     s->num_h_slices=1;
 693     s->num_v_slices=1;
 694
 695
 696     return 0;
 697 }
 698
 699 static int init_slice_state(FFV1Context *f){
 700     int i, j;
 701
 702     for(i=0; i<f->slice_count; i++){
 703         FFV1Context *fs= f->slice_context[i];
 704         for(j=0; j<f->plane_count; j++){
 705             PlaneContext * const p= &fs->plane[j];
 706
 707             if(fs->ac){
 708                 if(!p->    state) p->    state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 709                 if(!p->    state)
 710                     return AVERROR(ENOMEM);
 711             }else{
 712                 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 713                 if(!p->vlc_state)
 714                     return AVERROR(ENOMEM);
 715             }
 716         }
 717
 718         if (fs->ac>1){
 719             //FIXME only redo if state_transition changed
 720             for(j=1; j<256; j++){
 721                 fs->c.one_state [    j]= fs->state_transition[j];
 722                 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
 723             }
 724         }
 725     }
 726
 727     return 0;
 728 }
 729
 730 static av_cold int init_slice_contexts(FFV1Context *f){
 731     int i;
 732
 733     f->slice_count= f->num_h_slices * f->num_v_slices;
 734
 735     for(i=0; i<f->slice_count; i++){
 736         FFV1Context *fs= av_mallocz(sizeof(*fs));
 737         int sx= i % f->num_h_slices;
 738         int sy= i / f->num_h_slices;
 739         int sxs= f->avctx->width * sx    / f->num_h_slices;
 740         int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
 741         int sys= f->avctx->height* sy    / f->num_v_slices;
 742         int sye= f->avctx->height*(sy+1) / f->num_v_slices;
 743         f->slice_context[i]= fs;
 744         memcpy(fs, f, sizeof(*fs));
 745
 746         fs->slice_width = sxe - sxs;
 747         fs->slice_height= sye - sys;
 748         fs->slice_x     = sxs;
 749         fs->slice_y     = sys;
 750
 751         fs->sample_buffer = av_malloc(6 * (fs->width+6) * sizeof(*fs->sample_buffer));
 752         if (!fs->sample_buffer)
 753             return AVERROR(ENOMEM);
 754     }
 755     return 0;
 756 }
 757
 758 static int allocate_initial_states(FFV1Context *f){
 759     int i;
 760
 761     for(i=0; i<f->quant_table_count; i++){
 762         f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
 763         if(!f->initial_states[i])
 764             return AVERROR(ENOMEM);
 765         memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
 766     }
 767     return 0;
 768 }
 769
 770 #if CONFIG_FFV1_ENCODER
 771 static int write_extra_header(FFV1Context *f){
 772     RangeCoder * const c= &f->c;
 773     uint8_t state[CONTEXT_SIZE];
 774     int i, j, k;
 775     uint8_t state2[32][CONTEXT_SIZE];
 776
 777     memset(state2, 128, sizeof(state2));
 778     memset(state, 128, sizeof(state));
 779
 780     f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
 781     ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
 782     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 783
 784     put_symbol(c, state, f->version, 0);
 785     put_symbol(c, state, f->ac, 0);
 786     if(f->ac>1){
 787         for(i=1; i<256; i++){
 788             put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 789         }
 790     }
 791     put_symbol(c, state, f->colorspace, 0); //YUV cs type
 792     put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
 793     put_rac(c, state, 1); //chroma planes
 794         put_symbol(c, state, f->chroma_h_shift, 0);
 795         put_symbol(c, state, f->chroma_v_shift, 0);
 796     put_rac(c, state, 0); //no transparency plane
 797     put_symbol(c, state, f->num_h_slices-1, 0);
 798     put_symbol(c, state, f->num_v_slices-1, 0);
 799
 800     put_symbol(c, state, f->quant_table_count, 0);
 801     for(i=0; i<f->quant_table_count; i++)
 802         write_quant_tables(c, f->quant_tables[i]);
 803
 804     for(i=0; i<f->quant_table_count; i++){
 805         for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
 806             if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
 807                 break;
 808         if(j<f->context_count[i]*CONTEXT_SIZE){
 809             put_rac(c, state, 1);
 810             for(j=0; j<f->context_count[i]; j++){
 811                 for(k=0; k<CONTEXT_SIZE; k++){
 812                     int pred= j ? f->initial_states[i][j-1][k] : 128;
 813                     put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
 814                 }
 815             }
 816         }else{
 817             put_rac(c, state, 0);
 818         }
 819     }
 820
 821     f->avctx->extradata_size= ff_rac_terminate(c);
 822
 823     return 0;
 824 }
 825
 826 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
 827     int i,i2,changed,print=0;
 828
 829     do{
 830         changed=0;
 831         for(i=12; i<244; i++){
 832             for(i2=i+1; i2<245 && i2<i+4; i2++){
 833 #define COST(old, new) \
 834     s->rc_stat[old][0]*-log2((256-(new))/256.0)\
 835    +s->rc_stat[old][1]*-log2(     (new) /256.0)
 836
 837 #define COST2(old, new) \
 838     COST(old, new)\
 839    +COST(256-(old), 256-(new))
 840
 841                 double size0= COST2(i, i ) + COST2(i2, i2);
 842                 double sizeX= COST2(i, i2) + COST2(i2, i );
 843                 if(sizeX < size0 && i!=128 && i2!=128){
 844                     int j;
 845                     FFSWAP(int, stt[    i], stt[    i2]);
 846                     FFSWAP(int, s->rc_stat[i    ][0],s->rc_stat[    i2][0]);
 847                     FFSWAP(int, s->rc_stat[i    ][1],s->rc_stat[    i2][1]);
 848                     if(i != 256-i2){
 849                         FFSWAP(int, stt[256-i], stt[256-i2]);
 850                         FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
 851                         FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
 852                     }
 853                     for(j=1; j<256; j++){
 854                         if     (stt[j] == i ) stt[j] = i2;
 855                         else if(stt[j] == i2) stt[j] = i ;
 856                         if(i != 256-i2){
 857                             if     (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
 858                             else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
 859                         }
 860                     }
 861                     print=changed=1;
 862                 }
 863             }
 864         }
 865     }while(changed);
 866     return print;
 867 }
 868
 869 static av_cold int encode_init(AVCodecContext *avctx)
 870 {
 871     FFV1Context *s = avctx->priv_data;
 872     int i, j;
 873
 874     common_init(avctx);
 875
 876     s->version=0;
 877     s->ac= avctx->coder_type ? 2:0;
 878
 879     if(s->ac>1)
 880         for(i=1; i<256; i++)
 881             s->state_transition[i]=ver2_state[i];
 882
 883     s->plane_count=2;
 884     for(i=0; i<256; i++){
 885         s->quant_table_count=2;
 886         if(avctx->bits_per_raw_sample <=8){
 887             s->quant_tables[0][0][i]=           quant11[i];
 888             s->quant_tables[0][1][i]=        11*quant11[i];
 889             s->quant_tables[0][2][i]=     11*11*quant11[i];
 890             s->quant_tables[1][0][i]=           quant11[i];
 891             s->quant_tables[1][1][i]=        11*quant11[i];
 892             s->quant_tables[1][2][i]=     11*11*quant5 [i];
 893             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 894             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
 895         }else{
 896             s->quant_tables[0][0][i]=           quant9_10bit[i];
 897             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 898             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 899             s->quant_tables[1][0][i]=           quant9_10bit[i];
 900             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 901             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 902             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 903             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
 904         }
 905     }
 906     s->context_count[0]= (11*11*11+1)/2;
 907     s->context_count[1]= (11*11*5*5*5+1)/2;
 908     memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
 909
 910     for(i=0; i<s->plane_count; i++){
 911         PlaneContext * const p= &s->plane[i];
 912
 913         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 914         p->quant_table_index= avctx->context_model;
 915         p->context_count= s->context_count[p->quant_table_index];
 916     }
 917
 918     if(allocate_initial_states(s) < 0)
 919         return AVERROR(ENOMEM);
 920
 921     avctx->coded_frame= &s->picture;
 922     switch(avctx->pix_fmt){
 923     case PIX_FMT_YUV444P16:
 924     case PIX_FMT_YUV422P16:
 925     case PIX_FMT_YUV420P16:
 926         if(avctx->bits_per_raw_sample <=8){
 927             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 928             return -1;
 929         }
 930         if(!s->ac){
 931             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
 932             return -1;
 933         }
 934         s->version= FFMAX(s->version, 1);
 935     case PIX_FMT_YUV444P:
 936     case PIX_FMT_YUV422P:
 937     case PIX_FMT_YUV420P:
 938     case PIX_FMT_YUV411P:
 939     case PIX_FMT_YUV410P:
 940         s->colorspace= 0;
 941         break;
 942     case PIX_FMT_RGB32:
 943         s->colorspace= 1;
 944         break;
 945     default:
 946         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 947         return -1;
 948     }
 949     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 950
 951     s->picture_number=0;
 952
 953     if(avctx->stats_in){
 954         char *p= avctx->stats_in;
 955
 956         for(;;){
 957             for(j=0; j<256; j++){
 958                 for(i=0; i<2; i++){
 959                     char *next;
 960                     s->rc_stat[j][i]= strtol(p, &next, 0);
 961                     if(next==p){
 962                         av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
 963                         return -1;
 964                     }
 965                     p=next;
 966                 }
 967             }
 968             while(*p=='\n' || *p==' ') p++;
 969             if(p[0]==0) break;
 970         }
 971         sort_stt(s, s->state_transition);
 972     }
 973
 974     if(s->version>1){
 975         s->num_h_slices=2;
 976         s->num_v_slices=2;
 977         write_extra_header(s);
 978     }
 979
 980     if(init_slice_contexts(s) < 0)
 981         return -1;
 982     if(init_slice_state(s) < 0)
 983         return -1;
 984
 985 #define STATS_OUT_SIZE 1024*30
 986     if(avctx->flags & CODEC_FLAG_PASS1){
 987     avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
 988         for(i=0; i<s->quant_table_count; i++){
 989             for(j=0; j<s->slice_count; j++){
 990                 FFV1Context *sf= s->slice_context[j];
 991                 av_assert0(!sf->rc_stat2[i]);
 992                 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
 993                 if(!sf->rc_stat2[i])
 994                     return AVERROR(ENOMEM);
 995             }
 996         }
 997     }
 998
 999     return 0;
1000 }
1001 #endif /* CONFIG_FFV1_ENCODER */
1002
1003
1004 static void clear_state(FFV1Context *f){
1005     int i, si, j;
1006
1007     for(si=0; si<f->slice_count; si++){
1008         FFV1Context *fs= f->slice_context[si];
1009         for(i=0; i<f->plane_count; i++){
1010             PlaneContext *p= &fs->plane[i];
1011
1012             p->interlace_bit_state[0]= 128;
1013             p->interlace_bit_state[1]= 128;
1014
1015             if(fs->ac){
1016                 if(f->initial_states[p->quant_table_index]){
1017                     memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1018                 }else
1019                 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1020             }else{
1021             for(j=0; j<p->context_count; j++){
1022                     p->vlc_state[j].drift= 0;
1023                     p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1024                     p->vlc_state[j].bias= 0;
1025                     p->vlc_state[j].count= 1;
1026             }
1027             }
1028         }
1029     }
1030 }
1031
1032 #if CONFIG_FFV1_ENCODER
1033 static int encode_slice(AVCodecContext *c, void *arg){
1034     FFV1Context *fs= *(void**)arg;
1035     FFV1Context *f= fs->avctx->priv_data;
1036     int width = fs->slice_width;
1037     int height= fs->slice_height;
1038     int x= fs->slice_x;
1039     int y= fs->slice_y;
1040     AVFrame * const p= &f->picture;
1041
1042     if(f->colorspace==0){
1043         const int chroma_width = -((-width )>>f->chroma_h_shift);
1044         const int chroma_height= -((-height)>>f->chroma_v_shift);
1045         const int cx= x>>f->chroma_h_shift;
1046         const int cy= y>>f->chroma_v_shift;
1047
1048         encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1049
1050         encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1051         encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1052     }else{
1053         encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1054     }
1055     emms_c();
1056
1057     return 0;
1058 }
1059
1060 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1061     FFV1Context *f = avctx->priv_data;
1062     RangeCoder * const c= &f->slice_context[0]->c;
1063     AVFrame *pict = data;
1064     AVFrame * const p= &f->picture;
1065     int used_count= 0;
1066     uint8_t keystate=128;
1067     uint8_t *buf_p;
1068     int i;
1069
1070     ff_init_range_encoder(c, buf, buf_size);
1071     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1072
1073     *p = *pict;
1074     p->pict_type= FF_I_TYPE;
1075
1076     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1077         put_rac(c, &keystate, 1);
1078         p->key_frame= 1;
1079         write_header(f);
1080         clear_state(f);
1081     }else{
1082         put_rac(c, &keystate, 0);
1083         p->key_frame= 0;
1084     }
1085
1086     if(!f->ac){
1087         used_count += ff_rac_terminate(c);
1088 //printf("pos=%d\n", used_count);
1089         init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1090     }else if (f->ac>1){
1091         int i;
1092         for(i=1; i<256; i++){
1093             c->one_state[i]= f->state_transition[i];
1094             c->zero_state[256-i]= 256-c->one_state[i];
1095         }
1096     }
1097
1098     for(i=1; i<f->slice_count; i++){
1099         FFV1Context *fs= f->slice_context[i];
1100         uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1101         int len= buf_size/f->slice_count;
1102
1103         if(fs->ac){
1104             ff_init_range_encoder(&fs->c, start, len);
1105         }else{
1106             init_put_bits(&fs->pb, start, len);
1107         }
1108     }
1109     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1110
1111     buf_p=buf;
1112     for(i=0; i<f->slice_count; i++){
1113         FFV1Context *fs= f->slice_context[i];
1114         int bytes;
1115
1116         if(fs->ac){
1117             uint8_t state=128;
1118             put_rac(&fs->c, &state, 0);
1119             bytes= ff_rac_terminate(&fs->c);
1120         }else{
1121             flush_put_bits(&fs->pb); //nicer padding FIXME
1122             bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1123             used_count= 0;
1124         }
1125         if(i>0){
1126             av_assert0(bytes < buf_size/f->slice_count);
1127             memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1128             av_assert0(bytes < (1<<24));
1129             AV_WB24(buf_p+bytes, bytes);
1130             bytes+=3;
1131         }
1132         buf_p += bytes;
1133     }
1134
1135     if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1136         int j;
1137         char *p= avctx->stats_out;
1138         char *end= p + STATS_OUT_SIZE;
1139
1140         memset(f->rc_stat, 0, sizeof(f->rc_stat));
1141         for(j=0; j<f->slice_count; j++){
1142             FFV1Context *fs= f->slice_context[j];
1143             for(i=0; i<256; i++){
1144                 f->rc_stat[i][0] += fs->rc_stat[i][0];
1145                 f->rc_stat[i][1] += fs->rc_stat[i][1];
1146             }
1147         }
1148
1149         for(j=0; j<256; j++){
1150             snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1151             p+= strlen(p);
1152         }
1153         snprintf(p, end-p, "\n");
1154     } else if(avctx->flags&CODEC_FLAG_PASS1)
1155         avctx->stats_out[0] = '\0';
1156
1157     f->picture_number++;
1158     return buf_p-buf;
1159 }
1160 #endif /* CONFIG_FFV1_ENCODER */
1161
1162 static av_cold int common_end(AVCodecContext *avctx){
1163     FFV1Context *s = avctx->priv_data;
1164     int i, j;
1165
1166     for(j=0; j<s->slice_count; j++){
1167         FFV1Context *fs= s->slice_context[j];
1168         for(i=0; i<s->plane_count; i++){
1169             PlaneContext *p= &fs->plane[i];
1170
1171             av_freep(&p->state);
1172             av_freep(&p->vlc_state);
1173         }
1174         av_freep(&fs->sample_buffer);
1175     }
1176
1177     av_freep(&avctx->stats_out);
1178     for(j=0; j<s->quant_table_count; j++){
1179         av_freep(&s->initial_states[j]);
1180         for(i=0; i<s->slice_count; i++){
1181             FFV1Context *sf= s->slice_context[i];
1182             av_freep(&sf->rc_stat2[j]);
1183         }
1184     }
1185
1186     return 0;
1187 }
1188
1189 static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
1190     PlaneContext * const p= &s->plane[plane_index];
1191     RangeCoder * const c= &s->c;
1192     int x;
1193     int run_count=0;
1194     int run_mode=0;
1195     int run_index= s->run_index;
1196
1197     for(x=0; x<w; x++){
1198         int diff, context, sign;
1199
1200         context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1201         if(context < 0){
1202             context= -context;
1203             sign=1;
1204         }else
1205             sign=0;
1206
1207         av_assert2(context < p->context_count);
1208
1209         if(s->ac){
1210             diff= get_symbol_inline(c, p->state[context], 1);
1211         }else{
1212             if(context == 0 && run_mode==0) run_mode=1;
1213
1214             if(run_mode){
1215                 if(run_count==0 && run_mode==1){
1216                     if(get_bits1(&s->gb)){
1217                         run_count = 1<<ff_log2_run[run_index];
1218                         if(x + run_count <= w) run_index++;
1219                     }else{
1220                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1221                         else run_count=0;
1222                         if(run_index) run_index--;
1223                         run_mode=2;
1224                     }
1225                 }
1226                 run_count--;
1227                 if(run_count < 0){
1228                     run_mode=0;
1229                     run_count=0;
1230                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1231                     if(diff>=0) diff++;
1232                 }else
1233                     diff=0;
1234             }else
1235                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1236
1237 //            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));
1238         }
1239
1240         if(sign) diff= -diff;
1241
1242         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1243     }
1244     s->run_index= run_index;
1245 }
1246
1247 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1248     int x, y;
1249     int_fast16_t *sample[2];
1250     sample[0]=s->sample_buffer    +3;
1251     sample[1]=s->sample_buffer+w+6+3;
1252
1253     s->run_index=0;
1254
1255     memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1256
1257     for(y=0; y<h; y++){
1258         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
1259
1260         sample[0]= sample[1];
1261         sample[1]= temp;
1262
1263         sample[1][-1]= sample[0][0  ];
1264         sample[0][ w]= sample[0][w-1];
1265
1266 //{START_TIMER
1267         if(s->avctx->bits_per_raw_sample <= 8){
1268             decode_line(s, w, sample, plane_index, 8);
1269             for(x=0; x<w; x++){
1270                 src[x + stride*y]= sample[1][x];
1271             }
1272         }else{
1273             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1274             for(x=0; x<w; x++){
1275                 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1276             }
1277         }
1278 //STOP_TIMER("decode-line")}
1279     }
1280 }
1281
1282 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1283     int x, y, p;
1284     int_fast16_t *sample[3][2];
1285     for(x=0; x<3; x++){
1286         sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1287         sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1288     }
1289
1290     s->run_index=0;
1291
1292     memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1293
1294     for(y=0; y<h; y++){
1295         for(p=0; p<3; p++){
1296             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
1297
1298             sample[p][0]= sample[p][1];
1299             sample[p][1]= temp;
1300
1301             sample[p][1][-1]= sample[p][0][0  ];
1302             sample[p][0][ w]= sample[p][0][w-1];
1303             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1304         }
1305         for(x=0; x<w; x++){
1306             int g= sample[0][1][x];
1307             int b= sample[1][1][x];
1308             int r= sample[2][1][x];
1309
1310 //            assert(g>=0 && b>=0 && r>=0);
1311 //            assert(g<256 && b<512 && r<512);
1312
1313             b -= 0x100;
1314             r -= 0x100;
1315             g -= (b + r)>>2;
1316             b += g;
1317             r += g;
1318
1319             src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1320         }
1321     }
1322 }
1323
1324 static int decode_slice(AVCodecContext *c, void *arg){
1325     FFV1Context *fs= *(void**)arg;
1326     FFV1Context *f= fs->avctx->priv_data;
1327     int width = fs->slice_width;
1328     int height= fs->slice_height;
1329     int x= fs->slice_x;
1330     int y= fs->slice_y;
1331     AVFrame * const p= &f->picture;
1332
1333     av_assert1(width && height);
1334     if(f->colorspace==0){
1335         const int chroma_width = -((-width )>>f->chroma_h_shift);
1336         const int chroma_height= -((-height)>>f->chroma_v_shift);
1337         const int cx= x>>f->chroma_h_shift;
1338         const int cy= y>>f->chroma_v_shift;
1339         decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1340
1341         decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1342         decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1343     }else{
1344         decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1345     }
1346
1347     emms_c();
1348
1349     return 0;
1350 }
1351
1352 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1353     int v;
1354     int i=0;
1355     uint8_t state[CONTEXT_SIZE];
1356
1357     memset(state, 128, sizeof(state));
1358
1359     for(v=0; i<128 ; v++){
1360         int len= get_symbol(c, state, 0) + 1;
1361
1362         if(len + i > 128) return -1;
1363
1364         while(len--){
1365             quant_table[i] = scale*v;
1366             i++;
1367 //printf("%2d ",v);
1368 //if(i%16==0) printf("\n");
1369         }
1370     }
1371
1372     for(i=1; i<128; i++){
1373         quant_table[256-i]= -quant_table[i];
1374     }
1375     quant_table[128]= -quant_table[127];
1376
1377     return 2*v - 1;
1378 }
1379
1380 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1381     int i;
1382     int context_count=1;
1383
1384     for(i=0; i<5; i++){
1385         context_count*= read_quant_table(c, quant_table[i], context_count);
1386         if(context_count > 32768U){
1387             return -1;
1388         }
1389     }
1390     return (context_count+1)/2;
1391 }
1392
1393 static int read_extra_header(FFV1Context *f){
1394     RangeCoder * const c= &f->c;
1395     uint8_t state[CONTEXT_SIZE];
1396     int i, j, k;
1397     uint8_t state2[32][CONTEXT_SIZE];
1398
1399     memset(state2, 128, sizeof(state2));
1400     memset(state, 128, sizeof(state));
1401
1402     ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1403     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1404
1405     f->version= get_symbol(c, state, 0);
1406     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1407     if(f->ac>1){
1408         for(i=1; i<256; i++){
1409             f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1410         }
1411     }
1412     f->colorspace= get_symbol(c, state, 0); //YUV cs type
1413     f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1414     get_rac(c, state); //no chroma = false
1415     f->chroma_h_shift= get_symbol(c, state, 0);
1416     f->chroma_v_shift= get_symbol(c, state, 0);
1417     get_rac(c, state); //transparency plane
1418     f->plane_count= 2;
1419     f->num_h_slices= 1 + get_symbol(c, state, 0);
1420     f->num_v_slices= 1 + get_symbol(c, state, 0);
1421     if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1422         av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1423         return -1;
1424     }
1425
1426     f->quant_table_count= get_symbol(c, state, 0);
1427     if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1428         return -1;
1429     for(i=0; i<f->quant_table_count; i++){
1430         if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1431             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1432             return -1;
1433         }
1434     }
1435
1436     if(allocate_initial_states(f) < 0)
1437         return AVERROR(ENOMEM);
1438
1439     for(i=0; i<f->quant_table_count; i++){
1440         if(get_rac(c, state)){
1441             for(j=0; j<f->context_count[i]; j++){
1442                 for(k=0; k<CONTEXT_SIZE; k++){
1443                     int pred= j ? f->initial_states[i][j-1][k] : 128;
1444                     f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1445                 }
1446             }
1447         }
1448     }
1449
1450     return 0;
1451 }
1452
1453 static int read_header(FFV1Context *f){
1454     uint8_t state[CONTEXT_SIZE];
1455     int i, j, context_count;
1456     RangeCoder * const c= &f->slice_context[0]->c;
1457
1458     memset(state, 128, sizeof(state));
1459
1460     if(f->version < 2){
1461         f->version= get_symbol(c, state, 0);
1462         f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1463         if(f->ac>1){
1464             for(i=1; i<256; i++){
1465                 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1466             }
1467         }
1468         f->colorspace= get_symbol(c, state, 0); //YUV cs type
1469         if(f->version>0)
1470             f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1471         get_rac(c, state); //no chroma = false
1472         f->chroma_h_shift= get_symbol(c, state, 0);
1473         f->chroma_v_shift= get_symbol(c, state, 0);
1474         get_rac(c, state); //transparency plane
1475         f->plane_count= 2;
1476     }
1477
1478     if(f->colorspace==0){
1479         if(f->avctx->bits_per_raw_sample<=8){
1480             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1481             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1482             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1483             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1484             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1485             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1486             default:
1487                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1488                 return -1;
1489             }
1490         }else{
1491             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1492             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1493             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1494             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1495             default:
1496                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1497                 return -1;
1498             }
1499         }
1500     }else if(f->colorspace==1){
1501         if(f->chroma_h_shift || f->chroma_v_shift){
1502             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1503             return -1;
1504         }
1505         f->avctx->pix_fmt= PIX_FMT_RGB32;
1506     }else{
1507         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1508         return -1;
1509     }
1510
1511 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1512     if(f->version < 2){
1513         context_count= read_quant_tables(c, f->quant_table);
1514         if(context_count < 0){
1515                 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1516                 return -1;
1517         }
1518     }else{
1519         f->slice_count= get_symbol(c, state, 0);
1520         if(f->slice_count > (unsigned)MAX_SLICES)
1521             return -1;
1522     }
1523
1524     for(j=0; j<f->slice_count; j++){
1525         FFV1Context *fs= f->slice_context[j];
1526         fs->ac= f->ac;
1527
1528         if(f->version >= 2){
1529             fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1530             fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1531             fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1532             fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1533
1534             fs->slice_x /= f->num_h_slices;
1535             fs->slice_y /= f->num_v_slices;
1536             fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1537             fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1538             if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1539                 return -1;
1540             if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1541                 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1542                 return -1;
1543         }
1544
1545         for(i=0; i<f->plane_count; i++){
1546             PlaneContext * const p= &fs->plane[i];
1547
1548             if(f->version >= 2){
1549                 int idx=get_symbol(c, state, 0);
1550                 if(idx > (unsigned)f->quant_table_count){
1551                     av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1552                     return -1;
1553                 }
1554                 p->quant_table_index= idx;
1555                 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1556                 context_count= f->context_count[idx];
1557             }else{
1558                 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1559             }
1560
1561             if(p->context_count < context_count){
1562                 av_freep(&p->state);
1563                 av_freep(&p->vlc_state);
1564             }
1565             p->context_count= context_count;
1566         }
1567     }
1568
1569     return 0;
1570 }
1571
1572 static av_cold int decode_init(AVCodecContext *avctx)
1573 {
1574     FFV1Context *f = avctx->priv_data;
1575
1576     common_init(avctx);
1577
1578     if(avctx->extradata && read_extra_header(f) < 0)
1579         return -1;
1580
1581     if(init_slice_contexts(f) < 0)
1582         return -1;
1583
1584     return 0;
1585 }
1586
1587 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1588     const uint8_t *buf = avpkt->data;
1589     int buf_size = avpkt->size;
1590     FFV1Context *f = avctx->priv_data;
1591     RangeCoder * const c= &f->slice_context[0]->c;
1592     AVFrame * const p= &f->picture;
1593     int bytes_read, i;
1594     uint8_t keystate= 128;
1595     const uint8_t *buf_p;
1596
1597     AVFrame *picture = data;
1598
1599     ff_init_range_decoder(c, buf, buf_size);
1600     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1601
1602
1603     p->pict_type= FF_I_TYPE; //FIXME I vs. P
1604     if(get_rac(c, &keystate)){
1605         p->key_frame= 1;
1606         if(read_header(f) < 0)
1607             return -1;
1608         if(init_slice_state(f) < 0)
1609             return -1;
1610
1611         clear_state(f);
1612     }else{
1613         p->key_frame= 0;
1614     }
1615     if(f->ac>1){
1616         int i;
1617         for(i=1; i<256; i++){
1618             c->one_state[i]= f->state_transition[i];
1619             c->zero_state[256-i]= 256-c->one_state[i];
1620         }
1621     }
1622
1623     p->reference= 0;
1624     if(avctx->get_buffer(avctx, p) < 0){
1625         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1626         return -1;
1627     }
1628
1629     if(avctx->debug&FF_DEBUG_PICT_INFO)
1630         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1631
1632     if(!f->ac){
1633         bytes_read = c->bytestream - c->bytestream_start - 1;
1634         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1635 //printf("pos=%d\n", bytes_read);
1636         init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, buf_size - bytes_read);
1637     } else {
1638         bytes_read = 0; /* avoid warning */
1639     }
1640
1641     buf_p= buf + buf_size;
1642     for(i=f->slice_count-1; i>0; i--){
1643         FFV1Context *fs= f->slice_context[i];
1644         int v= AV_RB24(buf_p-3)+3;
1645         if(buf_p - buf <= v){
1646             av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1647             return -1;
1648         }
1649         buf_p -= v;
1650         if(fs->ac){
1651             ff_init_range_decoder(&fs->c, buf_p, v);
1652         }else{
1653             init_get_bits(&fs->gb, buf_p, v);
1654         }
1655     }
1656
1657     avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1658     f->picture_number++;
1659
1660     *picture= *p;
1661
1662     avctx->release_buffer(avctx, p); //FIXME
1663
1664     *data_size = sizeof(AVFrame);
1665
1666     return buf_size;
1667 }
1668
1669 AVCodec ffv1_decoder = {
1670     "ffv1",
1671     AVMEDIA_TYPE_VIDEO,
1672     CODEC_ID_FFV1,
1673     sizeof(FFV1Context),
1674     decode_init,
1675     NULL,
1676     common_end,
1677     decode_frame,
1678     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1679     NULL,
1680     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1681 };
1682
1683 #if CONFIG_FFV1_ENCODER
1684 AVCodec ffv1_encoder = {
1685     "ffv1",
1686     AVMEDIA_TYPE_VIDEO,
1687     CODEC_ID_FFV1,
1688     sizeof(FFV1Context),
1689     encode_init,
1690     encode_frame,
1691     common_end,
1692     .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},
1693     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1694 };
1695 #endif