2 * FFV1 codec for libavcodec
4 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
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.
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.
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
25 * FF Video Codec 1 (a lossless codec)
32 #include "rangecoder.h"
35 #include "libavutil/avassert.h"
38 #define CONTEXT_SIZE 32
40 #define MAX_QUANT_TABLES 8
41 #define MAX_CONTEXT_INPUTS 5
43 extern const uint8_t ff_log2_run[32];
45 static const int8_t quant3[256]={
46 0, 0, 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,-1,
58 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
59 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
60 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
61 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
64 static const int8_t quant5_10bit[256]={
65 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
66 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
67 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
68 1, 1, 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,-2,
74 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
75 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
76 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
77 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,
78 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
79 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
80 -1,-1,-1,-1,-1,-1,-0,-0,-0,-0,-0,-0,-0,-0,-0,-0,
83 static const int8_t quant5[256]={
84 0, 1, 1, 1, 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,-2,-2,-2,
96 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
97 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
98 -2,-2,-2,-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,-1,-1,-1,
101 static const int8_t quant7[256]={
102 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104 2, 2, 2, 2, 2, 2, 2, 2, 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,-3,-3,-3,-3,-3,-3,-3,
112 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
113 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
114 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
115 -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
116 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
117 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
119 static const int8_t quant9[256]={
120 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
121 3, 3, 3, 3, 3, 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,-4,-4,-4,-4,
131 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
132 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
133 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
134 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
135 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
137 static const int8_t quant9_10bit[256]={
138 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
139 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
140 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
141 3, 3, 3, 3, 3, 3, 3, 3, 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,-4,-4,-4,-4,-4,-4,-4,
147 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
148 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
149 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
150 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,
151 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
152 -3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
153 -2,-2,-2,-2,-1,-1,-1,-1,-1,-1,-1,-1,-0,-0,-0,-0,
156 static const int8_t quant11[256]={
157 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
158 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
159 4, 4, 4, 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,-5,-5,
167 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
168 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
169 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
170 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
171 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
172 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
174 static const int8_t quant13[256]={
175 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
176 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
177 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
178 5, 5, 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,-6,
184 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
185 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
186 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
187 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
188 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
189 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
190 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
193 static const uint8_t ver2_state[256]= {
194 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
195 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,
196 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,
197 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,
198 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,
199 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,
200 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,
201 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,
202 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,
203 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,
204 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,
205 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,
206 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,
207 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,
208 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,
209 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,
212 typedef struct VlcState{
219 typedef struct PlaneContext{
220 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
222 uint8_t (*state)[CONTEXT_SIZE];
224 uint8_t interlace_bit_state[2];
227 #define MAX_SLICES 256
229 typedef struct FFV1Context{
230 AVCodecContext *avctx;
236 int chroma_h_shift, chroma_v_shift;
241 int ac; ///< 1=range coder <-> 0=golomb rice
242 PlaneContext plane[MAX_PLANES];
243 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
244 int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
245 int context_count[MAX_QUANT_TABLES];
246 uint8_t state_transition[256];
249 int_fast16_t *sample_buffer;
251 int quant_table_count;
255 struct FFV1Context *slice_context[MAX_SLICES];
265 static av_always_inline int fold(int diff, int bits){
277 static inline int predict(int_fast16_t *src, int_fast16_t *last){
278 const int LT= last[-1];
279 const int T= last[ 0];
280 const int L = src[-1];
282 return mid_pred(L, L + T - LT, T);
285 static inline int get_context(PlaneContext *p, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
286 const int LT= last[-1];
287 const int T= last[ 0];
288 const int RT= last[ 1];
289 const int L = src[-1];
291 if(p->quant_table[3][127]){
292 const int TT= last2[0];
293 const int LL= src[-2];
294 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
295 +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
297 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
300 static inline void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed){
304 const int a= FFABS(v);
305 const int e= av_log2(a);
306 put_rac(c, state+0, 0);
309 put_rac(c, state+1+i, 1); //1..10
311 put_rac(c, state+1+i, 0);
313 for(i=e-1; i>=0; i--){
314 put_rac(c, state+22+i, (a>>i)&1); //22..31
318 put_rac(c, state+11 + e, v < 0); //11..21
321 put_rac(c, state+1+FFMIN(i,9), 1); //1..10
323 put_rac(c, state+1+9, 0);
325 for(i=e-1; i>=0; i--){
326 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
330 put_rac(c, state+11 + 10, v < 0); //11..21
333 put_rac(c, state+0, 1);
337 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
338 put_symbol_inline(c, state, v, is_signed);
341 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
342 if(get_rac(c, state+0))
347 while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
352 for(i=e-1; i>=0; i--){
353 a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
356 e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
361 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
362 return get_symbol_inline(c, state, is_signed);
365 static inline void update_vlc_state(VlcState * const state, const int v){
366 int drift= state->drift;
367 int count= state->count;
368 state->error_sum += FFABS(v);
371 if(count == 128){ //FIXME variable
374 state->error_sum >>= 1;
379 if(state->bias > -128) state->bias--;
385 if(state->bias < 127) state->bias++;
396 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
398 //printf("final: %d ", v);
399 v = fold(v - state->bias, bits);
403 while(i < state->error_sum){ //FIXME optimize
411 if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
414 code= v ^ ((2*state->drift + state->count)>>31);
417 //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);
418 set_sr_golomb(pb, code, k, 12, bits);
420 update_vlc_state(state, v);
423 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
428 while(i < state->error_sum){ //FIXME optimize
435 v= get_sr_golomb(gb, k, 12, bits);
436 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
439 if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
441 v ^= ((2*state->drift + state->count)>>31);
444 ret= fold(v + state->bias, bits);
446 update_vlc_state(state, v);
447 //printf("final: %d\n", ret);
451 #if CONFIG_FFV1_ENCODER
452 static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
453 PlaneContext * const p= &s->plane[plane_index];
454 RangeCoder * const c= &s->c;
456 int run_index= s->run_index;
461 if(c->bytestream_end - c->bytestream < w*20){
462 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
466 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
467 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
475 context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
476 diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
483 diff= fold(diff, bits);
486 put_symbol_inline(c, p->state[context], diff, 1);
488 if(context == 0) run_mode=1;
493 while(run_count >= 1<<ff_log2_run[run_index]){
494 run_count -= 1<<ff_log2_run[run_index];
496 put_bits(&s->pb, 1, 1);
499 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
500 if(run_index) run_index--;
509 // 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));
512 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
516 while(run_count >= 1<<ff_log2_run[run_index]){
517 run_count -= 1<<ff_log2_run[run_index];
519 put_bits(&s->pb, 1, 1);
523 put_bits(&s->pb, 1, 1);
525 s->run_index= run_index;
530 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
532 const int ring_size= s->avctx->context_model ? 3 : 2;
533 int_fast16_t *sample[3];
536 memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
539 for(i=0; i<ring_size; i++)
540 sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
542 sample[0][-1]= sample[1][0 ];
543 sample[1][ w]= sample[1][w-1];
545 if(s->avctx->bits_per_raw_sample<=8){
547 sample[0][x]= src[x + stride*y];
549 encode_line(s, w, sample, plane_index, 8);
552 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
554 encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
556 //STOP_TIMER("encode line")}
560 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
562 const int ring_size= s->avctx->context_model ? 3 : 2;
563 int_fast16_t *sample[3][3];
566 memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
569 for(i=0; i<ring_size; i++)
571 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
574 int v= src[x + stride*y];
585 // assert(g>=0 && b>=0 && r>=0);
586 // assert(g<256 && b<512 && r<512);
592 sample[p][0][-1]= sample[p][1][0 ];
593 sample[p][1][ w]= sample[p][1][w-1];
594 encode_line(s, w, sample[p], FFMIN(p, 1), 9);
599 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
602 uint8_t state[CONTEXT_SIZE];
603 memset(state, 128, sizeof(state));
605 for(i=1; i<128 ; i++){
606 if(quant_table[i] != quant_table[i-1]){
607 put_symbol(c, state, i-last-1, 0);
611 put_symbol(c, state, i-last-1, 0);
614 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
617 write_quant_table(c, quant_table[i]);
620 static void write_header(FFV1Context *f){
621 uint8_t state[CONTEXT_SIZE];
623 RangeCoder * const c= &f->slice_context[0]->c;
625 memset(state, 128, sizeof(state));
628 put_symbol(c, state, f->version, 0);
629 put_symbol(c, state, f->ac, 0);
631 for(i=1; i<256; i++){
632 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
635 put_symbol(c, state, f->colorspace, 0); //YUV cs type
637 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
638 put_rac(c, state, 1); //chroma planes
639 put_symbol(c, state, f->chroma_h_shift, 0);
640 put_symbol(c, state, f->chroma_v_shift, 0);
641 put_rac(c, state, 0); //no transparency plane
643 write_quant_tables(c, f->quant_table);
645 put_symbol(c, state, f->slice_count, 0);
646 for(i=0; i<f->slice_count; i++){
647 FFV1Context *fs= f->slice_context[i];
648 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
649 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
650 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
651 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
652 for(j=0; j<f->plane_count; j++)
653 put_symbol(c, state, f->avctx->context_model, 0);
657 #endif /* CONFIG_FFV1_ENCODER */
659 static av_cold int common_init(AVCodecContext *avctx){
660 FFV1Context *s = avctx->priv_data;
663 s->flags= avctx->flags;
665 dsputil_init(&s->dsp, avctx);
667 s->width = avctx->width;
668 s->height= avctx->height;
670 assert(s->width && s->height);
679 static int init_slice_state(FFV1Context *f){
682 for(i=0; i<f->slice_count; i++){
683 FFV1Context *fs= f->slice_context[i];
684 for(j=0; j<f->plane_count; j++){
685 PlaneContext * const p= &fs->plane[j];
688 if(!p-> state) p-> state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
690 return AVERROR(ENOMEM);
692 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
694 return AVERROR(ENOMEM);
699 //FIXME only redo if state_transition changed
700 for(j=1; j<256; j++){
701 fs->c.one_state [ j]= fs->state_transition[j];
702 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
710 static av_cold int init_slice_contexts(FFV1Context *f){
713 f->slice_count= f->num_h_slices * f->num_v_slices;
715 for(i=0; i<f->slice_count; i++){
716 FFV1Context *fs= av_mallocz(sizeof(*fs));
717 int sx= i % f->num_h_slices;
718 int sy= i / f->num_h_slices;
719 int sxs= f->avctx->width * sx / f->num_h_slices;
720 int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
721 int sys= f->avctx->height* sy / f->num_v_slices;
722 int sye= f->avctx->height*(sy+1) / f->num_v_slices;
723 f->slice_context[i]= fs;
724 memcpy(fs, f, sizeof(*fs));
726 fs->slice_width = sxe - sxs;
727 fs->slice_height= sye - sys;
731 fs->sample_buffer = av_malloc(6 * (fs->width+6) * sizeof(*fs->sample_buffer));
732 if (!fs->sample_buffer)
733 return AVERROR(ENOMEM);
738 #if CONFIG_FFV1_ENCODER
739 static int write_extra_header(FFV1Context *f){
740 RangeCoder * const c= &f->c;
741 uint8_t state[CONTEXT_SIZE];
743 memset(state, 128, sizeof(state));
745 f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000);
746 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
747 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
749 put_symbol(c, state, f->version, 0);
750 put_symbol(c, state, f->ac, 0);
752 for(i=1; i<256; i++){
753 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
756 put_symbol(c, state, f->colorspace, 0); //YUV cs type
757 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
758 put_rac(c, state, 1); //chroma planes
759 put_symbol(c, state, f->chroma_h_shift, 0);
760 put_symbol(c, state, f->chroma_v_shift, 0);
761 put_rac(c, state, 0); //no transparency plane
762 put_symbol(c, state, f->num_h_slices-1, 0);
763 put_symbol(c, state, f->num_v_slices-1, 0);
765 put_symbol(c, state, f->quant_table_count, 0);
766 for(i=0; i<f->quant_table_count; i++)
767 write_quant_tables(c, f->quant_tables[i]);
769 f->avctx->extradata_size= ff_rac_terminate(c);
774 static av_cold int encode_init(AVCodecContext *avctx)
776 FFV1Context *s = avctx->priv_data;
782 s->ac= avctx->coder_type ? 2:0;
786 s->state_transition[i]=ver2_state[i];
789 for(i=0; i<256; i++){
790 s->quant_table_count=2;
791 if(avctx->bits_per_raw_sample <=8){
792 s->quant_tables[0][0][i]= quant11[i];
793 s->quant_tables[0][1][i]= 11*quant11[i];
794 s->quant_tables[0][2][i]= 11*11*quant11[i];
795 s->quant_tables[1][0][i]= quant11[i];
796 s->quant_tables[1][1][i]= 11*quant11[i];
797 s->quant_tables[1][2][i]= 11*11*quant5 [i];
798 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
799 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
801 s->quant_tables[0][0][i]= quant9_10bit[i];
802 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
803 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
804 s->quant_tables[1][0][i]= quant9_10bit[i];
805 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
806 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
807 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
808 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
811 memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
813 for(i=0; i<s->plane_count; i++){
814 PlaneContext * const p= &s->plane[i];
816 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
817 if(avctx->context_model==0){
818 p->context_count= (11*11*11+1)/2;
820 p->context_count= (11*11*5*5*5+1)/2;
824 avctx->coded_frame= &s->picture;
825 switch(avctx->pix_fmt){
826 case PIX_FMT_YUV444P16:
827 case PIX_FMT_YUV422P16:
828 case PIX_FMT_YUV420P16:
829 if(avctx->bits_per_raw_sample <=8){
830 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
834 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
837 s->version= FFMAX(s->version, 1);
838 case PIX_FMT_YUV444P:
839 case PIX_FMT_YUV422P:
840 case PIX_FMT_YUV420P:
841 case PIX_FMT_YUV411P:
842 case PIX_FMT_YUV410P:
849 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
852 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
859 write_extra_header(s);
862 if(init_slice_contexts(s) < 0)
864 if(init_slice_state(s) < 0)
869 #endif /* CONFIG_FFV1_ENCODER */
872 static void clear_state(FFV1Context *f){
875 for(si=0; si<f->slice_count; si++){
876 FFV1Context *fs= f->slice_context[si];
877 for(i=0; i<f->plane_count; i++){
878 PlaneContext *p= &fs->plane[i];
880 p->interlace_bit_state[0]= 128;
881 p->interlace_bit_state[1]= 128;
883 for(j=0; j<p->context_count; j++){
885 memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
887 p->vlc_state[j].drift= 0;
888 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
889 p->vlc_state[j].bias= 0;
890 p->vlc_state[j].count= 1;
897 #if CONFIG_FFV1_ENCODER
898 static int encode_slice(AVCodecContext *c, void *arg){
899 FFV1Context *fs= *(void**)arg;
900 FFV1Context *f= fs->avctx->priv_data;
901 int width = fs->slice_width;
902 int height= fs->slice_height;
905 AVFrame * const p= &f->picture;
907 if(f->colorspace==0){
908 const int chroma_width = -((-width )>>f->chroma_h_shift);
909 const int chroma_height= -((-height)>>f->chroma_v_shift);
910 const int cx= x>>f->chroma_h_shift;
911 const int cy= y>>f->chroma_v_shift;
913 encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
915 encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
916 encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
918 encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
925 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
926 FFV1Context *f = avctx->priv_data;
927 RangeCoder * const c= &f->slice_context[0]->c;
928 AVFrame *pict = data;
929 AVFrame * const p= &f->picture;
931 uint8_t keystate=128;
935 ff_init_range_encoder(c, buf, buf_size);
936 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
939 p->pict_type= FF_I_TYPE;
941 if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
942 put_rac(c, &keystate, 1);
947 put_rac(c, &keystate, 0);
952 used_count += ff_rac_terminate(c);
953 //printf("pos=%d\n", used_count);
954 init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
957 for(i=1; i<256; i++){
958 c->one_state[i]= f->state_transition[i];
959 c->zero_state[256-i]= 256-c->one_state[i];
963 for(i=1; i<f->slice_count; i++){
964 FFV1Context *fs= f->slice_context[i];
965 uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
966 int len= buf_size/f->slice_count;
969 ff_init_range_encoder(&fs->c, start, len);
971 init_put_bits(&fs->pb, start, len);
974 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
977 for(i=0; i<f->slice_count; i++){
978 FFV1Context *fs= f->slice_context[i];
983 put_rac(&fs->c, &state, 0);
984 bytes= ff_rac_terminate(&fs->c);
986 flush_put_bits(&fs->pb); //nicer padding FIXME
987 bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
991 av_assert0(bytes < buf_size/f->slice_count);
992 memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
993 av_assert0(bytes < (1<<24));
994 AV_WB24(buf_p+bytes, bytes);
1000 f->picture_number++;
1003 #endif /* CONFIG_FFV1_ENCODER */
1005 static av_cold int common_end(AVCodecContext *avctx){
1006 FFV1Context *s = avctx->priv_data;
1009 for(j=0; j<s->slice_count; j++){
1010 FFV1Context *fs= s->slice_context[j];
1011 for(i=0; i<s->plane_count; i++){
1012 PlaneContext *p= &fs->plane[i];
1014 av_freep(&p->state);
1015 av_freep(&p->vlc_state);
1017 av_freep(&fs->sample_buffer);
1023 static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
1024 PlaneContext * const p= &s->plane[plane_index];
1025 RangeCoder * const c= &s->c;
1029 int run_index= s->run_index;
1032 int diff, context, sign;
1034 context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1041 av_assert2(context < p->context_count);
1044 diff= get_symbol_inline(c, p->state[context], 1);
1046 if(context == 0 && run_mode==0) run_mode=1;
1049 if(run_count==0 && run_mode==1){
1050 if(get_bits1(&s->gb)){
1051 run_count = 1<<ff_log2_run[run_index];
1052 if(x + run_count <= w) run_index++;
1054 if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1056 if(run_index) run_index--;
1064 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1069 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1071 // 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));
1074 if(sign) diff= -diff;
1076 sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1078 s->run_index= run_index;
1081 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1083 int_fast16_t *sample[2];
1084 sample[0]=s->sample_buffer +3;
1085 sample[1]=s->sample_buffer+w+6+3;
1089 memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1092 int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
1094 sample[0]= sample[1];
1097 sample[1][-1]= sample[0][0 ];
1098 sample[0][ w]= sample[0][w-1];
1101 if(s->avctx->bits_per_raw_sample <= 8){
1102 decode_line(s, w, sample, plane_index, 8);
1104 src[x + stride*y]= sample[1][x];
1107 decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1109 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1112 //STOP_TIMER("decode-line")}
1116 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1118 int_fast16_t *sample[3][2];
1120 sample[x][0] = s->sample_buffer + x*2 *(w+6) + 3;
1121 sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1126 memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1130 int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
1132 sample[p][0]= sample[p][1];
1135 sample[p][1][-1]= sample[p][0][0 ];
1136 sample[p][0][ w]= sample[p][0][w-1];
1137 decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1140 int g= sample[0][1][x];
1141 int b= sample[1][1][x];
1142 int r= sample[2][1][x];
1144 // assert(g>=0 && b>=0 && r>=0);
1145 // assert(g<256 && b<512 && r<512);
1153 src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1158 static int decode_slice(AVCodecContext *c, void *arg){
1159 FFV1Context *fs= *(void**)arg;
1160 FFV1Context *f= fs->avctx->priv_data;
1161 int width = fs->slice_width;
1162 int height= fs->slice_height;
1165 AVFrame * const p= &f->picture;
1167 av_assert1(width && height);
1168 if(f->colorspace==0){
1169 const int chroma_width = -((-width )>>f->chroma_h_shift);
1170 const int chroma_height= -((-height)>>f->chroma_v_shift);
1171 const int cx= x>>f->chroma_h_shift;
1172 const int cy= y>>f->chroma_v_shift;
1173 decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1175 decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1176 decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1178 decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1186 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1189 uint8_t state[CONTEXT_SIZE];
1191 memset(state, 128, sizeof(state));
1193 for(v=0; i<128 ; v++){
1194 int len= get_symbol(c, state, 0) + 1;
1196 if(len + i > 128) return -1;
1199 quant_table[i] = scale*v;
1202 //if(i%16==0) printf("\n");
1206 for(i=1; i<128; i++){
1207 quant_table[256-i]= -quant_table[i];
1209 quant_table[128]= -quant_table[127];
1214 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1216 int context_count=1;
1219 context_count*= read_quant_table(c, quant_table[i], context_count);
1220 if(context_count > 32768U){
1224 return (context_count+1)/2;
1227 static int read_extra_header(FFV1Context *f){
1228 RangeCoder * const c= &f->c;
1229 uint8_t state[CONTEXT_SIZE];
1232 memset(state, 128, sizeof(state));
1234 ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1235 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1237 f->version= get_symbol(c, state, 0);
1238 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1240 for(i=1; i<256; i++){
1241 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1244 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1245 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1246 get_rac(c, state); //no chroma = false
1247 f->chroma_h_shift= get_symbol(c, state, 0);
1248 f->chroma_v_shift= get_symbol(c, state, 0);
1249 get_rac(c, state); //transparency plane
1251 f->num_h_slices= 1 + get_symbol(c, state, 0);
1252 f->num_v_slices= 1 + get_symbol(c, state, 0);
1253 if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1254 av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1258 f->quant_table_count= get_symbol(c, state, 0);
1259 if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1261 for(i=0; i<f->quant_table_count; i++){
1262 if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1263 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1271 static int read_header(FFV1Context *f){
1272 uint8_t state[CONTEXT_SIZE];
1273 int i, j, context_count;
1274 RangeCoder * const c= &f->slice_context[0]->c;
1276 memset(state, 128, sizeof(state));
1279 f->version= get_symbol(c, state, 0);
1280 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1282 for(i=1; i<256; i++){
1283 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1286 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1288 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1289 get_rac(c, state); //no chroma = false
1290 f->chroma_h_shift= get_symbol(c, state, 0);
1291 f->chroma_v_shift= get_symbol(c, state, 0);
1292 get_rac(c, state); //transparency plane
1296 if(f->colorspace==0){
1297 if(f->avctx->bits_per_raw_sample<=8){
1298 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1299 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1300 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1301 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1302 case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1303 case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1305 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1309 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1310 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1311 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1312 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1314 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1318 }else if(f->colorspace==1){
1319 if(f->chroma_h_shift || f->chroma_v_shift){
1320 av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1323 f->avctx->pix_fmt= PIX_FMT_RGB32;
1325 av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1329 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1331 context_count= read_quant_tables(c, f->quant_table);
1332 if(context_count < 0){
1333 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1337 f->slice_count= get_symbol(c, state, 0);
1338 if(f->slice_count > (unsigned)MAX_SLICES)
1342 for(j=0; j<f->slice_count; j++){
1343 FFV1Context *fs= f->slice_context[j];
1346 if(f->version >= 2){
1347 fs->slice_x = get_symbol(c, state, 0) *f->width ;
1348 fs->slice_y = get_symbol(c, state, 0) *f->height;
1349 fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
1350 fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1352 fs->slice_x /= f->num_h_slices;
1353 fs->slice_y /= f->num_v_slices;
1354 fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
1355 fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1356 if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1358 if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
1359 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1363 for(i=0; i<f->plane_count; i++){
1364 PlaneContext * const p= &fs->plane[i];
1366 if(f->version >= 2){
1367 int idx=get_symbol(c, state, 0);
1368 if(idx > (unsigned)f->quant_table_count){
1369 av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1372 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1373 context_count= f->context_count[idx];
1375 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1378 if(p->context_count < context_count){
1379 av_freep(&p->state);
1380 av_freep(&p->vlc_state);
1382 p->context_count= context_count;
1389 static av_cold int decode_init(AVCodecContext *avctx)
1391 FFV1Context *f = avctx->priv_data;
1395 if(avctx->extradata && read_extra_header(f) < 0)
1398 if(init_slice_contexts(f) < 0)
1404 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1405 const uint8_t *buf = avpkt->data;
1406 int buf_size = avpkt->size;
1407 FFV1Context *f = avctx->priv_data;
1408 RangeCoder * const c= &f->slice_context[0]->c;
1409 AVFrame * const p= &f->picture;
1411 uint8_t keystate= 128;
1412 const uint8_t *buf_p;
1414 AVFrame *picture = data;
1416 ff_init_range_decoder(c, buf, buf_size);
1417 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1420 p->pict_type= FF_I_TYPE; //FIXME I vs. P
1421 if(get_rac(c, &keystate)){
1423 if(read_header(f) < 0)
1425 if(init_slice_state(f) < 0)
1434 for(i=1; i<256; i++){
1435 c->one_state[i]= f->state_transition[i];
1436 c->zero_state[256-i]= 256-c->one_state[i];
1441 if(avctx->get_buffer(avctx, p) < 0){
1442 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1446 if(avctx->debug&FF_DEBUG_PICT_INFO)
1447 av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1450 bytes_read = c->bytestream - c->bytestream_start - 1;
1451 if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1452 //printf("pos=%d\n", bytes_read);
1453 init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, buf_size - bytes_read);
1455 bytes_read = 0; /* avoid warning */
1458 buf_p= buf + buf_size;
1459 for(i=f->slice_count-1; i>0; i--){
1460 FFV1Context *fs= f->slice_context[i];
1461 int v= AV_RB24(buf_p-3)+3;
1462 if(buf_p - buf <= v){
1463 av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1468 ff_init_range_decoder(&fs->c, buf_p, v);
1470 init_get_bits(&fs->gb, buf_p, v);
1474 avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1475 f->picture_number++;
1479 avctx->release_buffer(avctx, p); //FIXME
1481 *data_size = sizeof(AVFrame);
1486 AVCodec ffv1_decoder = {
1490 sizeof(FFV1Context),
1495 CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1497 .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1500 #if CONFIG_FFV1_ENCODER
1501 AVCodec ffv1_encoder = {
1505 sizeof(FFV1Context),
1509 .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},
1510 .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),