libavcodec/ffv1.c

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