Make sure the next used frame is released so get_buffer() wont fail.
[libav.git] / libavcodec / snow.c
1 /*
2 * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 #include "avcodec.h"
22 #include "dsputil.h"
23 #include "snow.h"
24
25 #include "rangecoder.h"
26 #include "mathops.h"
27
28 #include "mpegvideo.h"
29
30 #undef NDEBUG
31 #include <assert.h>
32
33 static const int8_t quant3[256]={
34 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
35 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
36 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
37 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
38 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
39 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
40 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
41 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
42 -1,-1,-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, 0,
50 };
51 static const int8_t quant3b[256]={
52 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
53 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
54 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
55 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
56 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
57 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
58 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
59 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
60 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
61 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-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,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
65 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
66 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
67 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
68 };
69 static const int8_t quant3bA[256]={
70 0, 0, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
71 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
72 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
73 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-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, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
77 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
78 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
79 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
80 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
81 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
82 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
83 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
84 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
85 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
86 };
87 static const int8_t quant5[256]={
88 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
89 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
90 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
91 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
92 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
93 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
96 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
97 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
98 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
99 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
100 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
101 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
102 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
103 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
104 };
105 static const int8_t quant7[256]={
106 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
107 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
108 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
109 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
110 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
111 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
112 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
113 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
114 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
115 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
116 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
117 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
118 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
119 -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
120 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
121 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
122 };
123 static const int8_t quant9[256]={
124 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
125 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
126 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
127 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
128 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
129 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
130 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
131 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
132 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
133 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
134 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
135 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
136 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
137 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
138 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
139 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
140 };
141 static const int8_t quant11[256]={
142 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 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, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
145 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
146 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
147 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
148 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
149 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
150 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
151 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
152 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
153 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
154 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
155 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
156 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
157 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
158 };
159 static const int8_t quant13[256]={
160 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
161 4, 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, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
164 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
165 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
166 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
167 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
168 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
169 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
170 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
171 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
172 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
173 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
174 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
175 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
176 };
177
178 #if 0 //64*cubic
179 static const uint8_t obmc32[1024]={
180 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
181 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0,
182 0, 0, 0, 4, 4, 4, 4, 8, 8, 12, 12, 12, 16, 16, 16, 16, 16, 16, 16, 16, 12, 12, 12, 8, 8, 4, 4, 4, 4, 0, 0, 0,
183 0, 0, 4, 4, 8, 8, 12, 16, 16, 20, 24, 24, 28, 28, 32, 32, 32, 32, 28, 28, 24, 24, 20, 16, 16, 12, 8, 8, 4, 4, 0, 0,
184 0, 0, 4, 8, 8, 12, 16, 24, 28, 32, 36, 40, 44, 48, 48, 48, 48, 48, 48, 44, 40, 36, 32, 28, 24, 16, 12, 8, 8, 4, 0, 0,
185 0, 4, 4, 8, 12, 20, 24, 32, 40, 44, 52, 56, 60, 64, 68, 72, 72, 68, 64, 60, 56, 52, 44, 40, 32, 24, 20, 12, 8, 4, 4, 0,
186 0, 4, 4, 12, 16, 24, 32, 40, 52, 60, 68, 76, 80, 88, 88, 92, 92, 88, 88, 80, 76, 68, 60, 52, 40, 32, 24, 16, 12, 4, 4, 0,
187 0, 4, 8, 16, 24, 32, 40, 52, 64, 76, 84, 92,100,108,112,116,116,112,108,100, 92, 84, 76, 64, 52, 40, 32, 24, 16, 8, 4, 0,
188 0, 4, 8, 16, 28, 40, 52, 64, 76, 88,100,112,124,132,136,140,140,136,132,124,112,100, 88, 76, 64, 52, 40, 28, 16, 8, 4, 0,
189 0, 4, 12, 20, 32, 44, 60, 76, 88,104,120,132,144,152,160,164,164,160,152,144,132,120,104, 88, 76, 60, 44, 32, 20, 12, 4, 0,
190 0, 4, 12, 24, 36, 48, 68, 84,100,120,136,152,164,176,180,184,184,180,176,164,152,136,120,100, 84, 68, 48, 36, 24, 12, 4, 0,
191 0, 4, 12, 24, 40, 56, 76, 92,112,132,152,168,180,192,204,208,208,204,192,180,168,152,132,112, 92, 76, 56, 40, 24, 12, 4, 0,
192 0, 4, 16, 28, 44, 60, 80,100,124,144,164,180,196,208,220,224,224,220,208,196,180,164,144,124,100, 80, 60, 44, 28, 16, 4, 0,
193 0, 8, 16, 28, 48, 64, 88,108,132,152,176,192,208,224,232,240,240,232,224,208,192,176,152,132,108, 88, 64, 48, 28, 16, 8, 0,
194 0, 4, 16, 32, 48, 68, 88,112,136,160,180,204,220,232,244,248,248,244,232,220,204,180,160,136,112, 88, 68, 48, 32, 16, 4, 0,
195 1, 8, 16, 32, 48, 72, 92,116,140,164,184,208,224,240,248,255,255,248,240,224,208,184,164,140,116, 92, 72, 48, 32, 16, 8, 1,
196 1, 8, 16, 32, 48, 72, 92,116,140,164,184,208,224,240,248,255,255,248,240,224,208,184,164,140,116, 92, 72, 48, 32, 16, 8, 1,
197 0, 4, 16, 32, 48, 68, 88,112,136,160,180,204,220,232,244,248,248,244,232,220,204,180,160,136,112, 88, 68, 48, 32, 16, 4, 0,
198 0, 8, 16, 28, 48, 64, 88,108,132,152,176,192,208,224,232,240,240,232,224,208,192,176,152,132,108, 88, 64, 48, 28, 16, 8, 0,
199 0, 4, 16, 28, 44, 60, 80,100,124,144,164,180,196,208,220,224,224,220,208,196,180,164,144,124,100, 80, 60, 44, 28, 16, 4, 0,
200 0, 4, 12, 24, 40, 56, 76, 92,112,132,152,168,180,192,204,208,208,204,192,180,168,152,132,112, 92, 76, 56, 40, 24, 12, 4, 0,
201 0, 4, 12, 24, 36, 48, 68, 84,100,120,136,152,164,176,180,184,184,180,176,164,152,136,120,100, 84, 68, 48, 36, 24, 12, 4, 0,
202 0, 4, 12, 20, 32, 44, 60, 76, 88,104,120,132,144,152,160,164,164,160,152,144,132,120,104, 88, 76, 60, 44, 32, 20, 12, 4, 0,
203 0, 4, 8, 16, 28, 40, 52, 64, 76, 88,100,112,124,132,136,140,140,136,132,124,112,100, 88, 76, 64, 52, 40, 28, 16, 8, 4, 0,
204 0, 4, 8, 16, 24, 32, 40, 52, 64, 76, 84, 92,100,108,112,116,116,112,108,100, 92, 84, 76, 64, 52, 40, 32, 24, 16, 8, 4, 0,
205 0, 4, 4, 12, 16, 24, 32, 40, 52, 60, 68, 76, 80, 88, 88, 92, 92, 88, 88, 80, 76, 68, 60, 52, 40, 32, 24, 16, 12, 4, 4, 0,
206 0, 4, 4, 8, 12, 20, 24, 32, 40, 44, 52, 56, 60, 64, 68, 72, 72, 68, 64, 60, 56, 52, 44, 40, 32, 24, 20, 12, 8, 4, 4, 0,
207 0, 0, 4, 8, 8, 12, 16, 24, 28, 32, 36, 40, 44, 48, 48, 48, 48, 48, 48, 44, 40, 36, 32, 28, 24, 16, 12, 8, 8, 4, 0, 0,
208 0, 0, 4, 4, 8, 8, 12, 16, 16, 20, 24, 24, 28, 28, 32, 32, 32, 32, 28, 28, 24, 24, 20, 16, 16, 12, 8, 8, 4, 4, 0, 0,
209 0, 0, 0, 4, 4, 4, 4, 8, 8, 12, 12, 12, 16, 16, 16, 16, 16, 16, 16, 16, 12, 12, 12, 8, 8, 4, 4, 4, 4, 0, 0, 0,
210 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0,
211 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
212 //error:0.000022
213 };
214 static const uint8_t obmc16[256]={
215 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0,
216 0, 4, 4, 8, 16, 20, 20, 24, 24, 20, 20, 16, 8, 4, 4, 0,
217 0, 4, 16, 24, 36, 44, 52, 60, 60, 52, 44, 36, 24, 16, 4, 0,
218 0, 8, 24, 44, 60, 80, 96,104,104, 96, 80, 60, 44, 24, 8, 0,
219 0, 16, 36, 60, 92,116,136,152,152,136,116, 92, 60, 36, 16, 0,
220 0, 20, 44, 80,116,152,180,196,196,180,152,116, 80, 44, 20, 0,
221 4, 20, 52, 96,136,180,212,228,228,212,180,136, 96, 52, 20, 4,
222 4, 24, 60,104,152,196,228,248,248,228,196,152,104, 60, 24, 4,
223 4, 24, 60,104,152,196,228,248,248,228,196,152,104, 60, 24, 4,
224 4, 20, 52, 96,136,180,212,228,228,212,180,136, 96, 52, 20, 4,
225 0, 20, 44, 80,116,152,180,196,196,180,152,116, 80, 44, 20, 0,
226 0, 16, 36, 60, 92,116,136,152,152,136,116, 92, 60, 36, 16, 0,
227 0, 8, 24, 44, 60, 80, 96,104,104, 96, 80, 60, 44, 24, 8, 0,
228 0, 4, 16, 24, 36, 44, 52, 60, 60, 52, 44, 36, 24, 16, 4, 0,
229 0, 4, 4, 8, 16, 20, 20, 24, 24, 20, 20, 16, 8, 4, 4, 0,
230 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0,
231 //error:0.000033
232 };
233 #elif 1 // 64*linear
234 static const uint8_t obmc32[1024]={
235 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0,
236 0, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12, 8, 8, 8, 4, 4, 4, 0,
237 0, 4, 8, 8, 12, 12, 16, 20, 20, 24, 28, 28, 32, 32, 36, 40, 40, 36, 32, 32, 28, 28, 24, 20, 20, 16, 12, 12, 8, 8, 4, 0,
238 0, 4, 8, 12, 16, 20, 24, 28, 28, 32, 36, 40, 44, 48, 52, 56, 56, 52, 48, 44, 40, 36, 32, 28, 28, 24, 20, 16, 12, 8, 4, 0,
239 4, 8, 12, 16, 20, 24, 28, 32, 40, 44, 48, 52, 56, 60, 64, 68, 68, 64, 60, 56, 52, 48, 44, 40, 32, 28, 24, 20, 16, 12, 8, 4,
240 4, 8, 12, 20, 24, 32, 36, 40, 48, 52, 56, 64, 68, 76, 80, 84, 84, 80, 76, 68, 64, 56, 52, 48, 40, 36, 32, 24, 20, 12, 8, 4,
241 4, 8, 16, 24, 28, 36, 44, 48, 56, 60, 68, 76, 80, 88, 96,100,100, 96, 88, 80, 76, 68, 60, 56, 48, 44, 36, 28, 24, 16, 8, 4,
242 4, 12, 20, 28, 32, 40, 48, 56, 64, 72, 80, 88, 92,100,108,116,116,108,100, 92, 88, 80, 72, 64, 56, 48, 40, 32, 28, 20, 12, 4,
243 4, 12, 20, 28, 40, 48, 56, 64, 72, 80, 88, 96,108,116,124,132,132,124,116,108, 96, 88, 80, 72, 64, 56, 48, 40, 28, 20, 12, 4,
244 4, 16, 24, 32, 44, 52, 60, 72, 80, 92,100,108,120,128,136,148,148,136,128,120,108,100, 92, 80, 72, 60, 52, 44, 32, 24, 16, 4,
245 4, 16, 28, 36, 48, 56, 68, 80, 88,100,112,120,132,140,152,164,164,152,140,132,120,112,100, 88, 80, 68, 56, 48, 36, 28, 16, 4,
246 4, 16, 28, 40, 52, 64, 76, 88, 96,108,120,132,144,156,168,180,180,168,156,144,132,120,108, 96, 88, 76, 64, 52, 40, 28, 16, 4,
247 8, 20, 32, 44, 56, 68, 80, 92,108,120,132,144,156,168,180,192,192,180,168,156,144,132,120,108, 92, 80, 68, 56, 44, 32, 20, 8,
248 8, 20, 32, 48, 60, 76, 88,100,116,128,140,156,168,184,196,208,208,196,184,168,156,140,128,116,100, 88, 76, 60, 48, 32, 20, 8,
249 8, 20, 36, 52, 64, 80, 96,108,124,136,152,168,180,196,212,224,224,212,196,180,168,152,136,124,108, 96, 80, 64, 52, 36, 20, 8,
250 8, 24, 40, 56, 68, 84,100,116,132,148,164,180,192,208,224,240,240,224,208,192,180,164,148,132,116,100, 84, 68, 56, 40, 24, 8,
251 8, 24, 40, 56, 68, 84,100,116,132,148,164,180,192,208,224,240,240,224,208,192,180,164,148,132,116,100, 84, 68, 56, 40, 24, 8,
252 8, 20, 36, 52, 64, 80, 96,108,124,136,152,168,180,196,212,224,224,212,196,180,168,152,136,124,108, 96, 80, 64, 52, 36, 20, 8,
253 8, 20, 32, 48, 60, 76, 88,100,116,128,140,156,168,184,196,208,208,196,184,168,156,140,128,116,100, 88, 76, 60, 48, 32, 20, 8,
254 8, 20, 32, 44, 56, 68, 80, 92,108,120,132,144,156,168,180,192,192,180,168,156,144,132,120,108, 92, 80, 68, 56, 44, 32, 20, 8,
255 4, 16, 28, 40, 52, 64, 76, 88, 96,108,120,132,144,156,168,180,180,168,156,144,132,120,108, 96, 88, 76, 64, 52, 40, 28, 16, 4,
256 4, 16, 28, 36, 48, 56, 68, 80, 88,100,112,120,132,140,152,164,164,152,140,132,120,112,100, 88, 80, 68, 56, 48, 36, 28, 16, 4,
257 4, 16, 24, 32, 44, 52, 60, 72, 80, 92,100,108,120,128,136,148,148,136,128,120,108,100, 92, 80, 72, 60, 52, 44, 32, 24, 16, 4,
258 4, 12, 20, 28, 40, 48, 56, 64, 72, 80, 88, 96,108,116,124,132,132,124,116,108, 96, 88, 80, 72, 64, 56, 48, 40, 28, 20, 12, 4,
259 4, 12, 20, 28, 32, 40, 48, 56, 64, 72, 80, 88, 92,100,108,116,116,108,100, 92, 88, 80, 72, 64, 56, 48, 40, 32, 28, 20, 12, 4,
260 4, 8, 16, 24, 28, 36, 44, 48, 56, 60, 68, 76, 80, 88, 96,100,100, 96, 88, 80, 76, 68, 60, 56, 48, 44, 36, 28, 24, 16, 8, 4,
261 4, 8, 12, 20, 24, 32, 36, 40, 48, 52, 56, 64, 68, 76, 80, 84, 84, 80, 76, 68, 64, 56, 52, 48, 40, 36, 32, 24, 20, 12, 8, 4,
262 4, 8, 12, 16, 20, 24, 28, 32, 40, 44, 48, 52, 56, 60, 64, 68, 68, 64, 60, 56, 52, 48, 44, 40, 32, 28, 24, 20, 16, 12, 8, 4,
263 0, 4, 8, 12, 16, 20, 24, 28, 28, 32, 36, 40, 44, 48, 52, 56, 56, 52, 48, 44, 40, 36, 32, 28, 28, 24, 20, 16, 12, 8, 4, 0,
264 0, 4, 8, 8, 12, 12, 16, 20, 20, 24, 28, 28, 32, 32, 36, 40, 40, 36, 32, 32, 28, 28, 24, 20, 20, 16, 12, 12, 8, 8, 4, 0,
265 0, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12, 8, 8, 8, 4, 4, 4, 0,
266 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0,
267 //error:0.000020
268 };
269 static const uint8_t obmc16[256]={
270 0, 4, 4, 8, 8, 12, 12, 16, 16, 12, 12, 8, 8, 4, 4, 0,
271 4, 8, 16, 20, 28, 32, 40, 44, 44, 40, 32, 28, 20, 16, 8, 4,
272 4, 16, 24, 36, 44, 56, 64, 76, 76, 64, 56, 44, 36, 24, 16, 4,
273 8, 20, 36, 48, 64, 76, 92,104,104, 92, 76, 64, 48, 36, 20, 8,
274 8, 28, 44, 64, 80,100,116,136,136,116,100, 80, 64, 44, 28, 8,
275 12, 32, 56, 76,100,120,144,164,164,144,120,100, 76, 56, 32, 12,
276 12, 40, 64, 92,116,144,168,196,196,168,144,116, 92, 64, 40, 12,
277 16, 44, 76,104,136,164,196,224,224,196,164,136,104, 76, 44, 16,
278 16, 44, 76,104,136,164,196,224,224,196,164,136,104, 76, 44, 16,
279 12, 40, 64, 92,116,144,168,196,196,168,144,116, 92, 64, 40, 12,
280 12, 32, 56, 76,100,120,144,164,164,144,120,100, 76, 56, 32, 12,
281 8, 28, 44, 64, 80,100,116,136,136,116,100, 80, 64, 44, 28, 8,
282 8, 20, 36, 48, 64, 76, 92,104,104, 92, 76, 64, 48, 36, 20, 8,
283 4, 16, 24, 36, 44, 56, 64, 76, 76, 64, 56, 44, 36, 24, 16, 4,
284 4, 8, 16, 20, 28, 32, 40, 44, 44, 40, 32, 28, 20, 16, 8, 4,
285 0, 4, 4, 8, 8, 12, 12, 16, 16, 12, 12, 8, 8, 4, 4, 0,
286 //error:0.000015
287 };
288 #else //64*cos
289 static const uint8_t obmc32[1024]={
290 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
291 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0,
292 0, 0, 0, 4, 4, 4, 4, 8, 8, 12, 12, 12, 12, 16, 16, 16, 16, 16, 16, 12, 12, 12, 12, 8, 8, 4, 4, 4, 4, 0, 0, 0,
293 0, 0, 4, 4, 4, 8, 8, 12, 16, 20, 20, 24, 28, 28, 28, 28, 28, 28, 28, 28, 24, 20, 20, 16, 12, 8, 8, 4, 4, 4, 0, 0,
294 0, 0, 4, 4, 8, 12, 16, 20, 24, 28, 36, 40, 44, 44, 48, 48, 48, 48, 44, 44, 40, 36, 28, 24, 20, 16, 12, 8, 4, 4, 0, 0,
295 0, 0, 4, 8, 12, 20, 24, 32, 36, 44, 48, 56, 60, 64, 68, 68, 68, 68, 64, 60, 56, 48, 44, 36, 32, 24, 20, 12, 8, 4, 0, 0,
296 0, 4, 4, 8, 16, 24, 32, 40, 48, 60, 68, 76, 80, 84, 88, 92, 92, 88, 84, 80, 76, 68, 60, 48, 40, 32, 24, 16, 8, 4, 4, 0,
297 0, 4, 8, 12, 20, 32, 40, 52, 64, 76, 84, 96,104,108,112,116,116,112,108,104, 96, 84, 76, 64, 52, 40, 32, 20, 12, 8, 4, 0,
298 0, 4, 8, 16, 24, 36, 48, 64, 76, 92,104,116,124,132,136,140,140,136,132,124,116,104, 92, 76, 64, 48, 36, 24, 16, 8, 4, 0,
299 0, 4, 12, 20, 28, 44, 60, 76, 92,104,120,136,148,156,160,164,164,160,156,148,136,120,104, 92, 76, 60, 44, 28, 20, 12, 4, 0,
300 0, 4, 12, 20, 36, 48, 68, 84,104,120,140,152,168,176,184,188,188,184,176,168,152,140,120,104, 84, 68, 48, 36, 20, 12, 4, 0,
301 0, 4, 12, 24, 36, 56, 76, 96,116,136,152,172,184,196,204,208,208,204,196,184,172,152,136,116, 96, 76, 56, 36, 24, 12, 4, 0,
302 0, 4, 12, 24, 44, 60, 80,104,124,148,168,184,200,212,224,228,228,224,212,200,184,168,148,124,104, 80, 60, 44, 24, 12, 4, 0,
303 0, 4, 12, 28, 44, 64, 84,108,132,156,176,196,212,228,236,240,240,236,228,212,196,176,156,132,108, 84, 64, 44, 28, 12, 4, 0,
304 0, 4, 16, 28, 48, 68, 88,112,136,160,184,204,224,236,244,252,252,244,236,224,204,184,160,136,112, 88, 68, 48, 28, 16, 4, 0,
305 1, 4, 16, 28, 48, 68, 92,116,140,164,188,208,228,240,252,255,255,252,240,228,208,188,164,140,116, 92, 68, 48, 28, 16, 4, 1,
306 1, 4, 16, 28, 48, 68, 92,116,140,164,188,208,228,240,252,255,255,252,240,228,208,188,164,140,116, 92, 68, 48, 28, 16, 4, 1,
307 0, 4, 16, 28, 48, 68, 88,112,136,160,184,204,224,236,244,252,252,244,236,224,204,184,160,136,112, 88, 68, 48, 28, 16, 4, 0,
308 0, 4, 12, 28, 44, 64, 84,108,132,156,176,196,212,228,236,240,240,236,228,212,196,176,156,132,108, 84, 64, 44, 28, 12, 4, 0,
309 0, 4, 12, 24, 44, 60, 80,104,124,148,168,184,200,212,224,228,228,224,212,200,184,168,148,124,104, 80, 60, 44, 24, 12, 4, 0,
310 0, 4, 12, 24, 36, 56, 76, 96,116,136,152,172,184,196,204,208,208,204,196,184,172,152,136,116, 96, 76, 56, 36, 24, 12, 4, 0,
311 0, 4, 12, 20, 36, 48, 68, 84,104,120,140,152,168,176,184,188,188,184,176,168,152,140,120,104, 84, 68, 48, 36, 20, 12, 4, 0,
312 0, 4, 12, 20, 28, 44, 60, 76, 92,104,120,136,148,156,160,164,164,160,156,148,136,120,104, 92, 76, 60, 44, 28, 20, 12, 4, 0,
313 0, 4, 8, 16, 24, 36, 48, 64, 76, 92,104,116,124,132,136,140,140,136,132,124,116,104, 92, 76, 64, 48, 36, 24, 16, 8, 4, 0,
314 0, 4, 8, 12, 20, 32, 40, 52, 64, 76, 84, 96,104,108,112,116,116,112,108,104, 96, 84, 76, 64, 52, 40, 32, 20, 12, 8, 4, 0,
315 0, 4, 4, 8, 16, 24, 32, 40, 48, 60, 68, 76, 80, 84, 88, 92, 92, 88, 84, 80, 76, 68, 60, 48, 40, 32, 24, 16, 8, 4, 4, 0,
316 0, 0, 4, 8, 12, 20, 24, 32, 36, 44, 48, 56, 60, 64, 68, 68, 68, 68, 64, 60, 56, 48, 44, 36, 32, 24, 20, 12, 8, 4, 0, 0,
317 0, 0, 4, 4, 8, 12, 16, 20, 24, 28, 36, 40, 44, 44, 48, 48, 48, 48, 44, 44, 40, 36, 28, 24, 20, 16, 12, 8, 4, 4, 0, 0,
318 0, 0, 4, 4, 4, 8, 8, 12, 16, 20, 20, 24, 28, 28, 28, 28, 28, 28, 28, 28, 24, 20, 20, 16, 12, 8, 8, 4, 4, 4, 0, 0,
319 0, 0, 0, 4, 4, 4, 4, 8, 8, 12, 12, 12, 12, 16, 16, 16, 16, 16, 16, 12, 12, 12, 12, 8, 8, 4, 4, 4, 4, 0, 0, 0,
320 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0,
321 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
322 //error:0.000022
323 };
324 static const uint8_t obmc16[256]={
325 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0,
326 0, 0, 4, 8, 12, 16, 20, 20, 20, 20, 16, 12, 8, 4, 0, 0,
327 0, 4, 12, 24, 32, 44, 52, 56, 56, 52, 44, 32, 24, 12, 4, 0,
328 0, 8, 24, 40, 60, 80, 96,104,104, 96, 80, 60, 40, 24, 8, 0,
329 0, 12, 32, 64, 92,120,140,152,152,140,120, 92, 64, 32, 12, 0,
330 4, 16, 44, 80,120,156,184,196,196,184,156,120, 80, 44, 16, 4,
331 4, 20, 52, 96,140,184,216,232,232,216,184,140, 96, 52, 20, 4,
332 0, 20, 56,104,152,196,232,252,252,232,196,152,104, 56, 20, 0,
333 0, 20, 56,104,152,196,232,252,252,232,196,152,104, 56, 20, 0,
334 4, 20, 52, 96,140,184,216,232,232,216,184,140, 96, 52, 20, 4,
335 4, 16, 44, 80,120,156,184,196,196,184,156,120, 80, 44, 16, 4,
336 0, 12, 32, 64, 92,120,140,152,152,140,120, 92, 64, 32, 12, 0,
337 0, 8, 24, 40, 60, 80, 96,104,104, 96, 80, 60, 40, 24, 8, 0,
338 0, 4, 12, 24, 32, 44, 52, 56, 56, 52, 44, 32, 24, 12, 4, 0,
339 0, 0, 4, 8, 12, 16, 20, 20, 20, 20, 16, 12, 8, 4, 0, 0,
340 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0,
341 //error:0.000022
342 };
343 #endif /* 0 */
344
345 //linear *64
346 static const uint8_t obmc8[64]={
347 4, 12, 20, 28, 28, 20, 12, 4,
348 12, 36, 60, 84, 84, 60, 36, 12,
349 20, 60,100,140,140,100, 60, 20,
350 28, 84,140,196,196,140, 84, 28,
351 28, 84,140,196,196,140, 84, 28,
352 20, 60,100,140,140,100, 60, 20,
353 12, 36, 60, 84, 84, 60, 36, 12,
354 4, 12, 20, 28, 28, 20, 12, 4,
355 //error:0.000000
356 };
357
358 //linear *64
359 static const uint8_t obmc4[16]={
360 16, 48, 48, 16,
361 48,144,144, 48,
362 48,144,144, 48,
363 16, 48, 48, 16,
364 //error:0.000000
365 };
366
367 static const uint8_t * const obmc_tab[4]={
368 obmc32, obmc16, obmc8, obmc4
369 };
370
371 static int scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES];
372
373 typedef struct BlockNode{
374 int16_t mx;
375 int16_t my;
376 uint8_t ref;
377 uint8_t color[3];
378 uint8_t type;
379 //#define TYPE_SPLIT 1
380 #define BLOCK_INTRA 1
381 #define BLOCK_OPT 2
382 //#define TYPE_NOCOLOR 4
383 uint8_t level; //FIXME merge into type?
384 }BlockNode;
385
386 static const BlockNode null_block= { //FIXME add border maybe
387 .color= {128,128,128},
388 .mx= 0,
389 .my= 0,
390 .ref= 0,
391 .type= 0,
392 .level= 0,
393 };
394
395 #define LOG2_MB_SIZE 4
396 #define MB_SIZE (1<<LOG2_MB_SIZE)
397 #define ENCODER_EXTRA_BITS 4
398 #define HTAPS_MAX 8
399
400 typedef struct x_and_coeff{
401 int16_t x;
402 uint16_t coeff;
403 } x_and_coeff;
404
405 typedef struct SubBand{
406 int level;
407 int stride;
408 int width;
409 int height;
410 int qlog; ///< log(qscale)/log[2^(1/6)]
411 DWTELEM *buf;
412 IDWTELEM *ibuf;
413 int buf_x_offset;
414 int buf_y_offset;
415 int stride_line; ///< Stride measured in lines, not pixels.
416 x_and_coeff * x_coeff;
417 struct SubBand *parent;
418 uint8_t state[/*7*2*/ 7 + 512][32];
419 }SubBand;
420
421 typedef struct Plane{
422 int width;
423 int height;
424 SubBand band[MAX_DECOMPOSITIONS][4];
425
426 int htaps;
427 int8_t hcoeff[HTAPS_MAX/2];
428 int diag_mc;
429 int fast_mc;
430
431 int last_htaps;
432 int8_t last_hcoeff[HTAPS_MAX/2];
433 int last_diag_mc;
434 }Plane;
435
436 typedef struct SnowContext{
437 // MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
438
439 AVCodecContext *avctx;
440 RangeCoder c;
441 DSPContext dsp;
442 AVFrame new_picture;
443 AVFrame input_picture; ///< new_picture with the internal linesizes
444 AVFrame current_picture;
445 AVFrame last_picture[MAX_REF_FRAMES];
446 uint8_t *halfpel_plane[MAX_REF_FRAMES][4][4];
447 AVFrame mconly_picture;
448 // uint8_t q_context[16];
449 uint8_t header_state[32];
450 uint8_t block_state[128 + 32*128];
451 int keyframe;
452 int always_reset;
453 int version;
454 int spatial_decomposition_type;
455 int last_spatial_decomposition_type;
456 int temporal_decomposition_type;
457 int spatial_decomposition_count;
458 int last_spatial_decomposition_count;
459 int temporal_decomposition_count;
460 int max_ref_frames;
461 int ref_frames;
462 int16_t (*ref_mvs[MAX_REF_FRAMES])[2];
463 uint32_t *ref_scores[MAX_REF_FRAMES];
464 DWTELEM *spatial_dwt_buffer;
465 IDWTELEM *spatial_idwt_buffer;
466 int colorspace_type;
467 int chroma_h_shift;
468 int chroma_v_shift;
469 int spatial_scalability;
470 int qlog;
471 int last_qlog;
472 int lambda;
473 int lambda2;
474 int pass1_rc;
475 int mv_scale;
476 int last_mv_scale;
477 int qbias;
478 int last_qbias;
479 #define QBIAS_SHIFT 3
480 int b_width;
481 int b_height;
482 int block_max_depth;
483 int last_block_max_depth;
484 Plane plane[MAX_PLANES];
485 BlockNode *block;
486 #define ME_CACHE_SIZE 1024
487 int me_cache[ME_CACHE_SIZE];
488 int me_cache_generation;
489 slice_buffer sb;
490
491 MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
492
493 uint8_t *scratchbuf;
494 }SnowContext;
495
496 typedef struct {
497 IDWTELEM *b0;
498 IDWTELEM *b1;
499 IDWTELEM *b2;
500 IDWTELEM *b3;
501 int y;
502 } DWTCompose;
503
504 #define slice_buffer_get_line(slice_buf, line_num) ((slice_buf)->line[line_num] ? (slice_buf)->line[line_num] : slice_buffer_load_line((slice_buf), (line_num)))
505 //#define slice_buffer_get_line(slice_buf, line_num) (slice_buffer_load_line((slice_buf), (line_num)))
506
507 static void iterative_me(SnowContext *s);
508
509 static void slice_buffer_init(slice_buffer * buf, int line_count, int max_allocated_lines, int line_width, IDWTELEM * base_buffer)
510 {
511 int i;
512
513 buf->base_buffer = base_buffer;
514 buf->line_count = line_count;
515 buf->line_width = line_width;
516 buf->data_count = max_allocated_lines;
517 buf->line = av_mallocz (sizeof(IDWTELEM *) * line_count);
518 buf->data_stack = av_malloc (sizeof(IDWTELEM *) * max_allocated_lines);
519
520 for(i = 0; i < max_allocated_lines; i++){
521 buf->data_stack[i] = av_malloc (sizeof(IDWTELEM) * line_width);
522 }
523
524 buf->data_stack_top = max_allocated_lines - 1;
525 }
526
527 static IDWTELEM * slice_buffer_load_line(slice_buffer * buf, int line)
528 {
529 int offset;
530 IDWTELEM * buffer;
531
532 assert(buf->data_stack_top >= 0);
533 // assert(!buf->line[line]);
534 if (buf->line[line])
535 return buf->line[line];
536
537 offset = buf->line_width * line;
538 buffer = buf->data_stack[buf->data_stack_top];
539 buf->data_stack_top--;
540 buf->line[line] = buffer;
541
542 return buffer;
543 }
544
545 static void slice_buffer_release(slice_buffer * buf, int line)
546 {
547 int offset;
548 IDWTELEM * buffer;
549
550 assert(line >= 0 && line < buf->line_count);
551 assert(buf->line[line]);
552
553 offset = buf->line_width * line;
554 buffer = buf->line[line];
555 buf->data_stack_top++;
556 buf->data_stack[buf->data_stack_top] = buffer;
557 buf->line[line] = NULL;
558 }
559
560 static void slice_buffer_flush(slice_buffer * buf)
561 {
562 int i;
563 for(i = 0; i < buf->line_count; i++){
564 if (buf->line[i])
565 slice_buffer_release(buf, i);
566 }
567 }
568
569 static void slice_buffer_destroy(slice_buffer * buf)
570 {
571 int i;
572 slice_buffer_flush(buf);
573
574 for(i = buf->data_count - 1; i >= 0; i--){
575 av_freep(&buf->data_stack[i]);
576 }
577 av_freep(&buf->data_stack);
578 av_freep(&buf->line);
579 }
580
581 #ifdef __sgi
582 // Avoid a name clash on SGI IRIX
583 #undef qexp
584 #endif
585 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
586 static uint8_t qexp[QROOT];
587
588 static inline int mirror(int v, int m){
589 while((unsigned)v > (unsigned)m){
590 v=-v;
591 if(v<0) v+= 2*m;
592 }
593 return v;
594 }
595
596 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
597 int i;
598
599 if(v){
600 const int a= FFABS(v);
601 const int e= av_log2(a);
602 #if 1
603 const int el= FFMIN(e, 10);
604 put_rac(c, state+0, 0);
605
606 for(i=0; i<el; i++){
607 put_rac(c, state+1+i, 1); //1..10
608 }
609 for(; i<e; i++){
610 put_rac(c, state+1+9, 1); //1..10
611 }
612 put_rac(c, state+1+FFMIN(i,9), 0);
613
614 for(i=e-1; i>=el; i--){
615 put_rac(c, state+22+9, (a>>i)&1); //22..31
616 }
617 for(; i>=0; i--){
618 put_rac(c, state+22+i, (a>>i)&1); //22..31
619 }
620
621 if(is_signed)
622 put_rac(c, state+11 + el, v < 0); //11..21
623 #else
624
625 put_rac(c, state+0, 0);
626 if(e<=9){
627 for(i=0; i<e; i++){
628 put_rac(c, state+1+i, 1); //1..10
629 }
630 put_rac(c, state+1+i, 0);
631
632 for(i=e-1; i>=0; i--){
633 put_rac(c, state+22+i, (a>>i)&1); //22..31
634 }
635
636 if(is_signed)
637 put_rac(c, state+11 + e, v < 0); //11..21
638 }else{
639 for(i=0; i<e; i++){
640 put_rac(c, state+1+FFMIN(i,9), 1); //1..10
641 }
642 put_rac(c, state+1+FFMIN(i,9), 0);
643
644 for(i=e-1; i>=0; i--){
645 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
646 }
647
648 if(is_signed)
649 put_rac(c, state+11 + FFMIN(e,10), v < 0); //11..21
650 }
651 #endif /* 1 */
652 }else{
653 put_rac(c, state+0, 1);
654 }
655 }
656
657 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
658 if(get_rac(c, state+0))
659 return 0;
660 else{
661 int i, e, a;
662 e= 0;
663 while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
664 e++;
665 }
666
667 a= 1;
668 for(i=e-1; i>=0; i--){
669 a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
670 }
671
672 if(is_signed && get_rac(c, state+11 + FFMIN(e,10))) //11..21
673 return -a;
674 else
675 return a;
676 }
677 }
678
679 static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2){
680 int i;
681 int r= log2>=0 ? 1<<log2 : 1;
682
683 assert(v>=0);
684 assert(log2>=-4);
685
686 while(v >= r){
687 put_rac(c, state+4+log2, 1);
688 v -= r;
689 log2++;
690 if(log2>0) r+=r;
691 }
692 put_rac(c, state+4+log2, 0);
693
694 for(i=log2-1; i>=0; i--){
695 put_rac(c, state+31-i, (v>>i)&1);
696 }
697 }
698
699 static inline int get_symbol2(RangeCoder *c, uint8_t *state, int log2){
700 int i;
701 int r= log2>=0 ? 1<<log2 : 1;
702 int v=0;
703
704 assert(log2>=-4);
705
706 while(get_rac(c, state+4+log2)){
707 v+= r;
708 log2++;
709 if(log2>0) r+=r;
710 }
711
712 for(i=log2-1; i>=0; i--){
713 v+= get_rac(c, state+31-i)<<i;
714 }
715
716 return v;
717 }
718
719 static av_always_inline void
720 lift(DWTELEM *dst, DWTELEM *src, DWTELEM *ref,
721 int dst_step, int src_step, int ref_step,
722 int width, int mul, int add, int shift,
723 int highpass, int inverse){
724 const int mirror_left= !highpass;
725 const int mirror_right= (width&1) ^ highpass;
726 const int w= (width>>1) - 1 + (highpass & width);
727 int i;
728
729 #define LIFT(src, ref, inv) ((src) + ((inv) ? - (ref) : + (ref)))
730 if(mirror_left){
731 dst[0] = LIFT(src[0], ((mul*2*ref[0]+add)>>shift), inverse);
732 dst += dst_step;
733 src += src_step;
734 }
735
736 for(i=0; i<w; i++){
737 dst[i*dst_step] =
738 LIFT(src[i*src_step],
739 ((mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add)>>shift),
740 inverse);
741 }
742
743 if(mirror_right){
744 dst[w*dst_step] =
745 LIFT(src[w*src_step],
746 ((mul*2*ref[w*ref_step]+add)>>shift),
747 inverse);
748 }
749 }
750
751 static av_always_inline void
752 inv_lift(IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref,
753 int dst_step, int src_step, int ref_step,
754 int width, int mul, int add, int shift,
755 int highpass, int inverse){
756 const int mirror_left= !highpass;
757 const int mirror_right= (width&1) ^ highpass;
758 const int w= (width>>1) - 1 + (highpass & width);
759 int i;
760
761 #define LIFT(src, ref, inv) ((src) + ((inv) ? - (ref) : + (ref)))
762 if(mirror_left){
763 dst[0] = LIFT(src[0], ((mul*2*ref[0]+add)>>shift), inverse);
764 dst += dst_step;
765 src += src_step;
766 }
767
768 for(i=0; i<w; i++){
769 dst[i*dst_step] =
770 LIFT(src[i*src_step],
771 ((mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add)>>shift),
772 inverse);
773 }
774
775 if(mirror_right){
776 dst[w*dst_step] =
777 LIFT(src[w*src_step],
778 ((mul*2*ref[w*ref_step]+add)>>shift),
779 inverse);
780 }
781 }
782
783 #ifndef liftS
784 static av_always_inline void
785 liftS(DWTELEM *dst, DWTELEM *src, DWTELEM *ref,
786 int dst_step, int src_step, int ref_step,
787 int width, int mul, int add, int shift,
788 int highpass, int inverse){
789 const int mirror_left= !highpass;
790 const int mirror_right= (width&1) ^ highpass;
791 const int w= (width>>1) - 1 + (highpass & width);
792 int i;
793
794 assert(shift == 4);
795 #define LIFTS(src, ref, inv) \
796 ((inv) ? \
797 (src) + (((ref) + 4*(src))>>shift): \
798 -((-16*(src) + (ref) + add/4 + 1 + (5<<25))/(5*4) - (1<<23)))
799 if(mirror_left){
800 dst[0] = LIFTS(src[0], mul*2*ref[0]+add, inverse);
801 dst += dst_step;
802 src += src_step;
803 }
804
805 for(i=0; i<w; i++){
806 dst[i*dst_step] =
807 LIFTS(src[i*src_step],
808 mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add,
809 inverse);
810 }
811
812 if(mirror_right){
813 dst[w*dst_step] =
814 LIFTS(src[w*src_step], mul*2*ref[w*ref_step]+add, inverse);
815 }
816 }
817 static av_always_inline void
818 inv_liftS(IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref,
819 int dst_step, int src_step, int ref_step,
820 int width, int mul, int add, int shift,
821 int highpass, int inverse){
822 const int mirror_left= !highpass;
823 const int mirror_right= (width&1) ^ highpass;
824 const int w= (width>>1) - 1 + (highpass & width);
825 int i;
826
827 assert(shift == 4);
828 #define LIFTS(src, ref, inv) \
829 ((inv) ? \
830 (src) + (((ref) + 4*(src))>>shift): \
831 -((-16*(src) + (ref) + add/4 + 1 + (5<<25))/(5*4) - (1<<23)))
832 if(mirror_left){
833 dst[0] = LIFTS(src[0], mul*2*ref[0]+add, inverse);
834 dst += dst_step;
835 src += src_step;
836 }
837
838 for(i=0; i<w; i++){
839 dst[i*dst_step] =
840 LIFTS(src[i*src_step],
841 mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add,
842 inverse);
843 }
844
845 if(mirror_right){
846 dst[w*dst_step] =
847 LIFTS(src[w*src_step], mul*2*ref[w*ref_step]+add, inverse);
848 }
849 }
850 #endif /* ! liftS */
851
852 static void horizontal_decompose53i(DWTELEM *b, int width){
853 DWTELEM temp[width];
854 const int width2= width>>1;
855 int x;
856 const int w2= (width+1)>>1;
857
858 for(x=0; x<width2; x++){
859 temp[x ]= b[2*x ];
860 temp[x+w2]= b[2*x + 1];
861 }
862 if(width&1)
863 temp[x ]= b[2*x ];
864 #if 0
865 {
866 int A1,A2,A3,A4;
867 A2= temp[1 ];
868 A4= temp[0 ];
869 A1= temp[0+width2];
870 A1 -= (A2 + A4)>>1;
871 A4 += (A1 + 1)>>1;
872 b[0+width2] = A1;
873 b[0 ] = A4;
874 for(x=1; x+1<width2; x+=2){
875 A3= temp[x+width2];
876 A4= temp[x+1 ];
877 A3 -= (A2 + A4)>>1;
878 A2 += (A1 + A3 + 2)>>2;
879 b[x+width2] = A3;
880 b[x ] = A2;
881
882 A1= temp[x+1+width2];
883 A2= temp[x+2 ];
884 A1 -= (A2 + A4)>>1;
885 A4 += (A1 + A3 + 2)>>2;
886 b[x+1+width2] = A1;
887 b[x+1 ] = A4;
888 }
889 A3= temp[width-1];
890 A3 -= A2;
891 A2 += (A1 + A3 + 2)>>2;
892 b[width -1] = A3;
893 b[width2-1] = A2;
894 }
895 #else
896 lift(b+w2, temp+w2, temp, 1, 1, 1, width, -1, 0, 1, 1, 0);
897 lift(b , temp , b+w2, 1, 1, 1, width, 1, 2, 2, 0, 0);
898 #endif /* 0 */
899 }
900
901 static void vertical_decompose53iH0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
902 int i;
903
904 for(i=0; i<width; i++){
905 b1[i] -= (b0[i] + b2[i])>>1;
906 }
907 }
908
909 static void vertical_decompose53iL0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
910 int i;
911
912 for(i=0; i<width; i++){
913 b1[i] += (b0[i] + b2[i] + 2)>>2;
914 }
915 }
916
917 static void spatial_decompose53i(DWTELEM *buffer, int width, int height, int stride){
918 int y;
919 DWTELEM *b0= buffer + mirror(-2-1, height-1)*stride;
920 DWTELEM *b1= buffer + mirror(-2 , height-1)*stride;
921
922 for(y=-2; y<height; y+=2){
923 DWTELEM *b2= buffer + mirror(y+1, height-1)*stride;
924 DWTELEM *b3= buffer + mirror(y+2, height-1)*stride;
925
926 if(y+1<(unsigned)height) horizontal_decompose53i(b2, width);
927 if(y+2<(unsigned)height) horizontal_decompose53i(b3, width);
928
929 if(y+1<(unsigned)height) vertical_decompose53iH0(b1, b2, b3, width);
930 if(y+0<(unsigned)height) vertical_decompose53iL0(b0, b1, b2, width);
931
932 b0=b2;
933 b1=b3;
934 }
935 }
936
937 static void horizontal_decompose97i(DWTELEM *b, int width){
938 DWTELEM temp[width];
939 const int w2= (width+1)>>1;
940
941 lift (temp+w2, b +1, b , 1, 2, 2, width, W_AM, W_AO, W_AS, 1, 1);
942 liftS(temp , b , temp+w2, 1, 2, 1, width, W_BM, W_BO, W_BS, 0, 0);
943 lift (b +w2, temp+w2, temp , 1, 1, 1, width, W_CM, W_CO, W_CS, 1, 0);
944 lift (b , temp , b +w2, 1, 1, 1, width, W_DM, W_DO, W_DS, 0, 0);
945 }
946
947
948 static void vertical_decompose97iH0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
949 int i;
950
951 for(i=0; i<width; i++){
952 b1[i] -= (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
953 }
954 }
955
956 static void vertical_decompose97iH1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
957 int i;
958
959 for(i=0; i<width; i++){
960 b1[i] += (W_CM*(b0[i] + b2[i])+W_CO)>>W_CS;
961 }
962 }
963
964 static void vertical_decompose97iL0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
965 int i;
966
967 for(i=0; i<width; i++){
968 #ifdef liftS
969 b1[i] -= (W_BM*(b0[i] + b2[i])+W_BO)>>W_BS;
970 #else
971 b1[i] = (16*4*b1[i] - 4*(b0[i] + b2[i]) + W_BO*5 + (5<<27)) / (5*16) - (1<<23);
972 #endif
973 }
974 }
975
976 static void vertical_decompose97iL1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
977 int i;
978
979 for(i=0; i<width; i++){
980 b1[i] += (W_DM*(b0[i] + b2[i])+W_DO)>>W_DS;
981 }
982 }
983
984 static void spatial_decompose97i(DWTELEM *buffer, int width, int height, int stride){
985 int y;
986 DWTELEM *b0= buffer + mirror(-4-1, height-1)*stride;
987 DWTELEM *b1= buffer + mirror(-4 , height-1)*stride;
988 DWTELEM *b2= buffer + mirror(-4+1, height-1)*stride;
989 DWTELEM *b3= buffer + mirror(-4+2, height-1)*stride;
990
991 for(y=-4; y<height; y+=2){
992 DWTELEM *b4= buffer + mirror(y+3, height-1)*stride;
993 DWTELEM *b5= buffer + mirror(y+4, height-1)*stride;
994
995 if(y+3<(unsigned)height) horizontal_decompose97i(b4, width);
996 if(y+4<(unsigned)height) horizontal_decompose97i(b5, width);
997
998 if(y+3<(unsigned)height) vertical_decompose97iH0(b3, b4, b5, width);
999 if(y+2<(unsigned)height) vertical_decompose97iL0(b2, b3, b4, width);
1000 if(y+1<(unsigned)height) vertical_decompose97iH1(b1, b2, b3, width);
1001 if(y+0<(unsigned)height) vertical_decompose97iL1(b0, b1, b2, width);
1002
1003 b0=b2;
1004 b1=b3;
1005 b2=b4;
1006 b3=b5;
1007 }
1008 }
1009
1010 void ff_spatial_dwt(DWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count){
1011 int level;
1012
1013 for(level=0; level<decomposition_count; level++){
1014 switch(type){
1015 case DWT_97: spatial_decompose97i(buffer, width>>level, height>>level, stride<<level); break;
1016 case DWT_53: spatial_decompose53i(buffer, width>>level, height>>level, stride<<level); break;
1017 }
1018 }
1019 }
1020
1021 static void horizontal_compose53i(IDWTELEM *b, int width){
1022 IDWTELEM temp[width];
1023 const int width2= width>>1;
1024 const int w2= (width+1)>>1;
1025 int x;
1026
1027 #if 0
1028 int A1,A2,A3,A4;
1029 A2= temp[1 ];
1030 A4= temp[0 ];
1031 A1= temp[0+width2];
1032 A1 -= (A2 + A4)>>1;
1033 A4 += (A1 + 1)>>1;
1034 b[0+width2] = A1;
1035 b[0 ] = A4;
1036 for(x=1; x+1<width2; x+=2){
1037 A3= temp[x+width2];
1038 A4= temp[x+1 ];
1039 A3 -= (A2 + A4)>>1;
1040 A2 += (A1 + A3 + 2)>>2;
1041 b[x+width2] = A3;
1042 b[x ] = A2;
1043
1044 A1= temp[x+1+width2];
1045 A2= temp[x+2 ];
1046 A1 -= (A2 + A4)>>1;
1047 A4 += (A1 + A3 + 2)>>2;
1048 b[x+1+width2] = A1;
1049 b[x+1 ] = A4;
1050 }
1051 A3= temp[width-1];
1052 A3 -= A2;
1053 A2 += (A1 + A3 + 2)>>2;
1054 b[width -1] = A3;
1055 b[width2-1] = A2;
1056 #else
1057 inv_lift(temp , b , b+w2, 1, 1, 1, width, 1, 2, 2, 0, 1);
1058 inv_lift(temp+w2, b+w2, temp, 1, 1, 1, width, -1, 0, 1, 1, 1);
1059 #endif /* 0 */
1060 for(x=0; x<width2; x++){
1061 b[2*x ]= temp[x ];
1062 b[2*x + 1]= temp[x+w2];
1063 }
1064 if(width&1)
1065 b[2*x ]= temp[x ];
1066 }
1067
1068 static void vertical_compose53iH0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1069 int i;
1070
1071 for(i=0; i<width; i++){
1072 b1[i] += (b0[i] + b2[i])>>1;
1073 }
1074 }
1075
1076 static void vertical_compose53iL0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1077 int i;
1078
1079 for(i=0; i<width; i++){
1080 b1[i] -= (b0[i] + b2[i] + 2)>>2;
1081 }
1082 }
1083
1084 static void spatial_compose53i_buffered_init(DWTCompose *cs, slice_buffer * sb, int height, int stride_line){
1085 cs->b0 = slice_buffer_get_line(sb, mirror(-1-1, height-1) * stride_line);
1086 cs->b1 = slice_buffer_get_line(sb, mirror(-1 , height-1) * stride_line);
1087 cs->y = -1;
1088 }
1089
1090 static void spatial_compose53i_init(DWTCompose *cs, IDWTELEM *buffer, int height, int stride){
1091 cs->b0 = buffer + mirror(-1-1, height-1)*stride;
1092 cs->b1 = buffer + mirror(-1 , height-1)*stride;
1093 cs->y = -1;
1094 }
1095
1096 static void spatial_compose53i_dy_buffered(DWTCompose *cs, slice_buffer * sb, int width, int height, int stride_line){
1097 int y= cs->y;
1098
1099 IDWTELEM *b0= cs->b0;
1100 IDWTELEM *b1= cs->b1;
1101 IDWTELEM *b2= slice_buffer_get_line(sb, mirror(y+1, height-1) * stride_line);
1102 IDWTELEM *b3= slice_buffer_get_line(sb, mirror(y+2, height-1) * stride_line);
1103
1104 if(y+1<(unsigned)height) vertical_compose53iL0(b1, b2, b3, width);
1105 if(y+0<(unsigned)height) vertical_compose53iH0(b0, b1, b2, width);
1106
1107 if(y-1<(unsigned)height) horizontal_compose53i(b0, width);
1108 if(y+0<(unsigned)height) horizontal_compose53i(b1, width);
1109
1110 cs->b0 = b2;
1111 cs->b1 = b3;
1112 cs->y += 2;
1113 }
1114
1115 static void spatial_compose53i_dy(DWTCompose *cs, IDWTELEM *buffer, int width, int height, int stride){
1116 int y= cs->y;
1117 IDWTELEM *b0= cs->b0;
1118 IDWTELEM *b1= cs->b1;
1119 IDWTELEM *b2= buffer + mirror(y+1, height-1)*stride;
1120 IDWTELEM *b3= buffer + mirror(y+2, height-1)*stride;
1121
1122 if(y+1<(unsigned)height) vertical_compose53iL0(b1, b2, b3, width);
1123 if(y+0<(unsigned)height) vertical_compose53iH0(b0, b1, b2, width);
1124
1125 if(y-1<(unsigned)height) horizontal_compose53i(b0, width);
1126 if(y+0<(unsigned)height) horizontal_compose53i(b1, width);
1127
1128 cs->b0 = b2;
1129 cs->b1 = b3;
1130 cs->y += 2;
1131 }
1132
1133 static void av_unused spatial_compose53i(IDWTELEM *buffer, int width, int height, int stride){
1134 DWTCompose cs;
1135 spatial_compose53i_init(&cs, buffer, height, stride);
1136 while(cs.y <= height)
1137 spatial_compose53i_dy(&cs, buffer, width, height, stride);
1138 }
1139
1140
1141 void ff_snow_horizontal_compose97i(IDWTELEM *b, int width){
1142 IDWTELEM temp[width];
1143 const int w2= (width+1)>>1;
1144
1145 inv_lift (temp , b , b +w2, 1, 1, 1, width, W_DM, W_DO, W_DS, 0, 1);
1146 inv_lift (temp+w2, b +w2, temp , 1, 1, 1, width, W_CM, W_CO, W_CS, 1, 1);
1147 inv_liftS(b , temp , temp+w2, 2, 1, 1, width, W_BM, W_BO, W_BS, 0, 1);
1148 inv_lift (b+1 , temp+w2, b , 2, 1, 2, width, W_AM, W_AO, W_AS, 1, 0);
1149 }
1150
1151 static void vertical_compose97iH0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1152 int i;
1153
1154 for(i=0; i<width; i++){
1155 b1[i] += (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
1156 }
1157 }
1158
1159 static void vertical_compose97iH1(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1160 int i;
1161
1162 for(i=0; i<width; i++){
1163 b1[i] -= (W_CM*(b0[i] + b2[i])+W_CO)>>W_CS;
1164 }
1165 }
1166
1167 static void vertical_compose97iL0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1168 int i;
1169
1170 for(i=0; i<width; i++){
1171 #ifdef liftS
1172 b1[i] += (W_BM*(b0[i] + b2[i])+W_BO)>>W_BS;
1173 #else
1174 b1[i] += (W_BM*(b0[i] + b2[i])+4*b1[i]+W_BO)>>W_BS;
1175 #endif
1176 }
1177 }
1178
1179 static void vertical_compose97iL1(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1180 int i;
1181
1182 for(i=0; i<width; i++){
1183 b1[i] -= (W_DM*(b0[i] + b2[i])+W_DO)>>W_DS;
1184 }
1185 }
1186
1187 void ff_snow_vertical_compose97i(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5, int width){
1188 int i;
1189
1190 for(i=0; i<width; i++){
1191 b4[i] -= (W_DM*(b3[i] + b5[i])+W_DO)>>W_DS;
1192 b3[i] -= (W_CM*(b2[i] + b4[i])+W_CO)>>W_CS;
1193 #ifdef liftS
1194 b2[i] += (W_BM*(b1[i] + b3[i])+W_BO)>>W_BS;
1195 #else
1196 b2[i] += (W_BM*(b1[i] + b3[i])+4*b2[i]+W_BO)>>W_BS;
1197 #endif
1198 b1[i] += (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
1199 }
1200 }
1201
1202 static void spatial_compose97i_buffered_init(DWTCompose *cs, slice_buffer * sb, int height, int stride_line){
1203 cs->b0 = slice_buffer_get_line(sb, mirror(-3-1, height-1) * stride_line);
1204 cs->b1 = slice_buffer_get_line(sb, mirror(-3 , height-1) * stride_line);
1205 cs->b2 = slice_buffer_get_line(sb, mirror(-3+1, height-1) * stride_line);
1206 cs->b3 = slice_buffer_get_line(sb, mirror(-3+2, height-1) * stride_line);
1207 cs->y = -3;
1208 }
1209
1210 static void spatial_compose97i_init(DWTCompose *cs, IDWTELEM *buffer, int height, int stride){
1211 cs->b0 = buffer + mirror(-3-1, height-1)*stride;
1212 cs->b1 = buffer + mirror(-3 , height-1)*stride;
1213 cs->b2 = buffer + mirror(-3+1, height-1)*stride;
1214 cs->b3 = buffer + mirror(-3+2, height-1)*stride;
1215 cs->y = -3;
1216 }
1217
1218 static void spatial_compose97i_dy_buffered(DSPContext *dsp, DWTCompose *cs, slice_buffer * sb, int width, int height, int stride_line){
1219 int y = cs->y;
1220
1221 IDWTELEM *b0= cs->b0;
1222 IDWTELEM *b1= cs->b1;
1223 IDWTELEM *b2= cs->b2;
1224 IDWTELEM *b3= cs->b3;
1225 IDWTELEM *b4= slice_buffer_get_line(sb, mirror(y + 3, height - 1) * stride_line);
1226 IDWTELEM *b5= slice_buffer_get_line(sb, mirror(y + 4, height - 1) * stride_line);
1227
1228 if(y>0 && y+4<height){
1229 dsp->vertical_compose97i(b0, b1, b2, b3, b4, b5, width);
1230 }else{
1231 if(y+3<(unsigned)height) vertical_compose97iL1(b3, b4, b5, width);
1232 if(y+2<(unsigned)height) vertical_compose97iH1(b2, b3, b4, width);
1233 if(y+1<(unsigned)height) vertical_compose97iL0(b1, b2, b3, width);
1234 if(y+0<(unsigned)height) vertical_compose97iH0(b0, b1, b2, width);
1235 }
1236
1237 if(y-1<(unsigned)height) dsp->horizontal_compose97i(b0, width);
1238 if(y+0<(unsigned)height) dsp->horizontal_compose97i(b1, width);
1239
1240 cs->b0=b2;
1241 cs->b1=b3;
1242 cs->b2=b4;
1243 cs->b3=b5;
1244 cs->y += 2;
1245 }
1246
1247 static void spatial_compose97i_dy(DWTCompose *cs, IDWTELEM *buffer, int width, int height, int stride){
1248 int y = cs->y;
1249 IDWTELEM *b0= cs->b0;
1250 IDWTELEM *b1= cs->b1;
1251 IDWTELEM *b2= cs->b2;
1252 IDWTELEM *b3= cs->b3;
1253 IDWTELEM *b4= buffer + mirror(y+3, height-1)*stride;
1254 IDWTELEM *b5= buffer + mirror(y+4, height-1)*stride;
1255
1256 if(y+3<(unsigned)height) vertical_compose97iL1(b3, b4, b5, width);
1257 if(y+2<(unsigned)height) vertical_compose97iH1(b2, b3, b4, width);
1258 if(y+1<(unsigned)height) vertical_compose97iL0(b1, b2, b3, width);
1259 if(y+0<(unsigned)height) vertical_compose97iH0(b0, b1, b2, width);
1260
1261 if(y-1<(unsigned)height) ff_snow_horizontal_compose97i(b0, width);
1262 if(y+0<(unsigned)height) ff_snow_horizontal_compose97i(b1, width);
1263
1264 cs->b0=b2;
1265 cs->b1=b3;
1266 cs->b2=b4;
1267 cs->b3=b5;
1268 cs->y += 2;
1269 }
1270
1271 static void av_unused spatial_compose97i(IDWTELEM *buffer, int width, int height, int stride){
1272 DWTCompose cs;
1273 spatial_compose97i_init(&cs, buffer, height, stride);
1274 while(cs.y <= height)
1275 spatial_compose97i_dy(&cs, buffer, width, height, stride);
1276 }
1277
1278 static void ff_spatial_idwt_buffered_init(DWTCompose *cs, slice_buffer * sb, int width, int height, int stride_line, int type, int decomposition_count){
1279 int level;
1280 for(level=decomposition_count-1; level>=0; level--){
1281 switch(type){
1282 case DWT_97: spatial_compose97i_buffered_init(cs+level, sb, height>>level, stride_line<<level); break;
1283 case DWT_53: spatial_compose53i_buffered_init(cs+level, sb, height>>level, stride_line<<level); break;
1284 }
1285 }
1286 }
1287
1288 static void ff_spatial_idwt_init(DWTCompose *cs, IDWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count){
1289 int level;
1290 for(level=decomposition_count-1; level>=0; level--){
1291 switch(type){
1292 case DWT_97: spatial_compose97i_init(cs+level, buffer, height>>level, stride<<level); break;
1293 case DWT_53: spatial_compose53i_init(cs+level, buffer, height>>level, stride<<level); break;
1294 }
1295 }
1296 }
1297
1298 static void ff_spatial_idwt_slice(DWTCompose *cs, IDWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count, int y){
1299 const int support = type==1 ? 3 : 5;
1300 int level;
1301 if(type==2) return;
1302
1303 for(level=decomposition_count-1; level>=0; level--){
1304 while(cs[level].y <= FFMIN((y>>level)+support, height>>level)){
1305 switch(type){
1306 case DWT_97: spatial_compose97i_dy(cs+level, buffer, width>>level, height>>level, stride<<level);
1307 break;
1308 case DWT_53: spatial_compose53i_dy(cs+level, buffer, width>>level, height>>level, stride<<level);
1309 break;
1310 }
1311 }
1312 }
1313 }
1314
1315 static void ff_spatial_idwt_buffered_slice(DSPContext *dsp, DWTCompose *cs, slice_buffer * slice_buf, int width, int height, int stride_line, int type, int decomposition_count, int y){
1316 const int support = type==1 ? 3 : 5;
1317 int level;
1318 if(type==2) return;
1319
1320 for(level=decomposition_count-1; level>=0; level--){
1321 while(cs[level].y <= FFMIN((y>>level)+support, height>>level)){
1322 switch(type){
1323 case DWT_97: spatial_compose97i_dy_buffered(dsp, cs+level, slice_buf, width>>level, height>>level, stride_line<<level);
1324 break;
1325 case DWT_53: spatial_compose53i_dy_buffered(cs+level, slice_buf, width>>level, height>>level, stride_line<<level);
1326 break;
1327 }
1328 }
1329 }
1330 }
1331
1332 static void ff_spatial_idwt(IDWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count){
1333 DWTCompose cs[MAX_DECOMPOSITIONS];
1334 int y;
1335 ff_spatial_idwt_init(cs, buffer, width, height, stride, type, decomposition_count);
1336 for(y=0; y<height; y+=4)
1337 ff_spatial_idwt_slice(cs, buffer, width, height, stride, type, decomposition_count, y);
1338 }
1339
1340 static int encode_subband_c0run(SnowContext *s, SubBand *b, IDWTELEM *src, IDWTELEM *parent, int stride, int orientation){
1341 const int w= b->width;
1342 const int h= b->height;
1343 int x, y;
1344
1345 if(1){
1346 int run=0;
1347 int runs[w*h];
1348 int run_index=0;
1349 int max_index;
1350
1351 for(y=0; y<h; y++){
1352 for(x=0; x<w; x++){
1353 int v, p=0;
1354 int /*ll=0, */l=0, lt=0, t=0, rt=0;
1355 v= src[x + y*stride];
1356
1357 if(y){
1358 t= src[x + (y-1)*stride];
1359 if(x){
1360 lt= src[x - 1 + (y-1)*stride];
1361 }
1362 if(x + 1 < w){
1363 rt= src[x + 1 + (y-1)*stride];
1364 }
1365 }
1366 if(x){
1367 l= src[x - 1 + y*stride];
1368 /*if(x > 1){
1369 if(orientation==1) ll= src[y + (x-2)*stride];
1370 else ll= src[x - 2 + y*stride];
1371 }*/
1372 }
1373 if(parent){
1374 int px= x>>1;
1375 int py= y>>1;
1376 if(px<b->parent->width && py<b->parent->height)
1377 p= parent[px + py*2*stride];
1378 }
1379 if(!(/*ll|*/l|lt|t|rt|p)){
1380 if(v){
1381 runs[run_index++]= run;
1382 run=0;
1383 }else{
1384 run++;
1385 }
1386 }
1387 }
1388 }
1389 max_index= run_index;
1390 runs[run_index++]= run;
1391 run_index=0;
1392 run= runs[run_index++];
1393
1394 put_symbol2(&s->c, b->state[30], max_index, 0);
1395 if(run_index <= max_index)
1396 put_symbol2(&s->c, b->state[1], run, 3);
1397
1398 for(y=0; y<h; y++){
1399 if(s->c.bytestream_end - s->c.bytestream < w*40){
1400 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1401 return -1;
1402 }
1403 for(x=0; x<w; x++){
1404 int v, p=0;
1405 int /*ll=0, */l=0, lt=0, t=0, rt=0;
1406 v= src[x + y*stride];
1407
1408 if(y){
1409 t= src[x + (y-1)*stride];
1410 if(x){
1411 lt= src[x - 1 + (y-1)*stride];
1412 }
1413 if(x + 1 < w){
1414 rt= src[x + 1 + (y-1)*stride];
1415 }
1416 }
1417 if(x){
1418 l= src[x - 1 + y*stride];
1419 /*if(x > 1){
1420 if(orientation==1) ll= src[y + (x-2)*stride];
1421 else ll= src[x - 2 + y*stride];
1422 }*/
1423 }
1424 if(parent){
1425 int px= x>>1;
1426 int py= y>>1;
1427 if(px<b->parent->width && py<b->parent->height)
1428 p= parent[px + py*2*stride];
1429 }
1430 if(/*ll|*/l|lt|t|rt|p){
1431 int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
1432
1433 put_rac(&s->c, &b->state[0][context], !!v);
1434 }else{
1435 if(!run){
1436 run= runs[run_index++];
1437
1438 if(run_index <= max_index)
1439 put_symbol2(&s->c, b->state[1], run, 3);
1440 assert(v);
1441 }else{
1442 run--;
1443 assert(!v);
1444 }
1445 }
1446 if(v){
1447 int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
1448 int l2= 2*FFABS(l) + (l<0);
1449 int t2= 2*FFABS(t) + (t<0);
1450
1451 put_symbol2(&s->c, b->state[context + 2], FFABS(v)-1, context-4);
1452 put_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3bA[l2&0xFF] + 3*quant3bA[t2&0xFF]], v<0);
1453 }
1454 }
1455 }
1456 }
1457 return 0;
1458 }
1459
1460 static int encode_subband(SnowContext *s, SubBand *b, IDWTELEM *src, IDWTELEM *parent, int stride, int orientation){
1461 // encode_subband_qtree(s, b, src, parent, stride, orientation);
1462 // encode_subband_z0run(s, b, src, parent, stride, orientation);
1463 return encode_subband_c0run(s, b, src, parent, stride, orientation);
1464 // encode_subband_dzr(s, b, src, parent, stride, orientation);
1465 }
1466
1467 static inline void unpack_coeffs(SnowContext *s, SubBand *b, SubBand * parent, int orientation){
1468 const int w= b->width;
1469 const int h= b->height;
1470 int x,y;
1471
1472 if(1){
1473 int run, runs;
1474 x_and_coeff *xc= b->x_coeff;
1475 x_and_coeff *prev_xc= NULL;
1476 x_and_coeff *prev2_xc= xc;
1477 x_and_coeff *parent_xc= parent ? parent->x_coeff : NULL;
1478 x_and_coeff *prev_parent_xc= parent_xc;
1479
1480 runs= get_symbol2(&s->c, b->state[30], 0);
1481 if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
1482 else run= INT_MAX;
1483
1484 for(y=0; y<h; y++){
1485 int v=0;
1486 int lt=0, t=0, rt=0;
1487
1488 if(y && prev_xc->x == 0){
1489 rt= prev_xc->coeff;
1490 }
1491 for(x=0; x<w; x++){
1492 int p=0;
1493 const int l= v;
1494
1495 lt= t; t= rt;
1496
1497 if(y){
1498 if(prev_xc->x <= x)
1499 prev_xc++;
1500 if(prev_xc->x == x + 1)
1501 rt= prev_xc->coeff;
1502 else
1503 rt=0;
1504 }
1505 if(parent_xc){
1506 if(x>>1 > parent_xc->x){
1507 parent_xc++;
1508 }
1509 if(x>>1 == parent_xc->x){
1510 p= parent_xc->coeff;
1511 }
1512 }
1513 if(/*ll|*/l|lt|t|rt|p){
1514 int context= av_log2(/*FFABS(ll) + */3*(l>>1) + (lt>>1) + (t&~1) + (rt>>1) + (p>>1));
1515
1516 v=get_rac(&s->c, &b->state[0][context]);
1517 if(v){
1518 v= 2*(get_symbol2(&s->c, b->state[context + 2], context-4) + 1);
1519 v+=get_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3bA[l&0xFF] + 3*quant3bA[t&0xFF]]);
1520
1521 xc->x=x;
1522 (xc++)->coeff= v;
1523 }
1524 }else{
1525 if(!run){
1526 if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
1527 else run= INT_MAX;
1528 v= 2*(get_symbol2(&s->c, b->state[0 + 2], 0-4) + 1);
1529 v+=get_rac(&s->c, &b->state[0][16 + 1 + 3]);
1530
1531 xc->x=x;
1532 (xc++)->coeff= v;
1533 }else{
1534 int max_run;
1535 run--;
1536 v=0;
1537
1538 if(y) max_run= FFMIN(run, prev_xc->x - x - 2);
1539 else max_run= FFMIN(run, w-x-1);
1540 if(parent_xc)
1541 max_run= FFMIN(max_run, 2*parent_xc->x - x - 1);
1542 x+= max_run;
1543 run-= max_run;
1544 }
1545 }
1546 }
1547 (xc++)->x= w+1; //end marker
1548 prev_xc= prev2_xc;
1549 prev2_xc= xc;
1550
1551 if(parent_xc){
1552 if(y&1){
1553 while(parent_xc->x != parent->width+1)
1554 parent_xc++;
1555 parent_xc++;
1556 prev_parent_xc= parent_xc;
1557 }else{
1558 parent_xc= prev_parent_xc;
1559 }
1560 }
1561 }
1562
1563 (xc++)->x= w+1; //end marker
1564 }
1565 }
1566
1567 static inline void decode_subband_slice_buffered(SnowContext *s, SubBand *b, slice_buffer * sb, int start_y, int h, int save_state[1]){
1568 const int w= b->width;
1569 int y;
1570 const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1571 int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1572 int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
1573 int new_index = 0;
1574
1575 if(b->ibuf == s->spatial_idwt_buffer || s->qlog == LOSSLESS_QLOG){
1576 qadd= 0;
1577 qmul= 1<<QEXPSHIFT;
1578 }
1579
1580 /* If we are on the second or later slice, restore our index. */
1581 if (start_y != 0)
1582 new_index = save_state[0];
1583
1584
1585 for(y=start_y; y<h; y++){
1586 int x = 0;
1587 int v;
1588 IDWTELEM * line = slice_buffer_get_line(sb, y * b->stride_line + b->buf_y_offset) + b->buf_x_offset;
1589 memset(line, 0, b->width*sizeof(IDWTELEM));
1590 v = b->x_coeff[new_index].coeff;
1591 x = b->x_coeff[new_index++].x;
1592 while(x < w){
1593 register int t= ( (v>>1)*qmul + qadd)>>QEXPSHIFT;
1594 register int u= -(v&1);
1595 line[x] = (t^u) - u;
1596
1597 v = b->x_coeff[new_index].coeff;
1598 x = b->x_coeff[new_index++].x;
1599 }
1600 }
1601
1602 /* Save our variables for the next slice. */
1603 save_state[0] = new_index;
1604
1605 return;
1606 }
1607
1608 static void reset_contexts(SnowContext *s){ //FIXME better initial contexts
1609 int plane_index, level, orientation;
1610
1611 for(plane_index=0; plane_index<3; plane_index++){
1612 for(level=0; level<MAX_DECOMPOSITIONS; level++){
1613 for(orientation=level ? 1:0; orientation<4; orientation++){
1614 memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
1615 }
1616 }
1617 }
1618 memset(s->header_state, MID_STATE, sizeof(s->header_state));
1619 memset(s->block_state, MID_STATE, sizeof(s->block_state));
1620 }
1621
1622 static int alloc_blocks(SnowContext *s){
1623 int w= -((-s->avctx->width )>>LOG2_MB_SIZE);
1624 int h= -((-s->avctx->height)>>LOG2_MB_SIZE);
1625
1626 s->b_width = w;
1627 s->b_height= h;
1628
1629 av_free(s->block);
1630 s->block= av_mallocz(w * h * sizeof(BlockNode) << (s->block_max_depth*2));
1631 return 0;
1632 }
1633
1634 static inline void copy_rac_state(RangeCoder *d, RangeCoder *s){
1635 uint8_t *bytestream= d->bytestream;
1636 uint8_t *bytestream_start= d->bytestream_start;
1637 *d= *s;
1638 d->bytestream= bytestream;
1639 d->bytestream_start= bytestream_start;
1640 }
1641
1642 //near copy & paste from dsputil, FIXME
1643 static int pix_sum(uint8_t * pix, int line_size, int w)
1644 {
1645 int s, i, j;
1646
1647 s = 0;
1648 for (i = 0; i < w; i++) {
1649 for (j = 0; j < w; j++) {
1650 s += pix[0];
1651 pix ++;
1652 }
1653 pix += line_size - w;
1654 }
1655 return s;
1656 }
1657
1658 //near copy & paste from dsputil, FIXME
1659 static int pix_norm1(uint8_t * pix, int line_size, int w)
1660 {
1661 int s, i, j;
1662 uint32_t *sq = ff_squareTbl + 256;
1663
1664 s = 0;
1665 for (i = 0; i < w; i++) {
1666 for (j = 0; j < w; j ++) {
1667 s += sq[pix[0]];
1668 pix ++;
1669 }
1670 pix += line_size - w;
1671 }
1672 return s;
1673 }
1674
1675 static inline void set_blocks(SnowContext *s, int level, int x, int y, int l, int cb, int cr, int mx, int my, int ref, int type){
1676 const int w= s->b_width << s->block_max_depth;
1677 const int rem_depth= s->block_max_depth - level;
1678 const int index= (x + y*w) << rem_depth;
1679 const int block_w= 1<<rem_depth;
1680 BlockNode block;
1681 int i,j;
1682
1683 block.color[0]= l;
1684 block.color[1]= cb;
1685 block.color[2]= cr;
1686 block.mx= mx;
1687 block.my= my;
1688 block.ref= ref;
1689 block.type= type;
1690 block.level= level;
1691
1692 for(j=0; j<block_w; j++){
1693 for(i=0; i<block_w; i++){
1694 s->block[index + i + j*w]= block;
1695 }
1696 }
1697 }
1698
1699 static inline void init_ref(MotionEstContext *c, uint8_t *src[3], uint8_t *ref[3], uint8_t *ref2[3], int x, int y, int ref_index){
1700 const int offset[3]= {
1701 y*c-> stride + x,
1702 ((y*c->uvstride + x)>>1),
1703 ((y*c->uvstride + x)>>1),
1704 };
1705 int i;
1706 for(i=0; i<3; i++){
1707 c->src[0][i]= src [i];
1708 c->ref[0][i]= ref [i] + offset[i];
1709 }
1710 assert(!ref_index);
1711 }
1712
1713 static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
1714 const BlockNode *left, const BlockNode *top, const BlockNode *tr){
1715 if(s->ref_frames == 1){
1716 *mx = mid_pred(left->mx, top->mx, tr->mx);
1717 *my = mid_pred(left->my, top->my, tr->my);
1718 }else{
1719 const int *scale = scale_mv_ref[ref];
1720 *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
1721 (top ->mx * scale[top ->ref] + 128) >>8,
1722 (tr ->mx * scale[tr ->ref] + 128) >>8);
1723 *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
1724 (top ->my * scale[top ->ref] + 128) >>8,
1725 (tr ->my * scale[tr ->ref] + 128) >>8);
1726 }
1727 }
1728
1729 //FIXME copy&paste
1730 #define P_LEFT P[1]
1731 #define P_TOP P[2]
1732 #define P_TOPRIGHT P[3]
1733 #define P_MEDIAN P[4]
1734 #define P_MV1 P[9]
1735 #define FLAG_QPEL 1 //must be 1
1736
1737 static int encode_q_branch(SnowContext *s, int level, int x, int y){
1738 uint8_t p_buffer[1024];
1739 uint8_t i_buffer[1024];
1740 uint8_t p_state[sizeof(s->block_state)];
1741 uint8_t i_state[sizeof(s->block_state)];
1742 RangeCoder pc, ic;
1743 uint8_t *pbbak= s->c.bytestream;
1744 uint8_t *pbbak_start= s->c.bytestream_start;
1745 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
1746 const int w= s->b_width << s->block_max_depth;
1747 const int h= s->b_height << s->block_max_depth;
1748 const int rem_depth= s->block_max_depth - level;
1749 const int index= (x + y*w) << rem_depth;
1750 const int block_w= 1<<(LOG2_MB_SIZE - level);
1751 int trx= (x+1)<<rem_depth;
1752 int try= (y+1)<<rem_depth;
1753 const BlockNode *left = x ? &s->block[index-1] : &null_block;
1754 const BlockNode *top = y ? &s->block[index-w] : &null_block;
1755 const BlockNode *right = trx<w ? &s->block[index+1] : &null_block;
1756 const BlockNode *bottom= try<h ? &s->block[index+w] : &null_block;
1757 const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
1758 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
1759 int pl = left->color[0];
1760 int pcb= left->color[1];
1761 int pcr= left->color[2];
1762 int pmx, pmy;
1763 int mx=0, my=0;
1764 int l,cr,cb;
1765 const int stride= s->current_picture.linesize[0];
1766 const int uvstride= s->current_picture.linesize[1];
1767 uint8_t *current_data[3]= { s->input_picture.data[0] + (x + y* stride)*block_w,
1768 s->input_picture.data[1] + (x + y*uvstride)*block_w/2,
1769 s->input_picture.data[2] + (x + y*uvstride)*block_w/2};
1770 int P[10][2];
1771 int16_t last_mv[3][2];
1772 int qpel= !!(s->avctx->flags & CODEC_FLAG_QPEL); //unused
1773 const int shift= 1+qpel;
1774 MotionEstContext *c= &s->m.me;
1775 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
1776 int mx_context= av_log2(2*FFABS(left->mx - top->mx));
1777 int my_context= av_log2(2*FFABS(left->my - top->my));
1778 int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
1779 int ref, best_ref, ref_score, ref_mx, ref_my;
1780
1781 assert(sizeof(s->block_state) >= 256);
1782 if(s->keyframe){
1783 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
1784 return 0;
1785 }
1786
1787 // clip predictors / edge ?
1788
1789 P_LEFT[0]= left->mx;
1790 P_LEFT[1]= left->my;
1791 P_TOP [0]= top->mx;
1792 P_TOP [1]= top->my;
1793 P_TOPRIGHT[0]= tr->mx;
1794 P_TOPRIGHT[1]= tr->my;
1795
1796 last_mv[0][0]= s->block[index].mx;
1797 last_mv[0][1]= s->block[index].my;
1798 last_mv[1][0]= right->mx;
1799 last_mv[1][1]= right->my;
1800 last_mv[2][0]= bottom->mx;
1801 last_mv[2][1]= bottom->my;
1802
1803 s->m.mb_stride=2;
1804 s->m.mb_x=
1805 s->m.mb_y= 0;
1806 c->skip= 0;
1807
1808 assert(c-> stride == stride);
1809 assert(c->uvstride == uvstride);
1810
1811 c->penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
1812 c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
1813 c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);
1814 c->current_mv_penalty= c->mv_penalty[s->m.f_code=1] + MAX_MV;
1815
1816 c->xmin = - x*block_w - 16+2;
1817 c->ymin = - y*block_w - 16+2;
1818 c->xmax = - (x+1)*block_w + (w<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-2;
1819 c->ymax = - (y+1)*block_w + (h<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-2;
1820
1821 if(P_LEFT[0] > (c->xmax<<shift)) P_LEFT[0] = (c->xmax<<shift);
1822 if(P_LEFT[1] > (c->ymax<<shift)) P_LEFT[1] = (c->ymax<<shift);
1823 if(P_TOP[0] > (c->xmax<<shift)) P_TOP[0] = (c->xmax<<shift);
1824 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift);
1825 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift);
1826 if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); //due to pmx no clip
1827 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
1828
1829 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1830 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1831
1832 if (!y) {
1833 c->pred_x= P_LEFT[0];
1834 c->pred_y= P_LEFT[1];
1835 } else {
1836 c->pred_x = P_MEDIAN[0];
1837 c->pred_y = P_MEDIAN[1];
1838 }
1839
1840 score= INT_MAX;
1841 best_ref= 0;
1842 for(ref=0; ref<s->ref_frames; ref++){
1843 init_ref(c, current_data, s->last_picture[ref].data, NULL, block_w*x, block_w*y, 0);
1844
1845 ref_score= ff_epzs_motion_search(&s->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
1846 (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
1847
1848 assert(ref_mx >= c->xmin);
1849 assert(ref_mx <= c->xmax);
1850 assert(ref_my >= c->ymin);
1851 assert(ref_my <= c->ymax);
1852
1853 ref_score= c->sub_motion_search(&s->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
1854 ref_score= ff_get_mb_score(&s->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
1855 ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
1856 if(s->ref_mvs[ref]){
1857 s->ref_mvs[ref][index][0]= ref_mx;
1858 s->ref_mvs[ref][index][1]= ref_my;
1859 s->ref_scores[ref][index]= ref_score;
1860 }
1861 if(score > ref_score){
1862 score= ref_score;
1863 best_ref= ref;
1864 mx= ref_mx;
1865 my= ref_my;
1866 }
1867 }
1868 //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
1869
1870 // subpel search
1871 base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
1872 pc= s->c;
1873 pc.bytestream_start=
1874 pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo
1875 memcpy(p_state, s->block_state, sizeof(s->block_state));
1876
1877 if(level!=s->block_max_depth)
1878 put_rac(&pc, &p_state[4 + s_context], 1);
1879 put_rac(&pc, &p_state[1 + left->type + top->type], 0);
1880 if(s->ref_frames > 1)
1881 put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
1882 pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
1883 put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
1884 put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
1885 p_len= pc.bytestream - pc.bytestream_start;
1886 score += (s->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;
1887
1888 block_s= block_w*block_w;
1889 sum = pix_sum(current_data[0], stride, block_w);
1890 l= (sum + block_s/2)/block_s;
1891 iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
1892
1893 block_s= block_w*block_w>>2;
1894 sum = pix_sum(current_data[1], uvstride, block_w>>1);
1895 cb= (sum + block_s/2)/block_s;
1896 // iscore += pix_norm1(&current_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;
1897 sum = pix_sum(current_data[2], uvstride, block_w>>1);
1898 cr= (sum + block_s/2)/block_s;
1899 // iscore += pix_norm1(&current_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
1900
1901 ic= s->c;
1902 ic.bytestream_start=
1903 ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo
1904 memcpy(i_state, s->block_state, sizeof(s->block_state));
1905 if(level!=s->block_max_depth)
1906 put_rac(&ic, &i_state[4 + s_context], 1);
1907 put_rac(&ic, &i_state[1 + left->type + top->type], 1);
1908 put_symbol(&ic, &i_state[32], l-pl , 1);
1909 put_symbol(&ic, &i_state[64], cb-pcb, 1);
1910 put_symbol(&ic, &i_state[96], cr-pcr, 1);
1911 i_len= ic.bytestream - ic.bytestream_start;
1912 iscore += (s->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;
1913
1914 // assert(score==256*256*256*64-1);
1915 assert(iscore < 255*255*256 + s->lambda2*10);
1916 assert(iscore >= 0);
1917 assert(l>=0 && l<=255);
1918 assert(pl>=0 && pl<=255);
1919
1920 if(level==0){
1921 int varc= iscore >> 8;
1922 int vard= score >> 8;
1923 if (vard <= 64 || vard < varc)
1924 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
1925 else
1926 c->scene_change_score+= s->m.qscale;
1927 }
1928
1929 if(level!=s->block_max_depth){
1930 put_rac(&s->c, &s->block_state[4 + s_context], 0);
1931 score2 = encode_q_branch(s, level+1, 2*x+0, 2*y+0);
1932 score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+0);
1933 score2+= encode_q_branch(s, level+1, 2*x+0, 2*y+1);
1934 score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+1);
1935 score2+= s->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead
1936
1937 if(score2 < score && score2 < iscore)
1938 return score2;
1939 }
1940
1941 if(iscore < score){
1942 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
1943 memcpy(pbbak, i_buffer, i_len);
1944 s->c= ic;
1945 s->c.bytestream_start= pbbak_start;
1946 s->c.bytestream= pbbak + i_len;
1947 set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0, BLOCK_INTRA);
1948 memcpy(s->block_state, i_state, sizeof(s->block_state));
1949 return iscore;
1950 }else{
1951 memcpy(pbbak, p_buffer, p_len);
1952 s->c= pc;
1953 s->c.bytestream_start= pbbak_start;
1954 s->c.bytestream= pbbak + p_len;
1955 set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
1956 memcpy(s->block_state, p_state, sizeof(s->block_state));
1957 return score;
1958 }
1959 }
1960
1961 static av_always_inline int same_block(BlockNode *a, BlockNode *b){
1962 if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
1963 return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
1964 }else{
1965 return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
1966 }
1967 }
1968
1969 static void encode_q_branch2(SnowContext *s, int level, int x, int y){
1970 const int w= s->b_width << s->block_max_depth;
1971 const int rem_depth= s->block_max_depth - level;
1972 const int index= (x + y*w) << rem_depth;
1973 int trx= (x+1)<<rem_depth;
1974 BlockNode *b= &s->block[index];
1975 const BlockNode *left = x ? &s->block[index-1] : &null_block;
1976 const BlockNode *top = y ? &s->block[index-w] : &null_block;
1977 const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
1978 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
1979 int pl = left->color[0];
1980 int pcb= left->color[1];
1981 int pcr= left->color[2];
1982 int pmx, pmy;
1983 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
1984 int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 16*!!b->ref;
1985 int my_context= av_log2(2*FFABS(left->my - top->my)) + 16*!!b->ref;
1986 int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
1987
1988 if(s->keyframe){
1989 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
1990 return;
1991 }
1992
1993 if(level!=s->block_max_depth){
1994 if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){
1995 put_rac(&s->c, &s->block_state[4 + s_context], 1);