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