← Back to branch summary

~ubuntu-branches/ubuntu/utopic/libav/utopic

« back to all changes in this revision

Viewing changes to libavcodec/ffv1.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-03-20 12:09:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110320120931-nfhi9tiok27gxhw1
Tags: upstream-0.6.2
Import upstream version 0.6.2

Show diffs side-by-side

added added

removed removed

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