Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ 28a3f525

History | View | Annotate | Download (53.8 KB)

1 5e20f836 Michael Niedermayer
/*
2
 * FFV1 codec for libavcodec
3
 *
4
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5
 *
6 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
7
 *
8
 * FFmpeg is free software; you can redistribute it and/or
9 5e20f836 Michael Niedermayer
 * modify it under the terms of the GNU Lesser General Public
10
 * License as published by the Free Software Foundation; either
11 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
12 5e20f836 Michael Niedermayer
 *
13 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
14 5e20f836 Michael Niedermayer
 * 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 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
20 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 5e20f836 Michael Niedermayer
 */
22 115329f1 Diego Biurrun
23 5e20f836 Michael Niedermayer
/**
24 ba87f080 Diego Biurrun
 * @file
25 0e22d688 Michael Niedermayer
 * FF Video Codec 1 (a lossless codec)
26 5e20f836 Michael Niedermayer
 */
27
28
#include "avcodec.h"
29 9106a698 Stefano Sabatini
#include "get_bits.h"
30 b2755007 Stefano Sabatini
#include "put_bits.h"
31 5e20f836 Michael Niedermayer
#include "dsputil.h"
32 880eae9c Michael Niedermayer
#include "rangecoder.h"
33 11e659c2 Michael Niedermayer
#include "golomb.h"
34 199436b9 Aurelien Jacobs
#include "mathops.h"
35 e2b2f845 Michael Niedermayer
#include "libavutil/avassert.h"
36 5e20f836 Michael Niedermayer
37
#define MAX_PLANES 4
38 c2f1b2cb Michael Niedermayer
#define CONTEXT_SIZE 32
39
40 c5ac275b Michael Niedermayer
#define MAX_QUANT_TABLES 8
41 c868524b Michael Niedermayer
#define MAX_CONTEXT_INPUTS 5
42 c5ac275b Michael Niedermayer
43 b3bf98aa Stefan Gehrer
extern const uint8_t ff_log2_run[32];
44
45 11e659c2 Michael Niedermayer
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 5e20f836 Michael Niedermayer
 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 11e659c2 Michael Niedermayer
-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,
62
};
63 68f8d33b Michael Niedermayer
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,
81
};
82
83 11e659c2 Michael Niedermayer
static const int8_t quant5[256]={
84
 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
85 5e20f836 Michael Niedermayer
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
86 11e659c2 Michael Niedermayer
 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,
100
};
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,
118
};
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,
136
};
137 68f8d33b Michael Niedermayer
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,
154
};
155
156 11e659c2 Michael Niedermayer
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,
173
};
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,
191
};
192 5e20f836 Michael Niedermayer
193 00bbc093 Michael Niedermayer
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,
210
};
211
212 11e659c2 Michael Niedermayer
typedef struct VlcState{
213
    int16_t drift;
214
    uint16_t error_sum;
215
    int8_t bias;
216
    uint8_t count;
217
} VlcState;
218
219 5e20f836 Michael Niedermayer
typedef struct PlaneContext{
220 c868524b Michael Niedermayer
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
221 e1f51b88 Michael Niedermayer
    int quant_table_index;
222 5e20f836 Michael Niedermayer
    int context_count;
223 c2f1b2cb Michael Niedermayer
    uint8_t (*state)[CONTEXT_SIZE];
224 11e659c2 Michael Niedermayer
    VlcState *vlc_state;
225 5e20f836 Michael Niedermayer
    uint8_t interlace_bit_state[2];
226
} PlaneContext;
227
228 e2b2f845 Michael Niedermayer
#define MAX_SLICES 256
229
230 5e20f836 Michael Niedermayer
typedef struct FFV1Context{
231
    AVCodecContext *avctx;
232 880eae9c Michael Niedermayer
    RangeCoder c;
233 11e659c2 Michael Niedermayer
    GetBitContext gb;
234
    PutBitContext pb;
235 bc29ae4a Michael Niedermayer
    uint64_t rc_stat[256][2];
236 672e7e39 Michael Niedermayer
    uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
237 5e20f836 Michael Niedermayer
    int version;
238
    int width, height;
239
    int chroma_h_shift, chroma_v_shift;
240
    int flags;
241
    int picture_number;
242
    AVFrame picture;
243
    int plane_count;
244 2fee538a Lars Täuber
    int ac;                              ///< 1=range coder <-> 0=golomb rice
245 5e20f836 Michael Niedermayer
    PlaneContext plane[MAX_PLANES];
246 c868524b Michael Niedermayer
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
247
    int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
248 c5ac275b Michael Niedermayer
    int context_count[MAX_QUANT_TABLES];
249 00bbc093 Michael Niedermayer
    uint8_t state_transition[256];
250 99a5e935 Michael Niedermayer
    uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
251 2cbb7820 Michael Niedermayer
    int run_index;
252
    int colorspace;
253 cbabccc3 Måns Rullgård
    int_fast16_t *sample_buffer;
254 115329f1 Diego Biurrun
255 c5ac275b Michael Niedermayer
    int quant_table_count;
256
257 115329f1 Diego Biurrun
    DSPContext dsp;
258 e2b2f845 Michael Niedermayer
259
    struct FFV1Context *slice_context[MAX_SLICES];
260
    int slice_count;
261
    int num_v_slices;
262
    int num_h_slices;
263
    int slice_width;
264
    int slice_height;
265
    int slice_x;
266
    int slice_y;
267 5e20f836 Michael Niedermayer
}FFV1Context;
268
269 849f1035 Måns Rullgård
static av_always_inline int fold(int diff, int bits){
270 2cbb7820 Michael Niedermayer
    if(bits==8)
271
        diff= (int8_t)diff;
272
    else{
273
        diff+= 1<<(bits-1);
274
        diff&=(1<<bits)-1;
275
        diff-= 1<<(bits-1);
276
    }
277
278
    return diff;
279
}
280
281
static inline int predict(int_fast16_t *src, int_fast16_t *last){
282 11e659c2 Michael Niedermayer
    const int LT= last[-1];
283
    const int  T= last[ 0];
284
    const int L =  src[-1];
285 5e20f836 Michael Niedermayer
286 25bd2349 Michael Niedermayer
    return mid_pred(L, L + T - LT, T);
287 5e20f836 Michael Niedermayer
}
288
289 e42393d1 Michael Niedermayer
static inline int get_context(PlaneContext *p, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
290 11e659c2 Michael Niedermayer
    const int LT= last[-1];
291
    const int  T= last[ 0];
292
    const int RT= last[ 1];
293
    const int L =  src[-1];
294
295 e42393d1 Michael Niedermayer
    if(p->quant_table[3][127]){
296 11e659c2 Michael Niedermayer
        const int TT= last2[0];
297
        const int LL=  src[-2];
298 e42393d1 Michael Niedermayer
        return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
299
              +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
300 11e659c2 Michael Niedermayer
    }else
301 e42393d1 Michael Niedermayer
        return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
302 5e20f836 Michael Niedermayer
}
303 c2f1b2cb Michael Niedermayer
304 672e7e39 Michael Niedermayer
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]){
305 5e20f836 Michael Niedermayer
    int i;
306
307 bc29ae4a Michael Niedermayer
#define put_rac(C,S,B) \
308
do{\
309 349d7287 Michael Niedermayer
    if(rc_stat){\
310 bc29ae4a Michael Niedermayer
    rc_stat[*(S)][B]++;\
311 672e7e39 Michael Niedermayer
        rc_stat2[(S)-state][B]++;\
312 349d7287 Michael Niedermayer
    }\
313 bc29ae4a Michael Niedermayer
    put_rac(C,S,B);\
314
}while(0)
315
316 5e20f836 Michael Niedermayer
    if(v){
317 c26abfa5 Diego Biurrun
        const int a= FFABS(v);
318 5e20f836 Michael Niedermayer
        const int e= av_log2(a);
319 880eae9c Michael Niedermayer
        put_rac(c, state+0, 0);
320 68f8d33b Michael Niedermayer
        if(e<=9){
321 f83c5773 Michael Niedermayer
            for(i=0; i<e; i++){
322
                put_rac(c, state+1+i, 1);  //1..10
323
            }
324
            put_rac(c, state+1+i, 0);
325 085565f7 Michael Niedermayer
326 f83c5773 Michael Niedermayer
            for(i=e-1; i>=0; i--){
327
                put_rac(c, state+22+i, (a>>i)&1); //22..31
328
            }
329 d34a0746 Michael Niedermayer
330 f83c5773 Michael Niedermayer
            if(is_signed)
331
                put_rac(c, state+11 + e, v < 0); //11..21
332 68f8d33b Michael Niedermayer
        }else{
333
            for(i=0; i<e; i++){
334
                put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
335
            }
336
            put_rac(c, state+1+9, 0);
337
338
            for(i=e-1; i>=0; i--){
339
                put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
340
            }
341
342
            if(is_signed)
343
                put_rac(c, state+11 + 10, v < 0); //11..21
344
        }
345 5e20f836 Michael Niedermayer
    }else{
346 880eae9c Michael Niedermayer
        put_rac(c, state+0, 1);
347 5e20f836 Michael Niedermayer
    }
348 bc29ae4a Michael Niedermayer
#undef put_rac
349 5e20f836 Michael Niedermayer
}
350
351 217d34e3 Michael Niedermayer
static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
352 672e7e39 Michael Niedermayer
    put_symbol_inline(c, state, v, is_signed, NULL, NULL);
353 217d34e3 Michael Niedermayer
}
354
355 68f8d33b Michael Niedermayer
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
356 880eae9c Michael Niedermayer
    if(get_rac(c, state+0))
357 5e20f836 Michael Niedermayer
        return 0;
358
    else{
359 d34a0746 Michael Niedermayer
        int i, e, a;
360
        e= 0;
361 68f8d33b Michael Niedermayer
        while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
362 d34a0746 Michael Niedermayer
            e++;
363
        }
364 5e20f836 Michael Niedermayer
365 d34a0746 Michael Niedermayer
        a= 1;
366
        for(i=e-1; i>=0; i--){
367 68f8d33b Michael Niedermayer
            a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
368 085565f7 Michael Niedermayer
        }
369 d34a0746 Michael Niedermayer
370 68f8d33b Michael Niedermayer
        e= -(is_signed && get_rac(c, state+11 + FFMIN(e, 10))); //11..21
371 3788e661 Michael Niedermayer
        return (a^e)-e;
372 5e20f836 Michael Niedermayer
    }
373
}
374 11e659c2 Michael Niedermayer
375 217d34e3 Michael Niedermayer
static int av_noinline get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
376
    return get_symbol_inline(c, state, is_signed);
377
}
378
379 11e659c2 Michael Niedermayer
static inline void update_vlc_state(VlcState * const state, const int v){
380
    int drift= state->drift;
381
    int count= state->count;
382 c26abfa5 Diego Biurrun
    state->error_sum += FFABS(v);
383 11e659c2 Michael Niedermayer
    drift += v;
384
385
    if(count == 128){ //FIXME variable
386
        count >>= 1;
387
        drift >>= 1;
388
        state->error_sum >>= 1;
389
    }
390
    count++;
391
392
    if(drift <= -count){
393
        if(state->bias > -128) state->bias--;
394 115329f1 Diego Biurrun
395 11e659c2 Michael Niedermayer
        drift += count;
396
        if(drift <= -count)
397
            drift= -count + 1;
398
    }else if(drift > 0){
399
        if(state->bias <  127) state->bias++;
400 115329f1 Diego Biurrun
401 11e659c2 Michael Niedermayer
        drift -= count;
402 115329f1 Diego Biurrun
        if(drift > 0)
403 11e659c2 Michael Niedermayer
            drift= 0;
404
    }
405
406
    state->drift= drift;
407
    state->count= count;
408
}
409
410 2cbb7820 Michael Niedermayer
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v, int bits){
411 11e659c2 Michael Niedermayer
    int i, k, code;
412
//printf("final: %d ", v);
413 2cbb7820 Michael Niedermayer
    v = fold(v - state->bias, bits);
414
415 11e659c2 Michael Niedermayer
    i= state->count;
416
    k=0;
417
    while(i < state->error_sum){ //FIXME optimize
418
        k++;
419
        i += i;
420
    }
421 d9e6a6c6 Michael Niedermayer
422
    assert(k<=8);
423
424 11e659c2 Michael Niedermayer
#if 0 // JPEG LS
425
    if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
426
    else                                         code= v;
427
#else
428
     code= v ^ ((2*state->drift + state->count)>>31);
429
#endif
430 115329f1 Diego Biurrun
431 11e659c2 Michael Niedermayer
//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);
432 a6c01275 Michael Niedermayer
    set_sr_golomb(pb, code, k, 12, bits);
433 11e659c2 Michael Niedermayer
434
    update_vlc_state(state, v);
435
}
436
437 2cbb7820 Michael Niedermayer
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state, int bits){
438 11e659c2 Michael Niedermayer
    int k, i, v, ret;
439
440
    i= state->count;
441
    k=0;
442
    while(i < state->error_sum){ //FIXME optimize
443
        k++;
444
        i += i;
445
    }
446 d9e6a6c6 Michael Niedermayer
447
    assert(k<=8);
448
449 a6c01275 Michael Niedermayer
    v= get_sr_golomb(gb, k, 12, bits);
450 11e659c2 Michael Niedermayer
//printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
451 d9e6a6c6 Michael Niedermayer
452 11e659c2 Michael Niedermayer
#if 0 // JPEG LS
453
    if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
454
#else
455
     v ^= ((2*state->drift + state->count)>>31);
456 5e20f836 Michael Niedermayer
#endif
457
458 2cbb7820 Michael Niedermayer
    ret= fold(v + state->bias, bits);
459 115329f1 Diego Biurrun
460 11e659c2 Michael Niedermayer
    update_vlc_state(state, v);
461
//printf("final: %d\n", ret);
462
    return ret;
463
}
464
465 b250f9c6 Aurelien Jacobs
#if CONFIG_FFV1_ENCODER
466 fc3128c9 Michael Niedermayer
static av_always_inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
467 2cbb7820 Michael Niedermayer
    PlaneContext * const p= &s->plane[plane_index];
468 880eae9c Michael Niedermayer
    RangeCoder * const c= &s->c;
469 2cbb7820 Michael Niedermayer
    int x;
470
    int run_index= s->run_index;
471
    int run_count=0;
472
    int run_mode=0;
473
474 0ecca7a4 Michael Niedermayer
    if(s->ac){
475
        if(c->bytestream_end - c->bytestream < w*20){
476
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
477
            return -1;
478
        }
479
    }else{
480
        if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < w*4){
481
            av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
482
            return -1;
483
        }
484
    }
485
486 2cbb7820 Michael Niedermayer
    for(x=0; x<w; x++){
487
        int diff, context;
488 115329f1 Diego Biurrun
489 e42393d1 Michael Niedermayer
        context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
490 c172913a Michael Niedermayer
        diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
491 11e659c2 Michael Niedermayer
492 2cbb7820 Michael Niedermayer
        if(context < 0){
493
            context = -context;
494
            diff= -diff;
495
        }
496
497
        diff= fold(diff, bits);
498 115329f1 Diego Biurrun
499 2cbb7820 Michael Niedermayer
        if(s->ac){
500 349d7287 Michael Niedermayer
            if(s->flags & CODEC_FLAG_PASS1){
501 672e7e39 Michael Niedermayer
                put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
502 349d7287 Michael Niedermayer
            }else{
503 672e7e39 Michael Niedermayer
                put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
504 349d7287 Michael Niedermayer
            }
505 2cbb7820 Michael Niedermayer
        }else{
506
            if(context == 0) run_mode=1;
507 115329f1 Diego Biurrun
508 2cbb7820 Michael Niedermayer
            if(run_mode){
509
510
                if(diff){
511 b3bf98aa Stefan Gehrer
                    while(run_count >= 1<<ff_log2_run[run_index]){
512
                        run_count -= 1<<ff_log2_run[run_index];
513 2cbb7820 Michael Niedermayer
                        run_index++;
514
                        put_bits(&s->pb, 1, 1);
515
                    }
516 115329f1 Diego Biurrun
517 b3bf98aa Stefan Gehrer
                    put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);
518 2cbb7820 Michael Niedermayer
                    if(run_index) run_index--;
519
                    run_count=0;
520
                    run_mode=0;
521
                    if(diff>0) diff--;
522
                }else{
523
                    run_count++;
524
                }
525
            }
526 115329f1 Diego Biurrun
527 fe455f33 Alex Beregszaszi
//            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));
528 2cbb7820 Michael Niedermayer
529
            if(run_mode == 0)
530
                put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);
531
        }
532
    }
533
    if(run_mode){
534 b3bf98aa Stefan Gehrer
        while(run_count >= 1<<ff_log2_run[run_index]){
535
            run_count -= 1<<ff_log2_run[run_index];
536 2cbb7820 Michael Niedermayer
            run_index++;
537
            put_bits(&s->pb, 1, 1);
538
        }
539
540
        if(run_count)
541
            put_bits(&s->pb, 1, 1);
542
    }
543
    s->run_index= run_index;
544 115329f1 Diego Biurrun
545 0ecca7a4 Michael Niedermayer
    return 0;
546 2cbb7820 Michael Niedermayer
}
547 11e659c2 Michael Niedermayer
548 5e20f836 Michael Niedermayer
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
549 c172913a Michael Niedermayer
    int x,y,i;
550 fa2522d7 Michael Niedermayer
    const int ring_size= s->avctx->context_model ? 3 : 2;
551 cbabccc3 Måns Rullgård
    int_fast16_t *sample[3];
552 2cbb7820 Michael Niedermayer
    s->run_index=0;
553 115329f1 Diego Biurrun
554 cbabccc3 Måns Rullgård
    memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
555 115329f1 Diego Biurrun
556 5e20f836 Michael Niedermayer
    for(y=0; y<h; y++){
557 c172913a Michael Niedermayer
        for(i=0; i<ring_size; i++)
558 cbabccc3 Måns Rullgård
            sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
559 115329f1 Diego Biurrun
560 c172913a Michael Niedermayer
        sample[0][-1]= sample[1][0  ];
561
        sample[1][ w]= sample[1][w-1];
562 2cbb7820 Michael Niedermayer
//{START_TIMER
563 68f8d33b Michael Niedermayer
        if(s->avctx->bits_per_raw_sample<=8){
564 f83c5773 Michael Niedermayer
            for(x=0; x<w; x++){
565
                sample[0][x]= src[x + stride*y];
566
            }
567
            encode_line(s, w, sample, plane_index, 8);
568 68f8d33b Michael Niedermayer
        }else{
569
            for(x=0; x<w; x++){
570
                sample[0][x]= ((uint16_t*)(src + stride*y))[x] >> (16 - s->avctx->bits_per_raw_sample);
571
            }
572
            encode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
573
        }
574 2cbb7820 Michael Niedermayer
//STOP_TIMER("encode line")}
575
    }
576
}
577 5e20f836 Michael Niedermayer
578 2cbb7820 Michael Niedermayer
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
579 c172913a Michael Niedermayer
    int x, y, p, i;
580 fa2522d7 Michael Niedermayer
    const int ring_size= s->avctx->context_model ? 3 : 2;
581 cbabccc3 Måns Rullgård
    int_fast16_t *sample[3][3];
582 2cbb7820 Michael Niedermayer
    s->run_index=0;
583 115329f1 Diego Biurrun
584 cbabccc3 Måns Rullgård
    memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
585 115329f1 Diego Biurrun
586 2cbb7820 Michael Niedermayer
    for(y=0; y<h; y++){
587 c172913a Michael Niedermayer
        for(i=0; i<ring_size; i++)
588
            for(p=0; p<3; p++)
589 cbabccc3 Måns Rullgård
                sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
590 c172913a Michael Niedermayer
591 5e20f836 Michael Niedermayer
        for(x=0; x<w; x++){
592 2cbb7820 Michael Niedermayer
            int v= src[x + stride*y];
593
            int b= v&0xFF;
594
            int g= (v>>8)&0xFF;
595
            int r= (v>>16)&0xFF;
596 115329f1 Diego Biurrun
597 2cbb7820 Michael Niedermayer
            b -= g;
598
            r -= g;
599
            g += (b + r)>>2;
600
            b += 0x100;
601
            r += 0x100;
602 115329f1 Diego Biurrun
603 2cbb7820 Michael Niedermayer
//            assert(g>=0 && b>=0 && r>=0);
604
//            assert(g<256 && b<512 && r<512);
605
            sample[0][0][x]= g;
606
            sample[1][0][x]= b;
607
            sample[2][0][x]= r;
608 11e659c2 Michael Niedermayer
        }
609 2cbb7820 Michael Niedermayer
        for(p=0; p<3; p++){
610 c172913a Michael Niedermayer
            sample[p][0][-1]= sample[p][1][0  ];
611
            sample[p][1][ w]= sample[p][1][w-1];
612 2cbb7820 Michael Niedermayer
            encode_line(s, w, sample[p], FFMIN(p, 1), 9);
613 5e20f836 Michael Niedermayer
        }
614
    }
615
}
616
617 880eae9c Michael Niedermayer
static void write_quant_table(RangeCoder *c, int16_t *quant_table){
618 5e20f836 Michael Niedermayer
    int last=0;
619
    int i;
620 880eae9c Michael Niedermayer
    uint8_t state[CONTEXT_SIZE];
621
    memset(state, 128, sizeof(state));
622 5e20f836 Michael Niedermayer
623 11e659c2 Michael Niedermayer
    for(i=1; i<128 ; i++){
624 5e20f836 Michael Niedermayer
        if(quant_table[i] != quant_table[i-1]){
625 d34a0746 Michael Niedermayer
            put_symbol(c, state, i-last-1, 0);
626 5e20f836 Michael Niedermayer
            last= i;
627
        }
628
    }
629 d34a0746 Michael Niedermayer
    put_symbol(c, state, i-last-1, 0);
630 5e20f836 Michael Niedermayer
}
631
632 c868524b Michael Niedermayer
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
633 4f22b3bb Michael Niedermayer
    int i;
634
    for(i=0; i<5; i++)
635
        write_quant_table(c, quant_table[i]);
636
}
637
638 5e20f836 Michael Niedermayer
static void write_header(FFV1Context *f){
639 880eae9c Michael Niedermayer
    uint8_t state[CONTEXT_SIZE];
640 d56839fc Michael Niedermayer
    int i, j;
641 e2b2f845 Michael Niedermayer
    RangeCoder * const c= &f->slice_context[0]->c;
642 5e20f836 Michael Niedermayer
643 880eae9c Michael Niedermayer
    memset(state, 128, sizeof(state));
644 115329f1 Diego Biurrun
645 0f27aca7 Michael Niedermayer
    if(f->version < 2){
646 1da72577 Michael Niedermayer
        put_symbol(c, state, f->version, 0);
647
        put_symbol(c, state, f->ac, 0);
648
        if(f->ac>1){
649
            for(i=1; i<256; i++){
650 6019cd9f Michael Niedermayer
                put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
651 1da72577 Michael Niedermayer
            }
652 00bbc093 Michael Niedermayer
        }
653 1da72577 Michael Niedermayer
        put_symbol(c, state, f->colorspace, 0); //YUV cs type
654
        if(f->version>0)
655
            put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
656
        put_rac(c, state, 1); //chroma planes
657
            put_symbol(c, state, f->chroma_h_shift, 0);
658
            put_symbol(c, state, f->chroma_v_shift, 0);
659
        put_rac(c, state, 0); //no transparency plane
660
661
        write_quant_tables(c, f->quant_table);
662 c5ac275b Michael Niedermayer
    }else{
663 d56839fc Michael Niedermayer
        put_symbol(c, state, f->slice_count, 0);
664
        for(i=0; i<f->slice_count; i++){
665
            FFV1Context *fs= f->slice_context[i];
666
            put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
667
            put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
668
            put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
669
            put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
670 e1f51b88 Michael Niedermayer
            for(j=0; j<f->plane_count; j++){
671
                put_symbol(c, state, f->plane[j].quant_table_index, 0);
672
                av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
673
            }
674 d56839fc Michael Niedermayer
        }
675 0f27aca7 Michael Niedermayer
    }
676 5e20f836 Michael Niedermayer
}
677 f544a5fc Diego Biurrun
#endif /* CONFIG_FFV1_ENCODER */
678 5e20f836 Michael Niedermayer
679 98a6fff9 Zuxy Meng
static av_cold int common_init(AVCodecContext *avctx){
680 5e20f836 Michael Niedermayer
    FFV1Context *s = avctx->priv_data;
681
682
    s->avctx= avctx;
683
    s->flags= avctx->flags;
684 115329f1 Diego Biurrun
685 5e20f836 Michael Niedermayer
    dsputil_init(&s->dsp, avctx);
686 115329f1 Diego Biurrun
687 6081c30b Michael Niedermayer
    s->width = avctx->width;
688
    s->height= avctx->height;
689 115329f1 Diego Biurrun
690 6081c30b Michael Niedermayer
    assert(s->width && s->height);
691 e2b2f845 Michael Niedermayer
    //defaults
692
    s->num_h_slices=1;
693
    s->num_v_slices=1;
694 5e20f836 Michael Niedermayer
695 cbabccc3 Måns Rullgård
696 5e20f836 Michael Niedermayer
    return 0;
697
}
698
699 e2b2f845 Michael Niedermayer
static int init_slice_state(FFV1Context *f){
700
    int i, j;
701
702
    for(i=0; i<f->slice_count; i++){
703
        FFV1Context *fs= f->slice_context[i];
704
        for(j=0; j<f->plane_count; j++){
705
            PlaneContext * const p= &fs->plane[j];
706
707
            if(fs->ac){
708
                if(!p->    state) p->    state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
709
                if(!p->    state)
710
                    return AVERROR(ENOMEM);
711
            }else{
712
                if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
713
                if(!p->vlc_state)
714
                    return AVERROR(ENOMEM);
715
            }
716
        }
717
718
        if (fs->ac>1){
719
            //FIXME only redo if state_transition changed
720
            for(j=1; j<256; j++){
721
                fs->c.one_state [    j]= fs->state_transition[j];
722
                fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
723
            }
724
        }
725
    }
726
727
    return 0;
728
}
729
730
static av_cold int init_slice_contexts(FFV1Context *f){
731
    int i;
732
733
    f->slice_count= f->num_h_slices * f->num_v_slices;
734
735
    for(i=0; i<f->slice_count; i++){
736
        FFV1Context *fs= av_mallocz(sizeof(*fs));
737
        int sx= i % f->num_h_slices;
738
        int sy= i / f->num_h_slices;
739
        int sxs= f->avctx->width * sx    / f->num_h_slices;
740
        int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
741
        int sys= f->avctx->height* sy    / f->num_v_slices;
742
        int sye= f->avctx->height*(sy+1) / f->num_v_slices;
743
        f->slice_context[i]= fs;
744
        memcpy(fs, f, sizeof(*fs));
745
746
        fs->slice_width = sxe - sxs;
747
        fs->slice_height= sye - sys;
748
        fs->slice_x     = sxs;
749
        fs->slice_y     = sys;
750
751 d56839fc Michael Niedermayer
        fs->sample_buffer = av_malloc(6 * (fs->width+6) * sizeof(*fs->sample_buffer));
752 e2b2f845 Michael Niedermayer
        if (!fs->sample_buffer)
753
            return AVERROR(ENOMEM);
754
    }
755
    return 0;
756
}
757
758 99a5e935 Michael Niedermayer
static int allocate_initial_states(FFV1Context *f){
759
    int i;
760
761
    for(i=0; i<f->quant_table_count; i++){
762
        f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
763
        if(!f->initial_states[i])
764
            return AVERROR(ENOMEM);
765
        memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
766
    }
767
    return 0;
768
}
769
770 d721141f Michael Niedermayer
#if CONFIG_FFV1_ENCODER
771
static int write_extra_header(FFV1Context *f){
772
    RangeCoder * const c= &f->c;
773
    uint8_t state[CONTEXT_SIZE];
774 28a3f525 Michael Niedermayer
    int i, j, k;
775
    uint8_t state2[32][CONTEXT_SIZE];
776
777
    memset(state2, 128, sizeof(state2));
778 d721141f Michael Niedermayer
    memset(state, 128, sizeof(state));
779
780 28a3f525 Michael Niedermayer
    f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
781 d721141f Michael Niedermayer
    ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
782
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
783
784
    put_symbol(c, state, f->version, 0);
785
    put_symbol(c, state, f->ac, 0);
786
    if(f->ac>1){
787
        for(i=1; i<256; i++){
788 6019cd9f Michael Niedermayer
            put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
789 d721141f Michael Niedermayer
        }
790
    }
791
    put_symbol(c, state, f->colorspace, 0); //YUV cs type
792
    put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
793
    put_rac(c, state, 1); //chroma planes
794
        put_symbol(c, state, f->chroma_h_shift, 0);
795
        put_symbol(c, state, f->chroma_v_shift, 0);
796
    put_rac(c, state, 0); //no transparency plane
797
    put_symbol(c, state, f->num_h_slices-1, 0);
798
    put_symbol(c, state, f->num_v_slices-1, 0);
799
800
    put_symbol(c, state, f->quant_table_count, 0);
801
    for(i=0; i<f->quant_table_count; i++)
802
        write_quant_tables(c, f->quant_tables[i]);
803
804 28a3f525 Michael Niedermayer
    for(i=0; i<f->quant_table_count; i++){
805
        for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
806
            if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
807
                break;
808
        if(j<f->context_count[i]*CONTEXT_SIZE){
809
            put_rac(c, state, 1);
810
            for(j=0; j<f->context_count[i]; j++){
811
                for(k=0; k<CONTEXT_SIZE; k++){
812
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
813
                    put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
814
                }
815
            }
816
        }else{
817
            put_rac(c, state, 0);
818
        }
819
    }
820
821 d721141f Michael Niedermayer
    f->avctx->extradata_size= ff_rac_terminate(c);
822
823
    return 0;
824
}
825
826 ce3716bf Michael Niedermayer
static int sort_stt(FFV1Context *s, uint8_t stt[256]){
827
    int i,i2,changed,print=0;
828
829
    do{
830
        changed=0;
831
        for(i=12; i<244; i++){
832
            for(i2=i+1; i2<245 && i2<i+4; i2++){
833
#define COST(old, new) \
834
    s->rc_stat[old][0]*-log2((256-(new))/256.0)\
835
   +s->rc_stat[old][1]*-log2(     (new) /256.0)
836
837
#define COST2(old, new) \
838
    COST(old, new)\
839
   +COST(256-(old), 256-(new))
840
841
                double size0= COST2(i, i ) + COST2(i2, i2);
842
                double sizeX= COST2(i, i2) + COST2(i2, i );
843
                if(sizeX < size0 && i!=128 && i2!=128){
844
                    int j;
845
                    FFSWAP(int, stt[    i], stt[    i2]);
846
                    FFSWAP(int, s->rc_stat[i    ][0],s->rc_stat[    i2][0]);
847
                    FFSWAP(int, s->rc_stat[i    ][1],s->rc_stat[    i2][1]);
848
                    if(i != 256-i2){
849
                        FFSWAP(int, stt[256-i], stt[256-i2]);
850
                        FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
851
                        FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
852
                    }
853
                    for(j=1; j<256; j++){
854
                        if     (stt[j] == i ) stt[j] = i2;
855
                        else if(stt[j] == i2) stt[j] = i ;
856
                        if(i != 256-i2){
857
                            if     (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
858
                            else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
859
                        }
860
                    }
861
                    print=changed=1;
862
                }
863
            }
864
        }
865
    }while(changed);
866
    return print;
867
}
868
869 98a6fff9 Zuxy Meng
static av_cold int encode_init(AVCodecContext *avctx)
870 5e20f836 Michael Niedermayer
{
871
    FFV1Context *s = avctx->priv_data;
872 ce3716bf Michael Niedermayer
    int i, j;
873 5e20f836 Michael Niedermayer
874
    common_init(avctx);
875 115329f1 Diego Biurrun
876 5e20f836 Michael Niedermayer
    s->version=0;
877 00bbc093 Michael Niedermayer
    s->ac= avctx->coder_type ? 2:0;
878 115329f1 Diego Biurrun
879 6019cd9f Michael Niedermayer
    if(s->ac>1)
880
        for(i=1; i<256; i++)
881
            s->state_transition[i]=ver2_state[i];
882
883 27fc5352 Michael Niedermayer
    s->plane_count=2;
884 11e659c2 Michael Niedermayer
    for(i=0; i<256; i++){
885 c5ac275b Michael Niedermayer
        s->quant_table_count=2;
886 68f8d33b Michael Niedermayer
        if(avctx->bits_per_raw_sample <=8){
887 c5ac275b Michael Niedermayer
            s->quant_tables[0][0][i]=           quant11[i];
888
            s->quant_tables[0][1][i]=        11*quant11[i];
889
            s->quant_tables[0][2][i]=     11*11*quant11[i];
890
            s->quant_tables[1][0][i]=           quant11[i];
891
            s->quant_tables[1][1][i]=        11*quant11[i];
892
            s->quant_tables[1][2][i]=     11*11*quant5 [i];
893
            s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
894
            s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
895 68f8d33b Michael Niedermayer
        }else{
896 c5ac275b Michael Niedermayer
            s->quant_tables[0][0][i]=           quant9_10bit[i];
897
            s->quant_tables[0][1][i]=        11*quant9_10bit[i];
898
            s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
899
            s->quant_tables[1][0][i]=           quant9_10bit[i];
900
            s->quant_tables[1][1][i]=        11*quant9_10bit[i];
901
            s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
902
            s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
903
            s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
904 68f8d33b Michael Niedermayer
        }
905 11e659c2 Michael Niedermayer
    }
906 e1f51b88 Michael Niedermayer
    s->context_count[0]= (11*11*11+1)/2;
907
    s->context_count[1]= (11*11*5*5*5+1)/2;
908 c5ac275b Michael Niedermayer
    memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
909 5e20f836 Michael Niedermayer
910
    for(i=0; i<s->plane_count; i++){
911
        PlaneContext * const p= &s->plane[i];
912 115329f1 Diego Biurrun
913 e42393d1 Michael Niedermayer
        memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
914 e1f51b88 Michael Niedermayer
        p->quant_table_index= avctx->context_model;
915
        p->context_count= s->context_count[p->quant_table_index];
916 5e20f836 Michael Niedermayer
    }
917
918 99a5e935 Michael Niedermayer
    if(allocate_initial_states(s) < 0)
919
        return AVERROR(ENOMEM);
920
921 5e20f836 Michael Niedermayer
    avctx->coded_frame= &s->picture;
922
    switch(avctx->pix_fmt){
923 68f8d33b Michael Niedermayer
    case PIX_FMT_YUV444P16:
924
    case PIX_FMT_YUV422P16:
925
    case PIX_FMT_YUV420P16:
926
        if(avctx->bits_per_raw_sample <=8){
927 84c1b149 Carl Eugen Hoyos
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
928 68f8d33b Michael Niedermayer
            return -1;
929
        }
930 ef768b0c Michael Niedermayer
        if(!s->ac){
931
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
932
            return -1;
933
        }
934 228adaab Michael Niedermayer
        s->version= FFMAX(s->version, 1);
935 5e20f836 Michael Niedermayer
    case PIX_FMT_YUV444P:
936
    case PIX_FMT_YUV422P:
937
    case PIX_FMT_YUV420P:
938
    case PIX_FMT_YUV411P:
939
    case PIX_FMT_YUV410P:
940 2cbb7820 Michael Niedermayer
        s->colorspace= 0;
941
        break;
942 71e445fc Diego Biurrun
    case PIX_FMT_RGB32:
943 2cbb7820 Michael Niedermayer
        s->colorspace= 1;
944 5e20f836 Michael Niedermayer
        break;
945
    default:
946 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
947 5e20f836 Michael Niedermayer
        return -1;
948
    }
949 2cbb7820 Michael Niedermayer
    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
950
951 5e20f836 Michael Niedermayer
    s->picture_number=0;
952 115329f1 Diego Biurrun
953 bc29ae4a Michael Niedermayer
    if(avctx->stats_in){
954
        char *p= avctx->stats_in;
955
956
        for(;;){
957
            for(j=0; j<256; j++){
958
                for(i=0; i<2; i++){
959
                    char *next;
960
                    s->rc_stat[j][i]= strtol(p, &next, 0);
961
                    if(next==p){
962
                        av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
963
                        return -1;
964
                    }
965
                    p=next;
966
                }
967
            }
968
            while(*p=='\n' || *p==' ') p++;
969
            if(p[0]==0) break;
970
        }
971 ce3716bf Michael Niedermayer
        sort_stt(s, s->state_transition);
972 bc29ae4a Michael Niedermayer
    }
973
974 e2b2f845 Michael Niedermayer
    if(s->version>1){
975
        s->num_h_slices=2;
976
        s->num_v_slices=2;
977 0f27aca7 Michael Niedermayer
        write_extra_header(s);
978 e2b2f845 Michael Niedermayer
    }
979
980
    if(init_slice_contexts(s) < 0)
981
        return -1;
982
    if(init_slice_state(s) < 0)
983
        return -1;
984 0f27aca7 Michael Niedermayer
985 2a317c6b Michael Niedermayer
#define STATS_OUT_SIZE 1024*30
986 672e7e39 Michael Niedermayer
    if(avctx->flags & CODEC_FLAG_PASS1){
987 2a317c6b Michael Niedermayer
    avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
988 672e7e39 Michael Niedermayer
        for(i=0; i<s->quant_table_count; i++){
989
            for(j=0; j<s->slice_count; j++){
990
                FFV1Context *sf= s->slice_context[j];
991
                av_assert0(!sf->rc_stat2[i]);
992
                sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
993
                if(!sf->rc_stat2[i])
994
                    return AVERROR(ENOMEM);
995
            }
996
        }
997
    }
998 bc29ae4a Michael Niedermayer
999 5e20f836 Michael Niedermayer
    return 0;
1000
}
1001 f544a5fc Diego Biurrun
#endif /* CONFIG_FFV1_ENCODER */
1002 5e20f836 Michael Niedermayer
1003
1004
static void clear_state(FFV1Context *f){
1005 e2b2f845 Michael Niedermayer
    int i, si, j;
1006 5e20f836 Michael Niedermayer
1007 e2b2f845 Michael Niedermayer
    for(si=0; si<f->slice_count; si++){
1008
        FFV1Context *fs= f->slice_context[si];
1009 1da72577 Michael Niedermayer
        for(i=0; i<f->plane_count; i++){
1010
            PlaneContext *p= &fs->plane[i];
1011 5e20f836 Michael Niedermayer
1012 1da72577 Michael Niedermayer
            p->interlace_bit_state[0]= 128;
1013
            p->interlace_bit_state[1]= 128;
1014 115329f1 Diego Biurrun
1015 19721b23 Michael Niedermayer
            if(fs->ac){
1016 99a5e935 Michael Niedermayer
                if(f->initial_states[p->quant_table_index]){
1017
                    memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
1018
                }else
1019 19721b23 Michael Niedermayer
                memset(p->state, 128, CONTEXT_SIZE*p->context_count);
1020
            }else{
1021 1da72577 Michael Niedermayer
            for(j=0; j<p->context_count; j++){
1022
                    p->vlc_state[j].drift= 0;
1023
                    p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
1024
                    p->vlc_state[j].bias= 0;
1025
                    p->vlc_state[j].count= 1;
1026 19721b23 Michael Niedermayer
            }
1027 11e659c2 Michael Niedermayer
            }
1028 c2f1b2cb Michael Niedermayer
        }
1029 5e20f836 Michael Niedermayer
    }
1030
}
1031
1032 b250f9c6 Aurelien Jacobs
#if CONFIG_FFV1_ENCODER
1033 e2b2f845 Michael Niedermayer
static int encode_slice(AVCodecContext *c, void *arg){
1034
    FFV1Context *fs= *(void**)arg;
1035
    FFV1Context *f= fs->avctx->priv_data;
1036
    int width = fs->slice_width;
1037
    int height= fs->slice_height;
1038
    int x= fs->slice_x;
1039
    int y= fs->slice_y;
1040
    AVFrame * const p= &f->picture;
1041
1042
    if(f->colorspace==0){
1043
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1044
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1045
        const int cx= x>>f->chroma_h_shift;
1046
        const int cy= y>>f->chroma_v_shift;
1047
1048
        encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1049
1050
        encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1051
        encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
1052
    }else{
1053
        encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1054
    }
1055
    emms_c();
1056
1057
    return 0;
1058
}
1059
1060 5e20f836 Michael Niedermayer
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1061
    FFV1Context *f = avctx->priv_data;
1062 e2b2f845 Michael Niedermayer
    RangeCoder * const c= &f->slice_context[0]->c;
1063 5e20f836 Michael Niedermayer
    AVFrame *pict = data;
1064
    AVFrame * const p= &f->picture;
1065 11e659c2 Michael Niedermayer
    int used_count= 0;
1066 880eae9c Michael Niedermayer
    uint8_t keystate=128;
1067 e2b2f845 Michael Niedermayer
    uint8_t *buf_p;
1068
    int i;
1069 880eae9c Michael Niedermayer
1070
    ff_init_range_encoder(c, buf, buf_size);
1071
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1072 5e20f836 Michael Niedermayer
1073
    *p = *pict;
1074
    p->pict_type= FF_I_TYPE;
1075 115329f1 Diego Biurrun
1076 5e20f836 Michael Niedermayer
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
1077 880eae9c Michael Niedermayer
        put_rac(c, &keystate, 1);
1078 5e20f836 Michael Niedermayer
        p->key_frame= 1;
1079
        write_header(f);
1080
        clear_state(f);
1081
    }else{
1082 880eae9c Michael Niedermayer
        put_rac(c, &keystate, 0);
1083 5e20f836 Michael Niedermayer
        p->key_frame= 0;
1084
    }
1085
1086 11e659c2 Michael Niedermayer
    if(!f->ac){
1087 880eae9c Michael Niedermayer
        used_count += ff_rac_terminate(c);
1088 11e659c2 Michael Niedermayer
//printf("pos=%d\n", used_count);
1089 e2b2f845 Michael Niedermayer
        init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
1090 00bbc093 Michael Niedermayer
    }else if (f->ac>1){
1091
        int i;
1092
        for(i=1; i<256; i++){
1093
            c->one_state[i]= f->state_transition[i];
1094
            c->zero_state[256-i]= 256-c->one_state[i];
1095
        }
1096 11e659c2 Michael Niedermayer
    }
1097 115329f1 Diego Biurrun
1098 e2b2f845 Michael Niedermayer
    for(i=1; i<f->slice_count; i++){
1099
        FFV1Context *fs= f->slice_context[i];
1100
        uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
1101
        int len= buf_size/f->slice_count;
1102 5e20f836 Michael Niedermayer
1103 e2b2f845 Michael Niedermayer
        if(fs->ac){
1104
            ff_init_range_encoder(&fs->c, start, len);
1105
        }else{
1106
            init_put_bits(&fs->pb, start, len);
1107
        }
1108 5e20f836 Michael Niedermayer
    }
1109 e2b2f845 Michael Niedermayer
    avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1110 115329f1 Diego Biurrun
1111 e2b2f845 Michael Niedermayer
    buf_p=buf;
1112
    for(i=0; i<f->slice_count; i++){
1113
        FFV1Context *fs= f->slice_context[i];
1114
        int bytes;
1115 5e20f836 Michael Niedermayer
1116 e2b2f845 Michael Niedermayer
        if(fs->ac){
1117
            uint8_t state=128;
1118
            put_rac(&fs->c, &state, 0);
1119
            bytes= ff_rac_terminate(&fs->c);
1120
        }else{
1121
            flush_put_bits(&fs->pb); //nicer padding FIXME
1122
            bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
1123
            used_count= 0;
1124
        }
1125
        if(i>0){
1126
            av_assert0(bytes < buf_size/f->slice_count);
1127
            memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
1128
            av_assert0(bytes < (1<<24));
1129
            AV_WB24(buf_p+bytes, bytes);
1130
            bytes+=3;
1131
        }
1132
        buf_p += bytes;
1133 11e659c2 Michael Niedermayer
    }
1134 e2b2f845 Michael Niedermayer
1135 bc29ae4a Michael Niedermayer
    if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
1136
        int j;
1137
        char *p= avctx->stats_out;
1138 2a317c6b Michael Niedermayer
        char *end= p + STATS_OUT_SIZE;
1139 bc29ae4a Michael Niedermayer
1140
        memset(f->rc_stat, 0, sizeof(f->rc_stat));
1141
        for(j=0; j<f->slice_count; j++){
1142
            FFV1Context *fs= f->slice_context[j];
1143
            for(i=0; i<256; i++){
1144
                f->rc_stat[i][0] += fs->rc_stat[i][0];
1145
                f->rc_stat[i][1] += fs->rc_stat[i][1];
1146
            }
1147
        }
1148
1149
        for(j=0; j<256; j++){
1150
            snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
1151
            p+= strlen(p);
1152
        }
1153
        snprintf(p, end-p, "\n");
1154 c42c1007 Michael Niedermayer
    } else if(avctx->flags&CODEC_FLAG_PASS1)
1155 bc29ae4a Michael Niedermayer
        avctx->stats_out[0] = '\0';
1156
1157 e2b2f845 Michael Niedermayer
    f->picture_number++;
1158
    return buf_p-buf;
1159 5e20f836 Michael Niedermayer
}
1160 f544a5fc Diego Biurrun
#endif /* CONFIG_FFV1_ENCODER */
1161 5e20f836 Michael Niedermayer
1162 98a6fff9 Zuxy Meng
static av_cold int common_end(AVCodecContext *avctx){
1163 0c2aaa88 Loren Merritt
    FFV1Context *s = avctx->priv_data;
1164 e2b2f845 Michael Niedermayer
    int i, j;
1165 5e20f836 Michael Niedermayer
1166 e2b2f845 Michael Niedermayer
    for(j=0; j<s->slice_count; j++){
1167
        FFV1Context *fs= s->slice_context[j];
1168 1da72577 Michael Niedermayer
        for(i=0; i<s->plane_count; i++){
1169
            PlaneContext *p= &fs->plane[i];
1170 5e20f836 Michael Niedermayer
1171 1da72577 Michael Niedermayer
            av_freep(&p->state);
1172
            av_freep(&p->vlc_state);
1173
        }
1174 e2b2f845 Michael Niedermayer
        av_freep(&fs->sample_buffer);
1175
    }
1176 cbabccc3 Måns Rullgård
1177 bc29ae4a Michael Niedermayer
    av_freep(&avctx->stats_out);
1178 672e7e39 Michael Niedermayer
    for(j=0; j<s->quant_table_count; j++){
1179 99a5e935 Michael Niedermayer
        av_freep(&s->initial_states[j]);
1180 672e7e39 Michael Niedermayer
        for(i=0; i<s->slice_count; i++){
1181
            FFV1Context *sf= s->slice_context[i];
1182
            av_freep(&sf->rc_stat2[j]);
1183
        }
1184
    }
1185 bc29ae4a Michael Niedermayer
1186 5e20f836 Michael Niedermayer
    return 0;
1187
}
1188
1189 217d34e3 Michael Niedermayer
static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
1190 5e20f836 Michael Niedermayer
    PlaneContext * const p= &s->plane[plane_index];
1191 880eae9c Michael Niedermayer
    RangeCoder * const c= &s->c;
1192 2cbb7820 Michael Niedermayer
    int x;
1193
    int run_count=0;
1194
    int run_mode=0;
1195
    int run_index= s->run_index;
1196
1197
    for(x=0; x<w; x++){
1198
        int diff, context, sign;
1199 115329f1 Diego Biurrun
1200 e42393d1 Michael Niedermayer
        context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
1201 2cbb7820 Michael Niedermayer
        if(context < 0){
1202
            context= -context;
1203
            sign=1;
1204
        }else
1205
            sign=0;
1206 115329f1 Diego Biurrun
1207 f08ed90d Michael Niedermayer
        av_assert2(context < p->context_count);
1208 2cbb7820 Michael Niedermayer
1209 d34a0746 Michael Niedermayer
        if(s->ac){
1210 217d34e3 Michael Niedermayer
            diff= get_symbol_inline(c, p->state[context], 1);
1211 d34a0746 Michael Niedermayer
        }else{
1212 2cbb7820 Michael Niedermayer
            if(context == 0 && run_mode==0) run_mode=1;
1213 115329f1 Diego Biurrun
1214 2cbb7820 Michael Niedermayer
            if(run_mode){
1215
                if(run_count==0 && run_mode==1){
1216
                    if(get_bits1(&s->gb)){
1217 b3bf98aa Stefan Gehrer
                        run_count = 1<<ff_log2_run[run_index];
1218 2cbb7820 Michael Niedermayer
                        if(x + run_count <= w) run_index++;
1219
                    }else{
1220 b3bf98aa Stefan Gehrer
                        if(ff_log2_run[run_index]) run_count = get_bits(&s->gb, ff_log2_run[run_index]);
1221 2cbb7820 Michael Niedermayer
                        else run_count=0;
1222
                        if(run_index) run_index--;
1223
                        run_mode=2;
1224
                    }
1225
                }
1226
                run_count--;
1227
                if(run_count < 0){
1228
                    run_mode=0;
1229
                    run_count=0;
1230
                    diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1231
                    if(diff>=0) diff++;
1232
                }else
1233
                    diff=0;
1234
            }else
1235
                diff= get_vlc_symbol(&s->gb, &p->vlc_state[context], bits);
1236 115329f1 Diego Biurrun
1237 2cbb7820 Michael Niedermayer
//            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));
1238
        }
1239
1240
        if(sign) diff= -diff;
1241
1242
        sample[1][x]= (predict(sample[1] + x, sample[0] + x) + diff) & ((1<<bits)-1);
1243
    }
1244 115329f1 Diego Biurrun
    s->run_index= run_index;
1245 2cbb7820 Michael Niedermayer
}
1246
1247
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
1248
    int x, y;
1249 d1845b4c Carl Eugen Hoyos
    int_fast16_t *sample[2];
1250 cbabccc3 Måns Rullgård
    sample[0]=s->sample_buffer    +3;
1251
    sample[1]=s->sample_buffer+w+6+3;
1252 2cbb7820 Michael Niedermayer
1253
    s->run_index=0;
1254 115329f1 Diego Biurrun
1255 cbabccc3 Måns Rullgård
    memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
1256 115329f1 Diego Biurrun
1257 5e20f836 Michael Niedermayer
    for(y=0; y<h; y++){
1258 2cbb7820 Michael Niedermayer
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
1259 5e20f836 Michael Niedermayer
1260 d9ced4ca Michael Niedermayer
        sample[0]= sample[1];
1261
        sample[1]= temp;
1262 5e20f836 Michael Niedermayer
1263 d9ced4ca Michael Niedermayer
        sample[1][-1]= sample[0][0  ];
1264
        sample[0][ w]= sample[0][w-1];
1265 115329f1 Diego Biurrun
1266 2cbb7820 Michael Niedermayer
//{START_TIMER
1267 68f8d33b Michael Niedermayer
        if(s->avctx->bits_per_raw_sample <= 8){
1268 f83c5773 Michael Niedermayer
            decode_line(s, w, sample, plane_index, 8);
1269
            for(x=0; x<w; x++){
1270
                src[x + stride*y]= sample[1][x];
1271
            }
1272 68f8d33b Michael Niedermayer
        }else{
1273
            decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample);
1274
            for(x=0; x<w; x++){
1275
                ((uint16_t*)(src + stride*y))[x]= sample[1][x] << (16 - s->avctx->bits_per_raw_sample);
1276
            }
1277
        }
1278 2cbb7820 Michael Niedermayer
//STOP_TIMER("decode-line")}
1279
    }
1280
}
1281 5e20f836 Michael Niedermayer
1282 2cbb7820 Michael Niedermayer
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
1283
    int x, y, p;
1284 d1845b4c Carl Eugen Hoyos
    int_fast16_t *sample[3][2];
1285
    for(x=0; x<3; x++){
1286 cbabccc3 Måns Rullgård
        sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
1287
        sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
1288 d1845b4c Carl Eugen Hoyos
    }
1289 2cbb7820 Michael Niedermayer
1290
    s->run_index=0;
1291 115329f1 Diego Biurrun
1292 cbabccc3 Måns Rullgård
    memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
1293 115329f1 Diego Biurrun
1294 2cbb7820 Michael Niedermayer
    for(y=0; y<h; y++){
1295
        for(p=0; p<3; p++){
1296
            int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
1297
1298
            sample[p][0]= sample[p][1];
1299
            sample[p][1]= temp;
1300 5e20f836 Michael Niedermayer
1301 2cbb7820 Michael Niedermayer
            sample[p][1][-1]= sample[p][0][0  ];
1302
            sample[p][0][ w]= sample[p][0][w-1];
1303
            decode_line(s, w, sample[p], FFMIN(p, 1), 9);
1304
        }
1305
        for(x=0; x<w; x++){
1306
            int g= sample[0][1][x];
1307
            int b= sample[1][1][x];
1308
            int r= sample[2][1][x];
1309 11e659c2 Michael Niedermayer
1310 2cbb7820 Michael Niedermayer
//            assert(g>=0 && b>=0 && r>=0);
1311
//            assert(g<256 && b<512 && r<512);
1312 115329f1 Diego Biurrun
1313 2cbb7820 Michael Niedermayer
            b -= 0x100;
1314
            r -= 0x100;
1315
            g -= (b + r)>>2;
1316
            b += g;
1317
            r += g;
1318 115329f1 Diego Biurrun
1319 741b5fd4 Thad Ward
            src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
1320 5e20f836 Michael Niedermayer
        }
1321
    }
1322
}
1323
1324 e2b2f845 Michael Niedermayer
static int decode_slice(AVCodecContext *c, void *arg){
1325
    FFV1Context *fs= *(void**)arg;
1326
    FFV1Context *f= fs->avctx->priv_data;
1327
    int width = fs->slice_width;
1328
    int height= fs->slice_height;
1329
    int x= fs->slice_x;
1330
    int y= fs->slice_y;
1331
    AVFrame * const p= &f->picture;
1332
1333
    av_assert1(width && height);
1334
    if(f->colorspace==0){
1335
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1336
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1337
        const int cx= x>>f->chroma_h_shift;
1338
        const int cy= y>>f->chroma_v_shift;
1339
        decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
1340
1341
        decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
1342
        decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
1343
    }else{
1344
        decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
1345
    }
1346
1347
    emms_c();
1348
1349
    return 0;
1350
}
1351
1352 880eae9c Michael Niedermayer
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
1353 5e20f836 Michael Niedermayer
    int v;
1354
    int i=0;
1355 880eae9c Michael Niedermayer
    uint8_t state[CONTEXT_SIZE];
1356
1357
    memset(state, 128, sizeof(state));
1358 5e20f836 Michael Niedermayer
1359 11e659c2 Michael Niedermayer
    for(v=0; i<128 ; v++){
1360 d34a0746 Michael Niedermayer
        int len= get_symbol(c, state, 0) + 1;
1361 5e20f836 Michael Niedermayer
1362 11e659c2 Michael Niedermayer
        if(len + i > 128) return -1;
1363 115329f1 Diego Biurrun
1364 5e20f836 Michael Niedermayer
        while(len--){
1365 11e659c2 Michael Niedermayer
            quant_table[i] = scale*v;
1366
            i++;
1367 5e20f836 Michael Niedermayer
//printf("%2d ",v);
1368
//if(i%16==0) printf("\n");
1369
        }
1370
    }
1371 11e659c2 Michael Niedermayer
1372
    for(i=1; i<128; i++){
1373
        quant_table[256-i]= -quant_table[i];
1374
    }
1375
    quant_table[128]= -quant_table[127];
1376 115329f1 Diego Biurrun
1377 11e659c2 Michael Niedermayer
    return 2*v - 1;
1378 5e20f836 Michael Niedermayer
}
1379
1380 c868524b Michael Niedermayer
static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
1381 4f22b3bb Michael Niedermayer
    int i;
1382
    int context_count=1;
1383
1384
    for(i=0; i<5; i++){
1385
        context_count*= read_quant_table(c, quant_table[i], context_count);
1386
        if(context_count > 32768U){
1387
            return -1;
1388
        }
1389
    }
1390
    return (context_count+1)/2;
1391
}
1392
1393 0f27aca7 Michael Niedermayer
static int read_extra_header(FFV1Context *f){
1394
    RangeCoder * const c= &f->c;
1395
    uint8_t state[CONTEXT_SIZE];
1396 28a3f525 Michael Niedermayer
    int i, j, k;
1397
    uint8_t state2[32][CONTEXT_SIZE];
1398 0f27aca7 Michael Niedermayer
1399 28a3f525 Michael Niedermayer
    memset(state2, 128, sizeof(state2));
1400 0f27aca7 Michael Niedermayer
    memset(state, 128, sizeof(state));
1401
1402
    ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
1403
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1404
1405
    f->version= get_symbol(c, state, 0);
1406
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1407
    if(f->ac>1){
1408
        for(i=1; i<256; i++){
1409
            f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1410
        }
1411
    }
1412
    f->colorspace= get_symbol(c, state, 0); //YUV cs type
1413
    f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1414
    get_rac(c, state); //no chroma = false
1415
    f->chroma_h_shift= get_symbol(c, state, 0);
1416
    f->chroma_v_shift= get_symbol(c, state, 0);
1417
    get_rac(c, state); //transparency plane
1418
    f->plane_count= 2;
1419 e2b2f845 Michael Niedermayer
    f->num_h_slices= 1 + get_symbol(c, state, 0);
1420
    f->num_v_slices= 1 + get_symbol(c, state, 0);
1421 d56839fc Michael Niedermayer
    if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
1422 e2b2f845 Michael Niedermayer
        av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
1423
        return -1;
1424
    }
1425 0f27aca7 Michael Niedermayer
1426 c5ac275b Michael Niedermayer
    f->quant_table_count= get_symbol(c, state, 0);
1427
    if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
1428
        return -1;
1429
    for(i=0; i<f->quant_table_count; i++){
1430
        if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
1431
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1432
            return -1;
1433 0f27aca7 Michael Niedermayer
        }
1434
    }
1435
1436 28a3f525 Michael Niedermayer
    if(allocate_initial_states(f) < 0)
1437
        return AVERROR(ENOMEM);
1438
1439
    for(i=0; i<f->quant_table_count; i++){
1440
        if(get_rac(c, state)){
1441
            for(j=0; j<f->context_count[i]; j++){
1442
                for(k=0; k<CONTEXT_SIZE; k++){
1443
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
1444
                    f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
1445
                }
1446
            }
1447
        }
1448
    }
1449
1450 0f27aca7 Michael Niedermayer
    return 0;
1451
}
1452
1453 5e20f836 Michael Niedermayer
static int read_header(FFV1Context *f){
1454 880eae9c Michael Niedermayer
    uint8_t state[CONTEXT_SIZE];
1455 e2b2f845 Michael Niedermayer
    int i, j, context_count;
1456
    RangeCoder * const c= &f->slice_context[0]->c;
1457 115329f1 Diego Biurrun
1458 880eae9c Michael Niedermayer
    memset(state, 128, sizeof(state));
1459
1460 0f27aca7 Michael Niedermayer
    if(f->version < 2){
1461 1da72577 Michael Niedermayer
        f->version= get_symbol(c, state, 0);
1462
        f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1463
        if(f->ac>1){
1464
            for(i=1; i<256; i++){
1465
                f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
1466
            }
1467 00bbc093 Michael Niedermayer
        }
1468 1da72577 Michael Niedermayer
        f->colorspace= get_symbol(c, state, 0); //YUV cs type
1469
        if(f->version>0)
1470
            f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1471
        get_rac(c, state); //no chroma = false
1472
        f->chroma_h_shift= get_symbol(c, state, 0);
1473
        f->chroma_v_shift= get_symbol(c, state, 0);
1474
        get_rac(c, state); //transparency plane
1475
        f->plane_count= 2;
1476 0f27aca7 Michael Niedermayer
    }
1477 085565f7 Michael Niedermayer
1478 2cbb7820 Michael Niedermayer
    if(f->colorspace==0){
1479 68f8d33b Michael Niedermayer
        if(f->avctx->bits_per_raw_sample<=8){
1480 f83c5773 Michael Niedermayer
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1481
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
1482
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
1483
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
1484
            case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
1485
            case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
1486
            default:
1487
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1488
                return -1;
1489
            }
1490 68f8d33b Michael Niedermayer
        }else{
1491
            switch(16*f->chroma_h_shift + f->chroma_v_shift){
1492
            case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P16; break;
1493
            case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P16; break;
1494
            case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P16; break;
1495
            default:
1496
                av_log(f->avctx, AV_LOG_ERROR, "format not supported\n");
1497
                return -1;
1498
            }
1499
        }
1500 2cbb7820 Michael Niedermayer
    }else if(f->colorspace==1){
1501
        if(f->chroma_h_shift || f->chroma_v_shift){
1502 9b879566 Michel Bardiaux
            av_log(f->avctx, AV_LOG_ERROR, "chroma subsampling not supported in this colorspace\n");
1503 2cbb7820 Michael Niedermayer
            return -1;
1504
        }
1505 71e445fc Diego Biurrun
        f->avctx->pix_fmt= PIX_FMT_RGB32;
1506 2cbb7820 Michael Niedermayer
    }else{
1507 9b879566 Michel Bardiaux
        av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n");
1508 085565f7 Michael Niedermayer
        return -1;
1509
    }
1510 2cbb7820 Michael Niedermayer
1511 085565f7 Michael Niedermayer
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1512 0f27aca7 Michael Niedermayer
    if(f->version < 2){
1513 1da72577 Michael Niedermayer
        context_count= read_quant_tables(c, f->quant_table);
1514
        if(context_count < 0){
1515
                av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
1516
                return -1;
1517 085565f7 Michael Niedermayer
        }
1518 d56839fc Michael Niedermayer
    }else{
1519
        f->slice_count= get_symbol(c, state, 0);
1520
        if(f->slice_count > (unsigned)MAX_SLICES)
1521
            return -1;
1522 c5ac275b Michael Niedermayer
    }
1523 d56839fc Michael Niedermayer
1524 e2b2f845 Michael Niedermayer
    for(j=0; j<f->slice_count; j++){
1525
        FFV1Context *fs= f->slice_context[j];
1526
        fs->ac= f->ac;
1527 d56839fc Michael Niedermayer
1528
        if(f->version >= 2){
1529
            fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
1530
            fs->slice_y     = get_symbol(c, state, 0)   *f->height;
1531
            fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
1532
            fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
1533
1534
            fs->slice_x /= f->num_h_slices;
1535
            fs->slice_y /= f->num_v_slices;
1536
            fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
1537
            fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
1538
            if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
1539
                return -1;
1540
            if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
1541
                || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
1542
                return -1;
1543
        }
1544
1545 1da72577 Michael Niedermayer
        for(i=0; i<f->plane_count; i++){
1546
            PlaneContext * const p= &fs->plane[i];
1547
1548
            if(f->version >= 2){
1549
                int idx=get_symbol(c, state, 0);
1550
                if(idx > (unsigned)f->quant_table_count){
1551
                    av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
1552
                    return -1;
1553
                }
1554 e1f51b88 Michael Niedermayer
                p->quant_table_index= idx;
1555 1da72577 Michael Niedermayer
                memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
1556
                context_count= f->context_count[idx];
1557
            }else{
1558
                memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
1559 e42393d1 Michael Niedermayer
            }
1560
1561 1da72577 Michael Niedermayer
            if(p->context_count < context_count){
1562
                av_freep(&p->state);
1563
                av_freep(&p->vlc_state);
1564
            }
1565
            p->context_count= context_count;
1566 11e659c2 Michael Niedermayer
        }
1567 5e20f836 Michael Niedermayer
    }
1568 115329f1 Diego Biurrun
1569 5e20f836 Michael Niedermayer
    return 0;
1570
}
1571
1572 98a6fff9 Zuxy Meng
static av_cold int decode_init(AVCodecContext *avctx)
1573 5e20f836 Michael Niedermayer
{
1574 0f27aca7 Michael Niedermayer
    FFV1Context *f = avctx->priv_data;
1575 5e20f836 Michael Niedermayer
1576
    common_init(avctx);
1577 115329f1 Diego Biurrun
1578 e2b2f845 Michael Niedermayer
    if(avctx->extradata && read_extra_header(f) < 0)
1579
        return -1;
1580
1581
    if(init_slice_contexts(f) < 0)
1582
        return -1;
1583 0f27aca7 Michael Niedermayer
1584 5e20f836 Michael Niedermayer
    return 0;
1585
}
1586
1587 7a00bbad Thilo Borgmann
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
1588
    const uint8_t *buf = avpkt->data;
1589
    int buf_size = avpkt->size;
1590 5e20f836 Michael Niedermayer
    FFV1Context *f = avctx->priv_data;
1591 e2b2f845 Michael Niedermayer
    RangeCoder * const c= &f->slice_context[0]->c;
1592 5e20f836 Michael Niedermayer
    AVFrame * const p= &f->picture;
1593 e2b2f845 Michael Niedermayer
    int bytes_read, i;
1594 880eae9c Michael Niedermayer
    uint8_t keystate= 128;
1595 e2b2f845 Michael Niedermayer
    const uint8_t *buf_p;
1596 5e20f836 Michael Niedermayer
1597
    AVFrame *picture = data;
1598
1599 880eae9c Michael Niedermayer
    ff_init_range_decoder(c, buf, buf_size);
1600
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1601 e5017ab8 Laurent Aimar
1602 5e20f836 Michael Niedermayer
1603
    p->pict_type= FF_I_TYPE; //FIXME I vs. P
1604 880eae9c Michael Niedermayer
    if(get_rac(c, &keystate)){
1605 5e20f836 Michael Niedermayer
        p->key_frame= 1;
1606 ee7388c9 Michael Niedermayer
        if(read_header(f) < 0)
1607
            return -1;
1608 e2b2f845 Michael Niedermayer
        if(init_slice_state(f) < 0)
1609
            return -1;
1610
1611 5e20f836 Michael Niedermayer
        clear_state(f);
1612
    }else{
1613
        p->key_frame= 0;
1614
    }
1615 00bbc093 Michael Niedermayer
    if(f->ac>1){
1616
        int i;
1617
        for(i=1; i<256; i++){
1618
            c->one_state[i]= f->state_transition[i];
1619
            c->zero_state[256-i]= 256-c->one_state[i];
1620
        }
1621
    }
1622
1623 085565f7 Michael Niedermayer
    p->reference= 0;
1624
    if(avctx->get_buffer(avctx, p) < 0){
1625 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1626 085565f7 Michael Niedermayer
        return -1;
1627
    }
1628
1629 5e20f836 Michael Niedermayer
    if(avctx->debug&FF_DEBUG_PICT_INFO)
1630 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "keyframe:%d coder:%d\n", p->key_frame, f->ac);
1631 115329f1 Diego Biurrun
1632 11e659c2 Michael Niedermayer
    if(!f->ac){
1633 880eae9c Michael Niedermayer
        bytes_read = c->bytestream - c->bytestream_start - 1;
1634
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1635 11e659c2 Michael Niedermayer
//printf("pos=%d\n", bytes_read);
1636 e2b2f845 Michael Niedermayer
        init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, buf_size - bytes_read);
1637 1df1df0b Fabrice Bellard
    } else {
1638
        bytes_read = 0; /* avoid warning */
1639 11e659c2 Michael Niedermayer
    }
1640 115329f1 Diego Biurrun
1641 e2b2f845 Michael Niedermayer
    buf_p= buf + buf_size;
1642
    for(i=f->slice_count-1; i>0; i--){
1643
        FFV1Context *fs= f->slice_context[i];
1644
        int v= AV_RB24(buf_p-3)+3;
1645
        if(buf_p - buf <= v){
1646
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
1647
            return -1;
1648
        }
1649
        buf_p -= v;
1650
        if(fs->ac){
1651
            ff_init_range_decoder(&fs->c, buf_p, v);
1652
        }else{
1653
            init_get_bits(&fs->gb, buf_p, v);
1654
        }
1655 5e20f836 Michael Niedermayer
    }
1656 115329f1 Diego Biurrun
1657 e2b2f845 Michael Niedermayer
    avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1658 5e20f836 Michael Niedermayer
    f->picture_number++;
1659
1660
    *picture= *p;
1661 115329f1 Diego Biurrun
1662 5e20f836 Michael Niedermayer
    avctx->release_buffer(avctx, p); //FIXME
1663
1664
    *data_size = sizeof(AVFrame);
1665 115329f1 Diego Biurrun
1666 e2b2f845 Michael Niedermayer
    return buf_size;
1667 5e20f836 Michael Niedermayer
}
1668
1669
AVCodec ffv1_decoder = {
1670
    "ffv1",
1671 72415b2a Stefano Sabatini
    AVMEDIA_TYPE_VIDEO,
1672 5e20f836 Michael Niedermayer
    CODEC_ID_FFV1,
1673
    sizeof(FFV1Context),
1674
    decode_init,
1675
    NULL,
1676 0c2aaa88 Loren Merritt
    common_end,
1677 5e20f836 Michael Niedermayer
    decode_frame,
1678 c2f1b2cb Michael Niedermayer
    CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
1679 038f846e Stefano Sabatini
    NULL,
1680 7c6208d4 Lars Täuber
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1681 5e20f836 Michael Niedermayer
};
1682
1683 b250f9c6 Aurelien Jacobs
#if CONFIG_FFV1_ENCODER
1684 5e20f836 Michael Niedermayer
AVCodec ffv1_encoder = {
1685
    "ffv1",
1686 72415b2a Stefano Sabatini
    AVMEDIA_TYPE_VIDEO,
1687 5e20f836 Michael Niedermayer
    CODEC_ID_FFV1,
1688
    sizeof(FFV1Context),
1689
    encode_init,
1690
    encode_frame,
1691 0c2aaa88 Loren Merritt
    common_end,
1692 2ba83017 Reimar Döffinger
    .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},
1693 7c6208d4 Lars Täuber
    .long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
1694 5e20f836 Michael Niedermayer
};
1695 2a250222 Michael Niedermayer
#endif