Update to MPlayer SVN rev 29978 and FFmpeg SVN rev 20757.
[vaapi:challenzhous-mplayer.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 slice_buffer_init(slice_buffer * buf, int line_count, int max_allocated_lines, int line_width, IDWTELEM * base_buffer)
508 {
509     int i;
510
511     buf->base_buffer = base_buffer;
512     buf->line_count = line_count;
513     buf->line_width = line_width;
514     buf->data_count = max_allocated_lines;
515     buf->line = av_mallocz (sizeof(IDWTELEM *) * line_count);
516     buf->data_stack = av_malloc (sizeof(IDWTELEM *) * max_allocated_lines);
517
518     for(i = 0; i < max_allocated_lines; i++){
519         buf->data_stack[i] = av_malloc (sizeof(IDWTELEM) * line_width);
520     }
521
522     buf->data_stack_top = max_allocated_lines - 1;
523 }
524
525 static IDWTELEM * slice_buffer_load_line(slice_buffer * buf, int line)
526 {
527     IDWTELEM * buffer;
528
529     assert(buf->data_stack_top >= 0);
530 //  assert(!buf->line[line]);
531     if (buf->line[line])
532         return buf->line[line];
533
534     buffer = buf->data_stack[buf->data_stack_top];
535     buf->data_stack_top--;
536     buf->line[line] = buffer;
537
538     return buffer;
539 }
540
541 static void slice_buffer_release(slice_buffer * buf, int line)
542 {
543     IDWTELEM * buffer;
544
545     assert(line >= 0 && line < buf->line_count);
546     assert(buf->line[line]);
547
548     buffer = buf->line[line];
549     buf->data_stack_top++;
550     buf->data_stack[buf->data_stack_top] = buffer;
551     buf->line[line] = NULL;
552 }
553
554 static void slice_buffer_flush(slice_buffer * buf)
555 {
556     int i;
557     for(i = 0; i < buf->line_count; i++){
558         if (buf->line[i])
559             slice_buffer_release(buf, i);
560     }
561 }
562
563 static void slice_buffer_destroy(slice_buffer * buf)
564 {
565     int i;
566     slice_buffer_flush(buf);
567
568     for(i = buf->data_count - 1; i >= 0; i--){
569         av_freep(&buf->data_stack[i]);
570     }
571     av_freep(&buf->data_stack);
572     av_freep(&buf->line);
573 }
574
575 #ifdef __sgi
576 // Avoid a name clash on SGI IRIX
577 #undef qexp
578 #endif
579 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
580 static uint8_t qexp[QROOT];
581
582 static inline int mirror(int v, int m){
583     while((unsigned)v > (unsigned)m){
584         v=-v;
585         if(v<0) v+= 2*m;
586     }
587     return v;
588 }
589
590 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
591     int i;
592
593     if(v){
594         const int a= FFABS(v);
595         const int e= av_log2(a);
596 #if 1
597         const int el= FFMIN(e, 10);
598         put_rac(c, state+0, 0);
599
600         for(i=0; i<el; i++){
601             put_rac(c, state+1+i, 1);  //1..10
602         }
603         for(; i<e; i++){
604             put_rac(c, state+1+9, 1);  //1..10
605         }
606         put_rac(c, state+1+FFMIN(i,9), 0);
607
608         for(i=e-1; i>=el; i--){
609             put_rac(c, state+22+9, (a>>i)&1); //22..31
610         }
611         for(; i>=0; i--){
612             put_rac(c, state+22+i, (a>>i)&1); //22..31
613         }
614
615         if(is_signed)
616             put_rac(c, state+11 + el, v < 0); //11..21
617 #else
618
619         put_rac(c, state+0, 0);
620         if(e<=9){
621             for(i=0; i<e; i++){
622                 put_rac(c, state+1+i, 1);  //1..10
623             }
624             put_rac(c, state+1+i, 0);
625
626             for(i=e-1; i>=0; i--){
627                 put_rac(c, state+22+i, (a>>i)&1); //22..31
628             }
629
630             if(is_signed)
631                 put_rac(c, state+11 + e, v < 0); //11..21
632         }else{
633             for(i=0; i<e; i++){
634                 put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
635             }
636             put_rac(c, state+1+9, 0);
637
638             for(i=e-1; i>=0; i--){
639                 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
640             }
641
642             if(is_signed)
643                 put_rac(c, state+11 + 10, v < 0); //11..21
644         }
645 #endif /* 1 */
646     }else{
647         put_rac(c, state+0, 1);
648     }
649 }
650
651 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
652     if(get_rac(c, state+0))
653         return 0;
654     else{
655         int i, e, a;
656         e= 0;
657         while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
658             e++;
659         }
660
661         a= 1;
662         for(i=e-1; i>=0; i--){
663             a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
664         }
665
666         e= -(is_signed && get_rac(c, state+11 + FFMIN(e,10))); //11..21
667         return (a^e)-e;
668     }
669 }
670
671 static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2){
672     int i;
673     int r= log2>=0 ? 1<<log2 : 1;
674
675     assert(v>=0);
676     assert(log2>=-4);
677
678     while(v >= r){
679         put_rac(c, state+4+log2, 1);
680         v -= r;
681         log2++;
682         if(log2>0) r+=r;
683     }
684     put_rac(c, state+4+log2, 0);
685
686     for(i=log2-1; i>=0; i--){
687         put_rac(c, state+31-i, (v>>i)&1);
688     }
689 }
690
691 static inline int get_symbol2(RangeCoder *c, uint8_t *state, int log2){
692     int i;
693     int r= log2>=0 ? 1<<log2 : 1;
694     int v=0;
695
696     assert(log2>=-4);
697
698     while(get_rac(c, state+4+log2)){
699         v+= r;
700         log2++;
701         if(log2>0) r+=r;
702     }
703
704     for(i=log2-1; i>=0; i--){
705         v+= get_rac(c, state+31-i)<<i;
706     }
707
708     return v;
709 }
710
711 static av_always_inline void
712 lift(DWTELEM *dst, DWTELEM *src, DWTELEM *ref,
713      int dst_step, int src_step, int ref_step,
714      int width, int mul, int add, int shift,
715      int highpass, int inverse){
716     const int mirror_left= !highpass;
717     const int mirror_right= (width&1) ^ highpass;
718     const int w= (width>>1) - 1 + (highpass & width);
719     int i;
720
721 #define LIFT(src, ref, inv) ((src) + ((inv) ? - (ref) : + (ref)))
722     if(mirror_left){
723         dst[0] = LIFT(src[0], ((mul*2*ref[0]+add)>>shift), inverse);
724         dst += dst_step;
725         src += src_step;
726     }
727
728     for(i=0; i<w; i++){
729         dst[i*dst_step] =
730             LIFT(src[i*src_step],
731                  ((mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add)>>shift),
732                  inverse);
733     }
734
735     if(mirror_right){
736         dst[w*dst_step] =
737             LIFT(src[w*src_step],
738                  ((mul*2*ref[w*ref_step]+add)>>shift),
739                  inverse);
740     }
741 }
742
743 static av_always_inline void
744 inv_lift(IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref,
745          int dst_step, int src_step, int ref_step,
746          int width, int mul, int add, int shift,
747          int highpass, int inverse){
748     const int mirror_left= !highpass;
749     const int mirror_right= (width&1) ^ highpass;
750     const int w= (width>>1) - 1 + (highpass & width);
751     int i;
752
753 #define LIFT(src, ref, inv) ((src) + ((inv) ? - (ref) : + (ref)))
754     if(mirror_left){
755         dst[0] = LIFT(src[0], ((mul*2*ref[0]+add)>>shift), inverse);
756         dst += dst_step;
757         src += src_step;
758     }
759
760     for(i=0; i<w; i++){
761         dst[i*dst_step] =
762             LIFT(src[i*src_step],
763                  ((mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add)>>shift),
764                  inverse);
765     }
766
767     if(mirror_right){
768         dst[w*dst_step] =
769             LIFT(src[w*src_step],
770                  ((mul*2*ref[w*ref_step]+add)>>shift),
771                  inverse);
772     }
773 }
774
775 #ifndef liftS
776 static av_always_inline void
777 liftS(DWTELEM *dst, DWTELEM *src, DWTELEM *ref,
778       int dst_step, int src_step, int ref_step,
779       int width, int mul, int add, int shift,
780       int highpass, int inverse){
781     const int mirror_left= !highpass;
782     const int mirror_right= (width&1) ^ highpass;
783     const int w= (width>>1) - 1 + (highpass & width);
784     int i;
785
786     assert(shift == 4);
787 #define LIFTS(src, ref, inv) \
788         ((inv) ? \
789             (src) + (((ref) + 4*(src))>>shift): \
790             -((-16*(src) + (ref) + add/4 + 1 + (5<<25))/(5*4) - (1<<23)))
791     if(mirror_left){
792         dst[0] = LIFTS(src[0], mul*2*ref[0]+add, inverse);
793         dst += dst_step;
794         src += src_step;
795     }
796
797     for(i=0; i<w; i++){
798         dst[i*dst_step] =
799             LIFTS(src[i*src_step],
800                   mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add,
801                   inverse);
802     }
803
804     if(mirror_right){
805         dst[w*dst_step] =
806             LIFTS(src[w*src_step], mul*2*ref[w*ref_step]+add, inverse);
807     }
808 }
809 static av_always_inline void
810 inv_liftS(IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref,
811           int dst_step, int src_step, int ref_step,
812           int width, int mul, int add, int shift,
813           int highpass, int inverse){
814     const int mirror_left= !highpass;
815     const int mirror_right= (width&1) ^ highpass;
816     const int w= (width>>1) - 1 + (highpass & width);
817     int i;
818
819     assert(shift == 4);
820 #define LIFTS(src, ref, inv) \
821     ((inv) ? \
822         (src) + (((ref) + 4*(src))>>shift): \
823         -((-16*(src) + (ref) + add/4 + 1 + (5<<25))/(5*4) - (1<<23)))
824     if(mirror_left){
825         dst[0] = LIFTS(src[0], mul*2*ref[0]+add, inverse);
826         dst += dst_step;
827         src += src_step;
828     }
829
830     for(i=0; i<w; i++){
831         dst[i*dst_step] =
832             LIFTS(src[i*src_step],
833                   mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add,
834                   inverse);
835     }
836
837     if(mirror_right){
838         dst[w*dst_step] =
839             LIFTS(src[w*src_step], mul*2*ref[w*ref_step]+add, inverse);
840     }
841 }
842 #endif /* ! liftS */
843
844 static void horizontal_decompose53i(DWTELEM *b, int width){
845     DWTELEM temp[width];
846     const int width2= width>>1;
847     int x;
848     const int w2= (width+1)>>1;
849
850     for(x=0; x<width2; x++){
851         temp[x   ]= b[2*x    ];
852         temp[x+w2]= b[2*x + 1];
853     }
854     if(width&1)
855         temp[x   ]= b[2*x    ];
856 #if 0
857     {
858     int A1,A2,A3,A4;
859     A2= temp[1       ];
860     A4= temp[0       ];
861     A1= temp[0+width2];
862     A1 -= (A2 + A4)>>1;
863     A4 += (A1 + 1)>>1;
864     b[0+width2] = A1;
865     b[0       ] = A4;
866     for(x=1; x+1<width2; x+=2){
867         A3= temp[x+width2];
868         A4= temp[x+1     ];
869         A3 -= (A2 + A4)>>1;
870         A2 += (A1 + A3 + 2)>>2;
871         b[x+width2] = A3;
872         b[x       ] = A2;
873
874         A1= temp[x+1+width2];
875         A2= temp[x+2       ];
876         A1 -= (A2 + A4)>>1;
877         A4 += (A1 + A3 + 2)>>2;
878         b[x+1+width2] = A1;
879         b[x+1       ] = A4;
880     }
881     A3= temp[width-1];
882     A3 -= A2;
883     A2 += (A1 + A3 + 2)>>2;
884     b[width -1] = A3;
885     b[width2-1] = A2;
886     }
887 #else
888     lift(b+w2, temp+w2, temp, 1, 1, 1, width, -1, 0, 1, 1, 0);
889     lift(b   , temp   , b+w2, 1, 1, 1, width,  1, 2, 2, 0, 0);
890 #endif /* 0 */
891 }
892
893 static void vertical_decompose53iH0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
894     int i;
895
896     for(i=0; i<width; i++){
897         b1[i] -= (b0[i] + b2[i])>>1;
898     }
899 }
900
901 static void vertical_decompose53iL0(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] + 2)>>2;
906     }
907 }
908
909 static void spatial_decompose53i(DWTELEM *buffer, int width, int height, int stride){
910     int y;
911     DWTELEM *b0= buffer + mirror(-2-1, height-1)*stride;
912     DWTELEM *b1= buffer + mirror(-2  , height-1)*stride;
913
914     for(y=-2; y<height; y+=2){
915         DWTELEM *b2= buffer + mirror(y+1, height-1)*stride;
916         DWTELEM *b3= buffer + mirror(y+2, height-1)*stride;
917
918         if(y+1<(unsigned)height) horizontal_decompose53i(b2, width);
919         if(y+2<(unsigned)height) horizontal_decompose53i(b3, width);
920
921         if(y+1<(unsigned)height) vertical_decompose53iH0(b1, b2, b3, width);
922         if(y+0<(unsigned)height) vertical_decompose53iL0(b0, b1, b2, width);
923
924         b0=b2;
925         b1=b3;
926     }
927 }
928
929 static void horizontal_decompose97i(DWTELEM *b, int width){
930     DWTELEM temp[width];
931     const int w2= (width+1)>>1;
932
933     lift (temp+w2, b    +1, b      , 1, 2, 2, width,  W_AM, W_AO, W_AS, 1, 1);
934     liftS(temp   , b      , temp+w2, 1, 2, 1, width,  W_BM, W_BO, W_BS, 0, 0);
935     lift (b   +w2, temp+w2, temp   , 1, 1, 1, width,  W_CM, W_CO, W_CS, 1, 0);
936     lift (b      , temp   , b   +w2, 1, 1, 1, width,  W_DM, W_DO, W_DS, 0, 0);
937 }
938
939
940 static void vertical_decompose97iH0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
941     int i;
942
943     for(i=0; i<width; i++){
944         b1[i] -= (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
945     }
946 }
947
948 static void vertical_decompose97iH1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
949     int i;
950
951     for(i=0; i<width; i++){
952         b1[i] += (W_CM*(b0[i] + b2[i])+W_CO)>>W_CS;
953     }
954 }
955
956 static void vertical_decompose97iL0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
957     int i;
958
959     for(i=0; i<width; i++){
960 #ifdef liftS
961         b1[i] -= (W_BM*(b0[i] + b2[i])+W_BO)>>W_BS;
962 #else
963         b1[i] = (16*4*b1[i] - 4*(b0[i] + b2[i]) + W_BO*5 + (5<<27)) / (5*16) - (1<<23);
964 #endif
965     }
966 }
967
968 static void vertical_decompose97iL1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
969     int i;
970
971     for(i=0; i<width; i++){
972         b1[i] += (W_DM*(b0[i] + b2[i])+W_DO)>>W_DS;
973     }
974 }
975
976 static void spatial_decompose97i(DWTELEM *buffer, int width, int height, int stride){
977     int y;
978     DWTELEM *b0= buffer + mirror(-4-1, height-1)*stride;
979     DWTELEM *b1= buffer + mirror(-4  , height-1)*stride;
980     DWTELEM *b2= buffer + mirror(-4+1, height-1)*stride;
981     DWTELEM *b3= buffer + mirror(-4+2, height-1)*stride;
982
983     for(y=-4; y<height; y+=2){
984         DWTELEM *b4= buffer + mirror(y+3, height-1)*stride;
985         DWTELEM *b5= buffer + mirror(y+4, height-1)*stride;
986
987         if(y+3<(unsigned)height) horizontal_decompose97i(b4, width);
988         if(y+4<(unsigned)height) horizontal_decompose97i(b5, width);
989
990         if(y+3<(unsigned)height) vertical_decompose97iH0(b3, b4, b5, width);
991         if(y+2<(unsigned)height) vertical_decompose97iL0(b2, b3, b4, width);
992         if(y+1<(unsigned)height) vertical_decompose97iH1(b1, b2, b3, width);
993         if(y+0<(unsigned)height) vertical_decompose97iL1(b0, b1, b2, width);
994
995         b0=b2;
996         b1=b3;
997         b2=b4;
998         b3=b5;
999     }
1000 }
1001
1002 void ff_spatial_dwt(DWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count){
1003     int level;
1004
1005     for(level=0; level<decomposition_count; level++){
1006         switch(type){
1007         case DWT_97: spatial_decompose97i(buffer, width>>level, height>>level, stride<<level); break;
1008         case DWT_53: spatial_decompose53i(buffer, width>>level, height>>level, stride<<level); break;
1009         }
1010     }
1011 }
1012
1013 static void horizontal_compose53i(IDWTELEM *b, int width){
1014     IDWTELEM temp[width];
1015     const int width2= width>>1;
1016     const int w2= (width+1)>>1;
1017     int x;
1018
1019 #if 0
1020     int A1,A2,A3,A4;
1021     A2= temp[1       ];
1022     A4= temp[0       ];
1023     A1= temp[0+width2];
1024     A1 -= (A2 + A4)>>1;
1025     A4 += (A1 + 1)>>1;
1026     b[0+width2] = A1;
1027     b[0       ] = A4;
1028     for(x=1; x+1<width2; x+=2){
1029         A3= temp[x+width2];
1030         A4= temp[x+1     ];
1031         A3 -= (A2 + A4)>>1;
1032         A2 += (A1 + A3 + 2)>>2;
1033         b[x+width2] = A3;
1034         b[x       ] = A2;
1035
1036         A1= temp[x+1+width2];
1037         A2= temp[x+2       ];
1038         A1 -= (A2 + A4)>>1;
1039         A4 += (A1 + A3 + 2)>>2;
1040         b[x+1+width2] = A1;
1041         b[x+1       ] = A4;
1042     }
1043     A3= temp[width-1];
1044     A3 -= A2;
1045     A2 += (A1 + A3 + 2)>>2;
1046     b[width -1] = A3;
1047     b[width2-1] = A2;
1048 #else
1049     inv_lift(temp   , b   , b+w2, 1, 1, 1, width,  1, 2, 2, 0, 1);
1050     inv_lift(temp+w2, b+w2, temp, 1, 1, 1, width, -1, 0, 1, 1, 1);
1051 #endif /* 0 */
1052     for(x=0; x<width2; x++){
1053         b[2*x    ]= temp[x   ];
1054         b[2*x + 1]= temp[x+w2];
1055     }
1056     if(width&1)
1057         b[2*x    ]= temp[x   ];
1058 }
1059
1060 static void vertical_compose53iH0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1061     int i;
1062
1063     for(i=0; i<width; i++){
1064         b1[i] += (b0[i] + b2[i])>>1;
1065     }
1066 }
1067
1068 static void vertical_compose53iL0(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] + 2)>>2;
1073     }
1074 }
1075
1076 static void spatial_compose53i_buffered_init(DWTCompose *cs, slice_buffer * sb, int height, int stride_line){
1077     cs->b0 = slice_buffer_get_line(sb, mirror(-1-1, height-1) * stride_line);
1078     cs->b1 = slice_buffer_get_line(sb, mirror(-1  , height-1) * stride_line);
1079     cs->y = -1;
1080 }
1081
1082 static void spatial_compose53i_init(DWTCompose *cs, IDWTELEM *buffer, int height, int stride){
1083     cs->b0 = buffer + mirror(-1-1, height-1)*stride;
1084     cs->b1 = buffer + mirror(-1  , height-1)*stride;
1085     cs->y = -1;
1086 }
1087
1088 static void spatial_compose53i_dy_buffered(DWTCompose *cs, slice_buffer * sb, int width, int height, int stride_line){
1089     int y= cs->y;
1090
1091     IDWTELEM *b0= cs->b0;
1092     IDWTELEM *b1= cs->b1;
1093     IDWTELEM *b2= slice_buffer_get_line(sb, mirror(y+1, height-1) * stride_line);
1094     IDWTELEM *b3= slice_buffer_get_line(sb, mirror(y+2, height-1) * stride_line);
1095
1096         if(y+1<(unsigned)height) vertical_compose53iL0(b1, b2, b3, width);
1097         if(y+0<(unsigned)height) vertical_compose53iH0(b0, b1, b2, width);
1098
1099         if(y-1<(unsigned)height) horizontal_compose53i(b0, width);
1100         if(y+0<(unsigned)height) horizontal_compose53i(b1, width);
1101
1102     cs->b0 = b2;
1103     cs->b1 = b3;
1104     cs->y += 2;
1105 }
1106
1107 static void spatial_compose53i_dy(DWTCompose *cs, IDWTELEM *buffer, int width, int height, int stride){
1108     int y= cs->y;
1109     IDWTELEM *b0= cs->b0;
1110     IDWTELEM *b1= cs->b1;
1111     IDWTELEM *b2= buffer + mirror(y+1, height-1)*stride;
1112     IDWTELEM *b3= buffer + mirror(y+2, height-1)*stride;
1113
1114         if(y+1<(unsigned)height) vertical_compose53iL0(b1, b2, b3, width);
1115         if(y+0<(unsigned)height) vertical_compose53iH0(b0, b1, b2, width);
1116
1117         if(y-1<(unsigned)height) horizontal_compose53i(b0, width);
1118         if(y+0<(unsigned)height) horizontal_compose53i(b1, width);
1119
1120     cs->b0 = b2;
1121     cs->b1 = b3;
1122     cs->y += 2;
1123 }
1124
1125 static void av_unused spatial_compose53i(IDWTELEM *buffer, int width, int height, int stride){
1126     DWTCompose cs;
1127     spatial_compose53i_init(&cs, buffer, height, stride);
1128     while(cs.y <= height)
1129         spatial_compose53i_dy(&cs, buffer, width, height, stride);
1130 }
1131
1132
1133 void ff_snow_horizontal_compose97i(IDWTELEM *b, int width){
1134     IDWTELEM temp[width];
1135     const int w2= (width+1)>>1;
1136
1137     inv_lift (temp   , b      , b   +w2, 1, 1, 1, width,  W_DM, W_DO, W_DS, 0, 1);
1138     inv_lift (temp+w2, b   +w2, temp   , 1, 1, 1, width,  W_CM, W_CO, W_CS, 1, 1);
1139     inv_liftS(b      , temp   , temp+w2, 2, 1, 1, width,  W_BM, W_BO, W_BS, 0, 1);
1140     inv_lift (b+1    , temp+w2, b      , 2, 1, 2, width,  W_AM, W_AO, W_AS, 1, 0);
1141 }
1142
1143 static void vertical_compose97iH0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1144     int i;
1145
1146     for(i=0; i<width; i++){
1147         b1[i] += (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
1148     }
1149 }
1150
1151 static void vertical_compose97iH1(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1152     int i;
1153
1154     for(i=0; i<width; i++){
1155         b1[i] -= (W_CM*(b0[i] + b2[i])+W_CO)>>W_CS;
1156     }
1157 }
1158
1159 static void vertical_compose97iL0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1160     int i;
1161
1162     for(i=0; i<width; i++){
1163 #ifdef liftS
1164         b1[i] += (W_BM*(b0[i] + b2[i])+W_BO)>>W_BS;
1165 #else
1166         b1[i] += (W_BM*(b0[i] + b2[i])+4*b1[i]+W_BO)>>W_BS;
1167 #endif
1168     }
1169 }
1170
1171 static void vertical_compose97iL1(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1172     int i;
1173
1174     for(i=0; i<width; i++){
1175         b1[i] -= (W_DM*(b0[i] + b2[i])+W_DO)>>W_DS;
1176     }
1177 }
1178
1179 void ff_snow_vertical_compose97i(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5, int width){
1180     int i;
1181
1182     for(i=0; i<width; i++){
1183         b4[i] -= (W_DM*(b3[i] + b5[i])+W_DO)>>W_DS;
1184         b3[i] -= (W_CM*(b2[i] + b4[i])+W_CO)>>W_CS;
1185 #ifdef liftS
1186         b2[i] += (W_BM*(b1[i] + b3[i])+W_BO)>>W_BS;
1187 #else
1188         b2[i] += (W_BM*(b1[i] + b3[i])+4*b2[i]+W_BO)>>W_BS;
1189 #endif
1190         b1[i] += (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
1191     }
1192 }
1193
1194 static void spatial_compose97i_buffered_init(DWTCompose *cs, slice_buffer * sb, int height, int stride_line){
1195     cs->b0 = slice_buffer_get_line(sb, mirror(-3-1, height-1) * stride_line);
1196     cs->b1 = slice_buffer_get_line(sb, mirror(-3  , height-1) * stride_line);
1197     cs->b2 = slice_buffer_get_line(sb, mirror(-3+1, height-1) * stride_line);
1198     cs->b3 = slice_buffer_get_line(sb, mirror(-3+2, height-1) * stride_line);
1199     cs->y = -3;
1200 }
1201
1202 static void spatial_compose97i_init(DWTCompose *cs, IDWTELEM *buffer, int height, int stride){
1203     cs->b0 = buffer + mirror(-3-1, height-1)*stride;
1204     cs->b1 = buffer + mirror(-3  , height-1)*stride;
1205     cs->b2 = buffer + mirror(-3+1, height-1)*stride;
1206     cs->b3 = buffer + mirror(-3+2, height-1)*stride;
1207     cs->y = -3;
1208 }
1209
1210 static void spatial_compose97i_dy_buffered(DSPContext *dsp, DWTCompose *cs, slice_buffer * sb, int width, int height, int stride_line){
1211     int y = cs->y;
1212
1213     IDWTELEM *b0= cs->b0;
1214     IDWTELEM *b1= cs->b1;
1215     IDWTELEM *b2= cs->b2;
1216     IDWTELEM *b3= cs->b3;
1217     IDWTELEM *b4= slice_buffer_get_line(sb, mirror(y + 3, height - 1) * stride_line);
1218     IDWTELEM *b5= slice_buffer_get_line(sb, mirror(y + 4, height - 1) * stride_line);
1219
1220     if(y>0 && y+4<height){
1221         dsp->vertical_compose97i(b0, b1, b2, b3, b4, b5, width);
1222     }else{
1223         if(y+3<(unsigned)height) vertical_compose97iL1(b3, b4, b5, width);
1224         if(y+2<(unsigned)height) vertical_compose97iH1(b2, b3, b4, width);
1225         if(y+1<(unsigned)height) vertical_compose97iL0(b1, b2, b3, width);
1226         if(y+0<(unsigned)height) vertical_compose97iH0(b0, b1, b2, width);
1227     }
1228
1229     if(y-1<(unsigned)height) dsp->horizontal_compose97i(b0, width);
1230     if(y+0<(unsigned)height) dsp->horizontal_compose97i(b1, width);
1231
1232     cs->b0=b2;
1233     cs->b1=b3;
1234     cs->b2=b4;
1235     cs->b3=b5;
1236     cs->y += 2;
1237 }
1238
1239 static void spatial_compose97i_dy(DWTCompose *cs, IDWTELEM *buffer, int width, int height, int stride){
1240     int y = cs->y;
1241     IDWTELEM *b0= cs->b0;
1242     IDWTELEM *b1= cs->b1;
1243     IDWTELEM *b2= cs->b2;
1244     IDWTELEM *b3= cs->b3;
1245     IDWTELEM *b4= buffer + mirror(y+3, height-1)*stride;
1246     IDWTELEM *b5= buffer + mirror(y+4, height-1)*stride;
1247
1248     if(y+3<(unsigned)height) vertical_compose97iL1(b3, b4, b5, width);
1249     if(y+2<(unsigned)height) vertical_compose97iH1(b2, b3, b4, width);
1250     if(y+1<(unsigned)height) vertical_compose97iL0(b1, b2, b3, width);
1251     if(y+0<(unsigned)height) vertical_compose97iH0(b0, b1, b2, width);
1252
1253     if(y-1<(unsigned)height) ff_snow_horizontal_compose97i(b0, width);
1254     if(y+0<(unsigned)height) ff_snow_horizontal_compose97i(b1, width);
1255
1256     cs->b0=b2;
1257     cs->b1=b3;
1258     cs->b2=b4;
1259     cs->b3=b5;
1260     cs->y += 2;
1261 }
1262
1263 static void av_unused spatial_compose97i(IDWTELEM *buffer, int width, int height, int stride){
1264     DWTCompose cs;
1265     spatial_compose97i_init(&cs, buffer, height, stride);
1266     while(cs.y <= height)
1267         spatial_compose97i_dy(&cs, buffer, width, height, stride);
1268 }
1269
1270 static void ff_spatial_idwt_buffered_init(DWTCompose *cs, slice_buffer * sb, int width, int height, int stride_line, int type, int decomposition_count){
1271     int level;
1272     for(level=decomposition_count-1; level>=0; level--){
1273         switch(type){
1274         case DWT_97: spatial_compose97i_buffered_init(cs+level, sb, height>>level, stride_line<<level); break;
1275         case DWT_53: spatial_compose53i_buffered_init(cs+level, sb, height>>level, stride_line<<level); break;
1276         }
1277     }
1278 }
1279
1280 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){
1281     const int support = type==1 ? 3 : 5;
1282     int level;
1283     if(type==2) return;
1284
1285     for(level=decomposition_count-1; level>=0; level--){
1286         while(cs[level].y <= FFMIN((y>>level)+support, height>>level)){
1287             switch(type){
1288             case DWT_97: spatial_compose97i_dy_buffered(dsp, cs+level, slice_buf, width>>level, height>>level, stride_line<<level);
1289                 break;
1290             case DWT_53: spatial_compose53i_dy_buffered(cs+level, slice_buf, width>>level, height>>level, stride_line<<level);
1291                 break;
1292             }
1293         }
1294     }
1295 }
1296
1297 static inline void unpack_coeffs(SnowContext *s, SubBand *b, SubBand * parent, int orientation){
1298     const int w= b->width;
1299     const int h= b->height;
1300     int x,y;
1301
1302     if(1){
1303         int run, runs;
1304         x_and_coeff *xc= b->x_coeff;
1305         x_and_coeff *prev_xc= NULL;
1306         x_and_coeff *prev2_xc= xc;
1307         x_and_coeff *parent_xc= parent ? parent->x_coeff : NULL;
1308         x_and_coeff *prev_parent_xc= parent_xc;
1309
1310         runs= get_symbol2(&s->c, b->state[30], 0);
1311         if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
1312         else           run= INT_MAX;
1313
1314         for(y=0; y<h; y++){
1315             int v=0;
1316             int lt=0, t=0, rt=0;
1317
1318             if(y && prev_xc->x == 0){
1319                 rt= prev_xc->coeff;
1320             }
1321             for(x=0; x<w; x++){
1322                 int p=0;
1323                 const int l= v;
1324
1325                 lt= t; t= rt;
1326
1327                 if(y){
1328                     if(prev_xc->x <= x)
1329                         prev_xc++;
1330                     if(prev_xc->x == x + 1)
1331                         rt= prev_xc->coeff;
1332                     else
1333                         rt=0;
1334                 }
1335                 if(parent_xc){
1336                     if(x>>1 > parent_xc->x){
1337                         parent_xc++;
1338                     }
1339                     if(x>>1 == parent_xc->x){
1340                         p= parent_xc->coeff;
1341                     }
1342                 }
1343                 if(/*ll|*/l|lt|t|rt|p){
1344                     int context= av_log2(/*FFABS(ll) + */3*(l>>1) + (lt>>1) + (t&~1) + (rt>>1) + (p>>1));
1345
1346                     v=get_rac(&s->c, &b->state[0][context]);
1347                     if(v){
1348                         v= 2*(get_symbol2(&s->c, b->state[context + 2], context-4) + 1);
1349                         v+=get_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3bA[l&0xFF] + 3*quant3bA[t&0xFF]]);
1350
1351                         xc->x=x;
1352                         (xc++)->coeff= v;
1353                     }
1354                 }else{
1355                     if(!run){
1356                         if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
1357                         else           run= INT_MAX;
1358                         v= 2*(get_symbol2(&s->c, b->state[0 + 2], 0-4) + 1);
1359                         v+=get_rac(&s->c, &b->state[0][16 + 1 + 3]);
1360
1361                         xc->x=x;
1362                         (xc++)->coeff= v;
1363                     }else{
1364                         int max_run;
1365                         run--;
1366                         v=0;
1367
1368                         if(y) max_run= FFMIN(run, prev_xc->x - x - 2);
1369                         else  max_run= FFMIN(run, w-x-1);
1370                         if(parent_xc)
1371                             max_run= FFMIN(max_run, 2*parent_xc->x - x - 1);
1372                         x+= max_run;
1373                         run-= max_run;
1374                     }
1375                 }
1376             }
1377             (xc++)->x= w+1; //end marker
1378             prev_xc= prev2_xc;
1379             prev2_xc= xc;
1380
1381             if(parent_xc){
1382                 if(y&1){
1383                     while(parent_xc->x != parent->width+1)
1384                         parent_xc++;
1385                     parent_xc++;
1386                     prev_parent_xc= parent_xc;
1387                 }else{
1388                     parent_xc= prev_parent_xc;
1389                 }
1390             }
1391         }
1392
1393         (xc++)->x= w+1; //end marker
1394     }
1395 }
1396
1397 static inline void decode_subband_slice_buffered(SnowContext *s, SubBand *b, slice_buffer * sb, int start_y, int h, int save_state[1]){
1398     const int w= b->width;
1399     int y;
1400     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1401     int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1402     int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
1403     int new_index = 0;
1404
1405     if(b->ibuf == s->spatial_idwt_buffer || s->qlog == LOSSLESS_QLOG){
1406         qadd= 0;
1407         qmul= 1<<QEXPSHIFT;
1408     }
1409
1410     /* If we are on the second or later slice, restore our index. */
1411     if (start_y != 0)
1412         new_index = save_state[0];
1413
1414
1415     for(y=start_y; y<h; y++){
1416         int x = 0;
1417         int v;
1418         IDWTELEM * line = slice_buffer_get_line(sb, y * b->stride_line + b->buf_y_offset) + b->buf_x_offset;
1419         memset(line, 0, b->width*sizeof(IDWTELEM));
1420         v = b->x_coeff[new_index].coeff;
1421         x = b->x_coeff[new_index++].x;
1422         while(x < w){
1423             register int t= ( (v>>1)*qmul + qadd)>>QEXPSHIFT;
1424             register int u= -(v&1);
1425             line[x] = (t^u) - u;
1426
1427             v = b->x_coeff[new_index].coeff;
1428             x = b->x_coeff[new_index++].x;
1429         }
1430     }
1431
1432     /* Save our variables for the next slice. */
1433     save_state[0] = new_index;
1434
1435     return;
1436 }
1437
1438 static void reset_contexts(SnowContext *s){ //FIXME better initial contexts
1439     int plane_index, level, orientation;
1440
1441     for(plane_index=0; plane_index<3; plane_index++){
1442         for(level=0; level<MAX_DECOMPOSITIONS; level++){
1443             for(orientation=level ? 1:0; orientation<4; orientation++){
1444                 memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
1445             }
1446         }
1447     }
1448     memset(s->header_state, MID_STATE, sizeof(s->header_state));
1449     memset(s->block_state, MID_STATE, sizeof(s->block_state));
1450 }
1451
1452 static int alloc_blocks(SnowContext *s){
1453     int w= -((-s->avctx->width )>>LOG2_MB_SIZE);
1454     int h= -((-s->avctx->height)>>LOG2_MB_SIZE);
1455
1456     s->b_width = w;
1457     s->b_height= h;
1458
1459     av_free(s->block);
1460     s->block= av_mallocz(w * h * sizeof(BlockNode) << (s->block_max_depth*2));
1461     return 0;
1462 }
1463
1464 static inline void copy_rac_state(RangeCoder *d, RangeCoder *s){
1465     uint8_t *bytestream= d->bytestream;
1466     uint8_t *bytestream_start= d->bytestream_start;
1467     *d= *s;
1468     d->bytestream= bytestream;
1469     d->bytestream_start= bytestream_start;
1470 }
1471
1472 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){
1473     const int w= s->b_width << s->block_max_depth;
1474     const int rem_depth= s->block_max_depth - level;
1475     const int index= (x + y*w) << rem_depth;
1476     const int block_w= 1<<rem_depth;
1477     BlockNode block;
1478     int i,j;
1479
1480     block.color[0]= l;
1481     block.color[1]= cb;
1482     block.color[2]= cr;
1483     block.mx= mx;
1484     block.my= my;
1485     block.ref= ref;
1486     block.type= type;
1487     block.level= level;
1488
1489     for(j=0; j<block_w; j++){
1490         for(i=0; i<block_w; i++){
1491             s->block[index + i + j*w]= block;
1492         }
1493     }
1494 }
1495
1496 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){
1497     const int offset[3]= {
1498           y*c->  stride + x,
1499         ((y*c->uvstride + x)>>1),
1500         ((y*c->uvstride + x)>>1),
1501     };
1502     int i;
1503     for(i=0; i<3; i++){
1504         c->src[0][i]= src [i];
1505         c->ref[0][i]= ref [i] + offset[i];
1506     }
1507     assert(!ref_index);
1508 }
1509
1510 static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
1511                            const BlockNode *left, const BlockNode *top, const BlockNode *tr){
1512     if(s->ref_frames == 1){
1513         *mx = mid_pred(left->mx, top->mx, tr->mx);
1514         *my = mid_pred(left->my, top->my, tr->my);
1515     }else{
1516         const int *scale = scale_mv_ref[ref];
1517         *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
1518                        (top ->mx * scale[top ->ref] + 128) >>8,
1519                        (tr  ->mx * scale[tr  ->ref] + 128) >>8);
1520         *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
1521                        (top ->my * scale[top ->ref] + 128) >>8,
1522                        (tr  ->my * scale[tr  ->ref] + 128) >>8);
1523     }
1524 }
1525
1526 static av_always_inline int same_block(BlockNode *a, BlockNode *b){
1527     if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
1528         return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
1529     }else{
1530         return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
1531     }
1532 }
1533
1534 static void decode_q_branch(SnowContext *s, int level, int x, int y){
1535     const int w= s->b_width << s->block_max_depth;
1536     const int rem_depth= s->block_max_depth - level;
1537     const int index= (x + y*w) << rem_depth;
1538     int trx= (x+1)<<rem_depth;
1539     const BlockNode *left  = x ? &s->block[index-1] : &null_block;
1540     const BlockNode *top   = y ? &s->block[index-w] : &null_block;
1541     const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;
1542     const BlockNode *tr    = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
1543     int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
1544
1545     if(s->keyframe){
1546         set_blocks(s, level, x, y, null_block.color[0], null_block.color[1], null_block.color[2], null_block.mx, null_block.my, null_block.ref, BLOCK_INTRA);
1547         return;
1548     }
1549
1550     if(level==s->block_max_depth || get_rac(&s->c, &s->block_state[4 + s_context])){
1551         int type, mx, my;
1552         int l = left->color[0];
1553         int cb= left->color[1];
1554         int cr= left->color[2];
1555         int ref = 0;
1556         int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
1557         int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 0*av_log2(2*FFABS(tr->mx - top->mx));
1558         int my_context= av_log2(2*FFABS(left->my - top->my)) + 0*av_log2(2*FFABS(tr->my - top->my));
1559
1560         type= get_rac(&s->c, &s->block_state[1 + left->type + top->type]) ? BLOCK_INTRA : 0;
1561
1562         if(type){
1563             pred_mv(s, &mx, &my, 0, left, top, tr);
1564             l += get_symbol(&s->c, &s->block_state[32], 1);
1565             cb+= get_symbol(&s->c, &s->block_state[64], 1);
1566             cr+= get_symbol(&s->c, &s->block_state[96], 1);
1567         }else{
1568             if(s->ref_frames > 1)
1569                 ref= get_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], 0);
1570             pred_mv(s, &mx, &my, ref, left, top, tr);
1571             mx+= get_symbol(&s->c, &s->block_state[128 + 32*(mx_context + 16*!!ref)], 1);
1572             my+= get_symbol(&s->c, &s->block_state[128 + 32*(my_context + 16*!!ref)], 1);
1573         }
1574         set_blocks(s, level, x, y, l, cb, cr, mx, my, ref, type);
1575     }else{
1576         decode_q_branch(s, level+1, 2*x+0, 2*y+0);
1577         decode_q_branch(s, level+1, 2*x+1, 2*y+0);
1578         decode_q_branch(s, level+1, 2*x+0, 2*y+1);
1579         decode_q_branch(s, level+1, 2*x+1, 2*y+1);
1580     }
1581 }
1582
1583 static void decode_blocks(SnowContext *s){
1584     int x, y;
1585     int w= s->b_width;
1586     int h= s->b_height;
1587
1588     for(y=0; y<h; y++){
1589         for(x=0; x<w; x++){
1590             decode_q_branch(s, 0, x, y);
1591         }
1592     }
1593 }
1594
1595 static void mc_block(Plane *p, uint8_t *dst, const uint8_t *src, uint8_t *tmp, int stride, int b_w, int b_h, int dx, int dy){
1596     static const uint8_t weight[64]={
1597     8,7,6,5,4,3,2,1,
1598     7,7,0,0,0,0,0,1,
1599     6,0,6,0,0,0,2,0,
1600     5,0,0,5,0,3,0,0,
1601     4,0,0,0,4,0,0,0,
1602     3,0,0,5,0,3,0,0,
1603     2,0,6,0,0,0,2,0,
1604     1,7,0,0,0,0,0,1,
1605     };
1606
1607     static const uint8_t brane[256]={
1608     0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
1609     0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
1610     0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
1611     0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
1612     0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
1613     0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
1614     0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
1615     0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
1616     0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
1617     0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
1618     0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
1619     0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
1620     0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
1621     0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
1622     0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
1623     0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
1624     };
1625
1626     static const uint8_t needs[16]={
1627     0,1,0,0,
1628     2,4,2,0,
1629     0,1,0,0,
1630     15
1631     };
1632
1633     int x, y, b, r, l;
1634     int16_t tmpIt   [64*(32+HTAPS_MAX)];
1635     uint8_t tmp2t[3][stride*(32+HTAPS_MAX)];
1636     int16_t *tmpI= tmpIt;
1637     uint8_t *tmp2= tmp2t[0];
1638     const uint8_t *hpel[11];
1639     assert(dx<16 && dy<16);
1640     r= brane[dx + 16*dy]&15;
1641     l= brane[dx + 16*dy]>>4;
1642
1643     b= needs[l] | needs[r];
1644     if(p && !p->diag_mc)
1645         b= 15;
1646
1647     if(b&5){
1648         for(y=0; y < b_h+HTAPS_MAX-1; y++){
1649             for(x=0; x < b_w; x++){
1650                 int a_1=src[x + HTAPS_MAX/2-4];
1651                 int a0= src[x + HTAPS_MAX/2-3];
1652                 int a1= src[x + HTAPS_MAX/2-2];
1653                 int a2= src[x + HTAPS_MAX/2-1];
1654                 int a3= src[x + HTAPS_MAX/2+0];
1655                 int a4= src[x + HTAPS_MAX/2+1];
1656                 int a5= src[x + HTAPS_MAX/2+2];
1657                 int a6= src[x + HTAPS_MAX/2+3];
1658                 int am=0;
1659                 if(!p || p->fast_mc){
1660                     am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
1661                     tmpI[x]= am;
1662                     am= (am+16)>>5;
1663                 }else{
1664                     am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
1665                     tmpI[x]= am;
1666                     am= (am+32)>>6;
1667                 }
1668
1669                 if(am&(~255)) am= ~(am>>31);
1670                 tmp2[x]= am;
1671             }
1672             tmpI+= 64;
1673             tmp2+= stride;
1674             src += stride;
1675         }
1676         src -= stride*y;
1677     }
1678     src += HTAPS_MAX/2 - 1;
1679     tmp2= tmp2t[1];
1680
1681     if(b&2){
1682         for(y=0; y < b_h; y++){
1683             for(x=0; x < b_w+1; x++){
1684                 int a_1=src[x + (HTAPS_MAX/2-4)*stride];
1685                 int a0= src[x + (HTAPS_MAX/2-3)*stride];
1686                 int a1= src[x + (HTAPS_MAX/2-2)*stride];
1687                 int a2= src[x + (HTAPS_MAX/2-1)*stride];
1688                 int a3= src[x + (HTAPS_MAX/2+0)*stride];
1689                 int a4= src[x + (HTAPS_MAX/2+1)*stride];
1690                 int a5= src[x + (HTAPS_MAX/2+2)*stride];
1691                 int a6= src[x + (HTAPS_MAX/2+3)*stride];
1692                 int am=0;
1693                 if(!p || p->fast_mc)
1694                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
1695                 else
1696                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
1697
1698                 if(am&(~255)) am= ~(am>>31);
1699                 tmp2[x]= am;
1700             }
1701             src += stride;
1702             tmp2+= stride;
1703         }
1704         src -= stride*y;
1705     }
1706     src += stride*(HTAPS_MAX/2 - 1);
1707     tmp2= tmp2t[2];
1708     tmpI= tmpIt;
1709     if(b&4){
1710         for(y=0; y < b_h; y++){
1711             for(x=0; x < b_w; x++){
1712                 int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
1713                 int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
1714                 int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
1715                 int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
1716                 int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
1717                 int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
1718                 int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
1719                 int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
1720                 int am=0;
1721                 if(!p || p->fast_mc)
1722                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
1723                 else
1724                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
1725                 if(am&(~255)) am= ~(am>>31);
1726                 tmp2[x]= am;
1727             }
1728             tmpI+= 64;
1729             tmp2+= stride;
1730         }
1731     }
1732
1733     hpel[ 0]= src;
1734     hpel[ 1]= tmp2t[0] + stride*(HTAPS_MAX/2-1);
1735     hpel[ 2]= src + 1;
1736
1737     hpel[ 4]= tmp2t[1];
1738     hpel[ 5]= tmp2t[2];
1739     hpel[ 6]= tmp2t[1] + 1;
1740
1741     hpel[ 8]= src + stride;
1742     hpel[ 9]= hpel[1] + stride;
1743     hpel[10]= hpel[8] + 1;
1744
1745     if(b==15){
1746         const uint8_t *src1= hpel[dx/8 + dy/8*4  ];
1747         const uint8_t *src2= hpel[dx/8 + dy/8*4+1];
1748         const uint8_t *src3= hpel[dx/8 + dy/8*4+4];
1749         const uint8_t *src4= hpel[dx/8 + dy/8*4+5];
1750         dx&=7;
1751         dy&=7;
1752         for(y=0; y < b_h; y++){
1753             for(x=0; x < b_w; x++){
1754                 dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
1755                          (8-dx)*   dy *src3[x] + dx*   dy *src4[x]+32)>>6;
1756             }
1757             src1+=stride;
1758             src2+=stride;
1759             src3+=stride;
1760             src4+=stride;
1761             dst +=stride;
1762         }
1763     }else{
1764         const uint8_t *src1= hpel[l];
1765         const uint8_t *src2= hpel[r];
1766         int a= weight[((dx&7) + (8*(dy&7)))];
1767         int b= 8-a;
1768         for(y=0; y < b_h; y++){
1769             for(x=0; x < b_w; x++){
1770                 dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
1771             }
1772             src1+=stride;
1773             src2+=stride;
1774             dst +=stride;
1775         }
1776     }
1777 }
1778
1779 #define mca(dx,dy,b_w)\
1780 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, int stride, int h){\
1781     uint8_t tmp[stride*(b_w+HTAPS_MAX-1)];\
1782     assert(h==b_w);\
1783     mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, tmp, stride, b_w, b_w, dx, dy);\
1784 }
1785
1786 mca( 0, 0,16)
1787 mca( 8, 0,16)
1788 mca( 0, 8,16)
1789 mca( 8, 8,16)
1790 mca( 0, 0,8)
1791 mca( 8, 0,8)
1792 mca( 0, 8,8)
1793 mca( 8, 8,8)
1794
1795 static void pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h){
1796     if(block->type & BLOCK_INTRA){
1797         int x, y;
1798         const int color = block->color[plane_index];
1799         const int color4= color*0x01010101;
1800         if(b_w==32){
1801             for(y=0; y < b_h; y++){
1802                 *(uint32_t*)&dst[0 + y*stride]= color4;
1803                 *(uint32_t*)&dst[4 + y*stride]= color4;
1804                 *(uint32_t*)&dst[8 + y*stride]= color4;
1805                 *(uint32_t*)&dst[12+ y*stride]= color4;
1806                 *(uint32_t*)&dst[16+ y*stride]= color4;
1807                 *(uint32_t*)&dst[20+ y*stride]= color4;
1808                 *(uint32_t*)&dst[24+ y*stride]= color4;
1809                 *(uint32_t*)&dst[28+ y*stride]= color4;
1810             }
1811         }else if(b_w==16){
1812             for(y=0; y < b_h; y++){
1813                 *(uint32_t*)&dst[0 + y*stride]= color4;
1814                 *(uint32_t*)&dst[4 + y*stride]= color4;
1815                 *(uint32_t*)&dst[8 + y*stride]= color4;
1816                 *(uint32_t*)&dst[12+ y*stride]= color4;
1817             }
1818         }else if(b_w==8){
1819             for(y=0; y < b_h; y++){
1820                 *(uint32_t*)&dst[0 + y*stride]= color4;
1821                 *(uint32_t*)&dst[4 + y*stride]= color4;
1822             }
1823         }else if(b_w==4){
1824             for(y=0; y < b_h; y++){
1825                 *(uint32_t*)&dst[0 + y*stride]= color4;
1826             }
1827         }else{
1828             for(y=0; y < b_h; y++){
1829                 for(x=0; x < b_w; x++){
1830                     dst[x + y*stride]= color;
1831                 }
1832             }
1833         }
1834     }else{
1835         uint8_t *src= s->last_picture[block->ref].data[plane_index];
1836         const int scale= plane_index ?  s->mv_scale : 2*s->mv_scale;
1837         int mx= block->mx*scale;
1838         int my= block->my*scale;
1839         const int dx= mx&15;
1840         const int dy= my&15;
1841         const int tab_index= 3 - (b_w>>2) + (b_w>>4);
1842         sx += (mx>>4) - (HTAPS_MAX/2-1);
1843         sy += (my>>4) - (HTAPS_MAX/2-1);
1844         src += sx + sy*stride;
1845         if(   (unsigned)sx >= w - b_w - (HTAPS_MAX-2)
1846            || (unsigned)sy >= h - b_h - (HTAPS_MAX-2)){
1847             ff_emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);
1848             src= tmp + MB_SIZE;
1849         }
1850 //        assert(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h);
1851 //        assert(!(b_w&(b_w-1)));
1852         assert(b_w>1 && b_h>1);
1853         assert((tab_index>=0 && tab_index<4) || b_w==32);
1854         if((dx&3) || (dy&3) || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h) || (b_w&(b_w-1)) || !s->plane[plane_index].fast_mc )
1855             mc_block(&s->plane[plane_index], dst, src, tmp, stride, b_w, b_h, dx, dy);
1856         else if(b_w==32){
1857             int y;
1858             for(y=0; y<b_h; y+=16){
1859                 s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
1860                 s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
1861             }
1862         }else if(b_w==b_h)
1863             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
1864         else if(b_w==2*b_h){
1865             s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst    ,src + 3       + 3*stride,stride);
1866             s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
1867         }else{
1868             assert(2*b_w==b_h);
1869             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst           ,src + 3 + 3*stride           ,stride);
1870             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
1871         }
1872     }
1873 }
1874
1875 void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
1876                               int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){
1877     int y, x;
1878     IDWTELEM * dst;
1879     for(y=0; y<b_h; y++){
1880         //FIXME ugly misuse of obmc_stride
1881         const uint8_t *obmc1= obmc + y*obmc_stride;
1882         const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
1883         const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
1884         const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
1885         dst = slice_buffer_get_line(sb, src_y + y);
1886         for(x=0; x<b_w; x++){
1887             int v=   obmc1[x] * block[3][x + y*src_stride]
1888                     +obmc2[x] * block[2][x + y*src_stride]
1889                     +obmc3[x] * block[1][x + y*src_stride]
1890                     +obmc4[x] * block[0][x + y*src_stride];
1891
1892             v <<= 8 - LOG2_OBMC_MAX;
1893             if(FRAC_BITS != 8){
1894                 v >>= 8 - FRAC_BITS;
1895             }
1896             if(add){
1897                 v += dst[x + src_x];
1898                 v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
1899                 if(v&(~255)) v= ~(v>>31);
1900                 dst8[x + y*src_stride] = v;
1901             }else{
1902                 dst[x + src_x] -= v;
1903             }
1904         }
1905     }
1906 }
1907
1908 //FIXME name cleanup (b_w, block_w, b_width stuff)
1909 static av_always_inline void add_yblock(SnowContext *s, int sliced, slice_buffer *sb, IDWTELEM *dst, uint8_t *dst8, const uint8_t *obmc, int src_x, int src_y, int b_w, int b_h, int w, int h, int dst_stride, int src_stride, int obmc_stride, int b_x, int b_y, int add, int offset_dst, int plane_index){
1910     const int b_width = s->b_width  << s->block_max_depth;
1911     const int b_height= s->b_height << s->block_max_depth;
1912     const int b_stride= b_width;
1913     BlockNode *lt= &s->block[b_x + b_y*b_stride];
1914     BlockNode *rt= lt+1;
1915     BlockNode *lb= lt+b_stride;
1916     BlockNode *rb= lb+1;
1917     uint8_t *block[4];
1918     int tmp_step= src_stride >= 7*MB_SIZE ? MB_SIZE : MB_SIZE*src_stride;
1919     uint8_t *tmp = s->scratchbuf;
1920     uint8_t *ptmp;
1921     int x,y;
1922
1923     if(b_x<0){
1924         lt= rt;
1925         lb= rb;
1926     }else if(b_x + 1 >= b_width){
1927         rt= lt;
1928         rb= lb;
1929     }
1930     if(b_y<0){
1931         lt= lb;
1932         rt= rb;
1933     }else if(b_y + 1 >= b_height){
1934         lb= lt;
1935         rb= rt;
1936     }
1937
1938     if(src_x<0){ //FIXME merge with prev & always round internal width up to *16
1939         obmc -= src_x;
1940         b_w += src_x;
1941         if(!sliced && !offset_dst)
1942             dst -= src_x;
1943         src_x=0;
1944     }else if(src_x + b_w > w){
1945         b_w = w - src_x;
1946     }
1947     if(src_y<0){
1948         obmc -= src_y*obmc_stride;
1949         b_h += src_y;
1950         if(!sliced && !offset_dst)
1951             dst -= src_y*dst_stride;
1952         src_y=0;
1953     }else if(src_y + b_h> h){
1954         b_h = h - src_y;
1955     }
1956
1957     if(b_w<=0 || b_h<=0) return;
1958
1959     assert(src_stride > 2*MB_SIZE + 5);
1960
1961     if(!sliced && offset_dst)
1962         dst += src_x + src_y*dst_stride;
1963     dst8+= src_x + src_y*src_stride;
1964 //    src += src_x + src_y*src_stride;
1965
1966     ptmp= tmp + 3*tmp_step;
1967     block[0]= ptmp;
1968     ptmp+=tmp_step;
1969     pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
1970
1971     if(same_block(lt, rt)){
1972         block[1]= block[0];
1973     }else{
1974         block[1]= ptmp;
1975         ptmp+=tmp_step;
1976         pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
1977     }
1978
1979     if(same_block(lt, lb)){
1980         block[2]= block[0];
1981     }else if(same_block(rt, lb)){
1982         block[2]= block[1];
1983     }else{
1984         block[2]= ptmp;
1985         ptmp+=tmp_step;
1986         pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
1987     }
1988
1989     if(same_block(lt, rb) ){
1990         block[3]= block[0];
1991     }else if(same_block(rt, rb)){
1992         block[3]= block[1];
1993     }else if(same_block(lb, rb)){
1994         block[3]= block[2];
1995     }else{
1996         block[3]= ptmp;
1997         pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
1998     }
1999 #if 0
2000     for(y=0; y<b_h; y++){
2001         for(x=0; x<b_w; x++){
2002             int v=   obmc [x + y*obmc_stride] * block[3][x + y*src_stride] * (256/OBMC_MAX);
2003             if(add) dst[x + y*dst_stride] += v;
2004             else    dst[x + y*dst_stride] -= v;
2005         }
2006     }
2007     for(y=0; y<b_h; y++){
2008         uint8_t *obmc2= obmc + (obmc_stride>>1);
2009         for(x=0; x<b_w; x++){
2010             int v=   obmc2[x + y*obmc_stride] * block[2][x + y*src_stride] * (256/OBMC_MAX);
2011             if(add) dst[x + y*dst_stride] += v;
2012             else    dst[x + y*dst_stride] -= v;
2013         }
2014     }
2015     for(y=0; y<b_h; y++){
2016         uint8_t *obmc3= obmc + obmc_stride*(obmc_stride>>1);
2017         for(x=0; x<b_w; x++){
2018             int v=   obmc3[x + y*obmc_stride] * block[1][x + y*src_stride] * (256/OBMC_MAX);
2019             if(add) dst[x + y*dst_stride] += v;
2020             else    dst[x + y*dst_stride] -= v;
2021         }
2022     }
2023     for(y=0; y<b_h; y++){
2024         uint8_t *obmc3= obmc + obmc_stride*(obmc_stride>>1);
2025         uint8_t *obmc4= obmc3+ (obmc_stride>>1);
2026         for(x=0; x<b_w; x++){
2027             int v=   obmc4[x + y*obmc_stride] * block[0][x + y*src_stride] * (256/OBMC_MAX);
2028             if(add) dst[x + y*dst_stride] += v;
2029             else    dst[x + y*dst_stride] -= v;
2030         }
2031     }
2032 #else
2033     if(sliced){
2034         s->dsp.inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
2035     }else{
2036         for(y=0; y<b_h; y++){
2037             //FIXME ugly misuse of obmc_stride
2038             const uint8_t *obmc1= obmc + y*obmc_stride;
2039             const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
2040             const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
2041             const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
2042             for(x=0; x<b_w; x++){
2043                 int v=   obmc1[x] * block[3][x + y*src_stride]
2044                         +obmc2[x] * block[2][x + y*src_stride]
2045                         +obmc3[x] * block[1][x + y*src_stride]
2046                         +obmc4[x] * block[0][x + y*src_stride];
2047
2048                 v <<= 8 - LOG2_OBMC_MAX;
2049                 if(FRAC_BITS != 8){
2050                     v >>= 8 - FRAC_BITS;
2051                 }
2052                 if(add){
2053                     v += dst[x + y*dst_stride];
2054                     v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
2055                     if(v&(~255)) v= ~(v>>31);
2056                     dst8[x + y*src_stride] = v;
2057                 }else{
2058                     dst[x + y*dst_stride] -= v;
2059                 }
2060             }
2061         }
2062     }
2063 #endif /* 0 */
2064 }
2065
2066 static av_always_inline void predict_slice_buffered(SnowContext *s, slice_buffer * sb, IDWTELEM * old_buffer, int plane_index, int add, int mb_y){
2067     Plane *p= &s->plane[plane_index];
2068     const int mb_w= s->b_width  << s->block_max_depth;
2069     const int mb_h= s->b_height << s->block_max_depth;
2070     int x, y, mb_x;
2071     int block_size = MB_SIZE >> s->block_max_depth;
2072     int block_w    = plane_index ? block_size/2 : block_size;
2073     const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
2074     int obmc_stride= plane_index ? block_size : 2*block_size;
2075     int ref_stride= s->current_picture.linesize[plane_index];
2076     uint8_t *dst8= s->current_picture.data[plane_index];
2077     int w= p->width;
2078     int h= p->height;
2079
2080     if(s->keyframe || (s->avctx->debug&512)){
2081         if(mb_y==mb_h)
2082             return;
2083
2084         if(add){
2085             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
2086 //                DWTELEM * line = slice_buffer_get_line(sb, y);
2087                 IDWTELEM * line = sb->line[y];
2088                 for(x=0; x<w; x++){
2089 //                    int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
2090                     int v= line[x] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
2091                     v >>= FRAC_BITS;
2092                     if(v&(~255)) v= ~(v>>31);
2093                     dst8[x + y*ref_stride]= v;
2094                 }
2095             }
2096         }else{
2097             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
2098 //                DWTELEM * line = slice_buffer_get_line(sb, y);
2099                 IDWTELEM * line = sb->line[y];
2100                 for(x=0; x<w; x++){
2101                     line[x] -= 128 << FRAC_BITS;
2102 //                    buf[x + y*w]-= 128<<FRAC_BITS;
2103                 }
2104             }
2105         }
2106
2107         return;
2108     }
2109
2110     for(mb_x=0; mb_x<=mb_w; mb_x++){
2111         add_yblock(s, 1, sb, old_buffer, dst8, obmc,
2112                    block_w*mb_x - block_w/2,
2113                    block_w*mb_y - block_w/2,
2114                    block_w, block_w,
2115                    w, h,
2116                    w, ref_stride, obmc_stride,
2117                    mb_x - 1, mb_y - 1,
2118                    add, 0, plane_index);
2119     }
2120 }
2121
2122 static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y){
2123     Plane *p= &s->plane[plane_index];
2124     const int mb_w= s->b_width  << s->block_max_depth;
2125     const int mb_h= s->b_height << s->block_max_depth;
2126     int x, y, mb_x;
2127     int block_size = MB_SIZE >> s->block_max_depth;
2128     int block_w    = plane_index ? block_size/2 : block_size;
2129     const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
2130     const int obmc_stride= plane_index ? block_size : 2*block_size;
2131     int ref_stride= s->current_picture.linesize[plane_index];
2132     uint8_t *dst8= s->current_picture.data[plane_index];
2133     int w= p->width;
2134     int h= p->height;
2135
2136     if(s->keyframe || (s->avctx->debug&512)){
2137         if(mb_y==mb_h)
2138             return;
2139
2140         if(add){
2141             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
2142                 for(x=0; x<w; x++){
2143                     int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
2144                     v >>= FRAC_BITS;
2145                     if(v&(~255)) v= ~(v>>31);
2146                     dst8[x + y*ref_stride]= v;
2147                 }
2148             }
2149         }else{
2150             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
2151                 for(x=0; x<w; x++){
2152                     buf[x + y*w]-= 128<<FRAC_BITS;
2153                 }
2154             }
2155         }
2156
2157         return;
2158     }
2159
2160     for(mb_x=0; mb_x<=mb_w; mb_x++){
2161         add_yblock(s, 0, NULL, buf, dst8, obmc,
2162                    block_w*mb_x - block_w/2,
2163                    block_w*mb_y - block_w/2,
2164                    block_w, block_w,
2165                    w, h,
2166                    w, ref_stride, obmc_stride,
2167                    mb_x - 1, mb_y - 1,
2168                    add, 1, plane_index);
2169     }
2170 }
2171
2172 static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add){
2173     const int mb_h= s->b_height << s->block_max_depth;
2174     int mb_y;
2175     for(mb_y=0; mb_y<=mb_h; mb_y++)
2176         predict_slice(s, buf, plane_index, add, mb_y);
2177 }
2178
2179 static void dequantize_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, IDWTELEM *src, int stride, int start_y, int end_y){
2180     const int w= b->width;
2181     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
2182     const int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
2183     const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
2184     int x,y;
2185
2186     if(s->qlog == LOSSLESS_QLOG) return;
2187
2188     for(y=start_y; y<end_y; y++){
2189 //        DWTELEM * line = slice_buffer_get_line_from_address(sb, src + (y * stride));
2190         IDWTELEM * line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
2191         for(x=0; x<w; x++){
2192             int i= line[x];
2193             if(i<0){
2194                 line[x]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
2195             }else if(i>0){
2196                 line[x]=  (( i*qmul + qadd)>>(QEXPSHIFT));
2197             }
2198         }
2199     }
2200 }
2201
2202 static void correlate_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median, int start_y, int end_y){
2203     const int w= b->width;
2204     int x,y;
2205
2206     IDWTELEM * line=0; // silence silly "could be used without having been initialized" warning
2207     IDWTELEM * prev;
2208
2209     if (start_y != 0)
2210         line = slice_buffer_get_line(sb, ((start_y - 1) * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
2211
2212     for(y=start_y; y<end_y; y++){
2213         prev = line;
2214 //        line = slice_buffer_get_line_from_address(sb, src + (y * stride));
2215         line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
2216         for(x=0; x<w; x++){
2217             if(x){
2218                 if(use_median){
2219                     if(y && x+1<w) line[x] += mid_pred(line[x - 1], prev[x], prev[x + 1]);
2220                     else  line[x] += line[x - 1];
2221                 }else{
2222                     if(y) line[x] += mid_pred(line[x - 1], prev[x], line[x - 1] + prev[x] - prev[x - 1]);
2223                     else  line[x] += line[x - 1];
2224                 }
2225             }else{
2226                 if(y) line[x] += prev[x];
2227             }
2228         }
2229     }
2230 }
2231
2232 static void decode_qlogs(SnowContext *s){
2233     int plane_index, level, orientation;
2234
2235     for(plane_index=0; plane_index<3; plane_index++){
2236         for(level=0; level<s->spatial_decomposition_count; level++){
2237             for(orientation=level ? 1:0; orientation<4; orientation++){
2238                 int q;
2239                 if     (plane_index==2) q= s->plane[1].band[level][orientation].qlog;
2240                 else if(orientation==2) q= s->plane[plane_index].band[level][1].qlog;
2241                 else                    q= get_symbol(&s->c, s->header_state, 1);
2242                 s->plane[plane_index].band[level][orientation].qlog= q;
2243             }
2244         }
2245     }
2246 }
2247
2248 #define GET_S(dst, check) \
2249     tmp= get_symbol(&s->c, s->header_state, 0);\
2250     if(!(check)){\
2251         av_log(s->avctx, AV_LOG_ERROR, "Error " #dst " is %d\n", tmp);\
2252         return -1;\
2253     }\
2254     dst= tmp;
2255
2256 static int decode_header(SnowContext *s){
2257     int plane_index, tmp;
2258     uint8_t kstate[32];
2259
2260     memset(kstate, MID_STATE, sizeof(kstate));
2261
2262     s->keyframe= get_rac(&s->c, kstate);
2263     if(s->keyframe || s->always_reset){
2264         reset_contexts(s);
2265         s->spatial_decomposition_type=
2266         s->qlog=
2267         s->qbias=
2268         s->mv_scale=
2269         s->block_max_depth= 0;
2270     }
2271     if(s->keyframe){
2272         GET_S(s->version, tmp <= 0U)
2273         s->always_reset= get_rac(&s->c, s->header_state);
2274         s->temporal_decomposition_type= get_symbol(&s->c, s->header_state, 0);
2275         s->temporal_decomposition_count= get_symbol(&s->c, s->header_state, 0);
2276         GET_S(s->spatial_decomposition_count, 0 < tmp && tmp <= MAX_DECOMPOSITIONS)
2277         s->colorspace_type= get_symbol(&s->c, s->header_state, 0);
2278         s->chroma_h_shift= get_symbol(&s->c, s->header_state, 0);
2279         s->chroma_v_shift= get_symbol(&s->c, s->header_state, 0);
2280         s->spatial_scalability= get_rac(&s->c, s->header_state);
2281 //        s->rate_scalability= get_rac(&s->c, s->header_state);
2282         GET_S(s->max_ref_frames, tmp < (unsigned)MAX_REF_FRAMES)
2283         s->max_ref_frames++;
2284
2285         decode_qlogs(s);
2286     }
2287
2288     if(!s->keyframe){
2289         if(get_rac(&s->c, s->header_state)){
2290             for(plane_index=0; plane_index<2; plane_index++){
2291                 int htaps, i, sum=0;
2292                 Plane *p= &s->plane[plane_index];
2293                 p->diag_mc= get_rac(&s->c, s->header_state);
2294                 htaps= get_symbol(&s->c, s->header_state, 0)*2 + 2;
2295                 if((unsigned)htaps > HTAPS_MAX || htaps==0)
2296                     return -1;
2297                 p->htaps= htaps;
2298                 for(i= htaps/2; i; i--){
2299                     p->hcoeff[i]= get_symbol(&s->c, s->header_state, 0) * (1-2*(i&1));
2300                     sum += p->hcoeff[i];
2301                 }
2302                 p->hcoeff[0]= 32-sum;
2303             }
2304             s->plane[2].diag_mc= s->plane[1].diag_mc;
2305             s->plane[2].htaps  = s->plane[1].htaps;
2306             memcpy(s->plane[2].hcoeff, s->plane[1].hcoeff, sizeof(s->plane[1].hcoeff));
2307         }
2308         if(get_rac(&s->c, s->header_state)){
2309             GET_S(s->spatial_decomposition_count, 0 < tmp && tmp <= MAX_DECOMPOSITIONS)
2310             decode_qlogs(s);
2311         }
2312     }
2313
2314     s->spatial_decomposition_type+= get_symbol(&s->c, s->header_state, 1);
2315     if(s->spatial_decomposition_type > 1U){
2316         av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_type %d not supported", s->spatial_decomposition_type);
2317         return -1;
2318     }
2319     if(FFMIN(s->avctx-> width>>s->chroma_h_shift,
2320              s->avctx->height>>s->chroma_v_shift) >> (s->spatial_decomposition_count-1) <= 0){
2321         av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_count %d too large for size", s->spatial_decomposition_count);
2322         return -1;
2323     }
2324
2325     s->qlog           += get_symbol(&s->c, s->header_state, 1);
2326     s->mv_scale       += get_symbol(&s->c, s->header_state, 1);
2327     s->qbias          += get_symbol(&s->c, s->header_state, 1);
2328     s->block_max_depth+= get_symbol(&s->c, s->header_state, 1);
2329     if(s->block_max_depth > 1 || s->block_max_depth < 0){
2330         av_log(s->avctx, AV_LOG_ERROR, "block_max_depth= %d is too large", s->block_max_depth);
2331         s->block_max_depth= 0;
2332         return -1;
2333     }
2334
2335     return 0;
2336 }
2337
2338 static void init_qexp(void){
2339     int i;
2340     double v=128;
2341
2342     for(i=0; i<QROOT; i++){
2343         qexp[i]= lrintf(v);
2344         v *= pow(2, 1.0 / QROOT);
2345     }
2346 }
2347
2348 static av_cold int common_init(AVCodecContext *avctx){
2349     SnowContext *s = avctx->priv_data;
2350     int width, height;
2351     int i, j;
2352
2353     s->avctx= avctx;
2354     s->max_ref_frames=1; //just make sure its not an invalid value in case of no initial keyframe
2355
2356     dsputil_init(&s->dsp, avctx);
2357
2358 #define mcf(dx,dy)\
2359     s->dsp.put_qpel_pixels_tab       [0][dy+dx/4]=\
2360     s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
2361         s->dsp.put_h264_qpel_pixels_tab[0][dy+dx/4];\
2362     s->dsp.put_qpel_pixels_tab       [1][dy+dx/4]=\
2363     s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
2364         s->dsp.put_h264_qpel_pixels_tab[1][dy+dx/4];
2365
2366     mcf( 0, 0)
2367     mcf( 4, 0)
2368     mcf( 8, 0)
2369     mcf(12, 0)
2370     mcf( 0, 4)
2371     mcf( 4, 4)
2372     mcf( 8, 4)
2373     mcf(12, 4)
2374     mcf( 0, 8)
2375     mcf( 4, 8)
2376     mcf( 8, 8)
2377     mcf(12, 8)
2378     mcf( 0,12)
2379     mcf( 4,12)
2380     mcf( 8,12)
2381     mcf(12,12)
2382
2383 #define mcfh(dx,dy)\
2384     s->dsp.put_pixels_tab       [0][dy/4+dx/8]=\
2385     s->dsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
2386         mc_block_hpel ## dx ## dy ## 16;\
2387     s->dsp.put_pixels_tab       [1][dy/4+dx/8]=\
2388     s->dsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
2389         mc_block_hpel ## dx ## dy ## 8;
2390
2391     mcfh(0, 0)
2392     mcfh(8, 0)
2393     mcfh(0, 8)
2394     mcfh(8, 8)
2395
2396     if(!qexp[0])
2397         init_qexp();
2398
2399 //    dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
2400
2401     width= s->avctx->width;
2402     height= s->avctx->height;
2403
2404     s->spatial_idwt_buffer= av_mallocz(width*height*sizeof(IDWTELEM));
2405     s->spatial_dwt_buffer= av_mallocz(width*height*sizeof(DWTELEM)); //FIXME this does not belong here
2406
2407     for(i=0; i<MAX_REF_FRAMES; i++)
2408         for(j=0; j<MAX_REF_FRAMES; j++)
2409             scale_mv_ref[i][j] = 256*(i+1)/(j+1);
2410
2411     s->avctx->get_buffer(s->avctx, &s->mconly_picture);
2412     s->scratchbuf = av_malloc(s->mconly_picture.linesize[0]*7*MB_SIZE);
2413
2414     return 0;
2415 }
2416
2417 static int common_init_after_header(AVCodecContext *avctx){
2418     SnowContext *s = avctx->priv_data;
2419     int plane_index, level, orientation;
2420
2421     for(plane_index=0; plane_index<3; plane_index++){
2422         int w= s->avctx->width;
2423         int h= s->avctx->height;
2424
2425         if(plane_index){
2426             w>>= s->chroma_h_shift;
2427             h>>= s->chroma_v_shift;
2428         }
2429         s->plane[plane_index].width = w;
2430         s->plane[plane_index].height= h;
2431
2432         for(level=s->spatial_decomposition_count-1; level>=0; level--){
2433             for(orientation=level ? 1 : 0; orientation<4; orientation++){
2434                 SubBand *b= &s->plane[plane_index].band[level][orientation];
2435
2436                 b->buf= s->spatial_dwt_buffer;
2437                 b->level= level;
2438                 b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
2439                 b->width = (w + !(orientation&1))>>1;
2440                 b->height= (h + !(orientation>1))>>1;
2441
2442                 b->stride_line = 1 << (s->spatial_decomposition_count - level);
2443                 b->buf_x_offset = 0;
2444                 b->buf_y_offset = 0;
2445
2446                 if(orientation&1){
2447                     b->buf += (w+1)>>1;
2448                     b->buf_x_offset = (w+1)>>1;
2449                 }
2450                 if(orientation>1){
2451                     b->buf += b->stride>>1;
2452                     b->buf_y_offset = b->stride_line >> 1;
2453                 }
2454                 b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
2455
2456                 if(level)
2457                     b->parent= &s->plane[plane_index].band[level-1][orientation];
2458                 //FIXME avoid this realloc
2459                 av_freep(&b->x_coeff);
2460                 b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
2461             }
2462             w= (w+1)>>1;
2463             h= (h+1)>>1;
2464         }
2465     }
2466
2467     return 0;
2468 }
2469
2470 #define QUANTIZE2 0
2471
2472 #if QUANTIZE2==1
2473 #define Q2_STEP 8
2474
2475 static void find_sse(SnowContext *s, Plane *p, int *score, int score_stride, IDWTELEM *r0, IDWTELEM *r1, int level, int orientation){
2476     SubBand *b= &p->band[level][orientation];
2477     int x, y;
2478     int xo=0;
2479     int yo=0;
2480     int step= 1 << (s->spatial_decomposition_count - level);
2481
2482     if(orientation&1)
2483         xo= step>>1;
2484     if(orientation&2)
2485         yo= step>>1;
2486
2487     //FIXME bias for nonzero ?
2488     //FIXME optimize
2489     memset(score, 0, sizeof(*score)*score_stride*((p->height + Q2_STEP-1)/Q2_STEP));
2490     for(y=0; y<p->height; y++){
2491         for(x=0; x<p->width; x++){
2492             int sx= (x-xo + step/2) / step / Q2_STEP;
2493             int sy= (y-yo + step/2) / step / Q2_STEP;
2494             int v= r0[x + y*p->width] - r1[x + y*p->width];
2495             assert(sx>=0 && sy>=0 && sx < score_stride);
2496             v= ((v+8)>>4)<<4;
2497             score[sx + sy*score_stride] += v*v;
2498             assert(score[sx + sy*score_stride] >= 0);
2499         }
2500     }
2501 }
2502
2503 static void dequantize_all(SnowContext *s, Plane *p, IDWTELEM *buffer, int width, int height){
2504     int level, orientation;
2505
2506     for(level=0; level<s->spatial_decomposition_count; level++){
2507         for(orientation=level ? 1 : 0; orientation<4; orientation++){
2508             SubBand *b= &p->band[level][orientation];
2509             IDWTELEM *dst= buffer + (b->ibuf - s->spatial_idwt_buffer);
2510
2511             dequantize(s, b, dst, b->stride);
2512         }
2513     }
2514 }
2515
2516 static void dwt_quantize(SnowContext *s, Plane *p, DWTELEM *buffer, int width, int height, int stride, int type){
2517     int level, orientation, ys, xs, x, y, pass;
2518     IDWTELEM best_dequant[height * stride];
2519     IDWTELEM idwt2_buffer[height * stride];
2520     const int score_stride= (width + 10)/Q2_STEP;
2521     int best_score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP]; //FIXME size
2522     int score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP]; //FIXME size
2523     int threshold= (s->m.lambda * s->m.lambda) >> 6;
2524
2525     //FIXME pass the copy cleanly ?
2526
2527 //    memcpy(dwt_buffer, buffer, height * stride * sizeof(DWTELEM));
2528     ff_spatial_dwt(buffer, width, height, stride, type, s->spatial_decomposition_count);
2529
2530     for(level=0; level<s->spatial_decomposition_count; level++){
2531         for(orientation=level ? 1 : 0; orientation<4; orientation++){
2532             SubBand *b= &p->band[level][orientation];
2533             IDWTELEM *dst= best_dequant + (b->ibuf - s->spatial_idwt_buffer);
2534              DWTELEM *src=       buffer + (b-> buf - s->spatial_dwt_buffer);
2535             assert(src == b->buf); // code does not depend on this but it is true currently
2536
2537             quantize(s, b, dst, src, b->stride, s->qbias);
2538         }
2539     }
2540     for(pass=0; pass<1; pass++){
2541         if(s->qbias == 0) //keyframe
2542             continue;
2543         for(level=0; level<s->spatial_decomposition_count; level++){
2544             for(orientation=level ? 1 : 0; orientation<4; orientation++){
2545                 SubBand *b= &p->band[level][orientation];
2546                 IDWTELEM *dst= idwt2_buffer + (b->ibuf - s->spatial_idwt_buffer);
2547                 IDWTELEM *best_dst= best_dequant + (b->ibuf - s->spatial_idwt_buffer);
2548
2549                 for(ys= 0; ys<Q2_STEP; ys++){
2550                     for(xs= 0; xs<Q2_STEP; xs++){
2551                         memcpy(idwt2_buffer, best_dequant, height * stride * sizeof(IDWTELEM));
2552                         dequantize_all(s, p, idwt2_buffer, width, height);
2553                         ff_spatial_idwt(idwt2_buffer, width, height, stride, type, s->spatial_decomposition_count);
2554                         find_sse(s, p, best_score, score_stride, idwt2_buffer, s->spatial_idwt_buffer, level, orientation);
2555                         memcpy(idwt2_buffer, best_dequant, height * stride * sizeof(IDWTELEM));
2556                         for(y=ys; y<b->height; y+= Q2_STEP){
2557                             for(x=xs; x<b->width; x+= Q2_STEP){
2558                                 if(dst[x + y*b->stride]<0) dst[x + y*b->stride]++;
2559                                 if(dst[x + y*b->stride]>0) dst[x + y*b->stride]--;
2560                                 //FIXME try more than just --
2561                             }
2562                         }
2563                         dequantize_all(s, p, idwt2_buffer, width, height);
2564                         ff_spatial_idwt(idwt2_buffer, width, height, stride, type, s->spatial_decomposition_count);
2565                         find_sse(s, p, score, score_stride, idwt2_buffer, s->spatial_idwt_buffer, level, orientation);
2566                         for(y=ys; y<b->height; y+= Q2_STEP){
2567                             for(x=xs; x<b->width; x+= Q2_STEP){
2568                                 int score_idx= x/Q2_STEP + (y/Q2_STEP)*score_stride;
2569                                 if(score[score_idx] <= best_score[score_idx] + threshold){
2570                                     best_score[score_idx]= score[score_idx];
2571                                     if(best_dst[x + y*b->stride]<0) best_dst[x + y*b->stride]++;
2572                                     if(best_dst[x + y*b->stride]>0) best_dst[x + y*b->stride]--;
2573                                     //FIXME copy instead
2574                                 }
2575                             }
2576                         }
2577                     }
2578                 }
2579             }
2580         }
2581     }
2582     memcpy(s->spatial_idwt_buffer, best_dequant, height * stride * sizeof(IDWTELEM)); //FIXME work with that directly instead of copy at the end
2583 }
2584
2585 #endif /* QUANTIZE2==1 */
2586
2587 #define USE_HALFPEL_PLANE 0
2588
2589 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
2590     int p,x,y;
2591
2592     assert(!(s->avctx->flags & CODEC_FLAG_EMU_EDGE));
2593
2594     for(p=0; p<3; p++){
2595         int is_chroma= !!p;
2596         int w= s->avctx->width  >>is_chroma;
2597         int h= s->avctx->height >>is_chroma;
2598         int ls= frame->linesize[p];
2599         uint8_t *src= frame->data[p];
2600
2601         halfpel[1][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
2602         halfpel[2][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
2603         halfpel[3][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
2604
2605         halfpel[0][p]= src;
2606         for(y=0; y<h; y++){
2607             for(x=0; x<w; x++){
2608                 int i= y*ls + x;
2609
2610                 halfpel[1][p][i]= (20*(src[i] + src[i+1]) - 5*(src[i-1] + src[i+2]) + (src[i-2] + src[i+3]) + 16 )>>5;
2611             }
2612         }
2613         for(y=0; y<h; y++){
2614             for(x=0; x<w; x++){
2615                 int i= y*ls + x;
2616
2617                 halfpel[2][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
2618             }
2619         }
2620         src= halfpel[1][p];
2621         for(y=0; y<h; y++){
2622             for(x=0; x<w; x++){
2623                 int i= y*ls + x;
2624
2625                 halfpel[3][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
2626             }
2627         }
2628
2629 //FIXME border!
2630     }
2631 }
2632
2633 static void release_buffer(AVCodecContext *avctx){
2634     SnowContext *s = avctx->priv_data;
2635     int i;
2636
2637     if(s->last_picture[s->max_ref_frames-1].data[0]){
2638         avctx->release_buffer(avctx, &s->last_picture[s->max_ref_frames-1]);
2639         for(i=0; i<9; i++)
2640             if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
2641                 av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture.linesize[i%3]));
2642     }
2643 }
2644
2645 static int frame_start(SnowContext *s){
2646    AVFrame tmp;
2647    int w= s->avctx->width; //FIXME round up to x16 ?
2648    int h= s->avctx->height;
2649
2650     if(s->current_picture.data[0]){
2651         s->dsp.draw_edges(s->current_picture.data[0], s->current_picture.linesize[0], w   , h   , EDGE_WIDTH  );
2652         s->dsp.draw_edges(s->current_picture.data[1], s->current_picture.linesize[1], w>>1, h>>1, EDGE_WIDTH/2);
2653         s->dsp.draw_edges(s->current_picture.data[2], s->current_picture.linesize[2], w>>1, h>>1, EDGE_WIDTH/2);
2654     }
2655
2656     release_buffer(s->avctx);
2657
2658     tmp= s->last_picture[s->max_ref_frames-1];
2659     memmove(s->last_picture+1, s->last_picture, (s->max_ref_frames-1)*sizeof(AVFrame));
2660     memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
2661     if(USE_HALFPEL_PLANE && s->current_picture.data[0])
2662         halfpel_interpol(s, s->halfpel_plane[0], &s->current_picture);
2663     s->last_picture[0]= s->current_picture;
2664     s->current_picture= tmp;
2665
2666     if(s->keyframe){
2667         s->ref_frames= 0;
2668     }else{
2669         int i;
2670         for(i=0; i<s->max_ref_frames && s->last_picture[i].data[0]; i++)
2671             if(i && s->last_picture[i-1].key_frame)
2672                 break;
2673         s->ref_frames= i;
2674         if(s->ref_frames==0){
2675             av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
2676             return -1;
2677         }
2678     }
2679
2680     s->current_picture.reference= 1;
2681     if(s->avctx->get_buffer(s->avctx, &s->current_picture) < 0){
2682         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2683         return -1;
2684     }
2685
2686     s->current_picture.key_frame= s->keyframe;
2687
2688     return 0;
2689 }
2690
2691 static av_cold void common_end(SnowContext *s){
2692     int plane_index, level, orientation, i;
2693
2694     av_freep(&s->spatial_dwt_buffer);
2695     av_freep(&s->spatial_idwt_buffer);
2696
2697     s->m.me.temp= NULL;
2698     av_freep(&s->m.me.scratchpad);