Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ffv1.c @ cbabccc3

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