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 library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 /**
  23  * @file ffv1.c
  24  * FF Video Codec 1 (an experimental lossless codec)
  25  */
  26
  27 #include "common.h"
  28 #include "avcodec.h"
  29 #include "dsputil.h"
  30 #include "rangecoder.h"
  31 #include "golomb.h"
  32
  33 #define MAX_PLANES 4
  34 #define CONTEXT_SIZE 32
  35
  36 static const int8_t quant3[256]={
  37  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  38  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  39  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  40  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  41  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  42  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  43  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  44  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  45 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  46 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  47 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  48 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  49 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  50 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  51 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
  52 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
  53 };
  54 static const int8_t quant5[256]={
  55  0, 1, 1, 1, 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, 2,
  61  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  62  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  63 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  64 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  65 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  66 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  67 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  68 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  69 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  70 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
  71 };
  72 static const int8_t quant7[256]={
  73  0, 1, 1, 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, 3, 3, 3, 3, 3, 3, 3, 3,
  76  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  77  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  78  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  79  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  80  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  81 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  82 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  83 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  84 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  85 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
  86 -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
  87 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
  88 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
  89 };
  90 static const int8_t quant9[256]={
  91  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  92  3, 3, 3, 3, 3, 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, 4, 4, 4, 4, 4, 4, 4,
  99 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 100 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 101 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 102 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 103 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-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,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
 106 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
 107 };
 108 static const int8_t quant11[256]={
 109  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
 110  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
 111  4, 4, 4, 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,-5,-5,
 119 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 120 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 121 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 122 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
 123 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
 124 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
 125 };
 126 static const int8_t quant13[256]={
 127  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
 128  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 129  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
 130  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 131  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 132  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 133  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 134  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
 135 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 136 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 137 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 138 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
 139 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
 140 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 141 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
 142 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
 143 };
 144
 145 static const uint8_t log2_run[32]={
 146  0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
 147  4, 4, 5, 5, 6, 6, 7, 7,
 148  8, 9,10,11,12,13,14,15,
 149 };
 150
 151 typedef struct VlcState{
 152     int16_t drift;
 153     uint16_t error_sum;
 154     int8_t bias;
 155     uint8_t count;
 156 } VlcState;
 157
 158 typedef struct PlaneContext{
 159     int context_count;
 160     uint8_t (*state)[CONTEXT_SIZE];
 161     VlcState *vlc_state;
 162     uint8_t interlace_bit_state[2];
 163 } PlaneContext;
 164
 165 typedef struct FFV1Context{
 166     AVCodecContext *avctx;
 167     RangeCoder c;
 168     GetBitContext gb;
 169     PutBitContext pb;
 170     int version;
 171     int width, height;
 172     int chroma_h_shift, chroma_v_shift;
 173     int flags;
 174     int picture_number;
 175     AVFrame picture;
 176     int plane_count;
 177     int ac;                              ///< 1-> CABAC 0-> golomb rice
 178     PlaneContext plane[MAX_PLANES];
 179     int16_t quant_table[5][256];
 180     int run_index;
 181     int colorspace;
 182
 183     DSPContext dsp;
 184 }FFV1Context;
 185
 186 static always_inline int fold(int diff, int bits){
 187     if(bits==8)
 188         diff= (int8_t)diff;
 189     else{
 190         diff+= 1<<(bits-1);
 191         diff&=(1<<bits)-1;
 192         diff-= 1<<(bits-1);
 193     }
 194
 195     return diff;
 196 }
 197
 198 static inline int predict(int_fast16_t *src, int_fast16_t *last){
 199     const int LT= last[-1];
 200     const int  T= last[ 0];
 201     const int L =  src[-1];
 202
 203     return mid_pred(L, L + T - LT, T);
 204 }
 205
 206 static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
 207     const int LT= last[-1];
 208     const int  T= last[ 0];
 209     const int RT= last[ 1];
 210     const int L =  src[-1];
 211
 212     if(f->quant_table[3][127]){
 213         const int TT= last2[0];
 214         const int LL=  src[-2];
 215         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
 216               +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
 217     }else
 218         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
 219 }
 220
 221 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
 222     int i;
 223
 224     if(v){
 225         const int a= ABS(v);
 226         const int e= av_log2(a);
 227         put_rac(c, state+0, 0);
 228
 229         assert(e<=9);
 230
 231         for(i=0; i<e; i++){
 232             put_rac(c, state+1+i, 1);  //1..10
 233         }
 234         put_rac(c, state+1+i, 0);
 235
 236         for(i=e-1; i>=0; i--){
 237             put_rac(c, state+22+i, (a>>i)&1); //22..31
 238         }
 239
 240         if(is_signed)
 241             put_rac(c, state+11 + e, v < 0); //11..21
 242     }else{
 243         put_rac(c, state+0, 1);
 244     }
 245 }
 246
 247 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
 248     if(get_rac(c, state+0))
 249         return 0;
 250     else{
 251         int i, e, a;
 252         e= 0;
 253         while(get_rac(c, state+1 + e)){ //1..10
 254             e++;
 255         }
 256         assert(e<=9);
 257
 258         a= 1;
 259         for(i=e-1; i>=0; i--){
 260             a += a + get_rac(c, state+22 + i); //22..31
 261         }
 262
 263         if(is_signed && get_rac(c, state+11 + e)) //11..21
 264             return -a;
 265         else
 266             return a;
 267     }
 268 }
 269
 270 static inline void update_vlc_state(VlcState * const state, const int v){
 271     int drift= state->drift;
 272     int count= state->count;
 273     state->error_sum += ABS(v);
 274     drift += v;
 275
 276     if(count == 128){ //FIXME variable
 277         count >>= 1;
 278         drift >>= 1;
 279         state->error_sum >>= 1;
 280     }
 281     count++;
 282
 283     if(drift <= -count){
 284         if(state->bias > -128) state->bias--;
 285
 286         drift += count;
 287         if(drift <= -count)
 288             drift= -count + 1;
 289     }else if(drift > 0){
 290         if(state->bias <  127) state->bias++;
 291
 292         drift -= count;
 293         if(drift > 0)
 294             drift= 0;
 295     }
 296
 297     state->drift= drift;
 298     state->count= count;
 299 }
 300
 301 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
 302     int i, k, code;
 303 //printf("final: %d ", v);
 304     v = fold(v - state->bias, bits);
 305
 306     i= state->count;
 307     k=0;
 308     while(i < state->error_sum){ //FIXME optimize
 309         k++;
 310         i += i;
 311     }
 312
 313     assert(k<=8);
 314
 315 #if 0 // JPEG LS
 316     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
 317     else                                         code= v;
 318 #else
 319      code= v ^ ((2*state->drift + state->count)>>31);
 320 #endif
 321
 322 //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);
 323     set_sr_golomb(pb, code, k, 12, bits);
 324
 325     update_vlc_state(state, v);
 326 }
 327
 328 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
 329     int k, i, v, ret;
 330
 331     i= state->count;
 332     k=0;
 333     while(i < state->error_sum){ //FIXME optimize
 334         k++;
 335         i += i;
 336     }
 337
 338     assert(k<=8);
 339
 340     v= get_sr_golomb(gb, k, 12, bits);
 341 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
 342
 343 #if 0 // JPEG LS
 344     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
 345 #else
 346      v ^= ((2*state->drift + state->count)>>31);
 347 #endif
 348
 349     ret= fold(v + state->bias, bits);
 350
 351     update_vlc_state(state, v);
 352 //printf("final: %d\n", ret);
 353     return ret;
 354 }
 355
 356 static inline void encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
 357     PlaneContext * const p= &s->plane[plane_index];
 358     RangeCoder * const c= &s->c;
 359     int x;
 360     int run_index= s->run_index;
 361     int run_count=0;
 362     int run_mode=0;
 363
 364     for(x=0; x<w; x++){
 365         int diff, context;
 366
 367         context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
 368         diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
 369
 370         if(context < 0){
 371             context = -context;
 372             diff= -diff;
 373         }
 374
 375         diff= fold(diff, bits);
 376
 377         if(s->ac){
 378             put_symbol(c, p->state[context], diff, 1);
 379         }else{
 380             if(context == 0) run_mode=1;
 381
 382             if(run_mode){
 383
 384                 if(diff){
 385                     while(run_count >= 1<<log2_run[run_index]){
 386                         run_count -= 1<<log2_run[run_index];
 387                         run_index++;
 388                         put_bits(&s->pb, 1, 1);
 389                     }
 390
 391                     put_bits(&s->pb, 1 + log2_run[run_index], run_count);
 392                     if(run_index) run_index--;
 393                     run_count=0;
 394                     run_mode=0;
 395                     if(diff>0) diff--;
 396                 }else{
 397                     run_count++;
 398                 }
 399             }
 400
 401 //            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));
 402
 403             if(run_mode == 0)
 404                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
 405         }
 406     }
 407     if(run_mode){
 408         while(run_count >= 1<<log2_run[run_index]){
 409             run_count -= 1<<log2_run[run_index];
 410             run_index++;
 411             put_bits(&s->pb, 1, 1);
 412         }
 413
 414         if(run_count)
 415             put_bits(&s->pb, 1, 1);
 416     }
 417     s->run_index= run_index;
 418 }
 419
 420 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 421     int x,y,i;
 422     const int ring_size= s->avctx->context_model ? 3 : 2;
 423     int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
 424     s->run_index=0;
 425
 426     memset(sample_buffer, 0, sizeof(sample_buffer));
 427
 428     for(y=0; y<h; y++){
 429         for(i=0; i<ring_size; i++)
 430             sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
 431
 432         sample[0][-1]= sample[1][0  ];
 433         sample[1][ w]= sample[1][w-1];
 434 //{START_TIMER
 435         for(x=0; x<w; x++){
 436             sample[0][x]= src[x + stride*y];
 437         }
 438         encode_line(s, w, sample, plane_index, 8);
 439 //STOP_TIMER("encode line")}
 440     }
 441 }
 442
 443 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 444     int x, y, p, i;
 445     const int ring_size= s->avctx->context_model ? 3 : 2;
 446     int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
 447     s->run_index=0;
 448
 449     memset(sample_buffer, 0, sizeof(sample_buffer));
 450
 451     for(y=0; y<h; y++){
 452         for(i=0; i<ring_size; i++)
 453             for(p=0; p<3; p++)
 454                 sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
 455
 456         for(x=0; x<w; x++){
 457             int v= src[x + stride*y];
 458             int b= v&0xFF;
 459             int g= (v>>8)&0xFF;
 460             int r= (v>>16)&0xFF;
 461
 462             b -= g;
 463             r -= g;
 464             g += (b + r)>>2;
 465             b += 0x100;
 466             r += 0x100;
 467
 468 //            assert(g>=0 && b>=0 && r>=0);
 469 //            assert(g<256 && b<512 && r<512);
 470             sample[0][0][x]= g;
 471             sample[1][0][x]= b;
 472             sample[2][0][x]= r;
 473         }
 474         for(p=0; p<3; p++){
 475             sample[p][0][-1]= sample[p][1][0  ];
 476             sample[p][1][ w]= sample[p][1][w-1];
 477             encode_line(s, w, sample[p], FFMIN(p, 1), 9);
 478         }
 479     }
 480 }
 481
 482 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
 483     int last=0;
 484     int i;
 485     uint8_t state[CONTEXT_SIZE];
 486     memset(state, 128, sizeof(state));
 487
 488     for(i=1; i<128 ; i++){
 489         if(quant_table[i] != quant_table[i-1]){
 490             put_symbol(c, state, i-last-1, 0);
 491             last= i;
 492         }
 493     }
 494     put_symbol(c, state, i-last-1, 0);
 495 }
 496
 497 static void write_header(FFV1Context *f){
 498     uint8_t state[CONTEXT_SIZE];
 499     int i;
 500     RangeCoder * const c= &f->c;
 501
 502     memset(state, 128, sizeof(state));
 503
 504     put_symbol(c, state, f->version, 0);
 505     put_symbol(c, state, f->avctx->coder_type, 0);
 506     put_symbol(c, state, f->colorspace, 0); //YUV cs type
 507     put_rac(c, state, 1); //chroma planes
 508         put_symbol(c, state, f->chroma_h_shift, 0);
 509         put_symbol(c, state, f->chroma_v_shift, 0);
 510     put_rac(c, state, 0); //no transparency plane
 511
 512     for(i=0; i<5; i++)
 513         write_quant_table(c, f->quant_table[i]);
 514 }
 515
 516 static int common_init(AVCodecContext *avctx){
 517     FFV1Context *s = avctx->priv_data;
 518     int width, height;
 519
 520     s->avctx= avctx;
 521     s->flags= avctx->flags;
 522
 523     dsputil_init(&s->dsp, avctx);
 524
 525     width= s->width= avctx->width;
 526     height= s->height= avctx->height;
 527
 528     assert(width && height);
 529
 530     return 0;
 531 }
 532
 533 static int encode_init(AVCodecContext *avctx)
 534 {
 535     FFV1Context *s = avctx->priv_data;
 536     int i;
 537
 538     if(avctx->strict_std_compliance >= 0){
 539         av_log(avctx, AV_LOG_ERROR, "this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"
 540                "use vstrict=-1 to use it anyway\n");
 541         return -1;
 542     }
 543
 544     common_init(avctx);
 545
 546     s->version=0;
 547     s->ac= avctx->coder_type;
 548
 549     s->plane_count=2;
 550     for(i=0; i<256; i++){
 551         s->quant_table[0][i]=           quant11[i];
 552         s->quant_table[1][i]=        11*quant11[i];
 553         if(avctx->context_model==0){
 554             s->quant_table[2][i]=     11*11*quant11[i];
 555             s->quant_table[3][i]=
 556             s->quant_table[4][i]=0;
 557         }else{
 558             s->quant_table[2][i]=     11*11*quant5 [i];
 559             s->quant_table[3][i]=   5*11*11*quant5 [i];
 560             s->quant_table[4][i]= 5*5*11*11*quant5 [i];
 561         }
 562     }
 563
 564     for(i=0; i<s->plane_count; i++){
 565         PlaneContext * const p= &s->plane[i];
 566
 567         if(avctx->context_model==0){
 568             p->context_count= (11*11*11+1)/2;
 569         }else{
 570             p->context_count= (11*11*5*5*5+1)/2;
 571         }
 572
 573         if(s->ac){
 574             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 575         }else{
 576             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 577         }
 578     }
 579
 580     avctx->coded_frame= &s->picture;
 581     switch(avctx->pix_fmt){
 582     case PIX_FMT_YUV444P:
 583     case PIX_FMT_YUV422P:
 584     case PIX_FMT_YUV420P:
 585     case PIX_FMT_YUV411P:
 586     case PIX_FMT_YUV410P:
 587         s->colorspace= 0;
 588         break;
 589     case PIX_FMT_RGBA32:
 590         s->colorspace= 1;
 591         break;
 592     default:
 593         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 594         return -1;
 595     }
 596     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
 597
 598     s->picture_number=0;
 599
 600     return 0;
 601 }
 602
 603
 604 static void clear_state(FFV1Context *f){
 605     int i, j;
 606
 607     for(i=0; i<f->plane_count; i++){
 608         PlaneContext *p= &f->plane[i];
 609
 610         p->interlace_bit_state[0]= 128;
 611         p->interlace_bit_state[1]= 128;
 612
 613         for(j=0; j<p->context_count; j++){
 614             if(f->ac){
 615                 memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
 616             }else{
 617                 p->vlc_state[j].drift= 0;
 618                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
 619                 p->vlc_state[j].bias= 0;
 620                 p->vlc_state[j].count= 1;
 621             }
 622         }
 623     }
 624 }
 625
 626 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
 627     FFV1Context *f = avctx->priv_data;
 628     RangeCoder * const c= &f->c;
 629     AVFrame *pict = data;
 630     const int width= f->width;
 631     const int height= f->height;
 632     AVFrame * const p= &f->picture;
 633     int used_count= 0;
 634     uint8_t keystate=128;
 635
 636     ff_init_range_encoder(c, buf, buf_size);
 637 //    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
 638     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 639
 640     *p = *pict;
 641     p->pict_type= FF_I_TYPE;
 642
 643     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
 644         put_rac(c, &keystate, 1);
 645         p->key_frame= 1;
 646         write_header(f);
 647         clear_state(f);
 648     }else{
 649         put_rac(c, &keystate, 0);
 650         p->key_frame= 0;
 651     }
 652
 653     if(!f->ac){
 654         used_count += ff_rac_terminate(c);
 655 //printf("pos=%d\n", used_count);
 656         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
 657     }
 658
 659     if(f->colorspace==0){
 660         const int chroma_width = -((-width )>>f->chroma_h_shift);
 661         const int chroma_height= -((-height)>>f->chroma_v_shift);
 662
 663         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 664
 665         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 666         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 667     }else{
 668         encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
 669     }
 670     emms_c();
 671
 672     f->picture_number++;
 673
 674     if(f->ac){
 675         return ff_rac_terminate(c);
 676     }else{
 677         flush_put_bits(&f->pb); //nicer padding FIXME
 678         return used_count + (put_bits_count(&f->pb)+7)/8;
 679     }
 680 }
 681
 682 static void common_end(FFV1Context *s){
 683     int i;
 684
 685     for(i=0; i<s->plane_count; i++){
 686         PlaneContext *p= &s->plane[i];
 687
 688         av_freep(&p->state);
 689     }
 690 }
 691
 692 static int encode_end(AVCodecContext *avctx)
 693 {
 694     FFV1Context *s = avctx->priv_data;
 695
 696     common_end(s);
 697
 698     return 0;
 699 }
 700
 701 static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
 702     PlaneContext * const p= &s->plane[plane_index];
 703     RangeCoder * const c= &s->c;
 704     int x;
 705     int run_count=0;
 706     int run_mode=0;
 707     int run_index= s->run_index;
 708
 709     for(x=0; x<w; x++){
 710         int diff, context, sign;
 711
 712         context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
 713         if(context < 0){
 714             context= -context;
 715             sign=1;
 716         }else
 717             sign=0;
 718
 719
 720         if(s->ac){
 721             diff= get_symbol(c, p->state[context], 1);
 722         }else{
 723             if(context == 0 && run_mode==0) run_mode=1;
 724
 725             if(run_mode){
 726                 if(run_count==0 && run_mode==1){
 727                     if(get_bits1(&s->gb)){
 728                         run_count = 1<<log2_run[run_index];
 729                         if(x + run_count <= w) run_index++;
 730                     }else{
 731                         if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
 732                         else run_count=0;
 733                         if(run_index) run_index--;
 734                         run_mode=2;
 735                     }
 736                 }
 737                 run_count--;
 738                 if(run_count < 0){
 739                     run_mode=0;
 740                     run_count=0;
 741                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 742                     if(diff>=0) diff++;
 743                 }else
 744                     diff=0;
 745             }else
 746                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
 747
 748 //            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));
 749         }
 750
 751         if(sign) diff= -diff;
 752
 753         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
 754     }
 755     s->run_index= run_index;
 756 }
 757
 758 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
 759     int x, y;
 760     int_fast16_t sample_buffer[2][w+6];
 761     int_fast16_t *sample[2]= {sample_buffer[0]+3, sample_buffer[1]+3};
 762
 763     s->run_index=0;
 764
 765     memset(sample_buffer, 0, sizeof(sample_buffer));
 766
 767     for(y=0; y<h; y++){
 768         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
 769
 770         sample[0]= sample[1];
 771         sample[1]= temp;
 772
 773         sample[1][-1]= sample[0][0  ];
 774         sample[0][ w]= sample[0][w-1];
 775
 776 //{START_TIMER
 777         decode_line(s, w, sample, plane_index, 8);
 778         for(x=0; x<w; x++){
 779             src[x + stride*y]= sample[1][x];
 780         }
 781 //STOP_TIMER("decode-line")}
 782     }
 783 }
 784
 785 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
 786     int x, y, p;
 787     int_fast16_t sample_buffer[3][2][w+6];
 788     int_fast16_t *sample[3][2]= {
 789         {sample_buffer[0][0]+3, sample_buffer[0][1]+3},
 790         {sample_buffer[1][0]+3, sample_buffer[1][1]+3},
 791         {sample_buffer[2][0]+3, sample_buffer[2][1]+3}};
 792
 793     s->run_index=0;
 794
 795     memset(sample_buffer, 0, sizeof(sample_buffer));
 796
 797     for(y=0; y<h; y++){
 798         for(p=0; p<3; p++){
 799             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
 800
 801             sample[p][0]= sample[p][1];
 802             sample[p][1]= temp;
 803
 804             sample[p][1][-1]= sample[p][0][0  ];
 805             sample[p][0][ w]= sample[p][0][w-1];
 806             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
 807         }
 808         for(x=0; x<w; x++){
 809             int g= sample[0][1][x];
 810             int b= sample[1][1][x];
 811             int r= sample[2][1][x];
 812
 813 //            assert(g>=0 && b>=0 && r>=0);
 814 //            assert(g<256 && b<512 && r<512);
 815
 816             b -= 0x100;
 817             r -= 0x100;
 818             g -= (b + r)>>2;
 819             b += g;
 820             r += g;
 821
 822             src[x + stride*y]= b + (g<<8) + (r<<16);
 823         }
 824     }
 825 }
 826
 827 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
 828     int v;
 829     int i=0;
 830     uint8_t state[CONTEXT_SIZE];
 831
 832     memset(state, 128, sizeof(state));
 833
 834     for(v=0; i<128 ; v++){
 835         int len= get_symbol(c, state, 0) + 1;
 836
 837         if(len + i > 128) return -1;
 838
 839         while(len--){
 840             quant_table[i] = scale*v;
 841             i++;
 842 //printf("%2d ",v);
 843 //if(i%16==0) printf("\n");
 844         }
 845     }
 846
 847     for(i=1; i<128; i++){
 848         quant_table[256-i]= -quant_table[i];
 849     }
 850     quant_table[128]= -quant_table[127];
 851
 852     return 2*v - 1;
 853 }
 854
 855 static int read_header(FFV1Context *f){
 856     uint8_t state[CONTEXT_SIZE];
 857     int i, context_count;
 858     RangeCoder * const c= &f->c;
 859
 860     memset(state, 128, sizeof(state));
 861
 862     f->version= get_symbol(c, state, 0);
 863     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
 864     f->colorspace= get_symbol(c, state, 0); //YUV cs type
 865     get_rac(c, state); //no chroma = false
 866     f->chroma_h_shift= get_symbol(c, state, 0);
 867     f->chroma_v_shift= get_symbol(c, state, 0);
 868     get_rac(c, state); //transparency plane
 869     f->plane_count= 2;
 870
 871     if(f->colorspace==0){
 872         switch(16*f->chroma_h_shift + f->chroma_v_shift){
 873         case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
 874         case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
 875         case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
 876         case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
 877         case 0x33: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
 878         default:
 879             av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
 880             return -1;
 881         }
 882     }else if(f->colorspace==1){
 883         if(f->chroma_h_shift || f->chroma_v_shift){
 884             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
 885             return -1;
 886         }
 887         f->avctx->pix_fmt= PIX_FMT_RGBA32;
 888     }else{
 889         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
 890         return -1;
 891     }
 892
 893 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
 894
 895     context_count=1;
 896     for(i=0; i<5; i++){
 897         context_count*= read_quant_table(c, f->quant_table[i], context_count);
 898         if(context_count < 0){
 899             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
 900             return -1;
 901         }
 902     }
 903     context_count= (context_count+1)/2;
 904
 905     for(i=0; i<f->plane_count; i++){
 906         PlaneContext * const p= &f->plane[i];
 907
 908         p->context_count= context_count;
 909
 910         if(f->ac){
 911             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 912         }else{
 913             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 914         }
 915     }
 916
 917     return 0;
 918 }
 919
 920 static int decode_init(AVCodecContext *avctx)
 921 {
 922 //    FFV1Context *s = avctx->priv_data;
 923
 924     common_init(avctx);
 925
 926     return 0;
 927 }
 928
 929 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
 930     FFV1Context *f = avctx->priv_data;
 931     RangeCoder * const c= &f->c;
 932     const int width= f->width;
 933     const int height= f->height;
 934     AVFrame * const p= &f->picture;
 935     int bytes_read;
 936     uint8_t keystate= 128;
 937
 938     AVFrame *picture = data;
 939
 940     /* no supplementary picture */
 941     if (buf_size == 0)
 942         return 0;
 943
 944     ff_init_range_decoder(c, buf, buf_size);
 945     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 946
 947
 948     p->pict_type= FF_I_TYPE; //FIXME I vs. P
 949     if(get_rac(c, &keystate)){
 950         p->key_frame= 1;
 951         read_header(f);
 952         clear_state(f);
 953     }else{
 954         p->key_frame= 0;
 955     }
 956
 957     p->reference= 0;
 958     if(avctx->get_buffer(avctx, p) < 0){
 959         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 960         return -1;
 961     }
 962
 963     if(avctx->debug&FF_DEBUG_PICT_INFO)
 964         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
 965
 966     if(!f->ac){
 967         bytes_read = c->bytestream - c->bytestream_start - 1;
 968         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
 969 //printf("pos=%d\n", bytes_read);
 970         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
 971     } else {
 972         bytes_read = 0; /* avoid warning */
 973     }
 974
 975     if(f->colorspace==0){
 976         const int chroma_width = -((-width )>>f->chroma_h_shift);
 977         const int chroma_height= -((-height)>>f->chroma_v_shift);
 978         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
 979
 980         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
 981         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
 982     }else{
 983         decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
 984     }
 985
 986     emms_c();
 987
 988     f->picture_number++;
 989
 990     *picture= *p;
 991
 992     avctx->release_buffer(avctx, p); //FIXME
 993
 994     *data_size = sizeof(AVFrame);
 995
 996     if(f->ac){
 997         bytes_read= c->bytestream - c->bytestream_start - 1;
 998         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
 999     }else{
1000         bytes_read+= (get_bits_count(&f->gb)+7)/8;
1001     }
1002
1003     return bytes_read;
1004 }
1005
1006 AVCodec ffv1_decoder = {
1007     "ffv1",
1008     CODEC_TYPE_VIDEO,
1009     CODEC_ID_FFV1,
1010     sizeof(FFV1Context),
1011     decode_init,
1012     NULL,
1013     NULL,
1014     decode_frame,
1015     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1016     NULL
1017 };
1018
1019 #ifdef CONFIG_ENCODERS
1020 AVCodec ffv1_encoder = {
1021     "ffv1",
1022     CODEC_TYPE_VIDEO,
1023     CODEC_ID_FFV1,
1024     sizeof(FFV1Context),
1025     encode_init,
1026     encode_frame,
1027     encode_end,
1028 };
1029 #endif