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];
221 int quant_table_index;
223 uint8_t (*state)[CONTEXT_SIZE];
225 uint8_t interlace_bit_state[2];
228 #define MAX_SLICES 256
230 typedef struct FFV1Context{
231 AVCodecContext *avctx;
235 uint64_t rc_stat[256][2];
236 uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
239 int chroma_h_shift, chroma_v_shift;
244 int ac; ///< 1=range coder <-> 0=golomb rice
245 PlaneContext plane[MAX_PLANES];
246 int16_t quant_table[MAX_CONTEXT_INPUTS][256];
247 int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
248 int context_count[MAX_QUANT_TABLES];
249 uint8_t state_transition[256];
250 uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
253 int_fast16_t *sample_buffer;
256 int quant_table_count;
260 struct FFV1Context *slice_context[MAX_SLICES];
270 static av_always_inline int fold(int diff, int bits){
282 static inline int predict(int_fast16_t *src, int_fast16_t *last){
283 const int LT= last[-1];
284 const int T= last[ 0];
285 const int L = src[-1];
287 return mid_pred(L, L + T - LT, T);
290 static inline int get_context(PlaneContext *p, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
291 const int LT= last[-1];
292 const int T= last[ 0];
293 const int RT= last[ 1];
294 const int L = src[-1];
296 if(p->quant_table[3][127]){
297 const int TT= last2[0];
298 const int LL= src[-2];
299 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
300 +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
302 return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
305 static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
310 l2tab[i]= log2(i/256.0);
312 for(i=0; i<256; i++){
313 double best_len[256];
319 for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
323 for(k=0; k<256; k++){
324 double newocc[256]={0};
325 for(m=0; m<256; m++){
327 len -=occ[m]*( p *l2tab[ m]
328 + (1-p)*l2tab[256-m]);
331 if(len < best_len[k]){
335 for(m=0; m<256; m++){
337 newocc[ one_state[ m]] += occ[m]* p ;
338 newocc[256-one_state[256-m]] += occ[m]*(1-p);
341 memcpy(occ, newocc, sizeof(occ));
347 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2]){
350 #define put_rac(C,S,B) \
354 rc_stat2[(S)-state][B]++;\
360 const int a= FFABS(v);
361 const int e= av_log2(a);
362 put_rac(c, state+0, 0);
365 put_rac(c, state+1+i, 1); //1..10
367 put_rac(c, state+1+i, 0);
369 for(i=e-1; i>=0; i--){
370 put_rac(c, state+22+i, (a>>i)&1); //22..31
374 put_rac(c, state+11 + e, v < 0); //11..21
377 put_rac(c, state+1+FFMIN(i,9), 1); //1..10
379 put_rac(c, state+1+9, 0);
381 for(i=e-1; i>=0; i--){
382 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
386 put_rac(c, state+11 + 10, v < 0); //11..21
389 put_rac(c, state+0, 1);
394 static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
395 put_symbol_inline(c, state, v, is_signed, NULL, NULL);
398 static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
399 if(get_rac(c, state+0))
404 while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
409 for(i=e-1; i>=0; i--){
410 a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
413 e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
418 static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
419 return get_symbol_inline(c, state, is_signed);
422 static inline void update_vlc_state(VlcState * const state, const int v){
423 int drift= state->drift;
424 int count= state->count;
425 state->error_sum += FFABS(v);
428 if(count == 128){ //FIXME variable
431 state->error_sum >>= 1;
436 if(state->bias > -128) state->bias--;
442 if(state->bias < 127) state->bias++;
453 static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
455 //printf("final: %d ", v);
456 v = fold(v - state->bias, bits);
460 while(i < state->error_sum){ //FIXME optimize
468 if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
471 code= v ^ ((2*state->drift + state->count)>>31);
474 //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);
475 set_sr_golomb(pb, code, k, 12, bits);
477 update_vlc_state(state, v);
480 static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
485 while(i < state->error_sum){ //FIXME optimize
492 v= get_sr_golomb(gb, k, 12, bits);
493 //printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
496 if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
498 v ^= ((2*state->drift + state->count)>>31);
501 ret= fold(v + state->bias, bits);
503 update_vlc_state(state, v);
504 //printf("final: %d\n", ret);
508 #if CONFIG_FFV1_ENCODER
509 static av_always_inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
510 PlaneContext * const p= &s->plane[plane_index];
511 RangeCoder * const c= &s->c;
513 int run_index= s->run_index;
518 if(c->bytestream_end - c->bytestream < w*20){
519 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
523 if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
524 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
532 context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
533 diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
540 diff= fold(diff, bits);
543 if(s->flags & CODEC_FLAG_PASS1){
544 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
546 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
549 if(context == 0) run_mode=1;
554 while(run_count >= 1<<ff_log2_run[run_index]){
555 run_count -= 1<<ff_log2_run[run_index];
557 put_bits(&s->pb, 1, 1);
560 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
561 if(run_index) run_index--;
570 // 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));
573 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
577 while(run_count >= 1<<ff_log2_run[run_index]){
578 run_count -= 1<<ff_log2_run[run_index];
580 put_bits(&s->pb, 1, 1);
584 put_bits(&s->pb, 1, 1);
586 s->run_index= run_index;
591 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
593 const int ring_size= s->avctx->context_model ? 3 : 2;
594 int_fast16_t *sample[3];
597 memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
600 for(i=0; i<ring_size; i++)
601 sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
603 sample[0][-1]= sample[1][0 ];
604 sample[1][ w]= sample[1][w-1];
606 if(s->avctx->bits_per_raw_sample<=8){
608 sample[0][x]= src[x + stride*y];
610 encode_line(s, w, sample, plane_index, 8);
613 sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
615 encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
617 //STOP_TIMER("encode line")}
621 static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
623 const int ring_size= s->avctx->context_model ? 3 : 2;
624 int_fast16_t *sample[3][3];
627 memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
630 for(i=0; i<ring_size; i++)
632 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
635 int v= src[x + stride*y];
646 // assert(g>=0 && b>=0 && r>=0);
647 // assert(g<256 && b<512 && r<512);
653 sample[p][0][-1]= sample[p][1][0 ];
654 sample[p][1][ w]= sample[p][1][w-1];
655 encode_line(s, w, sample[p], FFMIN(p, 1), 9);
660 static void write_quant_table(RangeCoder *c, int16_t *quant_table){
663 uint8_t state[CONTEXT_SIZE];
664 memset(state, 128, sizeof(state));
666 for(i=1; i<128 ; i++){
667 if(quant_table[i] != quant_table[i-1]){
668 put_symbol(c, state, i-last-1, 0);
672 put_symbol(c, state, i-last-1, 0);
675 static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
678 write_quant_table(c, quant_table[i]);
681 static void write_header(FFV1Context *f){
682 uint8_t state[CONTEXT_SIZE];
684 RangeCoder * const c= &f->slice_context[0]->c;
686 memset(state, 128, sizeof(state));
689 put_symbol(c, state, f->version, 0);
690 put_symbol(c, state, f->ac, 0);
692 for(i=1; i<256; i++){
693 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
696 put_symbol(c, state, f->colorspace, 0); //YUV cs type
698 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
699 put_rac(c, state, 1); //chroma planes
700 put_symbol(c, state, f->chroma_h_shift, 0);
701 put_symbol(c, state, f->chroma_v_shift, 0);
702 put_rac(c, state, 0); //no transparency plane
704 write_quant_tables(c, f->quant_table);
706 put_symbol(c, state, f->slice_count, 0);
707 for(i=0; i<f->slice_count; i++){
708 FFV1Context *fs= f->slice_context[i];
709 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);
710 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
711 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
712 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
713 for(j=0; j<f->plane_count; j++){
714 put_symbol(c, state, f->plane[j].quant_table_index, 0);
715 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
720 #endif /* CONFIG_FFV1_ENCODER */
722 static av_cold int common_init(AVCodecContext *avctx){
723 FFV1Context *s = avctx->priv_data;
726 s->flags= avctx->flags;
728 dsputil_init(&s->dsp, avctx);
730 s->width = avctx->width;
731 s->height= avctx->height;
733 assert(s->width && s->height);
742 static int init_slice_state(FFV1Context *f){
745 for(i=0; i<f->slice_count; i++){
746 FFV1Context *fs= f->slice_context[i];
747 for(j=0; j<f->plane_count; j++){
748 PlaneContext * const p= &fs->plane[j];
751 if(!p-> state) p-> state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
753 return AVERROR(ENOMEM);
755 if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
757 return AVERROR(ENOMEM);
762 //FIXME only redo if state_transition changed
763 for(j=1; j<256; j++){
764 fs->c.one_state [ j]= fs->state_transition[j];
765 fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
773 static av_cold int init_slice_contexts(FFV1Context *f){
776 f->slice_count= f->num_h_slices * f->num_v_slices;
778 for(i=0; i<f->slice_count; i++){
779 FFV1Context *fs= av_mallocz(sizeof(*fs));
780 int sx= i % f->num_h_slices;
781 int sy= i / f->num_h_slices;
782 int sxs= f->avctx->width * sx / f->num_h_slices;
783 int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
784 int sys= f->avctx->height* sy / f->num_v_slices;
785 int sye= f->avctx->height*(sy+1) / f->num_v_slices;
786 f->slice_context[i]= fs;
787 memcpy(fs, f, sizeof(*fs));
788 memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
790 fs->slice_width = sxe - sxs;
791 fs->slice_height= sye - sys;
795 fs->sample_buffer = av_malloc(6 * (fs->width+6) * sizeof(*fs->sample_buffer));
796 if (!fs->sample_buffer)
797 return AVERROR(ENOMEM);
802 static int allocate_initial_states(FFV1Context *f){
805 for(i=0; i<f->quant_table_count; i++){
806 f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
807 if(!f->initial_states[i])
808 return AVERROR(ENOMEM);
809 memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
814 #if CONFIG_FFV1_ENCODER
815 static int write_extra_header(FFV1Context *f){
816 RangeCoder * const c= &f->c;
817 uint8_t state[CONTEXT_SIZE];
819 uint8_t state2[32][CONTEXT_SIZE];
821 memset(state2, 128, sizeof(state2));
822 memset(state, 128, sizeof(state));
824 f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
825 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
826 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
828 put_symbol(c, state, f->version, 0);
829 put_symbol(c, state, f->ac, 0);
831 for(i=1; i<256; i++){
832 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
835 put_symbol(c, state, f->colorspace, 0); //YUV cs type
836 put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
837 put_rac(c, state, 1); //chroma planes
838 put_symbol(c, state, f->chroma_h_shift, 0);
839 put_symbol(c, state, f->chroma_v_shift, 0);
840 put_rac(c, state, 0); //no transparency plane
841 put_symbol(c, state, f->num_h_slices-1, 0);
842 put_symbol(c, state, f->num_v_slices-1, 0);
844 put_symbol(c, state, f->quant_table_count, 0);
845 for(i=0; i<f->quant_table_count; i++)
846 write_quant_tables(c, f->quant_tables[i]);
848 for(i=0; i<f->quant_table_count; i++){
849 for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
850 if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
852 if(j<f->context_count[i]*CONTEXT_SIZE){
853 put_rac(c, state, 1);
854 for(j=0; j<f->context_count[i]; j++){
855 for(k=0; k<CONTEXT_SIZE; k++){
856 int pred= j ? f->initial_states[i][j-1][k] : 128;
857 put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
861 put_rac(c, state, 0);
865 f->avctx->extradata_size= ff_rac_terminate(c);
870 static int sort_stt(FFV1Context *s, uint8_t stt[256]){
871 int i,i2,changed,print=0;
875 for(i=12; i<244; i++){
876 for(i2=i+1; i2<245 && i2<i+4; i2++){
877 #define COST(old, new) \
878 s->rc_stat[old][0]*-log2((256-(new))/256.0)\
879 +s->rc_stat[old][1]*-log2( (new) /256.0)
881 #define COST2(old, new) \
883 +COST(256-(old), 256-(new))
885 double size0= COST2(i, i ) + COST2(i2, i2);
886 double sizeX= COST2(i, i2) + COST2(i2, i );
887 if(sizeX < size0 && i!=128 && i2!=128){
889 FFSWAP(int, stt[ i], stt[ i2]);
890 FFSWAP(int, s->rc_stat[i ][0],s->rc_stat[ i2][0]);
891 FFSWAP(int, s->rc_stat[i ][1],s->rc_stat[ i2][1]);
893 FFSWAP(int, stt[256-i], stt[256-i2]);
894 FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
895 FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
897 for(j=1; j<256; j++){
898 if (stt[j] == i ) stt[j] = i2;
899 else if(stt[j] == i2) stt[j] = i ;
901 if (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
902 else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
913 static av_cold int encode_init(AVCodecContext *avctx)
915 FFV1Context *s = avctx->priv_data;
921 s->ac= avctx->coder_type ? 2:0;
925 s->state_transition[i]=ver2_state[i];
928 for(i=0; i<256; i++){
929 s->quant_table_count=2;
930 if(avctx->bits_per_raw_sample <=8){
931 s->quant_tables[0][0][i]= quant11[i];
932 s->quant_tables[0][1][i]= 11*quant11[i];
933 s->quant_tables[0][2][i]= 11*11*quant11[i];
934 s->quant_tables[1][0][i]= quant11[i];
935 s->quant_tables[1][1][i]= 11*quant11[i];
936 s->quant_tables[1][2][i]= 11*11*quant5 [i];
937 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];
938 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
940 s->quant_tables[0][0][i]= quant9_10bit[i];
941 s->quant_tables[0][1][i]= 11*quant9_10bit[i];
942 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];
943 s->quant_tables[1][0][i]= quant9_10bit[i];
944 s->quant_tables[1][1][i]= 11*quant9_10bit[i];
945 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];
946 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];
947 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
950 s->context_count[0]= (11*11*11+1)/2;
951 s->context_count[1]= (11*11*5*5*5+1)/2;
952 memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
954 for(i=0; i<s->plane_count; i++){
955 PlaneContext * const p= &s->plane[i];
957 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
958 p->quant_table_index= avctx->context_model;
959 p->context_count= s->context_count[p->quant_table_index];
962 if(allocate_initial_states(s) < 0)
963 return AVERROR(ENOMEM);
965 avctx->coded_frame= &s->picture;
966 switch(avctx->pix_fmt){
967 case PIX_FMT_YUV444P16:
968 case PIX_FMT_YUV422P16:
969 case PIX_FMT_YUV420P16:
970 if(avctx->bits_per_raw_sample <=8){
971 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
975 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
978 s->version= FFMAX(s->version, 1);
979 case PIX_FMT_YUV444P:
980 case PIX_FMT_YUV422P:
981 case PIX_FMT_YUV420P:
982 case PIX_FMT_YUV411P:
983 case PIX_FMT_YUV410P:
990 av_log(avctx, AV_LOG_ERROR, "format not supported\n");
993 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
997 if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
998 for(i=0; i<s->quant_table_count; i++){
999 s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
1001 return AVERROR(ENOMEM);
1004 if(avctx->stats_in){
1005 char *p= avctx->stats_in;
1006 uint8_t best_state[256][256];
1010 av_assert0(s->version>=2);
1013 for(j=0; j<256; j++){
1015 s->rc_stat[j][i]= strtol(p, &next, 0);
1017 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
1023 for(i=0; i<s->quant_table_count; i++){
1024 for(j=0; j<s->context_count[i]; j++){
1025 for(k=0; k<32; k++){
1027 s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
1029 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
1037 gob_count= strtol(p, &next, 0);
1038 if(next==p || gob_count <0){
1039 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
1043 while(*p=='\n' || *p==' ') p++;
1046 sort_stt(s, s->state_transition);
1048 find_best_state(best_state, s->state_transition);
1050 for(i=0; i<s->quant_table_count; i++){
1051 for(j=0; j<s->context_count[i]; j++){
1052 for(k=0; k<32; k++){
1054 if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
1055 p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
1057 s->initial_states[i][j][k]= best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1])/gob_count, 0, 255)];
1066 write_extra_header(s);
1069 if(init_slice_contexts(s) < 0)
1071 if(init_slice_state(s) < 0)
1074 #define STATS_OUT_SIZE 1024*1024*6
1075 if(avctx->flags & CODEC_FLAG_PASS1){
1076 avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
1077 for(i=0; i<s->quant_table_count; i++){
1078 for(j=0; j<s->slice_count; j++){
1079 FFV1Context *sf= s->slice_context[j];
1080 av_assert0(!sf->rc_stat2[i]);
1081 sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
1082 if(!sf->rc_stat2[i])
1083 return AVERROR(ENOMEM);
1090 #endif /* CONFIG_FFV1_ENCODER */
1093 static void clear_state(FFV1Context *f){
1096 for(si=0; si<f->slice_count; si++){
1097 FFV1Context *fs= f->slice_context[si];
1098 for(i=0; i<f->plane_count; i++){
1099 PlaneContext *p= &fs->plane[i];
1101 p->interlace_bit_state[0]= 128;
1102 p->interlace_bit_state[1]= 128;
1105 if(f->initial_states[p->quant_table_index]){
1106 memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1108 memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1110 for(j=0; j<p->context_count; j++){
1111 p->vlc_state[j].drift= 0;
1112 p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1113 p->vlc_state[j].bias= 0;
1114 p->vlc_state[j].count= 1;
1121 #if CONFIG_FFV1_ENCODER
1122 static int encode_slice(AVCodecContext *c, void *arg){
1123 FFV1Context *fs= *(void**)arg;
1124 FFV1Context *f= fs->avctx->priv_data;
1125 int width = fs->slice_width;
1126 int height= fs->slice_height;
1129 AVFrame * const p= &f->picture;
1131 if(f->colorspace==0){
1132 const int chroma_width = -((-width )>>f->chroma_h_shift);
1133 const int chroma_height= -((-height)>>f->chroma_v_shift);
1134 const int cx= x>>f->chroma_h_shift;
1135 const int cy= y>>f->chroma_v_shift;
1137 encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1139 encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1140 encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1142 encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1149 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1150 FFV1Context *f = avctx->priv_data;
1151 RangeCoder * const c= &f->slice_context[0]->c;
1152 AVFrame *pict = data;
1153 AVFrame * const p= &f->picture;
1155 uint8_t keystate=128;
1159 ff_init_range_encoder(c, buf, buf_size);
1160 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1163 p->pict_type= FF_I_TYPE;
1165 if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1166 put_rac(c, &keystate, 1);
1172 put_rac(c, &keystate, 0);
1177 used_count += ff_rac_terminate(c);
1178 //printf("pos=%d\n", used_count);
1179 init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1182 for(i=1; i<256; i++){
1183 c->one_state[i]= f->state_transition[i];
1184 c->zero_state[256-i]= 256-c->one_state[i];
1188 for(i=1; i<f->slice_count; i++){
1189 FFV1Context *fs= f->slice_context[i];
1190 uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1191 int len= buf_size/f->slice_count;
1194 ff_init_range_encoder(&fs->c, start, len);
1196 init_put_bits(&fs->pb, start, len);
1199 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1202 for(i=0; i<f->slice_count; i++){
1203 FFV1Context *fs= f->slice_context[i];
1208 put_rac(&fs->c, &state, 0);
1209 bytes= ff_rac_terminate(&fs->c);
1211 flush_put_bits(&fs->pb); //nicer padding FIXME
1212 bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1216 av_assert0(bytes < buf_size/f->slice_count);
1217 memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1218 av_assert0(bytes < (1<<24));
1219 AV_WB24(buf_p+bytes, bytes);
1225 if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1227 char *p= avctx->stats_out;
1228 char *end= p + STATS_OUT_SIZE;
1230 memset(f->rc_stat, 0, sizeof(f->rc_stat));
1231 for(i=0; i<f->quant_table_count; i++)
1232 memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
1234 for(j=0; j<f->slice_count; j++){
1235 FFV1Context *fs= f->slice_context[j];
1236 for(i=0; i<256; i++){
1237 f->rc_stat[i][0] += fs->rc_stat[i][0];
1238 f->rc_stat[i][1] += fs->rc_stat[i][1];
1240 for(i=0; i<f->quant_table_count; i++){
1241 for(k=0; k<f->context_count[i]; k++){
1242 for(m=0; m<32; m++){
1243 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
1244 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
1250 for(j=0; j<256; j++){
1251 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1254 snprintf(p, end-p, "\n");
1256 for(i=0; i<f->quant_table_count; i++){
1257 for(j=0; j<f->context_count[i]; j++){
1258 for(m=0; m<32; m++){
1259 snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
1264 snprintf(p, end-p, "%d\n", f->gob_count);
1265 } else if(avctx->flags&CODEC_FLAG_PASS1)
1266 avctx->stats_out[0] = '\0';
1268 f->picture_number++;
1271 #endif /* CONFIG_FFV1_ENCODER */
1273 static av_cold int common_end(AVCodecContext *avctx){
1274 FFV1Context *s = avctx->priv_data;
1277 if (avctx->codec->decode && s->picture.data[0])
1278 avctx->release_buffer(avctx, &s->picture);
1280 for(j=0; j<s->slice_count; j++){
1281 FFV1Context *fs= s->slice_context[j];
1282 for(i=0; i<s->plane_count; i++){
1283 PlaneContext *p= &fs->plane[i];
1285 av_freep(&p->state);
1286 av_freep(&p->vlc_state);
1288 av_freep(&fs->sample_buffer);
1291 av_freep(&avctx->stats_out);
1292 for(j=0; j<s->quant_table_count; j++){
1293 av_freep(&s->initial_states[j]);
1294 for(i=0; i<s->slice_count; i++){
1295 FFV1Context *sf= s->slice_context[i];
1296 av_freep(&sf->rc_stat2[j]);
1298 av_freep(&s->rc_stat2[j]);
1301 for(i=0; i<s->slice_count; i++){
1302 av_freep(&s->slice_context[i]);
1308 static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
1309 PlaneContext * const p= &s->plane[plane_index];
1310 RangeCoder * const c= &s->c;
1314 int run_index= s->run_index;
1317 int diff, context, sign;
1319 context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1326 av_assert2(context < p->context_count);
1329 diff= get_symbol_inline(c, p->state[context], 1);
1331 if(context == 0 && run_mode==0) run_mode=1;
1334 if(run_count==0 && run_mode==1){
1335 if(get_bits1(&s->gb)){
1336 run_count = 1<<ff_log2_run[run_index];
1337 if(x + run_count <= w) run_index++;
1339 if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1341 if(run_index) run_index--;
1349 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1354 diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1356 // 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));
1359 if(sign) diff= -diff;
1361 sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1363 s->run_index= run_index;
1366 static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1368 int_fast16_t *sample[2];
1369 sample[0]=s->sample_buffer +3;
1370 sample[1]=s->sample_buffer+w+6+3;
1374 memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1377 int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
1379 sample[0]= sample[1];
1382 sample[1][-1]= sample[0][0 ];
1383 sample[0][ w]= sample[0][w-1];
1386 if(s->avctx->bits_per_raw_sample <= 8){
1387 decode_line(s, w, sample, plane_index, 8);
1389 src[x + stride*y]= sample[1][x];
1392 decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1394 ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1397 //STOP_TIMER("decode-line")}
1401 static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1403 int_fast16_t *sample[3][2];
1405 sample[x][0] = s->sample_buffer + x*2 *(w+6) + 3;
1406 sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1411 memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1415 int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
1417 sample[p][0]= sample[p][1];
1420 sample[p][1][-1]= sample[p][0][0 ];
1421 sample[p][0][ w]= sample[p][0][w-1];
1422 decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1425 int g= sample[0][1][x];
1426 int b= sample[1][1][x];
1427 int r= sample[2][1][x];
1429 // assert(g>=0 && b>=0 && r>=0);
1430 // assert(g<256 && b<512 && r<512);
1438 src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1443 static int decode_slice(AVCodecContext *c, void *arg){
1444 FFV1Context *fs= *(void**)arg;
1445 FFV1Context *f= fs->avctx->priv_data;
1446 int width = fs->slice_width;
1447 int height= fs->slice_height;
1450 AVFrame * const p= &f->picture;
1452 av_assert1(width && height);
1453 if(f->colorspace==0){
1454 const int chroma_width = -((-width )>>f->chroma_h_shift);
1455 const int chroma_height= -((-height)>>f->chroma_v_shift);
1456 const int cx= x>>f->chroma_h_shift;
1457 const int cy= y>>f->chroma_v_shift;
1458 decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1460 decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1461 decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1463 decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1471 static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1474 uint8_t state[CONTEXT_SIZE];
1476 memset(state, 128, sizeof(state));
1478 for(v=0; i<128 ; v++){
1479 int len= get_symbol(c, state, 0) + 1;
1481 if(len + i > 128) return -1;
1484 quant_table[i] = scale*v;
1487 //if(i%16==0) printf("\n");
1491 for(i=1; i<128; i++){
1492 quant_table[256-i]= -quant_table[i];
1494 quant_table[128]= -quant_table[127];
1499 static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1501 int context_count=1;
1504 context_count*= read_quant_table(c, quant_table[i], context_count);
1505 if(context_count > 32768U){
1509 return (context_count+1)/2;
1512 static int read_extra_header(FFV1Context *f){
1513 RangeCoder * const c= &f->c;
1514 uint8_t state[CONTEXT_SIZE];
1516 uint8_t state2[32][CONTEXT_SIZE];
1518 memset(state2, 128, sizeof(state2));
1519 memset(state, 128, sizeof(state));
1521 ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1522 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1524 f->version= get_symbol(c, state, 0);
1525 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1527 for(i=1; i<256; i++){
1528 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1531 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1532 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1533 get_rac(c, state); //no chroma = false
1534 f->chroma_h_shift= get_symbol(c, state, 0);
1535 f->chroma_v_shift= get_symbol(c, state, 0);
1536 get_rac(c, state); //transparency plane
1538 f->num_h_slices= 1 + get_symbol(c, state, 0);
1539 f->num_v_slices= 1 + get_symbol(c, state, 0);
1540 if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1541 av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1545 f->quant_table_count= get_symbol(c, state, 0);
1546 if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1548 for(i=0; i<f->quant_table_count; i++){
1549 if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1550 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1555 if(allocate_initial_states(f) < 0)
1556 return AVERROR(ENOMEM);
1558 for(i=0; i<f->quant_table_count; i++){
1559 if(get_rac(c, state)){
1560 for(j=0; j<f->context_count[i]; j++){
1561 for(k=0; k<CONTEXT_SIZE; k++){
1562 int pred= j ? f->initial_states[i][j-1][k] : 128;
1563 f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1572 static int read_header(FFV1Context *f){
1573 uint8_t state[CONTEXT_SIZE];
1574 int i, j, context_count;
1575 RangeCoder * const c= &f->slice_context[0]->c;
1577 memset(state, 128, sizeof(state));
1580 f->version= get_symbol(c, state, 0);
1581 f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1583 for(i=1; i<256; i++){
1584 f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1587 f->colorspace= get_symbol(c, state, 0); //YUV cs type
1589 f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1590 get_rac(c, state); //no chroma = false
1591 f->chroma_h_shift= get_symbol(c, state, 0);
1592 f->chroma_v_shift= get_symbol(c, state, 0);
1593 get_rac(c, state); //transparency plane
1597 if(f->colorspace==0){
1598 if(f->avctx->bits_per_raw_sample<=8){
1599 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1600 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1601 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1602 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1603 case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1604 case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1606 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1610 switch(16*f->chroma_h_shift + f->chroma_v_shift){
1611 case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1612 case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1613 case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1615 av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1619 }else if(f->colorspace==1){
1620 if(f->chroma_h_shift || f->chroma_v_shift){
1621 av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1624 f->avctx->pix_fmt= PIX_FMT_RGB32;
1626 av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1630 //printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1632 context_count= read_quant_tables(c, f->quant_table);
1633 if(context_count < 0){
1634 av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1638 f->slice_count= get_symbol(c, state, 0);
1639 if(f->slice_count > (unsigned)MAX_SLICES)
1643 for(j=0; j<f->slice_count; j++){
1644 FFV1Context *fs= f->slice_context[j];
1647 if(f->version >= 2){
1648 fs->slice_x = get_symbol(c, state, 0) *f->width ;
1649 fs->slice_y = get_symbol(c, state, 0) *f->height;
1650 fs->slice_width =(get_symbol(c, state, 0)+1)*f->width + fs->slice_x;
1651 fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1653 fs->slice_x /= f->num_h_slices;
1654 fs->slice_y /= f->num_v_slices;
1655 fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x;
1656 fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1657 if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1659 if( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width
1660 || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1664 for(i=0; i<f->plane_count; i++){
1665 PlaneContext * const p= &fs->plane[i];
1667 if(f->version >= 2){
1668 int idx=get_symbol(c, state, 0);
1669 if(idx > (unsigned)f->quant_table_count){
1670 av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1673 p->quant_table_index= idx;
1674 memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1675 context_count= f->context_count[idx];
1677 memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1680 if(p->context_count < context_count){
1681 av_freep(&p->state);
1682 av_freep(&p->vlc_state);
1684 p->context_count= context_count;
1691 static av_cold int decode_init(AVCodecContext *avctx)
1693 FFV1Context *f = avctx->priv_data;
1697 if(avctx->extradata && read_extra_header(f) < 0)
1700 if(init_slice_contexts(f) < 0)
1706 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1707 const uint8_t *buf = avpkt->data;
1708 int buf_size = avpkt->size;
1709 FFV1Context *f = avctx->priv_data;
1710 RangeCoder * const c= &f->slice_context[0]->c;
1711 AVFrame * const p= &f->picture;
1713 uint8_t keystate= 128;
1714 const uint8_t *buf_p;
1716 AVFrame *picture = data;
1718 /* release previously stored data */
1720 avctx->release_buffer(avctx, p);
1722 ff_init_range_decoder(c, buf, buf_size);
1723 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1726 p->pict_type= FF_I_TYPE; //FIXME I vs. P
1727 if(get_rac(c, &keystate)){
1729 if(read_header(f) < 0)
1731 if(init_slice_state(f) < 0)
1740 for(i=1; i<256; i++){
1741 c->one_state[i]= f->state_transition[i];
1742 c->zero_state[256-i]= 256-c->one_state[i];
1747 if(avctx->get_buffer(avctx, p) < 0){
1748 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1752 if(avctx->debug&FF_DEBUG_PICT_INFO)
1753 av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1756 bytes_read = c->bytestream - c->bytestream_start - 1;
1757 if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1758 //printf("pos=%d\n", bytes_read);
1759 init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, buf_size - bytes_read);
1761 bytes_read = 0; /* avoid warning */
1764 buf_p= buf + buf_size;
1765 for(i=f->slice_count-1; i>0; i--){
1766 FFV1Context *fs= f->slice_context[i];
1767 int v= AV_RB24(buf_p-3)+3;
1768 if(buf_p - buf <= v){
1769 av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1774 ff_init_range_decoder(&fs->c, buf_p, v);
1776 init_get_bits(&fs->gb, buf_p, v);
1780 avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1781 f->picture_number++;
1784 *data_size = sizeof(AVFrame);
1789 AVCodec ff_ffv1_decoder = {
1793 sizeof(FFV1Context),
1798 CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1800 .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1803 #if CONFIG_FFV1_ENCODER
1804 AVCodec ff_ffv1_encoder = {
1808 sizeof(FFV1Context),
1812 .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},
1813 .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),