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