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