git.sesse.net Git - ffmpeg/blob - libavcodec/ffv1.c

   1 /*
   2  * FFV1 codec for libavcodec
   3  *
   4  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * This file is part of 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 av_noinline void 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 av_noinline int 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     v = fold(v - state->bias, bits);
 387
 388     i= state->count;
 389     k=0;
 390     while(i < state->error_sum){ //FIXME optimize
 391         k++;
 392         i += i;
 393     }
 394
 395     assert(k<=8);
 396
 397 #if 0 // JPEG LS
 398     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
 399     else                                         code= v;
 400 #else
 401      code= v ^ ((2*state->drift + state->count)>>31);
 402 #endif
 403
 404      av_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,
 405              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     av_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d",
 425             v, state->bias, state->error_sum, state->drift, state->count, k);
 426
 427 #if 0 // JPEG LS
 428     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
 429 #else
 430      v ^= ((2*state->drift + state->count)>>31);
 431 #endif
 432
 433     ret= fold(v + state->bias, bits);
 434
 435     update_vlc_state(state, v);
 436
 437     return ret;
 438 }
 439
 440 #if CONFIG_FFV1_ENCODER
 441 static av_always_inline int encode_line(FFV1Context *s, int w,
 442                                         int16_t *sample[3],
 443                                         int plane_index, int bits)
 444 {
 445     PlaneContext * const p= &s->plane[plane_index];
 446     RangeCoder * const c= &s->c;
 447     int x;
 448     int run_index= s->run_index;
 449     int run_count=0;
 450     int run_mode=0;
 451
 452     if(s->ac){
 453         if(c->bytestream_end - c->bytestream < w*20){
 454             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 455             return -1;
 456         }
 457     }else{
 458         if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
 459             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 460             return -1;
 461         }
 462     }
 463
 464     for(x=0; x<w; x++){
 465         int diff, context;
 466
 467         context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
 468         diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
 469
 470         if(context < 0){
 471             context = -context;
 472             diff= -diff;
 473         }
 474
 475         diff= fold(diff, bits);
 476
 477         if(s->ac){
 478             if(s->flags & CODEC_FLAG_PASS1){
 479                 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
 480             }else{
 481                 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
 482             }
 483         }else{
 484             if(context == 0) run_mode=1;
 485
 486             if(run_mode){
 487
 488                 if(diff){
 489                     while(run_count >= 1<<ff_log2_run[run_index]){
 490                         run_count -= 1<<ff_log2_run[run_index];
 491                         run_index++;
 492                         put_bits(&s->pb, 1, 1);
 493                     }
 494
 495                     put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
 496                     if(run_index) run_index--;
 497                     run_count=0;
 498                     run_mode=0;
 499                     if(diff>0) diff--;
 500                 }else{
 501                     run_count++;
 502                 }
 503             }
 504
 505             av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
 506                     run_count, run_index, run_mode, x,
 507                     (int)put_bits_count(&s->pb));
 508
 509             if(run_mode == 0)
 510                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
 511         }
 512     }
 513     if(run_mode){
 514         while(run_count >= 1<<ff_log2_run[run_index]){
 515             run_count -= 1<<ff_log2_run[run_index];
 516             run_index++;
 517             put_bits(&s->pb, 1, 1);
 518         }
 519
 520         if(run_count)
 521             put_bits(&s->pb, 1, 1);
 522     }
 523     s->run_index= run_index;
 524
 525     return 0;
 526 }
 527
 528 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 529     int x,y,i;
 530     const int ring_size= s->avctx->context_model ? 3 : 2;
 531     int16_t *sample[3];
 532     s->run_index=0;
 533
 534     memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
 535
 536     for(y=0; y<h; y++){
 537         for(i=0; i<ring_size; i++)
 538             sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
 539
 540         sample[0][-1]= sample[1][0  ];
 541         sample[1][ w]= sample[1][w-1];
 542 //{START_TIMER
 543         if(s->avctx->bits_per_raw_sample<=8){
 544             for(x=0; x<w; x++){
 545                 sample[0][x]= src[x + stride*y];
 546             }
 547             encode_line(s, w, sample, plane_index, 8);
 548         }else{
 549             for(x=0; x<w; x++){
 550                 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
 551             }
 552             encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
 553         }
 554 //STOP_TIMER("encode line")}
 555     }
 556 }
 557
 558 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 559     int x, y, p, i;
 560     const int ring_size= s->avctx->context_model ? 3 : 2;
 561     int16_t *sample[3][3];
 562     s->run_index=0;
 563
 564     memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
 565
 566     for(y=0; y<h; y++){
 567         for(i=0; i<ring_size; i++)
 568             for(p=0; p<3; p++)
 569                 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
 570
 571         for(x=0; x<w; x++){
 572             int v= src[x + stride*y];
 573             int b= v&0xFF;
 574             int g= (v>>8)&0xFF;
 575             int r= (v>>16)&0xFF;
 576
 577             b -= g;
 578             r -= g;
 579             g += (b + r)>>2;
 580             b += 0x100;
 581             r += 0x100;
 582
 583 //            assert(g>=0 && b>=0 && r>=0);
 584 //            assert(g<256 && b<512 && r<512);
 585             sample[0][0][x]= g;
 586             sample[1][0][x]= b;
 587             sample[2][0][x]= r;
 588         }
 589         for(p=0; p<3; p++){
 590             sample[p][0][-1]= sample[p][1][0  ];
 591             sample[p][1][ w]= sample[p][1][w-1];
 592             encode_line(s, w, sample[p], FFMIN(p, 1), 9);
 593         }
 594     }
 595 }
 596
 597 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
 598     int last=0;
 599     int i;
 600     uint8_t state[CONTEXT_SIZE];
 601     memset(state, 128, sizeof(state));
 602
 603     for(i=1; i<128 ; i++){
 604         if(quant_table[i] != quant_table[i-1]){
 605             put_symbol(c, state, i-last-1, 0);
 606             last= i;
 607         }
 608     }
 609     put_symbol(c, state, i-last-1, 0);
 610 }
 611
 612 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
 613     int i;
 614     for(i=0; i<5; i++)
 615         write_quant_table(c, quant_table[i]);
 616 }
 617
 618 static void write_header(FFV1Context *f){
 619     uint8_t state[CONTEXT_SIZE];
 620     int i, j;
 621     RangeCoder * const c= &f->slice_context[0]->c;
 622
 623     memset(state, 128, sizeof(state));
 624
 625     if(f->version < 2){
 626         put_symbol(c, state, f->version, 0);
 627         put_symbol(c, state, f->ac, 0);
 628         if(f->ac>1){
 629             for(i=1; i<256; i++){
 630                 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 631             }
 632         }
 633         put_symbol(c, state, f->colorspace, 0); //YUV cs type
 634         if(f->version>0)
 635             put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
 636         put_rac(c, state, 1); //chroma planes
 637             put_symbol(c, state, f->chroma_h_shift, 0);
 638             put_symbol(c, state, f->chroma_v_shift, 0);
 639         put_rac(c, state, 0); //no transparency plane
 640
 641         write_quant_tables(c, f->quant_table);
 642     }else{
 643         put_symbol(c, state, f->slice_count, 0);
 644         for(i=0; i<f->slice_count; i++){
 645             FFV1Context *fs= f->slice_context[i];
 646             put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
 647             put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
 648             put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
 649             put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
 650             for(j=0; j<f->plane_count; j++){
 651                 put_symbol(c, state, f->plane[j].quant_table_index, 0);
 652                 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
 653             }
 654         }
 655     }
 656 }
 657 #endif /* CONFIG_FFV1_ENCODER */
 658
 659 static av_cold int common_init(AVCodecContext *avctx){
 660     FFV1Context *s = avctx->priv_data;
 661
 662     s->avctx= avctx;
 663     s->flags= avctx->flags;
 664
 665     ff_dsputil_init(&s->dsp, avctx);
 666
 667     s->width = avctx->width;
 668     s->height= avctx->height;
 669
 670     assert(s->width && s->height);
 671     //defaults
 672     s->num_h_slices=1;
 673     s->num_v_slices=1;
 674
 675
 676     return 0;
 677 }
 678
 679 static int init_slice_state(FFV1Context *f){
 680     int i, j;
 681
 682     for(i=0; i<f->slice_count; i++){
 683         FFV1Context *fs= f->slice_context[i];
 684         for(j=0; j<f->plane_count; j++){
 685             PlaneContext * const p= &fs->plane[j];
 686
 687             if(fs->ac){
 688                 if(!p->    state) p->    state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 689                 if(!p->    state)
 690                     return AVERROR(ENOMEM);
 691             }else{
 692                 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 693                 if(!p->vlc_state)
 694                     return AVERROR(ENOMEM);
 695             }
 696         }
 697
 698         if (fs->ac>1){
 699             //FIXME only redo if state_transition changed
 700             for(j=1; j<256; j++){
 701                 fs->c.one_state [    j]= fs->state_transition[j];
 702                 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
 703             }
 704         }
 705     }
 706
 707     return 0;
 708 }
 709
 710 static av_cold int init_slice_contexts(FFV1Context *f){
 711     int i;
 712
 713     f->slice_count= f->num_h_slices * f->num_v_slices;
 714
 715     for(i=0; i<f->slice_count; i++){
 716         FFV1Context *fs= av_mallocz(sizeof(*fs));
 717         int sx= i % f->num_h_slices;
 718         int sy= i / f->num_h_slices;
 719         int sxs= f->avctx->width * sx    / f->num_h_slices;
 720         int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
 721         int sys= f->avctx->height* sy    / f->num_v_slices;
 722         int sye= f->avctx->height*(sy+1) / f->num_v_slices;
 723         f->slice_context[i]= fs;
 724         memcpy(fs, f, sizeof(*fs));
 725         memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
 726
 727         fs->slice_width = sxe - sxs;
 728         fs->slice_height= sye - sys;
 729         fs->slice_x     = sxs;
 730         fs->slice_y     = sys;
 731
 732         fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
 733         if (!fs->sample_buffer)
 734             return AVERROR(ENOMEM);
 735     }
 736     return 0;
 737 }
 738
 739 static int allocate_initial_states(FFV1Context *f){
 740     int i;
 741
 742     for(i=0; i<f->quant_table_count; i++){
 743         f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
 744         if(!f->initial_states[i])
 745             return AVERROR(ENOMEM);
 746         memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
 747     }
 748     return 0;
 749 }
 750
 751 #if CONFIG_FFV1_ENCODER
 752 static int write_extra_header(FFV1Context *f){
 753     RangeCoder * const c= &f->c;
 754     uint8_t state[CONTEXT_SIZE];
 755     int i, j, k;
 756     uint8_t state2[32][CONTEXT_SIZE];
 757
 758     memset(state2, 128, sizeof(state2));
 759     memset(state, 128, sizeof(state));
 760
 761     f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
 762     ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
 763     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 764
 765     put_symbol(c, state, f->version, 0);
 766     put_symbol(c, state, f->ac, 0);
 767     if(f->ac>1){
 768         for(i=1; i<256; i++){
 769             put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 770         }
 771     }
 772     put_symbol(c, state, f->colorspace, 0); //YUV cs type
 773     put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
 774     put_rac(c, state, 1); //chroma planes
 775         put_symbol(c, state, f->chroma_h_shift, 0);
 776         put_symbol(c, state, f->chroma_v_shift, 0);
 777     put_rac(c, state, 0); //no transparency plane
 778     put_symbol(c, state, f->num_h_slices-1, 0);
 779     put_symbol(c, state, f->num_v_slices-1, 0);
 780
 781     put_symbol(c, state, f->quant_table_count, 0);
 782     for(i=0; i<f->quant_table_count; i++)
 783         write_quant_tables(c, f->quant_tables[i]);
 784
 785     for(i=0; i<f->quant_table_count; i++){
 786         for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
 787             if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
 788                 break;
 789         if(j<f->context_count[i]*CONTEXT_SIZE){
 790             put_rac(c, state, 1);
 791             for(j=0; j<f->context_count[i]; j++){
 792                 for(k=0; k<CONTEXT_SIZE; k++){
 793                     int pred= j ? f->initial_states[i][j-1][k] : 128;
 794                     put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
 795                 }
 796             }
 797         }else{
 798             put_rac(c, state, 0);
 799         }
 800     }
 801
 802     f->avctx->extradata_size= ff_rac_terminate(c);
 803
 804     return 0;
 805 }
 806
 807 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
 808     int i,i2,changed,print=0;
 809
 810     do{
 811         changed=0;
 812         for(i=12; i<244; i++){
 813             for(i2=i+1; i2<245 && i2<i+4; i2++){
 814 #define COST(old, new) \
 815     s->rc_stat[old][0]*-log2((256-(new))/256.0)\
 816    +s->rc_stat[old][1]*-log2(     (new) /256.0)
 817
 818 #define COST2(old, new) \
 819     COST(old, new)\
 820    +COST(256-(old), 256-(new))
 821
 822                 double size0= COST2(i, i ) + COST2(i2, i2);
 823                 double sizeX= COST2(i, i2) + COST2(i2, i );
 824                 if(sizeX < size0 && i!=128 && i2!=128){
 825                     int j;
 826                     FFSWAP(int, stt[    i], stt[    i2]);
 827                     FFSWAP(int, s->rc_stat[i    ][0],s->rc_stat[    i2][0]);
 828                     FFSWAP(int, s->rc_stat[i    ][1],s->rc_stat[    i2][1]);
 829                     if(i != 256-i2){
 830                         FFSWAP(int, stt[256-i], stt[256-i2]);
 831                         FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
 832                         FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
 833                     }
 834                     for(j=1; j<256; j++){
 835                         if     (stt[j] == i ) stt[j] = i2;
 836                         else if(stt[j] == i2) stt[j] = i ;
 837                         if(i != 256-i2){
 838                             if     (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
 839                             else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
 840                         }
 841                     }
 842                     print=changed=1;
 843                 }
 844             }
 845         }
 846     }while(changed);
 847     return print;
 848 }
 849
 850 static av_cold int encode_init(AVCodecContext *avctx)
 851 {
 852     FFV1Context *s = avctx->priv_data;
 853     int i, j, k, m;
 854
 855     common_init(avctx);
 856
 857     s->version=0;
 858     s->ac= avctx->coder_type ? 2:0;
 859
 860     if(s->ac>1)
 861         for(i=1; i<256; i++)
 862             s->state_transition[i]=ver2_state[i];
 863
 864     s->plane_count=2;
 865     for(i=0; i<256; i++){
 866         s->quant_table_count=2;
 867         if(avctx->bits_per_raw_sample <=8){
 868             s->quant_tables[0][0][i]=           quant11[i];
 869             s->quant_tables[0][1][i]=        11*quant11[i];
 870             s->quant_tables[0][2][i]=     11*11*quant11[i];
 871             s->quant_tables[1][0][i]=           quant11[i];
 872             s->quant_tables[1][1][i]=        11*quant11[i];
 873             s->quant_tables[1][2][i]=     11*11*quant5 [i];
 874             s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 875             s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
 876         }else{
 877             s->quant_tables[0][0][i]=           quant9_10bit[i];
 878             s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 879             s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 880             s->quant_tables[1][0][i]=           quant9_10bit[i];
 881             s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 882             s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 883             s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 884             s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
 885         }
 886     }
 887     s->context_count[0]= (11*11*11+1)/2;
 888     s->context_count[1]= (11*11*5*5*5+1)/2;
 889     memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
 890
 891     for(i=0; i<s->plane_count; i++){
 892         PlaneContext * const p= &s->plane[i];
 893
 894         memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 895         p->quant_table_index= avctx->context_model;
 896         p->context_count= s->context_count[p->quant_table_index];
 897     }
 898
 899     if(allocate_initial_states(s) < 0)
 900         return AVERROR(ENOMEM);
 901
 902     avctx->coded_frame= &s->picture;
 903     switch(avctx->pix_fmt){
 904     case PIX_FMT_YUV444P16:
 905     case PIX_FMT_YUV422P16:
 906     case PIX_FMT_YUV420P16:
 907         if(avctx->bits_per_raw_sample <=8){
 908             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 909             return -1;
 910         }
 911         if(!s->ac){
 912             av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
 913             return -1;
 914         }
 915         s->version= FFMAX(s->version, 1);
 916     case PIX_FMT_YUV444P:
 917     case PIX_FMT_YUV422P:
 918     case PIX_FMT_YUV420P:
 919     case PIX_FMT_YUV411P:
 920     case PIX_FMT_YUV410P:
 921         s->colorspace= 0;
 922         break;
 923     case PIX_FMT_RGB32:
 924         s->colorspace= 1;
 925         break;
 926     default:
 927         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 928         return -1;
 929     }
 930     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 931
 932     s->picture_number=0;
 933
 934     if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
 935         for(i=0; i<s->quant_table_count; i++){
 936             s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
 937             if(!s->rc_stat2[i])
 938                 return AVERROR(ENOMEM);
 939         }
 940     }
 941     if(avctx->stats_in){
 942         char *p= avctx->stats_in;
 943         uint8_t best_state[256][256];
 944         int gob_count=0;
 945         char *next;
 946
 947         av_assert0(s->version>=2);
 948
 949         for(;;){
 950             for(j=0; j<256; j++){
 951                 for(i=0; i<2; i++){
 952                     s->rc_stat[j][i]= strtol(p, &next, 0);
 953                     if(next==p){
 954                         av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
 955                         return -1;
 956                     }
 957                     p=next;
 958                 }
 959             }
 960             for(i=0; i<s->quant_table_count; i++){
 961                 for(j=0; j<s->context_count[i]; j++){
 962                     for(k=0; k<32; k++){
 963                         for(m=0; m<2; m++){
 964                             s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
 965                             if(next==p){
 966                                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
 967                                 return -1;
 968                             }
 969                             p=next;
 970                         }
 971                     }
 972                 }
 973             }
 974             gob_count= strtol(p, &next, 0);
 975             if(next==p || gob_count <0){
 976                 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
 977                 return -1;
 978             }
 979             p=next;
 980             while(*p=='\n' || *p==' ') p++;
 981             if(p[0]==0) break;
 982         }
 983         sort_stt(s, s->state_transition);
 984
 985         find_best_state(best_state, s->state_transition);
 986
 987         for(i=0; i<s->quant_table_count; i++){
 988             for(j=0; j<s->context_count[i]; j++){
 989                 for(k=0; k<32; k++){
 990                     double p= 128;
 991                     if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
 992                         p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
 993                     }
 994                     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)];
 995                 }
 996             }
 997         }
 998     }
 999
1000     if(s->version>1){
1001         s->num_h_slices=2;
1002         s->num_v_slices=2;
1003         write_extra_header(s);
1004     }
1005
1006     if(init_slice_contexts(s) < 0)
1007         return -1;
1008     if(init_slice_state(s) < 0)
1009         return -1;
1010
1011 #define STATS_OUT_SIZE 1024*1024*6
1012     if(avctx->flags & CODEC_FLAG_PASS1){
1013         avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1014         for(i=0; i<s->quant_table_count; i++){
1015             for(j=0; j<s->slice_count; j++){
1016                 FFV1Context *sf= s->slice_context[j];
1017                 av_assert0(!sf->rc_stat2[i]);
1018                 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1019                 if(!sf->rc_stat2[i])
1020                     return AVERROR(ENOMEM);
1021             }
1022         }
1023     }
1024
1025     return 0;
1026 }
1027 #endif /* CONFIG_FFV1_ENCODER */
1028
1029
1030 static void clear_state(FFV1Context *f){
1031     int i, si, j;
1032
1033     for(si=0; si<f->slice_count; si++){
1034         FFV1Context *fs= f->slice_context[si];
1035         for(i=0; i<f->plane_count; i++){
1036             PlaneContext *p= &fs->plane[i];
1037
1038             p->interlace_bit_state[0]= 128;
1039             p->interlace_bit_state[1]= 128;
1040
1041             if(fs->ac){
1042                 if(f->initial_states[p->quant_table_index]){
1043                     memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1044                 }else
1045                 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1046             }else{
1047             for(j=0; j<p->context_count; j++){
1048                     p->vlc_state[j].drift= 0;
1049                     p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1050                     p->vlc_state[j].bias= 0;
1051                     p->vlc_state[j].count= 1;
1052             }
1053             }
1054         }
1055     }
1056 }
1057
1058 #if CONFIG_FFV1_ENCODER
1059 static int encode_slice(AVCodecContext *c, void *arg){
1060     FFV1Context *fs= *(void**)arg;
1061     FFV1Context *f= fs->avctx->priv_data;
1062     int width = fs->slice_width;
1063     int height= fs->slice_height;
1064     int x= fs->slice_x;
1065     int y= fs->slice_y;
1066     AVFrame * const p= &f->picture;
1067
1068     if(f->colorspace==0){
1069         const int chroma_width = -((-width )>>f->chroma_h_shift);
1070         const int chroma_height= -((-height)>>f->chroma_v_shift);
1071         const int cx= x>>f->chroma_h_shift;
1072         const int cy= y>>f->chroma_v_shift;
1073
1074         encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1075
1076         encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1077         encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1078     }else{
1079         encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1080     }
1081     emms_c();
1082
1083     return 0;
1084 }
1085
1086 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1087                         const AVFrame *pict, int *got_packet)
1088 {
1089     FFV1Context *f = avctx->priv_data;
1090     RangeCoder * const c= &f->slice_context[0]->c;
1091     AVFrame * const p= &f->picture;
1092     int used_count= 0;
1093     uint8_t keystate=128;
1094     uint8_t *buf_p;
1095     int i, ret;
1096
1097     if (!pkt->data &&
1098         (ret = av_new_packet(pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8
1099                                   + FF_MIN_BUFFER_SIZE)) < 0) {
1100         av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
1101         return ret;
1102     }
1103
1104     ff_init_range_encoder(c, pkt->data, pkt->size);
1105     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1106
1107     *p = *pict;
1108     p->pict_type= AV_PICTURE_TYPE_I;
1109
1110     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1111         put_rac(c, &keystate, 1);
1112         p->key_frame= 1;
1113         f->gob_count++;
1114         write_header(f);
1115         clear_state(f);
1116     }else{
1117         put_rac(c, &keystate, 0);
1118         p->key_frame= 0;
1119     }
1120
1121     if(!f->ac){
1122         used_count += ff_rac_terminate(c);
1123         init_put_bits(&f->slice_context[0]->pb, pkt->data + used_count, pkt->size - used_count);
1124     }else if (f->ac>1){
1125         int i;
1126         for(i=1; i<256; i++){
1127             c->one_state[i]= f->state_transition[i];
1128             c->zero_state[256-i]= 256-c->one_state[i];
1129         }
1130     }
1131
1132     for(i=1; i<f->slice_count; i++){
1133         FFV1Context *fs= f->slice_context[i];
1134         uint8_t *start = pkt->data + (pkt->size-used_count)*i/f->slice_count;
1135         int len = pkt->size/f->slice_count;
1136
1137         if(fs->ac){
1138             ff_init_range_encoder(&fs->c, start, len);
1139         }else{
1140             init_put_bits(&fs->pb, start, len);
1141         }
1142     }
1143     avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1144
1145     buf_p = pkt->data;
1146     for(i=0; i<f->slice_count; i++){
1147         FFV1Context *fs= f->slice_context[i];
1148         int bytes;
1149
1150         if(fs->ac){
1151             uint8_t state=128;
1152             put_rac(&fs->c, &state, 0);
1153             bytes= ff_rac_terminate(&fs->c);
1154         }else{
1155             flush_put_bits(&fs->pb); //nicer padding FIXME
1156             bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1157             used_count= 0;
1158         }
1159         if(i>0){
1160             av_assert0(bytes < pkt->size/f->slice_count);
1161             memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1162             av_assert0(bytes < (1<<24));
1163             AV_WB24(buf_p+bytes, bytes);
1164             bytes+=3;
1165         }
1166         buf_p += bytes;
1167     }
1168
1169     if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1170         int j, k, m;
1171         char *p= avctx->stats_out;
1172         char *end= p + STATS_OUT_SIZE;
1173
1174         memset(f->rc_stat, 0, sizeof(f->rc_stat));
1175         for(i=0; i<f->quant_table_count; i++)
1176             memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1177
1178         for(j=0; j<f->slice_count; j++){
1179             FFV1Context *fs= f->slice_context[j];
1180             for(i=0; i<256; i++){
1181                 f->rc_stat[i][0] += fs->rc_stat[i][0];
1182                 f->rc_stat[i][1] += fs->rc_stat[i][1];
1183             }
1184             for(i=0; i<f->quant_table_count; i++){
1185                 for(k=0; k<f->context_count[i]; k++){
1186                     for(m=0; m<32; m++){
1187                         f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1188                         f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1189                     }
1190                 }
1191             }
1192         }
1193
1194         for(j=0; j<256; j++){
1195             snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1196             p+= strlen(p);
1197         }
1198         snprintf(p, end-p, "\n");
1199
1200         for(i=0; i<f->quant_table_count; i++){
1201             for(j=0; j<f->context_count[i]; j++){
1202                 for(m=0; m<32; m++){
1203                     snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1204                     p+= strlen(p);
1205                 }
1206             }
1207         }
1208         snprintf(p, end-p, "%d\n", f->gob_count);
1209     } else if(avctx->flags&CODEC_FLAG_PASS1)
1210         avctx->stats_out[0] = '\0';
1211
1212     f->picture_number++;
1213     pkt->size   = buf_p - pkt->data;
1214     pkt->flags |= AV_PKT_FLAG_KEY*p->key_frame;
1215     *got_packet = 1;
1216
1217     return 0;
1218 }
1219 #endif /* CONFIG_FFV1_ENCODER */
1220
1221 static av_cold int common_end(AVCodecContext *avctx){
1222     FFV1Context *s = avctx->priv_data;
1223     int i, j;
1224
1225     if (avctx->codec->decode && s->picture.data[0])
1226         avctx->release_buffer(avctx, &s->picture);
1227
1228     for(j=0; j<s->slice_count; j++){
1229         FFV1Context *fs= s->slice_context[j];
1230         for(i=0; i<s->plane_count; i++){
1231             PlaneContext *p= &fs->plane[i];
1232
1233             av_freep(&p->state);
1234             av_freep(&p->vlc_state);
1235         }
1236         av_freep(&fs->sample_buffer);
1237     }
1238
1239     av_freep(&avctx->stats_out);
1240     for(j=0; j<s->quant_table_count; j++){
1241         av_freep(&s->initial_states[j]);
1242         for(i=0; i<s->slice_count; i++){
1243             FFV1Context *sf= s->slice_context[i];
1244             av_freep(&sf->rc_stat2[j]);
1245         }
1246         av_freep(&s->rc_stat2[j]);
1247     }
1248
1249     for(i=0; i<s->slice_count; i++){
1250         av_freep(&s->slice_context[i]);
1251     }
1252
1253     return 0;
1254 }
1255
1256 static av_always_inline void decode_line(FFV1Context *s, int w,
1257                                          int16_t *sample[2],
1258                                          int plane_index, int bits)
1259 {
1260     PlaneContext * const p= &s->plane[plane_index];
1261     RangeCoder * const c= &s->c;
1262     int x;
1263     int run_count=0;
1264     int run_mode=0;
1265     int run_index= s->run_index;
1266
1267     for(x=0; x<w; x++){
1268         int diff, context, sign;
1269
1270         context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1271         if(context < 0){
1272             context= -context;
1273             sign=1;
1274         }else
1275             sign=0;
1276
1277         av_assert2(context < p->context_count);
1278
1279         if(s->ac){
1280             diff= get_symbol_inline(c, p->state[context], 1);
1281         }else{
1282             if(context == 0 && run_mode==0) run_mode=1;
1283
1284             if(run_mode){
1285                 if(run_count==0 && run_mode==1){
1286                     if(get_bits1(&s->gb)){
1287                         run_count = 1<<ff_log2_run[run_index];
1288                         if(x + run_count <= w) run_index++;
1289                     }else{
1290                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1291                         else run_count=0;
1292                         if(run_index) run_index--;
1293                         run_mode=2;
1294                     }
1295                 }
1296                 run_count--;
1297                 if(run_count < 0){
1298                     run_mode=0;
1299                     run_count=0;
1300                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1301                     if(diff>=0) diff++;
1302                 }else
1303                     diff=0;
1304             }else
1305                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1306
1307             av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",
1308                     run_count, run_index, run_mode, x, get_bits_count(&s->gb));
1309         }
1310
1311         if(sign) diff= -diff;
1312
1313         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1314     }
1315     s->run_index= run_index;
1316 }
1317
1318 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1319     int x, y;
1320     int16_t *sample[2];
1321     sample[0]=s->sample_buffer    +3;
1322     sample[1]=s->sample_buffer+w+6+3;
1323
1324     s->run_index=0;
1325
1326     memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1327
1328     for(y=0; y<h; y++){
1329         int16_t *temp = sample[0]; //FIXME try a normal buffer
1330
1331         sample[0]= sample[1];
1332         sample[1]= temp;
1333
1334         sample[1][-1]= sample[0][0  ];
1335         sample[0][ w]= sample[0][w-1];
1336
1337 //{START_TIMER
1338         if(s->avctx->bits_per_raw_sample <= 8){
1339             decode_line(s, w, sample, plane_index, 8);
1340             for(x=0; x<w; x++){
1341                 src[x + stride*y]= sample[1][x];
1342             }
1343         }else{
1344             decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1345             for(x=0; x<w; x++){
1346                 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1347             }
1348         }
1349 //STOP_TIMER("decode-line")}
1350     }
1351 }
1352
1353 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1354     int x, y, p;
1355     int16_t *sample[3][2];
1356     for(x=0; x<3; x++){
1357         sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1358         sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1359     }
1360
1361     s->run_index=0;
1362
1363     memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1364
1365     for(y=0; y<h; y++){
1366         for(p=0; p<3; p++){
1367             int16_t *temp = sample[p][0]; //FIXME try a normal buffer
1368
1369             sample[p][0]= sample[p][1];
1370             sample[p][1]= temp;
1371
1372             sample[p][1][-1]= sample[p][0][0  ];
1373             sample[p][0][ w]= sample[p][0][w-1];
1374             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1375         }
1376         for(x=0; x<w; x++){
1377             int g= sample[0][1][x];
1378             int b= sample[1][1][x];
1379             int r= sample[2][1][x];
1380
1381 //            assert(g>=0 && b>=0 && r>=0);
1382 //            assert(g<256 && b<512 && r<512);
1383
1384             b -= 0x100;
1385             r -= 0x100;
1386             g -= (b + r)>>2;
1387             b += g;
1388             r += g;
1389
1390             src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1391         }
1392     }
1393 }
1394
1395 static int decode_slice(AVCodecContext *c, void *arg){
1396     FFV1Context *fs= *(void**)arg;
1397     FFV1Context *f= fs->avctx->priv_data;
1398     int width = fs->slice_width;
1399     int height= fs->slice_height;
1400     int x= fs->slice_x;
1401     int y= fs->slice_y;
1402     AVFrame * const p= &f->picture;
1403
1404     av_assert1(width && height);
1405     if(f->colorspace==0){
1406         const int chroma_width = -((-width )>>f->chroma_h_shift);
1407         const int chroma_height= -((-height)>>f->chroma_v_shift);
1408         const int cx= x>>f->chroma_h_shift;
1409         const int cy= y>>f->chroma_v_shift;
1410         decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1411
1412         decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1413         decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1414     }else{
1415         decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1416     }
1417
1418     emms_c();
1419
1420     return 0;
1421 }
1422
1423 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1424     int v;
1425     int i=0;
1426     uint8_t state[CONTEXT_SIZE];
1427
1428     memset(state, 128, sizeof(state));
1429
1430     for(v=0; i<128 ; v++){
1431         int len= get_symbol(c, state, 0) + 1;
1432
1433         if(len + i > 128) return -1;
1434
1435         while(len--){
1436             quant_table[i] = scale*v;
1437             i++;
1438         }
1439     }
1440
1441     for(i=1; i<128; i++){
1442         quant_table[256-i]= -quant_table[i];
1443     }
1444     quant_table[128]= -quant_table[127];
1445
1446     return 2*v - 1;
1447 }
1448
1449 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1450     int i;
1451     int context_count=1;
1452
1453     for(i=0; i<5; i++){
1454         context_count*= read_quant_table(c, quant_table[i], context_count);
1455         if(context_count > 32768U){
1456             return -1;
1457         }
1458     }
1459     return (context_count+1)/2;
1460 }
1461
1462 static int read_extra_header(FFV1Context *f){
1463     RangeCoder * const c= &f->c;
1464     uint8_t state[CONTEXT_SIZE];
1465     int i, j, k;
1466     uint8_t state2[32][CONTEXT_SIZE];
1467
1468     memset(state2, 128, sizeof(state2));
1469     memset(state, 128, sizeof(state));
1470
1471     ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1472     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1473
1474     f->version= get_symbol(c, state, 0);
1475     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1476     if(f->ac>1){
1477         for(i=1; i<256; i++){
1478             f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1479         }
1480     }
1481     f->colorspace= get_symbol(c, state, 0); //YUV cs type
1482     f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1483     get_rac(c, state); //no chroma = false
1484     f->chroma_h_shift= get_symbol(c, state, 0);
1485     f->chroma_v_shift= get_symbol(c, state, 0);
1486     get_rac(c, state); //transparency plane
1487     f->plane_count= 2;
1488     f->num_h_slices= 1 + get_symbol(c, state, 0);
1489     f->num_v_slices= 1 + get_symbol(c, state, 0);
1490     if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1491         av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1492         return -1;
1493     }
1494
1495     f->quant_table_count= get_symbol(c, state, 0);
1496     if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1497         return -1;
1498     for(i=0; i<f->quant_table_count; i++){
1499         if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1500             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1501             return -1;
1502         }
1503     }
1504
1505     if(allocate_initial_states(f) < 0)
1506         return AVERROR(ENOMEM);
1507
1508     for(i=0; i<f->quant_table_count; i++){
1509         if(get_rac(c, state)){
1510             for(j=0; j<f->context_count[i]; j++){
1511                 for(k=0; k<CONTEXT_SIZE; k++){
1512                     int pred= j ? f->initial_states[i][j-1][k] : 128;
1513                     f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1514                 }
1515             }
1516         }
1517     }
1518
1519     return 0;
1520 }
1521
1522 static int read_header(FFV1Context *f){
1523     uint8_t state[CONTEXT_SIZE];
1524     int i, j, context_count;
1525     RangeCoder * const c= &f->slice_context[0]->c;
1526
1527     memset(state, 128, sizeof(state));
1528
1529     if(f->version < 2){
1530         f->version= get_symbol(c, state, 0);
1531         f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1532         if(f->ac>1){
1533             for(i=1; i<256; i++){
1534                 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1535             }
1536         }
1537         f->colorspace= get_symbol(c, state, 0); //YUV cs type
1538         if(f->version>0)
1539             f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1540         get_rac(c, state); //no chroma = false
1541         f->chroma_h_shift= get_symbol(c, state, 0);
1542         f->chroma_v_shift= get_symbol(c, state, 0);
1543         get_rac(c, state); //transparency plane
1544         f->plane_count= 2;
1545     }
1546
1547     if(f->colorspace==0){
1548         if(f->avctx->bits_per_raw_sample<=8){
1549             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1550             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1551             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1552             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1553             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1554             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1555             default:
1556                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1557                 return -1;
1558             }
1559         }else{
1560             switch(16*f->chroma_h_shift + f->chroma_v_shift){
1561             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1562             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1563             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1564             default:
1565                 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1566                 return -1;
1567             }
1568         }
1569     }else if(f->colorspace==1){
1570         if(f->chroma_h_shift || f->chroma_v_shift){
1571             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1572             return -1;
1573         }
1574         f->avctx->pix_fmt= PIX_FMT_RGB32;
1575     }else{
1576         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1577         return -1;
1578     }
1579
1580     av_dlog(f->avctx, "%d %d %d\n",
1581             f->chroma_h_shift, f->chroma_v_shift, f->avctx->pix_fmt);
1582     if(f->version < 2){
1583         context_count= read_quant_tables(c, f->quant_table);
1584         if(context_count < 0){
1585                 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1586                 return -1;
1587         }
1588     }else{
1589         f->slice_count= get_symbol(c, state, 0);
1590         if(f->slice_count > (unsigned)MAX_SLICES)
1591             return -1;
1592     }
1593
1594     for(j=0; j<f->slice_count; j++){
1595         FFV1Context *fs= f->slice_context[j];
1596         fs->ac= f->ac;
1597
1598         if(f->version >= 2){
1599             fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1600             fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1601             fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1602             fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1603
1604             fs->slice_x /= f->num_h_slices;
1605             fs->slice_y /= f->num_v_slices;
1606             fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1607             fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1608             if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1609                 return -1;
1610             if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1611                 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1612                 return -1;
1613         }
1614
1615         for(i=0; i<f->plane_count; i++){
1616             PlaneContext * const p= &fs->plane[i];
1617
1618             if(f->version >= 2){
1619                 int idx=get_symbol(c, state, 0);
1620                 if(idx > (unsigned)f->quant_table_count){
1621                     av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1622                     return -1;
1623                 }
1624                 p->quant_table_index= idx;
1625                 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1626                 context_count= f->context_count[idx];
1627             }else{
1628                 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1629             }
1630
1631             if(p->context_count < context_count){
1632                 av_freep(&p->state);
1633                 av_freep(&p->vlc_state);
1634             }
1635             p->context_count= context_count;
1636         }
1637     }
1638
1639     return 0;
1640 }
1641
1642 static av_cold int decode_init(AVCodecContext *avctx)
1643 {
1644     FFV1Context *f = avctx->priv_data;
1645
1646     common_init(avctx);
1647
1648     if(avctx->extradata && read_extra_header(f) < 0)
1649         return -1;
1650
1651     if(init_slice_contexts(f) < 0)
1652         return -1;
1653
1654     return 0;
1655 }
1656
1657 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1658     const uint8_t *buf = avpkt->data;
1659     int buf_size = avpkt->size;
1660     FFV1Context *f = avctx->priv_data;
1661     RangeCoder * const c= &f->slice_context[0]->c;
1662     AVFrame * const p= &f->picture;
1663     int bytes_read, i;
1664     uint8_t keystate= 128;
1665     const uint8_t *buf_p;
1666
1667     AVFrame *picture = data;
1668
1669     /* release previously stored data */
1670     if (p->data[0])
1671         avctx->release_buffer(avctx, p);
1672
1673     ff_init_range_decoder(c, buf, buf_size);
1674     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1675
1676
1677     p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
1678     if(get_rac(c, &keystate)){
1679         p->key_frame= 1;
1680         if(read_header(f) < 0)
1681             return -1;
1682         if(init_slice_state(f) < 0)
1683             return -1;
1684
1685         clear_state(f);
1686     }else{
1687         p->key_frame= 0;
1688     }
1689     if(f->ac>1){
1690         int i;
1691         for(i=1; i<256; i++){
1692             c->one_state[i]= f->state_transition[i];
1693             c->zero_state[256-i]= 256-c->one_state[i];
1694         }
1695     }
1696
1697     p->reference= 0;
1698     if(avctx->get_buffer(avctx, p) < 0){
1699         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1700         return -1;
1701     }
1702
1703     if(avctx->debug&FF_DEBUG_PICT_INFO)
1704         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1705
1706     if(!f->ac){
1707         bytes_read = c->bytestream - c->bytestream_start - 1;
1708         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1709         init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
1710     } else {
1711         bytes_read = 0; /* avoid warning */
1712     }
1713
1714     buf_p= buf + buf_size;
1715     for(i=f->slice_count-1; i>0; i--){
1716         FFV1Context *fs= f->slice_context[i];
1717         int v= AV_RB24(buf_p-3)+3;
1718         if(buf_p - buf <= v){
1719             av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1720             return -1;
1721         }
1722         buf_p -= v;
1723         if(fs->ac){
1724             ff_init_range_decoder(&fs->c, buf_p, v);
1725         }else{
1726             init_get_bits(&fs->gb, buf_p, v * 8);
1727         }
1728     }
1729
1730     avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1731     f->picture_number++;
1732
1733     *picture= *p;
1734     *data_size = sizeof(AVFrame);
1735
1736     return buf_size;
1737 }
1738
1739 AVCodec ff_ffv1_decoder = {
1740     .name           = "ffv1",
1741     .type           = AVMEDIA_TYPE_VIDEO,
1742     .id             = AV_CODEC_ID_FFV1,
1743     .priv_data_size = sizeof(FFV1Context),
1744     .init           = decode_init,
1745     .close          = common_end,
1746     .decode         = decode_frame,
1747     .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ |
1748                       CODEC_CAP_SLICE_THREADS,
1749     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1750 };
1751
1752 #if CONFIG_FFV1_ENCODER
1753 AVCodec ff_ffv1_encoder = {
1754     .name           = "ffv1",
1755     .type           = AVMEDIA_TYPE_VIDEO,
1756     .id             = AV_CODEC_ID_FFV1,
1757     .priv_data_size = sizeof(FFV1Context),
1758     .init           = encode_init,
1759     .encode2        = encode_frame,
1760     .close          = common_end,
1761     .capabilities   = CODEC_CAP_SLICE_THREADS,
1762     .pix_fmts       = (const enum PixelFormat[]){
1763         PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P,
1764         PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16,
1765         PIX_FMT_YUV444P16, PIX_FMT_NONE
1766     },
1767     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1768 };
1769 #endif