FFmpeg: libavcodec/ffv1.c Source File

00001 /*
00002  * FFV1 codec for libavcodec
00003  *
00004  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
00005  *
00006  * This file is part of FFmpeg.
00007  *
00008  * FFmpeg is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public
00010  * License as published by the Free Software Foundation; either
00011  * version 2.1 of the License, or (at your option) any later version.
00012  *
00013  * FFmpeg is distributed in the hope that it will be useful,
00014  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with FFmpeg; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00021  */
00022 
00028 #include "avcodec.h"
00029 #include "bitstream.h"
00030 #include "dsputil.h"
00031 #include "rangecoder.h"
00032 #include "golomb.h"
00033 #include "mathops.h"
00034 
00035 #define MAX_PLANES 4
00036 #define CONTEXT_SIZE 32
00037 
00038 extern const uint8_t ff_log2_run[32];
00039 
00040 static const int8_t quant3[256]={
00041  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00042  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00043  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00044  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00045  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00046  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00047  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00048  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00049 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00050 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00051 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00052 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00053 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00054 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00055 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00056 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
00057 };
00058 static const int8_t quant5[256]={
00059  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00060  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00061  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00062  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00063  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00064  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00065  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00066  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00067 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00068 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00069 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00070 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00071 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00072 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00073 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00074 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
00075 };
00076 static const int8_t quant7[256]={
00077  0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00078  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00079  2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
00080  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00081  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00082  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00083  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00084  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00085 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00086 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00087 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00088 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00089 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00090 -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
00091 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00092 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
00093 };
00094 static const int8_t quant9[256]={
00095  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00096  3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00097  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00098  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00099  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00100  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00101  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00102  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00103 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00104 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00105 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00106 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00107 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00108 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00109 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
00110 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
00111 };
00112 static const int8_t quant11[256]={
00113  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
00114  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00115  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00116  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00117  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00118  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00119  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00120  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00121 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00122 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00123 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00124 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00125 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00126 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
00127 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00128 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
00129 };
00130 static const int8_t quant13[256]={
00131  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
00132  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00133  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00134  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00135  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00136  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00137  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00138  6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00139 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00140 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00141 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00142 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00143 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
00144 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00145 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00146 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
00147 };
00148 
00149 typedef struct VlcState{
00150     int16_t drift;
00151     uint16_t error_sum;
00152     int8_t bias;
00153     uint8_t count;
00154 } VlcState;
00155 
00156 typedef struct PlaneContext{
00157     int context_count;
00158     uint8_t (*state)[CONTEXT_SIZE];
00159     VlcState *vlc_state;
00160     uint8_t interlace_bit_state[2];
00161 } PlaneContext;
00162 
00163 typedef struct FFV1Context{
00164     AVCodecContext *avctx;
00165     RangeCoder c;
00166     GetBitContext gb;
00167     PutBitContext pb;
00168     int version;
00169     int width, height;
00170     int chroma_h_shift, chroma_v_shift;
00171     int flags;
00172     int picture_number;
00173     AVFrame picture;
00174     int plane_count;
00175     int ac;                              
00176     PlaneContext plane[MAX_PLANES];
00177     int16_t quant_table[5][256];
00178     int run_index;
00179     int colorspace;
00180 
00181     DSPContext dsp;
00182 }FFV1Context;
00183 
00184 static av_always_inline int fold(int diff, int bits){
00185     if(bits==8)
00186         diff= (int8_t)diff;
00187     else{
00188         diff+= 1<<(bits-1);
00189         diff&=(1<<bits)-1;
00190         diff-= 1<<(bits-1);
00191     }
00192 
00193     return diff;
00194 }
00195 
00196 static inline int predict(int_fast16_t *src, int_fast16_t *last){
00197     const int LT= last[-1];
00198     const int  T= last[ 0];
00199     const int L =  src[-1];
00200 
00201     return mid_pred(L, L + T - LT, T);
00202 }
00203 
00204 static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
00205     const int LT= last[-1];
00206     const int  T= last[ 0];
00207     const int RT= last[ 1];
00208     const int L =  src[-1];
00209 
00210     if(f->quant_table[3][127]){
00211         const int TT= last2[0];
00212         const int LL=  src[-2];
00213         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
00214               +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
00215     }else
00216         return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
00217 }
00218 
00219 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
00220     int i;
00221 
00222     if(v){
00223         const int a= FFABS(v);
00224         const int e= av_log2(a);
00225         put_rac(c, state+0, 0);
00226 
00227         assert(e<=9);
00228 
00229         for(i=0; i<e; i++){
00230             put_rac(c, state+1+i, 1);  //1..10
00231         }
00232         put_rac(c, state+1+i, 0);
00233 
00234         for(i=e-1; i>=0; i--){
00235             put_rac(c, state+22+i, (a>>i)&1); //22..31
00236         }
00237 
00238         if(is_signed)
00239             put_rac(c, state+11 + e, v < 0); //11..21
00240     }else{
00241         put_rac(c, state+0, 1);
00242     }
00243 }
00244 
00245 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
00246     if(get_rac(c, state+0))
00247         return 0;
00248     else{
00249         int i, e, a;
00250         e= 0;
00251         while(get_rac(c, state+1 + e) && e<9){ //1..10
00252             e++;
00253         }
00254 
00255         a= 1;
00256         for(i=e-1; i>=0; i--){
00257             a += a + get_rac(c, state+22 + i); //22..31
00258         }
00259 
00260         if(is_signed && get_rac(c, state+11 + e)) //11..21
00261             return -a;
00262         else
00263             return a;
00264     }
00265 }
00266 
00267 static inline void update_vlc_state(VlcState * const state, const int v){
00268     int drift= state->drift;
00269     int count= state->count;
00270     state->error_sum += FFABS(v);
00271     drift += v;
00272 
00273     if(count == 128){ //FIXME variable
00274         count >>= 1;
00275         drift >>= 1;
00276         state->error_sum >>= 1;
00277     }
00278     count++;
00279 
00280     if(drift <= -count){
00281         if(state->bias > -128) state->bias--;
00282 
00283         drift += count;
00284         if(drift <= -count)
00285             drift= -count + 1;
00286     }else if(drift > 0){
00287         if(state->bias <  127) state->bias++;
00288 
00289         drift -= count;
00290         if(drift > 0)
00291             drift= 0;
00292     }
00293 
00294     state->drift= drift;
00295     state->count= count;
00296 }
00297 
00298 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
00299     int i, k, code;
00300 //printf("final: %d ", v);
00301     v = fold(v - state->bias, bits);
00302 
00303     i= state->count;
00304     k=0;
00305     while(i < state->error_sum){ //FIXME optimize
00306         k++;
00307         i += i;
00308     }
00309 
00310     assert(k<=8);
00311 
00312 #if 0 // JPEG LS
00313     if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
00314     else                                         code= v;
00315 #else
00316      code= v ^ ((2*state->drift + state->count)>>31);
00317 #endif
00318 
00319 //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);
00320     set_sr_golomb(pb, code, k, 12, bits);
00321 
00322     update_vlc_state(state, v);
00323 }
00324 
00325 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
00326     int k, i, v, ret;
00327 
00328     i= state->count;
00329     k=0;
00330     while(i < state->error_sum){ //FIXME optimize
00331         k++;
00332         i += i;
00333     }
00334 
00335     assert(k<=8);
00336 
00337     v= get_sr_golomb(gb, k, 12, bits);
00338 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
00339 
00340 #if 0 // JPEG LS
00341     if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
00342 #else
00343      v ^= ((2*state->drift + state->count)>>31);
00344 #endif
00345 
00346     ret= fold(v + state->bias, bits);
00347 
00348     update_vlc_state(state, v);
00349 //printf("final: %d\n", ret);
00350     return ret;
00351 }
00352 
00353 #if CONFIG_FFV1_ENCODER
00354 static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
00355     PlaneContext * const p= &s->plane[plane_index];
00356     RangeCoder * const c= &s->c;
00357     int x;
00358     int run_index= s->run_index;
00359     int run_count=0;
00360     int run_mode=0;
00361 
00362     if(s->ac){
00363         if(c->bytestream_end - c->bytestream < w*20){
00364             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00365             return -1;
00366         }
00367     }else{
00368         if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
00369             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00370             return -1;
00371         }
00372     }
00373 
00374     for(x=0; x<w; x++){
00375         int diff, context;
00376 
00377         context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
00378         diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
00379 
00380         if(context < 0){
00381             context = -context;
00382             diff= -diff;
00383         }
00384 
00385         diff= fold(diff, bits);
00386 
00387         if(s->ac){
00388             put_symbol(c, p->state[context], diff, 1);
00389         }else{
00390             if(context == 0) run_mode=1;
00391 
00392             if(run_mode){
00393 
00394                 if(diff){
00395                     while(run_count >= 1<<ff_log2_run[run_index]){
00396                         run_count -= 1<<ff_log2_run[run_index];
00397                         run_index++;
00398                         put_bits(&s->pb, 1, 1);
00399                     }
00400 
00401                     put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
00402                     if(run_index) run_index--;
00403                     run_count=0;
00404                     run_mode=0;
00405                     if(diff>0) diff--;
00406                 }else{
00407                     run_count++;
00408                 }
00409             }
00410 
00411 //            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));
00412 
00413             if(run_mode == 0)
00414                 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
00415         }
00416     }
00417     if(run_mode){
00418         while(run_count >= 1<<ff_log2_run[run_index]){
00419             run_count -= 1<<ff_log2_run[run_index];
00420             run_index++;
00421             put_bits(&s->pb, 1, 1);
00422         }
00423 
00424         if(run_count)
00425             put_bits(&s->pb, 1, 1);
00426     }
00427     s->run_index= run_index;
00428 
00429     return 0;
00430 }
00431 
00432 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
00433     int x,y,i;
00434     const int ring_size= s->avctx->context_model ? 3 : 2;
00435     int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
00436     s->run_index=0;
00437 
00438     memset(sample_buffer, 0, sizeof(sample_buffer));
00439 
00440     for(y=0; y<h; y++){
00441         for(i=0; i<ring_size; i++)
00442             sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
00443 
00444         sample[0][-1]= sample[1][0  ];
00445         sample[1][ w]= sample[1][w-1];
00446 //{START_TIMER
00447         for(x=0; x<w; x++){
00448             sample[0][x]= src[x + stride*y];
00449         }
00450         encode_line(s, w, sample, plane_index, 8);
00451 //STOP_TIMER("encode line")}
00452     }
00453 }
00454 
00455 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
00456     int x, y, p, i;
00457     const int ring_size= s->avctx->context_model ? 3 : 2;
00458     int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
00459     s->run_index=0;
00460 
00461     memset(sample_buffer, 0, sizeof(sample_buffer));
00462 
00463     for(y=0; y<h; y++){
00464         for(i=0; i<ring_size; i++)
00465             for(p=0; p<3; p++)
00466                 sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
00467 
00468         for(x=0; x<w; x++){
00469             int v= src[x + stride*y];
00470             int b= v&0xFF;
00471             int g= (v>>8)&0xFF;
00472             int r= (v>>16)&0xFF;
00473 
00474             b -= g;
00475             r -= g;
00476             g += (b + r)>>2;
00477             b += 0x100;
00478             r += 0x100;
00479 
00480 //            assert(g>=0 && b>=0 && r>=0);
00481 //            assert(g<256 && b<512 && r<512);
00482             sample[0][0][x]= g;
00483             sample[1][0][x]= b;
00484             sample[2][0][x]= r;
00485         }
00486         for(p=0; p<3; p++){
00487             sample[p][0][-1]= sample[p][1][0  ];
00488             sample[p][1][ w]= sample[p][1][w-1];
00489             encode_line(s, w, sample[p], FFMIN(p, 1), 9);
00490         }
00491     }
00492 }
00493 
00494 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
00495     int last=0;
00496     int i;
00497     uint8_t state[CONTEXT_SIZE];
00498     memset(state, 128, sizeof(state));
00499 
00500     for(i=1; i<128 ; i++){
00501         if(quant_table[i] != quant_table[i-1]){
00502             put_symbol(c, state, i-last-1, 0);
00503             last= i;
00504         }
00505     }
00506     put_symbol(c, state, i-last-1, 0);
00507 }
00508 
00509 static void write_header(FFV1Context *f){
00510     uint8_t state[CONTEXT_SIZE];
00511     int i;
00512     RangeCoder * const c= &f->c;
00513 
00514     memset(state, 128, sizeof(state));
00515 
00516     put_symbol(c, state, f->version, 0);
00517     put_symbol(c, state, f->avctx->coder_type, 0);
00518     put_symbol(c, state, f->colorspace, 0); //YUV cs type
00519     put_rac(c, state, 1); //chroma planes
00520         put_symbol(c, state, f->chroma_h_shift, 0);
00521         put_symbol(c, state, f->chroma_v_shift, 0);
00522     put_rac(c, state, 0); //no transparency plane
00523 
00524     for(i=0; i<5; i++)
00525         write_quant_table(c, f->quant_table[i]);
00526 }
00527 #endif /* CONFIG_FFV1_ENCODER */
00528 
00529 static av_cold int common_init(AVCodecContext *avctx){
00530     FFV1Context *s = avctx->priv_data;
00531     int width, height;
00532 
00533     s->avctx= avctx;
00534     s->flags= avctx->flags;
00535 
00536     dsputil_init(&s->dsp, avctx);
00537 
00538     width= s->width= avctx->width;
00539     height= s->height= avctx->height;
00540 
00541     assert(width && height);
00542 
00543     return 0;
00544 }
00545 
00546 #if CONFIG_FFV1_ENCODER
00547 static av_cold int encode_init(AVCodecContext *avctx)
00548 {
00549     FFV1Context *s = avctx->priv_data;
00550     int i;
00551 
00552     common_init(avctx);
00553 
00554     s->version=0;
00555     s->ac= avctx->coder_type;
00556 
00557     s->plane_count=2;
00558     for(i=0; i<256; i++){
00559         s->quant_table[0][i]=           quant11[i];
00560         s->quant_table[1][i]=        11*quant11[i];
00561         if(avctx->context_model==0){
00562             s->quant_table[2][i]=     11*11*quant11[i];
00563             s->quant_table[3][i]=
00564             s->quant_table[4][i]=0;
00565         }else{
00566             s->quant_table[2][i]=     11*11*quant5 [i];
00567             s->quant_table[3][i]=   5*11*11*quant5 [i];
00568             s->quant_table[4][i]= 5*5*11*11*quant5 [i];
00569         }
00570     }
00571 
00572     for(i=0; i<s->plane_count; i++){
00573         PlaneContext * const p= &s->plane[i];
00574 
00575         if(avctx->context_model==0){
00576             p->context_count= (11*11*11+1)/2;
00577         }else{
00578             p->context_count= (11*11*5*5*5+1)/2;
00579         }
00580 
00581         if(s->ac){
00582             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
00583         }else{
00584             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
00585         }
00586     }
00587 
00588     avctx->coded_frame= &s->picture;
00589     switch(avctx->pix_fmt){
00590     case PIX_FMT_YUV444P:
00591     case PIX_FMT_YUV422P:
00592     case PIX_FMT_YUV420P:
00593     case PIX_FMT_YUV411P:
00594     case PIX_FMT_YUV410P:
00595         s->colorspace= 0;
00596         break;
00597     case PIX_FMT_RGB32:
00598         s->colorspace= 1;
00599         break;
00600     default:
00601         av_log(avctx, AV_LOG_ERROR, "format not supported\n");
00602         return -1;
00603     }
00604     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
00605 
00606     s->picture_number=0;
00607 
00608     return 0;
00609 }
00610 #endif /* CONFIG_FFV1_ENCODER */
00611 
00612 
00613 static void clear_state(FFV1Context *f){
00614     int i, j;
00615 
00616     for(i=0; i<f->plane_count; i++){
00617         PlaneContext *p= &f->plane[i];
00618 
00619         p->interlace_bit_state[0]= 128;
00620         p->interlace_bit_state[1]= 128;
00621 
00622         for(j=0; j<p->context_count; j++){
00623             if(f->ac){
00624                 memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
00625             }else{
00626                 p->vlc_state[j].drift= 0;
00627                 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
00628                 p->vlc_state[j].bias= 0;
00629                 p->vlc_state[j].count= 1;
00630             }
00631         }
00632     }
00633 }
00634 
00635 #if CONFIG_FFV1_ENCODER
00636 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
00637     FFV1Context *f = avctx->priv_data;
00638     RangeCoder * const c= &f->c;
00639     AVFrame *pict = data;
00640     const int width= f->width;
00641     const int height= f->height;
00642     AVFrame * const p= &f->picture;
00643     int used_count= 0;
00644     uint8_t keystate=128;
00645 
00646     ff_init_range_encoder(c, buf, buf_size);
00647 //    ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
00648     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
00649 
00650     *p = *pict;
00651     p->pict_type= FF_I_TYPE;
00652 
00653     if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
00654         put_rac(c, &keystate, 1);
00655         p->key_frame= 1;
00656         write_header(f);
00657         clear_state(f);
00658     }else{
00659         put_rac(c, &keystate, 0);
00660         p->key_frame= 0;
00661     }
00662 
00663     if(!f->ac){
00664         used_count += ff_rac_terminate(c);
00665 //printf("pos=%d\n", used_count);
00666         init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
00667     }
00668 
00669     if(f->colorspace==0){
00670         const int chroma_width = -((-width )>>f->chroma_h_shift);
00671         const int chroma_height= -((-height)>>f->chroma_v_shift);
00672 
00673         encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
00674 
00675         encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
00676         encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
00677     }else{
00678         encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
00679     }
00680     emms_c();
00681 
00682     f->picture_number++;
00683 
00684     if(f->ac){
00685         return ff_rac_terminate(c);
00686     }else{
00687         flush_put_bits(&f->pb); //nicer padding FIXME
00688         return used_count + (put_bits_count(&f->pb)+7)/8;
00689     }
00690 }
00691 #endif /* CONFIG_FFV1_ENCODER */
00692 
00693 static av_cold int common_end(AVCodecContext *avctx){
00694     FFV1Context *s = avctx->priv_data;
00695     int i;
00696 
00697     for(i=0; i<s->plane_count; i++){
00698         PlaneContext *p= &s->plane[i];
00699 
00700         av_freep(&p->state);
00701         av_freep(&p->vlc_state);
00702     }
00703 
00704     return 0;
00705 }
00706 
00707 static inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
00708     PlaneContext * const p= &s->plane[plane_index];
00709     RangeCoder * const c= &s->c;
00710     int x;
00711     int run_count=0;
00712     int run_mode=0;
00713     int run_index= s->run_index;
00714 
00715     for(x=0; x<w; x++){
00716         int diff, context, sign;
00717 
00718         context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
00719         if(context < 0){
00720             context= -context;
00721             sign=1;
00722         }else
00723             sign=0;
00724 
00725 
00726         if(s->ac){
00727             diff= get_symbol(c, p->state[context], 1);
00728         }else{
00729             if(context == 0 && run_mode==0) run_mode=1;
00730 
00731             if(run_mode){
00732                 if(run_count==0 && run_mode==1){
00733                     if(get_bits1(&s->gb)){
00734                         run_count = 1<<ff_log2_run[run_index];
00735                         if(x + run_count <= w) run_index++;
00736                     }else{
00737                         if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
00738                         else run_count=0;
00739                         if(run_index) run_index--;
00740                         run_mode=2;
00741                     }
00742                 }
00743                 run_count--;
00744                 if(run_count < 0){
00745                     run_mode=0;
00746                     run_count=0;
00747                     diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
00748                     if(diff>=0) diff++;
00749                 }else
00750                     diff=0;
00751             }else
00752                 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
00753 
00754 //            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));
00755         }
00756 
00757         if(sign) diff= -diff;
00758 
00759         sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
00760     }
00761     s->run_index= run_index;
00762 }
00763 
00764 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
00765     int x, y;
00766     int_fast16_t sample_buffer[2][w+6];
00767     int_fast16_t *sample[2];
00768     sample[0]=sample_buffer[0]+3;
00769     sample[1]=sample_buffer[1]+3;
00770 
00771     s->run_index=0;
00772 
00773     memset(sample_buffer, 0, sizeof(sample_buffer));
00774 
00775     for(y=0; y<h; y++){
00776         int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
00777 
00778         sample[0]= sample[1];
00779         sample[1]= temp;
00780 
00781         sample[1][-1]= sample[0][0  ];
00782         sample[0][ w]= sample[0][w-1];
00783 
00784 //{START_TIMER
00785         decode_line(s, w, sample, plane_index, 8);
00786         for(x=0; x<w; x++){
00787             src[x + stride*y]= sample[1][x];
00788         }
00789 //STOP_TIMER("decode-line")}
00790     }
00791 }
00792 
00793 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
00794     int x, y, p;
00795     int_fast16_t sample_buffer[3][2][w+6];
00796     int_fast16_t *sample[3][2];
00797     for(x=0; x<3; x++){
00798         sample[x][0] = sample_buffer[x][0]+3;
00799         sample[x][1] = sample_buffer[x][1]+3;
00800     }
00801 
00802     s->run_index=0;
00803 
00804     memset(sample_buffer, 0, sizeof(sample_buffer));
00805 
00806     for(y=0; y<h; y++){
00807         for(p=0; p<3; p++){
00808             int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
00809 
00810             sample[p][0]= sample[p][1];
00811             sample[p][1]= temp;
00812 
00813             sample[p][1][-1]= sample[p][0][0  ];
00814             sample[p][0][ w]= sample[p][0][w-1];
00815             decode_line(s, w, sample[p], FFMIN(p, 1), 9);
00816         }
00817         for(x=0; x<w; x++){
00818             int g= sample[0][1][x];
00819             int b= sample[1][1][x];
00820             int r= sample[2][1][x];
00821 
00822 //            assert(g>=0 && b>=0 && r>=0);
00823 //            assert(g<256 && b<512 && r<512);
00824 
00825             b -= 0x100;
00826             r -= 0x100;
00827             g -= (b + r)>>2;
00828             b += g;
00829             r += g;
00830 
00831             src[x + stride*y]= b + (g<<8) + (r<<16);
00832         }
00833     }
00834 }
00835 
00836 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
00837     int v;
00838     int i=0;
00839     uint8_t state[CONTEXT_SIZE];
00840 
00841     memset(state, 128, sizeof(state));
00842 
00843     for(v=0; i<128 ; v++){
00844         int len= get_symbol(c, state, 0) + 1;
00845 
00846         if(len + i > 128) return -1;
00847 
00848         while(len--){
00849             quant_table[i] = scale*v;
00850             i++;
00851 //printf("%2d ",v);
00852 //if(i%16==0) printf("\n");
00853         }
00854     }
00855 
00856     for(i=1; i<128; i++){
00857         quant_table[256-i]= -quant_table[i];
00858     }
00859     quant_table[128]= -quant_table[127];
00860 
00861     return 2*v - 1;
00862 }
00863 
00864 static int read_header(FFV1Context *f){
00865     uint8_t state[CONTEXT_SIZE];
00866     int i, context_count;
00867     RangeCoder * const c= &f->c;
00868 
00869     memset(state, 128, sizeof(state));
00870 
00871     f->version= get_symbol(c, state, 0);
00872     f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
00873     f->colorspace= get_symbol(c, state, 0); //YUV cs type
00874     get_rac(c, state); //no chroma = false
00875     f->chroma_h_shift= get_symbol(c, state, 0);
00876     f->chroma_v_shift= get_symbol(c, state, 0);
00877     get_rac(c, state); //transparency plane
00878     f->plane_count= 2;
00879 
00880     if(f->colorspace==0){
00881         switch(16*f->chroma_h_shift + f->chroma_v_shift){
00882         case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
00883         case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
00884         case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
00885         case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
00886         case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
00887         default:
00888             av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
00889             return -1;
00890         }
00891     }else if(f->colorspace==1){
00892         if(f->chroma_h_shift || f->chroma_v_shift){
00893             av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
00894             return -1;
00895         }
00896         f->avctx->pix_fmt= PIX_FMT_RGB32;
00897     }else{
00898         av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
00899         return -1;
00900     }
00901 
00902 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
00903 
00904     context_count=1;
00905     for(i=0; i<5; i++){
00906         context_count*= read_quant_table(c, f->quant_table[i], context_count);
00907         if(context_count < 0 || context_count > 32768){
00908             av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
00909             return -1;
00910         }
00911     }
00912     context_count= (context_count+1)/2;
00913 
00914     for(i=0; i<f->plane_count; i++){
00915         PlaneContext * const p= &f->plane[i];
00916 
00917         p->context_count= context_count;
00918 
00919         if(f->ac){
00920             if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
00921         }else{
00922             if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
00923         }
00924     }
00925 
00926     return 0;
00927 }
00928 
00929 static av_cold int decode_init(AVCodecContext *avctx)
00930 {
00931 //    FFV1Context *s = avctx->priv_data;
00932 
00933     common_init(avctx);
00934 
00935     return 0;
00936 }
00937 
00938 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size){
00939     FFV1Context *f = avctx->priv_data;
00940     RangeCoder * const c= &f->c;
00941     const int width= f->width;
00942     const int height= f->height;
00943     AVFrame * const p= &f->picture;
00944     int bytes_read;
00945     uint8_t keystate= 128;
00946 
00947     AVFrame *picture = data;
00948 
00949     ff_init_range_decoder(c, buf, buf_size);
00950     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
00951 
00952 
00953     p->pict_type= FF_I_TYPE; //FIXME I vs. P
00954     if(get_rac(c, &keystate)){
00955         p->key_frame= 1;
00956         if(read_header(f) < 0)
00957             return -1;
00958         clear_state(f);
00959     }else{
00960         p->key_frame= 0;
00961     }
00962     if(!f->plane[0].state && !f->plane[0].vlc_state)
00963         return -1;
00964 
00965     p->reference= 0;
00966     if(avctx->get_buffer(avctx, p) < 0){
00967         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
00968         return -1;
00969     }
00970 
00971     if(avctx->debug&FF_DEBUG_PICT_INFO)
00972         av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
00973 
00974     if(!f->ac){
00975         bytes_read = c->bytestream - c->bytestream_start - 1;
00976         if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
00977 //printf("pos=%d\n", bytes_read);
00978         init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
00979     } else {
00980         bytes_read = 0; /* avoid warning */
00981     }
00982 
00983     if(f->colorspace==0){
00984         const int chroma_width = -((-width )>>f->chroma_h_shift);
00985         const int chroma_height= -((-height)>>f->chroma_v_shift);
00986         decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
00987 
00988         decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
00989         decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
00990     }else{
00991         decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
00992     }
00993 
00994     emms_c();
00995 
00996     f->picture_number++;
00997 
00998     *picture= *p;
00999 
01000     avctx->release_buffer(avctx, p); //FIXME
01001 
01002     *data_size = sizeof(AVFrame);
01003 
01004     if(f->ac){
01005         bytes_read= c->bytestream - c->bytestream_start - 1;
01006         if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
01007     }else{
01008         bytes_read+= (get_bits_count(&f->gb)+7)/8;
01009     }
01010 
01011     return bytes_read;
01012 }
01013 
01014 AVCodec ffv1_decoder = {
01015     "ffv1",
01016     CODEC_TYPE_VIDEO,
01017     CODEC_ID_FFV1,
01018     sizeof(FFV1Context),
01019     decode_init,
01020     NULL,
01021     common_end,
01022     decode_frame,
01023     CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
01024     NULL,
01025     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
01026 };
01027 
01028 #if CONFIG_FFV1_ENCODER
01029 AVCodec ffv1_encoder = {
01030     "ffv1",
01031     CODEC_TYPE_VIDEO,
01032     CODEC_ID_FFV1,
01033     sizeof(FFV1Context),
01034     encode_init,
01035     encode_frame,
01036     common_end,
01037     .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_NONE},
01038     .long_name= NULL_IF_CONFIG_SMALL("FFmpeg codec #1"),
01039 };
01040 #endif