← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.quantal

« back to all changes in this revision

Viewing changes to libavcodec/ffv1.c

  • Committer: Gauvain Pocentek
  • Date: 2011-08-21 07:22:23 UTC
  • mfrom: (66.1.11 oneiric)
  • Revision ID: gauvain@pocentek.net-20110821072223-ummeossdz7okpb3d
http://bugs.debian.org/577761
http://bugs.debian.org/591525
http://bugs.debian.org/594093
http://bugs.debian.org/595452
http://bugs.debian.org/598431
http://bugs.debian.org/612473
http://bugs.debian.org/617826
http://bugs.debian.org/623304
http://bugs.debian.org/634277
http://bugs.debian.org/634773
* Merge from Ubuntu:
  - put back faac support
  - recommends apport-hooks-medibuntu
  - change Maintainer, Uploaders & Vcs-* fields.
* New upstream snapshot
  - update 23mplayer-debug-printf.patch
  - fixes miscompilation with gcc 4.6, Closes: #623304
  - improved internal mkv demuxer, Closes: #595452
  - Fixed segfault due to missing sanitation on playlist files,
    Closes: #591525
  - Fixed byteorder on 16-bit displays, Closes: #594093
  - tighten build depends on libav
  - --enable-largefile switch has been dropped
  - add build dependency on yasm
* Fix build dependency on libjpeg-dev, Closes: #634277
* rewrite debian/copyright in DEP5 format
* fix clean target
* don't remove snapshot_version file
* enable XVID, MP3 and X264 encoders
* simply architecture specific dependencies, Closes: #634773
* make buildlogs verbose
* unbreak building mplayer-doc package
* don't fail debian package build if not all shlibdeps information could be retrieved
* update configure flags for static libav* libraries
* fix spelling in mplayer-dbg description, Closes: #617826
* enable blueray support, Closes: #577761
* Select oss as default audio output module on kFreeBSD, Closes: #598431
* Update documentation with regard to our modifications to the upstream tarball.
* really no longer build mplayer-gui, Closes: #612473
* simplify/remove instruction to get upstream sources
* normalize debian/{control,copyright,mplayer.install} with wrap-and-sort
* bump standards version

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