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

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