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