00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00028 #include "avcodec.h"
00029 #include "get_bits.h"
00030 #include "put_bits.h"
00031 #include "dsputil.h"
00032 #include "rangecoder.h"
00033 #include "golomb.h"
00034 #include "mathops.h"
00035
00036 #define MAX_PLANES 4
00037 #define CONTEXT_SIZE 32
00038
00039 extern const uint8_t ff_log2_run[32];
00040
00041 static const int8_t quant3[256]={
00042 0, 0, 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,-1,
00057 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
00058 };
00059
00060 static const int8_t quant5_10bit[256]={
00061 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
00062 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00063 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00064 1, 1, 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,-1,
00074 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00075 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
00076 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
00077 };
00078
00079 static const int8_t quant5[256]={
00080 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00081 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00082 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00083 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00084 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00085 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00086 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00087 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00088 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00089 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00090 -2,-2,-2,-2,-2,-2,-2,-2,-2,-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,-2,-2,
00093 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00094 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00095 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
00096 };
00097 static const int8_t quant7[256]={
00098 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00099 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00100 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
00101 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00102 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00103 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00104 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00105 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00106 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00107 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00108 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00109 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00110 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00111 -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
00112 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00113 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
00114 };
00115 static const int8_t quant9[256]={
00116 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00117 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00118 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00119 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00120 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00121 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00122 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00123 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00124 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00125 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00126 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-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,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00129 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00130 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
00131 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
00132 };
00133 static const int8_t quant9_10bit[256]={
00134 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
00135 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
00136 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
00137 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
00138 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00139 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00140 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00141 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00142 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00143 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00144 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00145 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00146 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
00147 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
00148 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
00149 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
00150 };
00151
00152 static const int8_t quant11[256]={
00153 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
00154 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
00155 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00156 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00157 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00158 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00159 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00160 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00161 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00162 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00163 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00164 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00165 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00166 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
00167 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
00168 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
00169 };
00170 static const int8_t quant13[256]={
00171 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
00172 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00173 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00174 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00175 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00176 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00177 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00178 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
00179 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00180 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00181 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00182 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
00183 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
00184 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00185 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
00186 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
00187 };
00188
00189 static const uint8_t ver2_state[256]= {
00190 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
00191 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
00192 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
00193 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
00194 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
00195 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
00196 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
00197 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
00198 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
00199 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
00200 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
00201 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
00202 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
00203 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
00204 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
00205 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
00206 };
00207
00208 typedef struct VlcState{
00209 int16_t drift;
00210 uint16_t error_sum;
00211 int8_t bias;
00212 uint8_t count;
00213 } VlcState;
00214
00215 typedef struct PlaneContext{
00216 int context_count;
00217 uint8_t (*state)[CONTEXT_SIZE];
00218 VlcState *vlc_state;
00219 uint8_t interlace_bit_state[2];
00220 } PlaneContext;
00221
00222 typedef struct FFV1Context{
00223 AVCodecContext *avctx;
00224 RangeCoder c;
00225 GetBitContext gb;
00226 PutBitContext pb;
00227 int version;
00228 int width, height;
00229 int chroma_h_shift, chroma_v_shift;
00230 int flags;
00231 int picture_number;
00232 AVFrame picture;
00233 int plane_count;
00234 int ac;
00235 PlaneContext plane[MAX_PLANES];
00236 int16_t quant_table[5][256];
00237 uint8_t state_transition[256];
00238 int run_index;
00239 int colorspace;
00240
00241 DSPContext dsp;
00242 }FFV1Context;
00243
00244 static av_always_inline int fold(int diff, int bits){
00245 if(bits==8)
00246 diff= (int8_t)diff;
00247 else{
00248 diff+= 1<<(bits-1);
00249 diff&=(1<<bits)-1;
00250 diff-= 1<<(bits-1);
00251 }
00252
00253 return diff;
00254 }
00255
00256 static inline int predict(int_fast16_t *src, int_fast16_t *last){
00257 const int LT= last[-1];
00258 const int T= last[ 0];
00259 const int L = src[-1];
00260
00261 return mid_pred(L, L + T - LT, T);
00262 }
00263
00264 static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
00265 const int LT= last[-1];
00266 const int T= last[ 0];
00267 const int RT= last[ 1];
00268 const int L = src[-1];
00269
00270 if(f->quant_table[3][127]){
00271 const int TT= last2[0];
00272 const int LL= src[-2];
00273 return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
00274 +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
00275 }else
00276 return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
00277 }
00278
00279 static inline void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed){
00280 int i;
00281
00282 if(v){
00283 const int a= FFABS(v);
00284 const int e= av_log2(a);
00285 put_rac(c, state+0, 0);
00286 if(e<=9){
00287 for(i=0; i<e; i++){
00288 put_rac(c, state+1+i, 1);
00289 }
00290 put_rac(c, state+1+i, 0);
00291
00292 for(i=e-1; i>=0; i--){
00293 put_rac(c, state+22+i, (a>>i)&1);
00294 }
00295
00296 if(is_signed)
00297 put_rac(c, state+11 + e, v < 0);
00298 }else{
00299 for(i=0; i<e; i++){
00300 put_rac(c, state+1+FFMIN(i,9), 1);
00301 }
00302 put_rac(c, state+1+9, 0);
00303
00304 for(i=e-1; i>=0; i--){
00305 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1);
00306 }
00307
00308 if(is_signed)
00309 put_rac(c, state+11 + 10, v < 0);
00310 }
00311 }else{
00312 put_rac(c, state+0, 1);
00313 }
00314 }
00315
00316 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
00317 put_symbol_inline(c, state, v, is_signed);
00318 }
00319
00320 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
00321 if(get_rac(c, state+0))
00322 return 0;
00323 else{
00324 int i, e, a;
00325 e= 0;
00326 while(get_rac(c, state+1 + FFMIN(e,9))){
00327 e++;
00328 }
00329
00330 a= 1;
00331 for(i=e-1; i>=0; i--){
00332 a += a + get_rac(c, state+22 + FFMIN(i,9));
00333 }
00334
00335 e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10)));
00336 return (a^e)-e;
00337 }
00338 }
00339
00340 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
00341 return get_symbol_inline(c, state, is_signed);
00342 }
00343
00344 static inline void update_vlc_state(VlcState * const state, const int v){
00345 int drift= state->drift;
00346 int count= state->count;
00347 state->error_sum += FFABS(v);
00348 drift += v;
00349
00350 if(count == 128){
00351 count >>= 1;
00352 drift >>= 1;
00353 state->error_sum >>= 1;
00354 }
00355 count++;
00356
00357 if(drift <= -count){
00358 if(state->bias > -128) state->bias--;
00359
00360 drift += count;
00361 if(drift <= -count)
00362 drift= -count + 1;
00363 }else if(drift > 0){
00364 if(state->bias < 127) state->bias++;
00365
00366 drift -= count;
00367 if(drift > 0)
00368 drift= 0;
00369 }
00370
00371 state->drift= drift;
00372 state->count= count;
00373 }
00374
00375 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
00376 int i, k, code;
00377
00378 v = fold(v - state->bias, bits);
00379
00380 i= state->count;
00381 k=0;
00382 while(i < state->error_sum){
00383 k++;
00384 i += i;
00385 }
00386
00387 assert(k<=8);
00388
00389 #if 0 // JPEG LS
00390 if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
00391 else code= v;
00392 #else
00393 code= v ^ ((2*state->drift + state->count)>>31);
00394 #endif
00395
00396
00397 set_sr_golomb(pb, code, k, 12, bits);
00398
00399 update_vlc_state(state, v);
00400 }
00401
00402 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
00403 int k, i, v, ret;
00404
00405 i= state->count;
00406 k=0;
00407 while(i < state->error_sum){
00408 k++;
00409 i += i;
00410 }
00411
00412 assert(k<=8);
00413
00414 v= get_sr_golomb(gb, k, 12, bits);
00415
00416
00417 #if 0 // JPEG LS
00418 if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
00419 #else
00420 v ^= ((2*state->drift + state->count)>>31);
00421 #endif
00422
00423 ret= fold(v + state->bias, bits);
00424
00425 update_vlc_state(state, v);
00426
00427 return ret;
00428 }
00429
00430 #if CONFIG_FFV1_ENCODER
00431 static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
00432 PlaneContext * const p= &s->plane[plane_index];
00433 RangeCoder * const c= &s->c;
00434 int x;
00435 int run_index= s->run_index;
00436 int run_count=0;
00437 int run_mode=0;
00438
00439 if(s->ac){
00440 if(c->bytestream_end - c->bytestream < w*20){
00441 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00442 return -1;
00443 }
00444 }else{
00445 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
00446 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
00447 return -1;
00448 }
00449 }
00450
00451 for(x=0; x<w; x++){
00452 int diff, context;
00453
00454 context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
00455 diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
00456
00457 if(context < 0){
00458 context = -context;
00459 diff= -diff;
00460 }
00461
00462 diff= fold(diff, bits);
00463
00464 if(s->ac){
00465 put_symbol_inline(c, p->state[context], diff, 1);
00466 }else{
00467 if(context == 0) run_mode=1;
00468
00469 if(run_mode){
00470
00471 if(diff){
00472 while(run_count >= 1<<ff_log2_run[run_index]){
00473 run_count -= 1<<ff_log2_run[run_index];
00474 run_index++;
00475 put_bits(&s->pb, 1, 1);
00476 }
00477
00478 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
00479 if(run_index) run_index--;
00480 run_count=0;
00481 run_mode=0;
00482 if(diff>0) diff--;
00483 }else{
00484 run_count++;
00485 }
00486 }
00487
00488
00489
00490 if(run_mode == 0)
00491 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
00492 }
00493 }
00494 if(run_mode){
00495 while(run_count >= 1<<ff_log2_run[run_index]){
00496 run_count -= 1<<ff_log2_run[run_index];
00497 run_index++;
00498 put_bits(&s->pb, 1, 1);
00499 }
00500
00501 if(run_count)
00502 put_bits(&s->pb, 1, 1);
00503 }
00504 s->run_index= run_index;
00505
00506 return 0;
00507 }
00508
00509 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
00510 int x,y,i;
00511 const int ring_size= s->avctx->context_model ? 3 : 2;
00512 int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
00513 s->run_index=0;
00514
00515 memset(sample_buffer, 0, sizeof(sample_buffer));
00516
00517 for(y=0; y<h; y++){
00518 for(i=0; i<ring_size; i++)
00519 sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
00520
00521 sample[0][-1]= sample[1][0 ];
00522 sample[1][ w]= sample[1][w-1];
00523
00524 if(s->avctx->bits_per_raw_sample<=8){
00525 for(x=0; x<w; x++){
00526 sample[0][x]= src[x + stride*y];
00527 }
00528 encode_line(s, w, sample, plane_index, 8);
00529 }else{
00530 for(x=0; x<w; x++){
00531 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
00532 }
00533 encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
00534 }
00535
00536 }
00537 }
00538
00539 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
00540 int x, y, p, i;
00541 const int ring_size= s->avctx->context_model ? 3 : 2;
00542 int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
00543 s->run_index=0;
00544
00545 memset(sample_buffer, 0, sizeof(sample_buffer));
00546
00547 for(y=0; y<h; y++){
00548 for(i=0; i<ring_size; i++)
00549 for(p=0; p<3; p++)
00550 sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
00551
00552 for(x=0; x<w; x++){
00553 int v= src[x + stride*y];
00554 int b= v&0xFF;
00555 int g= (v>>8)&0xFF;
00556 int r= (v>>16)&0xFF;
00557
00558 b -= g;
00559 r -= g;
00560 g += (b + r)>>2;
00561 b += 0x100;
00562 r += 0x100;
00563
00564
00565
00566 sample[0][0][x]= g;
00567 sample[1][0][x]= b;
00568 sample[2][0][x]= r;
00569 }
00570 for(p=0; p<3; p++){
00571 sample[p][0][-1]= sample[p][1][0 ];
00572 sample[p][1][ w]= sample[p][1][w-1];
00573 encode_line(s, w, sample[p], FFMIN(p, 1), 9);
00574 }
00575 }
00576 }
00577
00578 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
00579 int last=0;
00580 int i;
00581 uint8_t state[CONTEXT_SIZE];
00582 memset(state, 128, sizeof(state));
00583
00584 for(i=1; i<128 ; i++){
00585 if(quant_table[i] != quant_table[i-1]){
00586 put_symbol(c, state, i-last-1, 0);
00587 last= i;
00588 }
00589 }
00590 put_symbol(c, state, i-last-1, 0);
00591 }
00592
00593 static void write_header(FFV1Context *f){
00594 uint8_t state[CONTEXT_SIZE];
00595 int i;
00596 RangeCoder * const c= &f->c;
00597
00598 memset(state, 128, sizeof(state));
00599
00600 put_symbol(c, state, f->version, 0);
00601 put_symbol(c, state, f->ac, 0);
00602 if(f->ac>1){
00603 for(i=1; i<256; i++){
00604 f->state_transition[i]=ver2_state[i];
00605 put_symbol(c, state, ver2_state[i] - c->one_state[i], 1);
00606 }
00607 }
00608 put_symbol(c, state, f->colorspace, 0);
00609 if(f->version>0)
00610 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
00611 put_rac(c, state, 1);
00612 put_symbol(c, state, f->chroma_h_shift, 0);
00613 put_symbol(c, state, f->chroma_v_shift, 0);
00614 put_rac(c, state, 0);
00615
00616 for(i=0; i<5; i++)
00617 write_quant_table(c, f->quant_table[i]);
00618 }
00619 #endif
00620
00621 static av_cold int common_init(AVCodecContext *avctx){
00622 FFV1Context *s = avctx->priv_data;
00623
00624 s->avctx= avctx;
00625 s->flags= avctx->flags;
00626
00627 dsputil_init(&s->dsp, avctx);
00628
00629 s->width = avctx->width;
00630 s->height= avctx->height;
00631
00632 assert(s->width && s->height);
00633
00634 return 0;
00635 }
00636
00637 #if CONFIG_FFV1_ENCODER
00638 static av_cold int encode_init(AVCodecContext *avctx)
00639 {
00640 FFV1Context *s = avctx->priv_data;
00641 int i;
00642
00643 common_init(avctx);
00644
00645 s->version=0;
00646 s->ac= avctx->coder_type ? 2:0;
00647
00648 s->plane_count=2;
00649 for(i=0; i<256; i++){
00650 if(avctx->bits_per_raw_sample <=8){
00651 s->quant_table[0][i]= quant11[i];
00652 s->quant_table[1][i]= 11*quant11[i];
00653 if(avctx->context_model==0){
00654 s->quant_table[2][i]= 11*11*quant11[i];
00655 s->quant_table[3][i]=
00656 s->quant_table[4][i]=0;
00657 }else{
00658 s->quant_table[2][i]= 11*11*quant5 [i];
00659 s->quant_table[3][i]= 5*11*11*quant5 [i];
00660 s->quant_table[4][i]= 5*5*11*11*quant5 [i];
00661 }
00662 }else{
00663 s->quant_table[0][i]= quant9_10bit[i];
00664 s->quant_table[1][i]= 11*quant9_10bit[i];
00665 if(avctx->context_model==0){
00666 s->quant_table[2][i]= 11*11*quant9_10bit[i];
00667 s->quant_table[3][i]=
00668 s->quant_table[4][i]=0;
00669 }else{
00670 s->quant_table[2][i]= 11*11*quant5_10bit[i];
00671 s->quant_table[3][i]= 5*11*11*quant5_10bit[i];
00672 s->quant_table[4][i]= 5*5*11*11*quant5_10bit[i];
00673 }
00674 }
00675 }
00676
00677 for(i=0; i<s->plane_count; i++){
00678 PlaneContext * const p= &s->plane[i];
00679
00680 if(avctx->context_model==0){
00681 p->context_count= (11*11*11+1)/2;
00682 }else{
00683 p->context_count= (11*11*5*5*5+1)/2;
00684 }
00685
00686 if(s->ac){
00687 if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
00688 }else{
00689 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
00690 }
00691 }
00692
00693 avctx->coded_frame= &s->picture;
00694 switch(avctx->pix_fmt){
00695 case PIX_FMT_YUV444P16:
00696 case PIX_FMT_YUV422P16:
00697 case PIX_FMT_YUV420P16:
00698 if(avctx->bits_per_raw_sample <=8){
00699 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
00700 return -1;
00701 }
00702 if(!s->ac){
00703 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
00704 return -1;
00705 }
00706 s->version= 1;
00707 case PIX_FMT_YUV444P:
00708 case PIX_FMT_YUV422P:
00709 case PIX_FMT_YUV420P:
00710 case PIX_FMT_YUV411P:
00711 case PIX_FMT_YUV410P:
00712 s->colorspace= 0;
00713 break;
00714 case PIX_FMT_RGB32:
00715 s->colorspace= 1;
00716 break;
00717 default:
00718 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
00719 return -1;
00720 }
00721 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
00722
00723 s->picture_number=0;
00724
00725 return 0;
00726 }
00727 #endif
00728
00729
00730 static void clear_state(FFV1Context *f){
00731 int i, j;
00732
00733 for(i=0; i<f->plane_count; i++){
00734 PlaneContext *p= &f->plane[i];
00735
00736 p->interlace_bit_state[0]= 128;
00737 p->interlace_bit_state[1]= 128;
00738
00739 for(j=0; j<p->context_count; j++){
00740 if(f->ac){
00741 memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
00742 }else{
00743 p->vlc_state[j].drift= 0;
00744 p->vlc_state[j].error_sum= 4;
00745 p->vlc_state[j].bias= 0;
00746 p->vlc_state[j].count= 1;
00747 }
00748 }
00749 }
00750 }
00751
00752 #if CONFIG_FFV1_ENCODER
00753 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
00754 FFV1Context *f = avctx->priv_data;
00755 RangeCoder * const c= &f->c;
00756 AVFrame *pict = data;
00757 const int width= f->width;
00758 const int height= f->height;
00759 AVFrame * const p= &f->picture;
00760 int used_count= 0;
00761 uint8_t keystate=128;
00762
00763 ff_init_range_encoder(c, buf, buf_size);
00764 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
00765
00766 *p = *pict;
00767 p->pict_type= FF_I_TYPE;
00768
00769 if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
00770 put_rac(c, &keystate, 1);
00771 p->key_frame= 1;
00772 write_header(f);
00773 clear_state(f);
00774 }else{
00775 put_rac(c, &keystate, 0);
00776 p->key_frame= 0;
00777 }
00778
00779 if(!f->ac){
00780 used_count += ff_rac_terminate(c);
00781
00782 init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
00783 }else if (f->ac>1){
00784 int i;
00785 for(i=1; i<256; i++){
00786 c->one_state[i]= f->state_transition[i];
00787 c->zero_state[256-i]= 256-c->one_state[i];
00788 }
00789 }
00790
00791 if(f->colorspace==0){
00792 const int chroma_width = -((-width )>>f->chroma_h_shift);
00793 const int chroma_height= -((-height)>>f->chroma_v_shift);
00794
00795 encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
00796
00797 encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
00798 encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
00799 }else{
00800 encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
00801 }
00802 emms_c();
00803
00804 f->picture_number++;
00805
00806 if(f->ac){
00807 return ff_rac_terminate(c);
00808 }else{
00809 flush_put_bits(&f->pb);
00810 return used_count + (put_bits_count(&f->pb)+7)/8;
00811 }
00812 }
00813 #endif
00814
00815 static av_cold int common_end(AVCodecContext *avctx){
00816 FFV1Context *s = avctx->priv_data;
00817 int i;
00818
00819 for(i=0; i<s->plane_count; i++){
00820 PlaneContext *p= &s->plane[i];
00821
00822 av_freep(&p->state);
00823 av_freep(&p->vlc_state);
00824 }
00825
00826 return 0;
00827 }
00828
00829 static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
00830 PlaneContext * const p= &s->plane[plane_index];
00831 RangeCoder * const c= &s->c;
00832 int x;
00833 int run_count=0;
00834 int run_mode=0;
00835 int run_index= s->run_index;
00836
00837 for(x=0; x<w; x++){
00838 int diff, context, sign;
00839
00840 context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
00841 if(context < 0){
00842 context= -context;
00843 sign=1;
00844 }else
00845 sign=0;
00846
00847
00848 if(s->ac){
00849 diff= get_symbol_inline(c, p->state[context], 1);
00850 }else{
00851 if(context == 0 && run_mode==0) run_mode=1;
00852
00853 if(run_mode){
00854 if(run_count==0 && run_mode==1){
00855 if(get_bits1(&s->gb)){
00856 run_count = 1<<ff_log2_run[run_index];
00857 if(x + run_count <= w) run_index++;
00858 }else{
00859 if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
00860 else run_count=0;
00861 if(run_index) run_index--;
00862 run_mode=2;
00863 }
00864 }
00865 run_count--;
00866 if(run_count < 0){
00867 run_mode=0;
00868 run_count=0;
00869 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
00870 if(diff>=0) diff++;
00871 }else
00872 diff=0;
00873 }else
00874 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
00875
00876
00877 }
00878
00879 if(sign) diff= -diff;
00880
00881 sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
00882 }
00883 s->run_index= run_index;
00884 }
00885
00886 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
00887 int x, y;
00888 int_fast16_t sample_buffer[2][w+6];
00889 int_fast16_t *sample[2];
00890 sample[0]=sample_buffer[0]+3;
00891 sample[1]=sample_buffer[1]+3;
00892
00893 s->run_index=0;
00894
00895 memset(sample_buffer, 0, sizeof(sample_buffer));
00896
00897 for(y=0; y<h; y++){
00898 int_fast16_t *temp= sample[0];
00899
00900 sample[0]= sample[1];
00901 sample[1]= temp;
00902
00903 sample[1][-1]= sample[0][0 ];
00904 sample[0][ w]= sample[0][w-1];
00905
00906
00907 if(s->avctx->bits_per_raw_sample <= 8){
00908 decode_line(s, w, sample, plane_index, 8);
00909 for(x=0; x<w; x++){
00910 src[x + stride*y]= sample[1][x];
00911 }
00912 }else{
00913 decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
00914 for(x=0; x<w; x++){
00915 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
00916 }
00917 }
00918
00919 }
00920 }
00921
00922 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
00923 int x, y, p;
00924 int_fast16_t sample_buffer[3][2][w+6];
00925 int_fast16_t *sample[3][2];
00926 for(x=0; x<3; x++){
00927 sample[x][0] = sample_buffer[x][0]+3;
00928 sample[x][1] = sample_buffer[x][1]+3;
00929 }
00930
00931 s->run_index=0;
00932
00933 memset(sample_buffer, 0, sizeof(sample_buffer));
00934
00935 for(y=0; y<h; y++){
00936 for(p=0; p<3; p++){
00937 int_fast16_t *temp= sample[p][0];
00938
00939 sample[p][0]= sample[p][1];
00940 sample[p][1]= temp;
00941
00942 sample[p][1][-1]= sample[p][0][0 ];
00943 sample[p][0][ w]= sample[p][0][w-1];
00944 decode_line(s, w, sample[p], FFMIN(p, 1), 9);
00945 }
00946 for(x=0; x<w; x++){
00947 int g= sample[0][1][x];
00948 int b= sample[1][1][x];
00949 int r= sample[2][1][x];
00950
00951
00952
00953
00954 b -= 0x100;
00955 r -= 0x100;
00956 g -= (b + r)>>2;
00957 b += g;
00958 r += g;
00959
00960 src[x + stride*y]= b + (g<<8) + (r<<16);
00961 }
00962 }
00963 }
00964
00965 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
00966 int v;
00967 int i=0;
00968 uint8_t state[CONTEXT_SIZE];
00969
00970 memset(state, 128, sizeof(state));
00971
00972 for(v=0; i<128 ; v++){
00973 int len= get_symbol(c, state, 0) + 1;
00974
00975 if(len + i > 128) return -1;
00976
00977 while(len--){
00978 quant_table[i] = scale*v;
00979 i++;
00980
00981
00982 }
00983 }
00984
00985 for(i=1; i<128; i++){
00986 quant_table[256-i]= -quant_table[i];
00987 }
00988 quant_table[128]= -quant_table[127];
00989
00990 return 2*v - 1;
00991 }
00992
00993 static int read_header(FFV1Context *f){
00994 uint8_t state[CONTEXT_SIZE];
00995 int i, context_count;
00996 RangeCoder * const c= &f->c;
00997
00998 memset(state, 128, sizeof(state));
00999
01000 f->version= get_symbol(c, state, 0);
01001 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
01002 if(f->ac>1){
01003 for(i=1; i<256; i++){
01004 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
01005 }
01006 }
01007 f->colorspace= get_symbol(c, state, 0);
01008 if(f->version>0)
01009 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
01010 get_rac(c, state);
01011 f->chroma_h_shift= get_symbol(c, state, 0);
01012 f->chroma_v_shift= get_symbol(c, state, 0);
01013 get_rac(c, state);
01014 f->plane_count= 2;
01015
01016 if(f->colorspace==0){
01017 if(f->avctx->bits_per_raw_sample<=8){
01018 switch(16*f->chroma_h_shift + f->chroma_v_shift){
01019 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
01020 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
01021 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
01022 case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
01023 case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
01024 default:
01025 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
01026 return -1;
01027 }
01028 }else{
01029 switch(16*f->chroma_h_shift + f->chroma_v_shift){
01030 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
01031 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
01032 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
01033 default:
01034 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
01035 return -1;
01036 }
01037 }
01038 }else if(f->colorspace==1){
01039 if(f->chroma_h_shift || f->chroma_v_shift){
01040 av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
01041 return -1;
01042 }
01043 f->avctx->pix_fmt= PIX_FMT_RGB32;
01044 }else{
01045 av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
01046 return -1;
01047 }
01048
01049
01050
01051 context_count=1;
01052 for(i=0; i<5; i++){
01053 context_count*= read_quant_table(c, f->quant_table[i], context_count);
01054 if(context_count < 0 || context_count > 32768){
01055 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
01056 return -1;
01057 }
01058 }
01059 context_count= (context_count+1)/2;
01060
01061 for(i=0; i<f->plane_count; i++){
01062 PlaneContext * const p= &f->plane[i];
01063
01064 p->context_count= context_count;
01065
01066 if(f->ac){
01067 if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
01068 }else{
01069 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
01070 }
01071 }
01072
01073 return 0;
01074 }
01075
01076 static av_cold int decode_init(AVCodecContext *avctx)
01077 {
01078
01079
01080 common_init(avctx);
01081
01082 return 0;
01083 }
01084
01085 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
01086 const uint8_t *buf = avpkt->data;
01087 int buf_size = avpkt->size;
01088 FFV1Context *f = avctx->priv_data;
01089 RangeCoder * const c= &f->c;
01090 const int width= f->width;
01091 const int height= f->height;
01092 AVFrame * const p= &f->picture;
01093 int bytes_read;
01094 uint8_t keystate= 128;
01095
01096 AVFrame *picture = data;
01097
01098 ff_init_range_decoder(c, buf, buf_size);
01099 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
01100
01101
01102 p->pict_type= FF_I_TYPE;
01103 if(get_rac(c, &keystate)){
01104 p->key_frame= 1;
01105 if(read_header(f) < 0)
01106 return -1;
01107 clear_state(f);
01108 }else{
01109 p->key_frame= 0;
01110 }
01111 if(f->ac>1){
01112 int i;
01113 for(i=1; i<256; i++){
01114 c->one_state[i]= f->state_transition[i];
01115 c->zero_state[256-i]= 256-c->one_state[i];
01116 }
01117 }
01118
01119 if(!f->plane[0].state && !f->plane[0].vlc_state)
01120 return -1;
01121
01122 p->reference= 0;
01123 if(avctx->get_buffer(avctx, p) < 0){
01124 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
01125 return -1;
01126 }
01127
01128 if(avctx->debug&FF_DEBUG_PICT_INFO)
01129 av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
01130
01131 if(!f->ac){
01132 bytes_read = c->bytestream - c->bytestream_start - 1;
01133 if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n");
01134
01135 init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
01136 } else {
01137 bytes_read = 0;
01138 }
01139
01140 if(f->colorspace==0){
01141 const int chroma_width = -((-width )>>f->chroma_h_shift);
01142 const int chroma_height= -((-height)>>f->chroma_v_shift);
01143 decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
01144
01145 decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
01146 decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
01147 }else{
01148 decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
01149 }
01150
01151 emms_c();
01152
01153 f->picture_number++;
01154
01155 *picture= *p;
01156
01157 avctx->release_buffer(avctx, p);
01158
01159 *data_size = sizeof(AVFrame);
01160
01161 if(f->ac){
01162 bytes_read= c->bytestream - c->bytestream_start - 1;
01163 if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
01164 }else{
01165 bytes_read+= (get_bits_count(&f->gb)+7)/8;
01166 }
01167
01168 return bytes_read;
01169 }
01170
01171 AVCodec ffv1_decoder = {
01172 "ffv1",
01173 AVMEDIA_TYPE_VIDEO,
01174 CODEC_ID_FFV1,
01175 sizeof(FFV1Context),
01176 decode_init,
01177 NULL,
01178 common_end,
01179 decode_frame,
01180 CODEC_CAP_DR1 ,
01181 NULL,
01182 .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
01183 };
01184
01185 #if CONFIG_FFV1_ENCODER
01186 AVCodec ffv1_encoder = {
01187 "ffv1",
01188 AVMEDIA_TYPE_VIDEO,
01189 CODEC_ID_FFV1,
01190 sizeof(FFV1Context),
01191 encode_init,
01192 encode_frame,
01193 common_end,
01194 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_NONE},
01195 .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
01196 };
01197 #endif