Remove unused functions, fixes the warnings:
[ffmpeg.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
27 #include "mpegvideo.h"
28
29 #undef NDEBUG
30 #include <assert.h>
31
32 static const int8_t quant3[256]={
33  0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
34  1, 1, 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, 0,
49 };
50 static const int8_t quant3b[256]={
51  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
52  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
53  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
54  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
55  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
56  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
57  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 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 };
68 static const int8_t quant3bA[256]={
69  0, 0, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
70  1,-1, 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 };
86 static const int8_t quant5[256]={
87  0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
88  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
89  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
90  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
91  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
92  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
93  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-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,-1,-1,-1,
103 };
104 static const int8_t quant7[256]={
105  0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
107  2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
108  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
109  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
110  3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
111  3, 3, 3, 3, 3, 3, 3, 3, 3, 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,-2,-2,-2,-2,-2,-2,-2,
119 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
120 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
121 };
122 static const int8_t quant9[256]={
123  0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
124  3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
125  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
126  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
127  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
128  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
129  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
130  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 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,-3,-3,-3,-3,
138 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
139 };
140 static const int8_t quant11[256]={
141  0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
142  4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
143  4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
144  5, 5, 5, 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,-4,-4,
155 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
156 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
157 };
158 static const int8_t quant13[256]={
159  0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
160  4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
161  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
162  5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
163  6, 6, 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,-5,
172 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
173 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
174 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
175 };
176
177 #if 0 //64*cubic
178 static const uint8_t obmc32[1024]={
179   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,
180   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,
181   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,
182   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,
183   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,
184   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,
185   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,
186   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,
187   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,
188   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,
189   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,
190   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,
191   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,
192   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,
193   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,
194   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,
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   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,
197   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,
198   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,
199   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,
200   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,
201   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,
202   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,
203   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,
204   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,
205   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,
206   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,
207   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,
208   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,
209   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,
210   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,
211 //error:0.000022
212 };
213 static const uint8_t obmc16[256]={
214   0,  0,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  0,  0,
215   0,  4,  4,  8, 16, 20, 20, 24, 24, 20, 20, 16,  8,  4,  4,  0,
216   0,  4, 16, 24, 36, 44, 52, 60, 60, 52, 44, 36, 24, 16,  4,  0,
217   0,  8, 24, 44, 60, 80, 96,104,104, 96, 80, 60, 44, 24,  8,  0,
218   0, 16, 36, 60, 92,116,136,152,152,136,116, 92, 60, 36, 16,  0,
219   0, 20, 44, 80,116,152,180,196,196,180,152,116, 80, 44, 20,  0,
220   4, 20, 52, 96,136,180,212,228,228,212,180,136, 96, 52, 20,  4,
221   4, 24, 60,104,152,196,228,248,248,228,196,152,104, 60, 24,  4,
222   4, 24, 60,104,152,196,228,248,248,228,196,152,104, 60, 24,  4,
223   4, 20, 52, 96,136,180,212,228,228,212,180,136, 96, 52, 20,  4,
224   0, 20, 44, 80,116,152,180,196,196,180,152,116, 80, 44, 20,  0,
225   0, 16, 36, 60, 92,116,136,152,152,136,116, 92, 60, 36, 16,  0,
226   0,  8, 24, 44, 60, 80, 96,104,104, 96, 80, 60, 44, 24,  8,  0,
227   0,  4, 16, 24, 36, 44, 52, 60, 60, 52, 44, 36, 24, 16,  4,  0,
228   0,  4,  4,  8, 16, 20, 20, 24, 24, 20, 20, 16,  8,  4,  4,  0,
229   0,  0,  0,  0,  0,  0,  4,  4,  4,  4,  0,  0,  0,  0,  0,  0,
230 //error:0.000033
231 };
232 #elif 1 // 64*linear
233 static const uint8_t obmc32[1024]={
234   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,
235   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,
236   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,
237   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,
238   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,
239   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,
240   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,
241   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,
242   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,
243   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,
244   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,
245   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,
246   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,
247   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,
248   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,
249   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,
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, 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,
252   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,
253   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,
254   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,
255   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,
256   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,
257   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,
258   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,
259   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,
260   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,
261   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,
262   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,
263   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,
264   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,
265   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,
266  //error:0.000020
267 };
268 static const uint8_t obmc16[256]={
269   0,  4,  4,  8,  8, 12, 12, 16, 16, 12, 12,  8,  8,  4,  4,  0,
270   4,  8, 16, 20, 28, 32, 40, 44, 44, 40, 32, 28, 20, 16,  8,  4,
271   4, 16, 24, 36, 44, 56, 64, 76, 76, 64, 56, 44, 36, 24, 16,  4,
272   8, 20, 36, 48, 64, 76, 92,104,104, 92, 76, 64, 48, 36, 20,  8,
273   8, 28, 44, 64, 80,100,116,136,136,116,100, 80, 64, 44, 28,  8,
274  12, 32, 56, 76,100,120,144,164,164,144,120,100, 76, 56, 32, 12,
275  12, 40, 64, 92,116,144,168,196,196,168,144,116, 92, 64, 40, 12,
276  16, 44, 76,104,136,164,196,224,224,196,164,136,104, 76, 44, 16,
277  16, 44, 76,104,136,164,196,224,224,196,164,136,104, 76, 44, 16,
278  12, 40, 64, 92,116,144,168,196,196,168,144,116, 92, 64, 40, 12,
279  12, 32, 56, 76,100,120,144,164,164,144,120,100, 76, 56, 32, 12,
280   8, 28, 44, 64, 80,100,116,136,136,116,100, 80, 64, 44, 28,  8,
281   8, 20, 36, 48, 64, 76, 92,104,104, 92, 76, 64, 48, 36, 20,  8,
282   4, 16, 24, 36, 44, 56, 64, 76, 76, 64, 56, 44, 36, 24, 16,  4,
283   4,  8, 16, 20, 28, 32, 40, 44, 44, 40, 32, 28, 20, 16,  8,  4,
284   0,  4,  4,  8,  8, 12, 12, 16, 16, 12, 12,  8,  8,  4,  4,  0,
285 //error:0.000015
286 };
287 #else //64*cos
288 static const uint8_t obmc32[1024]={
289   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,
290   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,
291   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,
292   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,
293   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,
294   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,
295   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,
296   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,
297   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,
298   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,
299   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,
300   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,
301   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,
302   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,
303   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,
304   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,
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   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,
307   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,
308   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,
309   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,
310   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,
311   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,
312   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,
313   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,
314   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,
315   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,
316   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,
317   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,
318   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,
319   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,
320   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,
321 //error:0.000022
322 };
323 static const uint8_t obmc16[256]={
324   0,  0,  0,  0,  0,  4,  4,  4,  4,  4,  4,  0,  0,  0,  0,  0,
325   0,  0,  4,  8, 12, 16, 20, 20, 20, 20, 16, 12,  8,  4,  0,  0,
326   0,  4, 12, 24, 32, 44, 52, 56, 56, 52, 44, 32, 24, 12,  4,  0,
327   0,  8, 24, 40, 60, 80, 96,104,104, 96, 80, 60, 40, 24,  8,  0,
328   0, 12, 32, 64, 92,120,140,152,152,140,120, 92, 64, 32, 12,  0,
329   4, 16, 44, 80,120,156,184,196,196,184,156,120, 80, 44, 16,  4,
330   4, 20, 52, 96,140,184,216,232,232,216,184,140, 96, 52, 20,  4,
331   0, 20, 56,104,152,196,232,252,252,232,196,152,104, 56, 20,  0,
332   0, 20, 56,104,152,196,232,252,252,232,196,152,104, 56, 20,  0,
333   4, 20, 52, 96,140,184,216,232,232,216,184,140, 96, 52, 20,  4,
334   4, 16, 44, 80,120,156,184,196,196,184,156,120, 80, 44, 16,  4,
335   0, 12, 32, 64, 92,120,140,152,152,140,120, 92, 64, 32, 12,  0,
336   0,  8, 24, 40, 60, 80, 96,104,104, 96, 80, 60, 40, 24,  8,  0,
337   0,  4, 12, 24, 32, 44, 52, 56, 56, 52, 44, 32, 24, 12,  4,  0,
338   0,  0,  4,  8, 12, 16, 20, 20, 20, 20, 16, 12,  8,  4,  0,  0,
339   0,  0,  0,  0,  0,  4,  4,  4,  4,  4,  4,  0,  0,  0,  0,  0,
340 //error:0.000022
341 };
342 #endif /* 0 */
343
344 //linear *64
345 static const uint8_t obmc8[64]={
346   4, 12, 20, 28, 28, 20, 12,  4,
347  12, 36, 60, 84, 84, 60, 36, 12,
348  20, 60,100,140,140,100, 60, 20,
349  28, 84,140,196,196,140, 84, 28,
350  28, 84,140,196,196,140, 84, 28,
351  20, 60,100,140,140,100, 60, 20,
352  12, 36, 60, 84, 84, 60, 36, 12,
353   4, 12, 20, 28, 28, 20, 12,  4,
354 //error:0.000000
355 };
356
357 //linear *64
358 static const uint8_t obmc4[16]={
359  16, 48, 48, 16,
360  48,144,144, 48,
361  48,144,144, 48,
362  16, 48, 48, 16,
363 //error:0.000000
364 };
365
366 static const uint8_t *obmc_tab[4]={
367     obmc32, obmc16, obmc8, obmc4
368 };
369
370 static int scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES];
371
372 typedef struct BlockNode{
373     int16_t mx;
374     int16_t my;
375     uint8_t ref;
376     uint8_t color[3];
377     uint8_t type;
378 //#define TYPE_SPLIT    1
379 #define BLOCK_INTRA   1
380 #define BLOCK_OPT     2
381 //#define TYPE_NOCOLOR  4
382     uint8_t level; //FIXME merge into type?
383 }BlockNode;
384
385 static const BlockNode null_block= { //FIXME add border maybe
386     .color= {128,128,128},
387     .mx= 0,
388     .my= 0,
389     .ref= 0,
390     .type= 0,
391     .level= 0,
392 };
393
394 #define LOG2_MB_SIZE 4
395 #define MB_SIZE (1<<LOG2_MB_SIZE)
396 #define ENCODER_EXTRA_BITS 4
397 #define HTAPS_MAX 8
398
399 typedef struct x_and_coeff{
400     int16_t x;
401     uint16_t coeff;
402 } x_and_coeff;
403
404 typedef struct SubBand{
405     int level;
406     int stride;
407     int width;
408     int height;
409     int qlog;                                   ///< log(qscale)/log[2^(1/6)]
410     DWTELEM *buf;
411     IDWTELEM *ibuf;
412     int buf_x_offset;
413     int buf_y_offset;
414     int stride_line; ///< Stride measured in lines, not pixels.
415     x_and_coeff * x_coeff;
416     struct SubBand *parent;
417     uint8_t state[/*7*2*/ 7 + 512][32];
418 }SubBand;
419
420 typedef struct Plane{
421     int width;
422     int height;
423     SubBand band[MAX_DECOMPOSITIONS][4];
424
425     int htaps;
426     int8_t hcoeff[HTAPS_MAX/2];
427     int diag_mc;
428     int fast_mc;
429
430     int last_htaps;
431     int8_t last_hcoeff[HTAPS_MAX/2];
432     int last_diag_mc;
433 }Plane;
434
435 typedef struct SnowContext{
436 //    MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to make the motion estimation eventually independent of MpegEncContext, so this will be removed then (FIXME/XXX)
437
438     AVCodecContext *avctx;
439     RangeCoder c;
440     DSPContext dsp;
441     AVFrame new_picture;
442     AVFrame input_picture;              ///< new_picture with the internal linesizes
443     AVFrame current_picture;
444     AVFrame last_picture[MAX_REF_FRAMES];
445     uint8_t *halfpel_plane[MAX_REF_FRAMES][4][4];
446     AVFrame mconly_picture;
447 //     uint8_t q_context[16];
448     uint8_t header_state[32];
449     uint8_t block_state[128 + 32*128];
450     int keyframe;
451     int always_reset;
452     int version;
453     int spatial_decomposition_type;
454     int last_spatial_decomposition_type;
455     int temporal_decomposition_type;
456     int spatial_decomposition_count;
457     int last_spatial_decomposition_count;
458     int temporal_decomposition_count;
459     int max_ref_frames;
460     int ref_frames;
461     int16_t (*ref_mvs[MAX_REF_FRAMES])[2];
462     uint32_t *ref_scores[MAX_REF_FRAMES];
463     DWTELEM *spatial_dwt_buffer;
464     IDWTELEM *spatial_idwt_buffer;
465     int colorspace_type;
466     int chroma_h_shift;
467     int chroma_v_shift;
468     int spatial_scalability;
469     int qlog;
470     int last_qlog;
471     int lambda;
472     int lambda2;
473     int pass1_rc;
474     int mv_scale;
475     int last_mv_scale;
476     int qbias;
477     int last_qbias;
478 #define QBIAS_SHIFT 3
479     int b_width;
480     int b_height;
481     int block_max_depth;
482     int last_block_max_depth;
483     Plane plane[MAX_PLANES];
484     BlockNode *block;
485 #define ME_CACHE_SIZE 1024
486     int me_cache[ME_CACHE_SIZE];
487     int me_cache_generation;
488     slice_buffer sb;
489
490     MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to make the motion estimation eventually independent of MpegEncContext, so this will be removed then (FIXME/XXX)
491 }SnowContext;
492
493 typedef struct {
494     IDWTELEM *b0;
495     IDWTELEM *b1;
496     IDWTELEM *b2;
497     IDWTELEM *b3;
498     int y;
499 } dwt_compose_t;
500
501 #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)))
502 //#define slice_buffer_get_line(slice_buf, line_num) (slice_buffer_load_line((slice_buf), (line_num)))
503
504 static void iterative_me(SnowContext *s);
505
506 static void slice_buffer_init(slice_buffer * buf, int line_count, int max_allocated_lines, int line_width, IDWTELEM * base_buffer)
507 {
508     int i;
509
510     buf->base_buffer = base_buffer;
511     buf->line_count = line_count;
512     buf->line_width = line_width;
513     buf->data_count = max_allocated_lines;
514     buf->line = av_mallocz (sizeof(IDWTELEM *) * line_count);
515     buf->data_stack = av_malloc (sizeof(IDWTELEM *) * max_allocated_lines);
516
517     for (i = 0; i < max_allocated_lines; i++)
518     {
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     int offset;
528     IDWTELEM * buffer;
529
530 //  av_log(NULL, AV_LOG_DEBUG, "Cache hit: %d\n", line);
531
532     assert(buf->data_stack_top >= 0);
533 //  assert(!buf->line[line]);
534     if (buf->line[line])
535         return buf->line[line];
536
537     offset = buf->line_width * line;
538     buffer = buf->data_stack[buf->data_stack_top];
539     buf->data_stack_top--;
540     buf->line[line] = buffer;
541
542 //  av_log(NULL, AV_LOG_DEBUG, "slice_buffer_load_line: line: %d remaining: %d\n", line, buf->data_stack_top + 1);
543
544     return buffer;
545 }
546
547 static void slice_buffer_release(slice_buffer * buf, int line)
548 {
549     int offset;
550     IDWTELEM * buffer;
551
552     assert(line >= 0 && line < buf->line_count);
553     assert(buf->line[line]);
554
555     offset = buf->line_width * line;
556     buffer = buf->line[line];
557     buf->data_stack_top++;
558     buf->data_stack[buf->data_stack_top] = buffer;
559     buf->line[line] = NULL;
560
561 //  av_log(NULL, AV_LOG_DEBUG, "slice_buffer_release: line: %d remaining: %d\n", line, buf->data_stack_top + 1);
562 }
563
564 static void slice_buffer_flush(slice_buffer * buf)
565 {
566     int i;
567     for (i = 0; i < buf->line_count; i++)
568     {
569         if (buf->line[i])
570         {
571 //      av_log(NULL, AV_LOG_DEBUG, "slice_buffer_flush: line: %d \n", i);
572             slice_buffer_release(buf, i);
573         }
574     }
575 }
576
577 static void slice_buffer_destroy(slice_buffer * buf)
578 {
579     int i;
580     slice_buffer_flush(buf);
581
582     for (i = buf->data_count - 1; i >= 0; i--)
583     {
584         av_freep(&buf->data_stack[i]);
585     }
586     av_freep(&buf->data_stack);
587     av_freep(&buf->line);
588 }
589
590 #ifdef __sgi
591 // Avoid a name clash on SGI IRIX
592 #undef qexp
593 #endif
594 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
595 static uint8_t qexp[QROOT];
596
597 static inline int mirror(int v, int m){
598     while((unsigned)v > (unsigned)m){
599         v=-v;
600         if(v<0) v+= 2*m;
601     }
602     return v;
603 }
604
605 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
606     int i;
607
608     if(v){
609         const int a= FFABS(v);
610         const int e= av_log2(a);
611 #if 1
612         const int el= FFMIN(e, 10);
613         put_rac(c, state+0, 0);
614
615         for(i=0; i<el; i++){
616             put_rac(c, state+1+i, 1);  //1..10
617         }
618         for(; i<e; i++){
619             put_rac(c, state+1+9, 1);  //1..10
620         }
621         put_rac(c, state+1+FFMIN(i,9), 0);
622
623         for(i=e-1; i>=el; i--){
624             put_rac(c, state+22+9, (a>>i)&1); //22..31
625         }
626         for(; 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 + el, v < 0); //11..21
632 #else
633
634         put_rac(c, state+0, 0);
635         if(e<=9){
636             for(i=0; i<e; i++){
637                 put_rac(c, state+1+i, 1);  //1..10
638             }
639             put_rac(c, state+1+i, 0);
640
641             for(i=e-1; i>=0; i--){
642                 put_rac(c, state+22+i, (a>>i)&1); //22..31
643             }
644
645             if(is_signed)
646                 put_rac(c, state+11 + e, v < 0); //11..21
647         }else{
648             for(i=0; i<e; i++){
649                 put_rac(c, state+1+FFMIN(i,9), 1);  //1..10
650             }
651             put_rac(c, state+1+FFMIN(i,9), 0);
652
653             for(i=e-1; i>=0; i--){
654                 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
655             }
656
657             if(is_signed)
658                 put_rac(c, state+11 + FFMIN(e,10), v < 0); //11..21
659         }
660 #endif /* 1 */
661     }else{
662         put_rac(c, state+0, 1);
663     }
664 }
665
666 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
667     if(get_rac(c, state+0))
668         return 0;
669     else{
670         int i, e, a;
671         e= 0;
672         while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
673             e++;
674         }
675
676         a= 1;
677         for(i=e-1; i>=0; i--){
678             a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
679         }
680
681         if(is_signed && get_rac(c, state+11 + FFMIN(e,10))) //11..21
682             return -a;
683         else
684             return a;
685     }
686 }
687
688 static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2){
689     int i;
690     int r= log2>=0 ? 1<<log2 : 1;
691
692     assert(v>=0);
693     assert(log2>=-4);
694
695     while(v >= r){
696         put_rac(c, state+4+log2, 1);
697         v -= r;
698         log2++;
699         if(log2>0) r+=r;
700     }
701     put_rac(c, state+4+log2, 0);
702
703     for(i=log2-1; i>=0; i--){
704         put_rac(c, state+31-i, (v>>i)&1);
705     }
706 }
707
708 static inline int get_symbol2(RangeCoder *c, uint8_t *state, int log2){
709     int i;
710     int r= log2>=0 ? 1<<log2 : 1;
711     int v=0;
712
713     assert(log2>=-4);
714
715     while(get_rac(c, state+4+log2)){
716         v+= r;
717         log2++;
718         if(log2>0) r+=r;
719     }
720
721     for(i=log2-1; i>=0; i--){
722         v+= get_rac(c, state+31-i)<<i;
723     }
724
725     return v;
726 }
727
728 static av_always_inline void
729 lift(DWTELEM *dst, DWTELEM *src, DWTELEM *ref,
730      int dst_step, int src_step, int ref_step,
731      int width, int mul, int add, int shift,
732      int highpass, int inverse){
733     const int mirror_left= !highpass;
734     const int mirror_right= (width&1) ^ highpass;
735     const int w= (width>>1) - 1 + (highpass & width);
736     int i;
737
738 #define LIFT(src, ref, inv) ((src) + ((inv) ? - (ref) : + (ref)))
739     if(mirror_left){
740         dst[0] = LIFT(src[0], ((mul*2*ref[0]+add)>>shift), inverse);
741         dst += dst_step;
742         src += src_step;
743     }
744
745     for(i=0; i<w; i++){
746         dst[i*dst_step] =
747             LIFT(src[i*src_step],
748                  ((mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add)>>shift),
749                  inverse);
750     }
751
752     if(mirror_right){
753         dst[w*dst_step] =
754             LIFT(src[w*src_step],
755                  ((mul*2*ref[w*ref_step]+add)>>shift),
756                  inverse);
757     }
758 }
759
760 static av_always_inline void
761 inv_lift(IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref,
762          int dst_step, int src_step, int ref_step,
763          int width, int mul, int add, int shift,
764          int highpass, int inverse){
765     const int mirror_left= !highpass;
766     const int mirror_right= (width&1) ^ highpass;
767     const int w= (width>>1) - 1 + (highpass & width);
768     int i;
769
770 #define LIFT(src, ref, inv) ((src) + ((inv) ? - (ref) : + (ref)))
771     if(mirror_left){
772         dst[0] = LIFT(src[0], ((mul*2*ref[0]+add)>>shift), inverse);
773         dst += dst_step;
774         src += src_step;
775     }
776
777     for(i=0; i<w; i++){
778         dst[i*dst_step] =
779             LIFT(src[i*src_step],
780                  ((mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add)>>shift),
781                  inverse);
782     }
783
784     if(mirror_right){
785         dst[w*dst_step] =
786             LIFT(src[w*src_step],
787                  ((mul*2*ref[w*ref_step]+add)>>shift),
788                  inverse);
789     }
790 }
791
792 #ifndef liftS
793 static av_always_inline void
794 liftS(DWTELEM *dst, DWTELEM *src, DWTELEM *ref,
795       int dst_step, int src_step, int ref_step,
796       int width, int mul, int add, int shift,
797       int highpass, int inverse){
798     const int mirror_left= !highpass;
799     const int mirror_right= (width&1) ^ highpass;
800     const int w= (width>>1) - 1 + (highpass & width);
801     int i;
802
803     assert(shift == 4);
804 #define LIFTS(src, ref, inv) \
805         ((inv) ? \
806             (src) + (((ref) + 4*(src))>>shift): \
807             -((-16*(src) + (ref) + add/4 + 1 + (5<<25))/(5*4) - (1<<23)))
808     if(mirror_left){
809         dst[0] = LIFTS(src[0], mul*2*ref[0]+add, inverse);
810         dst += dst_step;
811         src += src_step;
812     }
813
814     for(i=0; i<w; i++){
815         dst[i*dst_step] =
816             LIFTS(src[i*src_step],
817                   mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add,
818                   inverse);
819     }
820
821     if(mirror_right){
822         dst[w*dst_step] =
823             LIFTS(src[w*src_step], mul*2*ref[w*ref_step]+add, inverse);
824     }
825 }
826 static av_always_inline void
827 inv_liftS(IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref,
828           int dst_step, int src_step, int ref_step,
829           int width, int mul, int add, int shift,
830           int highpass, int inverse){
831     const int mirror_left= !highpass;
832     const int mirror_right= (width&1) ^ highpass;
833     const int w= (width>>1) - 1 + (highpass & width);
834     int i;
835
836     assert(shift == 4);
837 #define LIFTS(src, ref, inv) \
838     ((inv) ? \
839         (src) + (((ref) + 4*(src))>>shift): \
840         -((-16*(src) + (ref) + add/4 + 1 + (5<<25))/(5*4) - (1<<23)))
841     if(mirror_left){
842         dst[0] = LIFTS(src[0], mul*2*ref[0]+add, inverse);
843         dst += dst_step;
844         src += src_step;
845     }
846
847     for(i=0; i<w; i++){
848         dst[i*dst_step] =
849             LIFTS(src[i*src_step],
850                   mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add,
851                   inverse);
852     }
853
854     if(mirror_right){
855         dst[w*dst_step] =
856             LIFTS(src[w*src_step], mul*2*ref[w*ref_step]+add, inverse);
857     }
858 }
859 #endif
860
861 static void horizontal_decompose53i(DWTELEM *b, int width){
862     DWTELEM temp[width];
863     const int width2= width>>1;
864     int x;
865     const int w2= (width+1)>>1;
866
867     for(x=0; x<width2; x++){
868         temp[x   ]= b[2*x    ];
869         temp[x+w2]= b[2*x + 1];
870     }
871     if(width&1)
872         temp[x   ]= b[2*x    ];
873 #if 0
874     {
875     int A1,A2,A3,A4;
876     A2= temp[1       ];
877     A4= temp[0       ];
878     A1= temp[0+width2];
879     A1 -= (A2 + A4)>>1;
880     A4 += (A1 + 1)>>1;
881     b[0+width2] = A1;
882     b[0       ] = A4;
883     for(x=1; x+1<width2; x+=2){
884         A3= temp[x+width2];
885         A4= temp[x+1     ];
886         A3 -= (A2 + A4)>>1;
887         A2 += (A1 + A3 + 2)>>2;
888         b[x+width2] = A3;
889         b[x       ] = A2;
890
891         A1= temp[x+1+width2];
892         A2= temp[x+2       ];
893         A1 -= (A2 + A4)>>1;
894         A4 += (A1 + A3 + 2)>>2;
895         b[x+1+width2] = A1;
896         b[x+1       ] = A4;
897     }
898     A3= temp[width-1];
899     A3 -= A2;
900     A2 += (A1 + A3 + 2)>>2;
901     b[width -1] = A3;
902     b[width2-1] = A2;
903     }
904 #else
905     lift(b+w2, temp+w2, temp, 1, 1, 1, width, -1, 0, 1, 1, 0);
906     lift(b   , temp   , b+w2, 1, 1, 1, width,  1, 2, 2, 0, 0);
907 #endif
908 }
909
910 static void vertical_decompose53iH0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
911     int i;
912
913     for(i=0; i<width; i++){
914         b1[i] -= (b0[i] + b2[i])>>1;
915     }
916 }
917
918 static void vertical_decompose53iL0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
919     int i;
920
921     for(i=0; i<width; i++){
922         b1[i] += (b0[i] + b2[i] + 2)>>2;
923     }
924 }
925
926 static void spatial_decompose53i(DWTELEM *buffer, int width, int height, int stride){
927     int y;
928     DWTELEM *b0= buffer + mirror(-2-1, height-1)*stride;
929     DWTELEM *b1= buffer + mirror(-2  , height-1)*stride;
930
931     for(y=-2; y<height; y+=2){
932         DWTELEM *b2= buffer + mirror(y+1, height-1)*stride;
933         DWTELEM *b3= buffer + mirror(y+2, height-1)*stride;
934
935 {START_TIMER
936         if(y+1<(unsigned)height) horizontal_decompose53i(b2, width);
937         if(y+2<(unsigned)height) horizontal_decompose53i(b3, width);
938 STOP_TIMER("horizontal_decompose53i")}
939
940 {START_TIMER
941         if(y+1<(unsigned)height) vertical_decompose53iH0(b1, b2, b3, width);
942         if(y+0<(unsigned)height) vertical_decompose53iL0(b0, b1, b2, width);
943 STOP_TIMER("vertical_decompose53i*")}
944
945         b0=b2;
946         b1=b3;
947     }
948 }
949
950 static void horizontal_decompose97i(DWTELEM *b, int width){
951     DWTELEM temp[width];
952     const int w2= (width+1)>>1;
953
954     lift (temp+w2, b    +1, b      , 1, 2, 2, width,  W_AM, W_AO, W_AS, 1, 1);
955     liftS(temp   , b      , temp+w2, 1, 2, 1, width,  W_BM, W_BO, W_BS, 0, 0);
956     lift (b   +w2, temp+w2, temp   , 1, 1, 1, width,  W_CM, W_CO, W_CS, 1, 0);
957     lift (b      , temp   , b   +w2, 1, 1, 1, width,  W_DM, W_DO, W_DS, 0, 0);
958 }
959
960
961 static void vertical_decompose97iH0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
962     int i;
963
964     for(i=0; i<width; i++){
965         b1[i] -= (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
966     }
967 }
968
969 static void vertical_decompose97iH1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
970     int i;
971
972     for(i=0; i<width; i++){
973         b1[i] += (W_CM*(b0[i] + b2[i])+W_CO)>>W_CS;
974     }
975 }
976
977 static void vertical_decompose97iL0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
978     int i;
979
980     for(i=0; i<width; i++){
981 #ifdef liftS
982         b1[i] -= (W_BM*(b0[i] + b2[i])+W_BO)>>W_BS;
983 #else
984         b1[i] = (16*4*b1[i] - 4*(b0[i] + b2[i]) + W_BO*5 + (5<<27)) / (5*16) - (1<<23);
985 #endif
986     }
987 }
988
989 static void vertical_decompose97iL1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
990     int i;
991
992     for(i=0; i<width; i++){
993         b1[i] += (W_DM*(b0[i] + b2[i])+W_DO)>>W_DS;
994     }
995 }
996
997 static void spatial_decompose97i(DWTELEM *buffer, int width, int height, int stride){
998     int y;
999     DWTELEM *b0= buffer + mirror(-4-1, height-1)*stride;
1000     DWTELEM *b1= buffer + mirror(-4  , height-1)*stride;
1001     DWTELEM *b2= buffer + mirror(-4+1, height-1)*stride;
1002     DWTELEM *b3= buffer + mirror(-4+2, height-1)*stride;
1003
1004     for(y=-4; y<height; y+=2){
1005         DWTELEM *b4= buffer + mirror(y+3, height-1)*stride;
1006         DWTELEM *b5= buffer + mirror(y+4, height-1)*stride;
1007
1008 {START_TIMER
1009         if(y+3<(unsigned)height) horizontal_decompose97i(b4, width);
1010         if(y+4<(unsigned)height) horizontal_decompose97i(b5, width);
1011 if(width>400){
1012 STOP_TIMER("horizontal_decompose97i")
1013 }}
1014
1015 {START_TIMER
1016         if(y+3<(unsigned)height) vertical_decompose97iH0(b3, b4, b5, width);
1017         if(y+2<(unsigned)height) vertical_decompose97iL0(b2, b3, b4, width);
1018         if(y+1<(unsigned)height) vertical_decompose97iH1(b1, b2, b3, width);
1019         if(y+0<(unsigned)height) vertical_decompose97iL1(b0, b1, b2, width);
1020
1021 if(width>400){
1022 STOP_TIMER("vertical_decompose97i")
1023 }}
1024
1025         b0=b2;
1026         b1=b3;
1027         b2=b4;
1028         b3=b5;
1029     }
1030 }
1031
1032 void ff_spatial_dwt(DWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count){
1033     int level;
1034
1035     for(level=0; level<decomposition_count; level++){
1036         switch(type){
1037         case DWT_97: spatial_decompose97i(buffer, width>>level, height>>level, stride<<level); break;
1038         case DWT_53: spatial_decompose53i(buffer, width>>level, height>>level, stride<<level); break;
1039         }
1040     }
1041 }
1042
1043 static void horizontal_compose53i(IDWTELEM *b, int width){
1044     IDWTELEM temp[width];
1045     const int width2= width>>1;
1046     const int w2= (width+1)>>1;
1047     int x;
1048
1049 #if 0
1050     int A1,A2,A3,A4;
1051     A2= temp[1       ];
1052     A4= temp[0       ];
1053     A1= temp[0+width2];
1054     A1 -= (A2 + A4)>>1;
1055     A4 += (A1 + 1)>>1;
1056     b[0+width2] = A1;
1057     b[0       ] = A4;
1058     for(x=1; x+1<width2; x+=2){
1059         A3= temp[x+width2];
1060         A4= temp[x+1     ];
1061         A3 -= (A2 + A4)>>1;
1062         A2 += (A1 + A3 + 2)>>2;
1063         b[x+width2] = A3;
1064         b[x       ] = A2;
1065
1066         A1= temp[x+1+width2];
1067         A2= temp[x+2       ];
1068         A1 -= (A2 + A4)>>1;
1069         A4 += (A1 + A3 + 2)>>2;
1070         b[x+1+width2] = A1;
1071         b[x+1       ] = A4;
1072     }
1073     A3= temp[width-1];
1074     A3 -= A2;
1075     A2 += (A1 + A3 + 2)>>2;
1076     b[width -1] = A3;
1077     b[width2-1] = A2;
1078 #else
1079     inv_lift(temp   , b   , b+w2, 1, 1, 1, width,  1, 2, 2, 0, 1);
1080     inv_lift(temp+w2, b+w2, temp, 1, 1, 1, width, -1, 0, 1, 1, 1);
1081 #endif /* 0 */
1082     for(x=0; x<width2; x++){
1083         b[2*x    ]= temp[x   ];
1084         b[2*x + 1]= temp[x+w2];
1085     }
1086     if(width&1)
1087         b[2*x    ]= temp[x   ];
1088 }
1089
1090 static void vertical_compose53iH0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1091     int i;
1092
1093     for(i=0; i<width; i++){
1094         b1[i] += (b0[i] + b2[i])>>1;
1095     }
1096 }
1097
1098 static void vertical_compose53iL0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1099     int i;
1100
1101     for(i=0; i<width; i++){
1102         b1[i] -= (b0[i] + b2[i] + 2)>>2;
1103     }
1104 }
1105
1106 static void spatial_compose53i_buffered_init(dwt_compose_t *cs, slice_buffer * sb, int height, int stride_line){
1107     cs->b0 = slice_buffer_get_line(sb, mirror(-1-1, height-1) * stride_line);
1108     cs->b1 = slice_buffer_get_line(sb, mirror(-1  , height-1) * stride_line);
1109     cs->y = -1;
1110 }
1111
1112 static void spatial_compose53i_init(dwt_compose_t *cs, IDWTELEM *buffer, int height, int stride){
1113     cs->b0 = buffer + mirror(-1-1, height-1)*stride;
1114     cs->b1 = buffer + mirror(-1  , height-1)*stride;
1115     cs->y = -1;
1116 }
1117
1118 static void spatial_compose53i_dy_buffered(dwt_compose_t *cs, slice_buffer * sb, int width, int height, int stride_line){
1119     int y= cs->y;
1120
1121     IDWTELEM *b0= cs->b0;
1122     IDWTELEM *b1= cs->b1;
1123     IDWTELEM *b2= slice_buffer_get_line(sb, mirror(y+1, height-1) * stride_line);
1124     IDWTELEM *b3= slice_buffer_get_line(sb, mirror(y+2, height-1) * stride_line);
1125
1126 {START_TIMER
1127         if(y+1<(unsigned)height) vertical_compose53iL0(b1, b2, b3, width);
1128         if(y+0<(unsigned)height) vertical_compose53iH0(b0, b1, b2, width);
1129 STOP_TIMER("vertical_compose53i*")}
1130
1131 {START_TIMER
1132         if(y-1<(unsigned)height) horizontal_compose53i(b0, width);
1133         if(y+0<(unsigned)height) horizontal_compose53i(b1, width);
1134 STOP_TIMER("horizontal_compose53i")}
1135
1136     cs->b0 = b2;
1137     cs->b1 = b3;
1138     cs->y += 2;
1139 }
1140
1141 static void spatial_compose53i_dy(dwt_compose_t *cs, IDWTELEM *buffer, int width, int height, int stride){
1142     int y= cs->y;
1143     IDWTELEM *b0= cs->b0;
1144     IDWTELEM *b1= cs->b1;
1145     IDWTELEM *b2= buffer + mirror(y+1, height-1)*stride;
1146     IDWTELEM *b3= buffer + mirror(y+2, height-1)*stride;
1147
1148 {START_TIMER
1149         if(y+1<(unsigned)height) vertical_compose53iL0(b1, b2, b3, width);
1150         if(y+0<(unsigned)height) vertical_compose53iH0(b0, b1, b2, width);
1151 STOP_TIMER("vertical_compose53i*")}
1152
1153 {START_TIMER
1154         if(y-1<(unsigned)height) horizontal_compose53i(b0, width);
1155         if(y+0<(unsigned)height) horizontal_compose53i(b1, width);
1156 STOP_TIMER("horizontal_compose53i")}
1157
1158     cs->b0 = b2;
1159     cs->b1 = b3;
1160     cs->y += 2;
1161 }
1162
1163
1164 void ff_snow_horizontal_compose97i(IDWTELEM *b, int width){
1165     IDWTELEM temp[width];
1166     const int w2= (width+1)>>1;
1167
1168     inv_lift (temp   , b      , b   +w2, 1, 1, 1, width,  W_DM, W_DO, W_DS, 0, 1);
1169     inv_lift (temp+w2, b   +w2, temp   , 1, 1, 1, width,  W_CM, W_CO, W_CS, 1, 1);
1170     inv_liftS(b      , temp   , temp+w2, 2, 1, 1, width,  W_BM, W_BO, W_BS, 0, 1);
1171     inv_lift (b+1    , temp+w2, b      , 2, 1, 2, width,  W_AM, W_AO, W_AS, 1, 0);
1172 }
1173
1174 static void vertical_compose97iH0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1175     int i;
1176
1177     for(i=0; i<width; i++){
1178         b1[i] += (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
1179     }
1180 }
1181
1182 static void vertical_compose97iH1(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1183     int i;
1184
1185     for(i=0; i<width; i++){
1186         b1[i] -= (W_CM*(b0[i] + b2[i])+W_CO)>>W_CS;
1187     }
1188 }
1189
1190 static void vertical_compose97iL0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1191     int i;
1192
1193     for(i=0; i<width; i++){
1194 #ifdef liftS
1195         b1[i] += (W_BM*(b0[i] + b2[i])+W_BO)>>W_BS;
1196 #else
1197         b1[i] += (W_BM*(b0[i] + b2[i])+4*b1[i]+W_BO)>>W_BS;
1198 #endif
1199     }
1200 }
1201
1202 static void vertical_compose97iL1(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1203     int i;
1204
1205     for(i=0; i<width; i++){
1206         b1[i] -= (W_DM*(b0[i] + b2[i])+W_DO)>>W_DS;
1207     }
1208 }
1209
1210 void ff_snow_vertical_compose97i(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5, int width){
1211     int i;
1212
1213     for(i=0; i<width; i++){
1214         b4[i] -= (W_DM*(b3[i] + b5[i])+W_DO)>>W_DS;
1215         b3[i] -= (W_CM*(b2[i] + b4[i])+W_CO)>>W_CS;
1216 #ifdef liftS
1217         b2[i] += (W_BM*(b1[i] + b3[i])+W_BO)>>W_BS;
1218 #else
1219         b2[i] += (W_BM*(b1[i] + b3[i])+4*b2[i]+W_BO)>>W_BS;
1220 #endif
1221         b1[i] += (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
1222     }
1223 }
1224
1225 static void spatial_compose97i_buffered_init(dwt_compose_t *cs, slice_buffer * sb, int height, int stride_line){
1226     cs->b0 = slice_buffer_get_line(sb, mirror(-3-1, height-1) * stride_line);
1227     cs->b1 = slice_buffer_get_line(sb, mirror(-3  , height-1) * stride_line);
1228     cs->b2 = slice_buffer_get_line(sb, mirror(-3+1, height-1) * stride_line);
1229     cs->b3 = slice_buffer_get_line(sb, mirror(-3+2, height-1) * stride_line);
1230     cs->y = -3;
1231 }
1232
1233 static void spatial_compose97i_init(dwt_compose_t *cs, IDWTELEM *buffer, int height, int stride){
1234     cs->b0 = buffer + mirror(-3-1, height-1)*stride;
1235     cs->b1 = buffer + mirror(-3  , height-1)*stride;
1236     cs->b2 = buffer + mirror(-3+1, height-1)*stride;
1237     cs->b3 = buffer + mirror(-3+2, height-1)*stride;
1238     cs->y = -3;
1239 }
1240
1241 static void spatial_compose97i_dy_buffered(DSPContext *dsp, dwt_compose_t *cs, slice_buffer * sb, int width, int height, int stride_line){
1242     int y = cs->y;
1243
1244     IDWTELEM *b0= cs->b0;
1245     IDWTELEM *b1= cs->b1;
1246     IDWTELEM *b2= cs->b2;
1247     IDWTELEM *b3= cs->b3;
1248     IDWTELEM *b4= slice_buffer_get_line(sb, mirror(y + 3, height - 1) * stride_line);
1249     IDWTELEM *b5= slice_buffer_get_line(sb, mirror(y + 4, height - 1) * stride_line);
1250
1251 {START_TIMER
1252     if(y>0 && y+4<height){
1253         dsp->vertical_compose97i(b0, b1, b2, b3, b4, b5, width);
1254     }else{
1255         if(y+3<(unsigned)height) vertical_compose97iL1(b3, b4, b5, width);
1256         if(y+2<(unsigned)height) vertical_compose97iH1(b2, b3, b4, width);
1257         if(y+1<(unsigned)height) vertical_compose97iL0(b1, b2, b3, width);
1258         if(y+0<(unsigned)height) vertical_compose97iH0(b0, b1, b2, width);
1259     }
1260 if(width>400){
1261 STOP_TIMER("vertical_compose97i")}}
1262
1263 {START_TIMER
1264         if(y-1<(unsigned)height) dsp->horizontal_compose97i(b0, width);
1265         if(y+0<(unsigned)height) dsp->horizontal_compose97i(b1, width);
1266 if(width>400 && y+0<(unsigned)height){
1267 STOP_TIMER("horizontal_compose97i")}}
1268
1269     cs->b0=b2;
1270     cs->b1=b3;
1271     cs->b2=b4;
1272     cs->b3=b5;
1273     cs->y += 2;
1274 }
1275
1276 static void spatial_compose97i_dy(dwt_compose_t *cs, IDWTELEM *buffer, int width, int height, int stride){
1277     int y = cs->y;
1278     IDWTELEM *b0= cs->b0;
1279     IDWTELEM *b1= cs->b1;
1280     IDWTELEM *b2= cs->b2;
1281     IDWTELEM *b3= cs->b3;
1282     IDWTELEM *b4= buffer + mirror(y+3, height-1)*stride;
1283     IDWTELEM *b5= buffer + mirror(y+4, height-1)*stride;
1284
1285 {START_TIMER
1286         if(y+3<(unsigned)height) vertical_compose97iL1(b3, b4, b5, width);
1287         if(y+2<(unsigned)height) vertical_compose97iH1(b2, b3, b4, width);
1288         if(y+1<(unsigned)height) vertical_compose97iL0(b1, b2, b3, width);
1289         if(y+0<(unsigned)height) vertical_compose97iH0(b0, b1, b2, width);
1290 if(width>400){
1291 STOP_TIMER("vertical_compose97i")}}
1292
1293 {START_TIMER
1294         if(y-1<(unsigned)height) ff_snow_horizontal_compose97i(b0, width);
1295         if(y+0<(unsigned)height) ff_snow_horizontal_compose97i(b1, width);
1296 if(width>400 && b0 <= b2){
1297 STOP_TIMER("horizontal_compose97i")}}
1298
1299     cs->b0=b2;
1300     cs->b1=b3;
1301     cs->b2=b4;
1302     cs->b3=b5;
1303     cs->y += 2;
1304 }
1305
1306 static void ff_spatial_idwt_buffered_init(dwt_compose_t *cs, slice_buffer * sb, int width, int height, int stride_line, int type, int decomposition_count){
1307     int level;
1308     for(level=decomposition_count-1; level>=0; level--){
1309         switch(type){
1310         case DWT_97: spatial_compose97i_buffered_init(cs+level, sb, height>>level, stride_line<<level); break;
1311         case DWT_53: spatial_compose53i_buffered_init(cs+level, sb, height>>level, stride_line<<level); break;
1312         }
1313     }
1314 }
1315
1316 static void ff_spatial_idwt_init(dwt_compose_t *cs, IDWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count){
1317     int level;
1318     for(level=decomposition_count-1; level>=0; level--){
1319         switch(type){
1320         case DWT_97: spatial_compose97i_init(cs+level, buffer, height>>level, stride<<level); break;
1321         case DWT_53: spatial_compose53i_init(cs+level, buffer, height>>level, stride<<level); break;
1322         }
1323     }
1324 }
1325
1326 static void ff_spatial_idwt_slice(dwt_compose_t *cs, IDWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count, int y){
1327     const int support = type==1 ? 3 : 5;
1328     int level;
1329     if(type==2) return;
1330
1331     for(level=decomposition_count-1; level>=0; level--){
1332         while(cs[level].y <= FFMIN((y>>level)+support, height>>level)){
1333             switch(type){
1334             case DWT_97: spatial_compose97i_dy(cs+level, buffer, width>>level, height>>level, stride<<level);
1335                     break;
1336             case DWT_53: spatial_compose53i_dy(cs+level, buffer, width>>level, height>>level, stride<<level);
1337                     break;
1338             }
1339         }
1340     }
1341 }
1342
1343 static void ff_spatial_idwt_buffered_slice(DSPContext *dsp, dwt_compose_t *cs, slice_buffer * slice_buf, int width, int height, int stride_line, int type, int decomposition_count, int y){
1344     const int support = type==1 ? 3 : 5;
1345     int level;
1346     if(type==2) return;
1347
1348     for(level=decomposition_count-1; level>=0; level--){
1349         while(cs[level].y <= FFMIN((y>>level)+support, height>>level)){
1350             switch(type){
1351             case DWT_97: spatial_compose97i_dy_buffered(dsp, cs+level, slice_buf, width>>level, height>>level, stride_line<<level);
1352                     break;
1353             case DWT_53: spatial_compose53i_dy_buffered(cs+level, slice_buf, width>>level, height>>level, stride_line<<level);
1354                     break;
1355             }
1356         }
1357     }
1358 }
1359
1360 static void ff_spatial_idwt(IDWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count){
1361         dwt_compose_t cs[MAX_DECOMPOSITIONS];
1362         int y;
1363         ff_spatial_idwt_init(cs, buffer, width, height, stride, type, decomposition_count);
1364         for(y=0; y<height; y+=4)
1365             ff_spatial_idwt_slice(cs, buffer, width, height, stride, type, decomposition_count, y);
1366 }
1367
1368 static int encode_subband_c0run(SnowContext *s, SubBand *b, IDWTELEM *src, IDWTELEM *parent, int stride, int orientation){
1369     const int w= b->width;
1370     const int h= b->height;
1371     int x, y;
1372
1373     if(1){
1374         int run=0;
1375         int runs[w*h];
1376         int run_index=0;
1377         int max_index;
1378
1379         for(y=0; y<h; y++){
1380             for(x=0; x<w; x++){
1381                 int v, p=0;
1382                 int /*ll=0, */l=0, lt=0, t=0, rt=0;
1383                 v= src[x + y*stride];
1384
1385                 if(y){
1386                     t= src[x + (y-1)*stride];
1387                     if(x){
1388                         lt= src[x - 1 + (y-1)*stride];
1389                     }
1390                     if(x + 1 < w){
1391                         rt= src[x + 1 + (y-1)*stride];
1392                     }
1393                 }
1394                 if(x){
1395                     l= src[x - 1 + y*stride];
1396                     /*if(x > 1){
1397                         if(orientation==1) ll= src[y + (x-2)*stride];
1398                         else               ll= src[x - 2 + y*stride];
1399                     }*/
1400                 }
1401                 if(parent){
1402                     int px= x>>1;
1403                     int py= y>>1;
1404                     if(px<b->parent->width && py<b->parent->height)
1405                         p= parent[px + py*2*stride];
1406                 }
1407                 if(!(/*ll|*/l|lt|t|rt|p)){
1408                     if(v){
1409                         runs[run_index++]= run;
1410                         run=0;
1411                     }else{
1412                         run++;
1413                     }
1414                 }
1415             }
1416         }
1417         max_index= run_index;
1418         runs[run_index++]= run;
1419         run_index=0;
1420         run= runs[run_index++];
1421
1422         put_symbol2(&s->c, b->state[30], max_index, 0);
1423         if(run_index <= max_index)
1424             put_symbol2(&s->c, b->state[1], run, 3);
1425
1426         for(y=0; y<h; y++){
1427             if(s->c.bytestream_end - s->c.bytestream < w*40){
1428                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1429                 return -1;
1430             }
1431             for(x=0; x<w; x++){
1432                 int v, p=0;
1433                 int /*ll=0, */l=0, lt=0, t=0, rt=0;
1434                 v= src[x + y*stride];
1435
1436                 if(y){
1437                     t= src[x + (y-1)*stride];
1438                     if(x){
1439                         lt= src[x - 1 + (y-1)*stride];
1440                     }
1441                     if(x + 1 < w){
1442                         rt= src[x + 1 + (y-1)*stride];
1443                     }
1444                 }
1445                 if(x){
1446                     l= src[x - 1 + y*stride];
1447                     /*if(x > 1){
1448                         if(orientation==1) ll= src[y + (x-2)*stride];
1449                         else               ll= src[x - 2 + y*stride];
1450                     }*/
1451                 }
1452                 if(parent){
1453                     int px= x>>1;
1454                     int py= y>>1;
1455                     if(px<b->parent->width && py<b->parent->height)
1456                         p= parent[px + py*2*stride];
1457                 }
1458                 if(/*ll|*/l|lt|t|rt|p){
1459                     int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
1460
1461                     put_rac(&s->c, &b->state[0][context], !!v);
1462                 }else{
1463                     if(!run){
1464                         run= runs[run_index++];
1465
1466                         if(run_index <= max_index)
1467                             put_symbol2(&s->c, b->state[1], run, 3);
1468                         assert(v);
1469                     }else{
1470                         run--;
1471                         assert(!v);
1472                     }
1473                 }
1474                 if(v){
1475                     int context= av_log2(/*FFABS(ll) + */3*FFABS(l) + FFABS(lt) + 2*FFABS(t) + FFABS(rt) + FFABS(p));
1476                     int l2= 2*FFABS(l) + (l<0);
1477                     int t2= 2*FFABS(t) + (t<0);
1478
1479                     put_symbol2(&s->c, b->state[context + 2], FFABS(v)-1, context-4);
1480                     put_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3bA[l2&0xFF] + 3*quant3bA[t2&0xFF]], v<0);
1481                 }
1482             }
1483         }
1484     }
1485     return 0;
1486 }
1487
1488 static int encode_subband(SnowContext *s, SubBand *b, IDWTELEM *src, IDWTELEM *parent, int stride, int orientation){
1489 //    encode_subband_qtree(s, b, src, parent, stride, orientation);
1490 //    encode_subband_z0run(s, b, src, parent, stride, orientation);
1491     return encode_subband_c0run(s, b, src, parent, stride, orientation);
1492 //    encode_subband_dzr(s, b, src, parent, stride, orientation);
1493 }
1494
1495 static inline void unpack_coeffs(SnowContext *s, SubBand *b, SubBand * parent, int orientation){
1496     const int w= b->width;
1497     const int h= b->height;
1498     int x,y;
1499
1500     if(1){
1501         int run, runs;
1502         x_and_coeff *xc= b->x_coeff;
1503         x_and_coeff *prev_xc= NULL;
1504         x_and_coeff *prev2_xc= xc;
1505         x_and_coeff *parent_xc= parent ? parent->x_coeff : NULL;
1506         x_and_coeff *prev_parent_xc= parent_xc;
1507
1508         runs= get_symbol2(&s->c, b->state[30], 0);
1509         if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
1510         else           run= INT_MAX;
1511
1512         for(y=0; y<h; y++){
1513             int v=0;
1514             int lt=0, t=0, rt=0;
1515
1516             if(y && prev_xc->x == 0){
1517                 rt= prev_xc->coeff;
1518             }
1519             for(x=0; x<w; x++){
1520                 int p=0;
1521                 const int l= v;
1522
1523                 lt= t; t= rt;
1524
1525                 if(y){
1526                     if(prev_xc->x <= x)
1527                         prev_xc++;
1528                     if(prev_xc->x == x + 1)
1529                         rt= prev_xc->coeff;
1530                     else
1531                         rt=0;
1532                 }
1533                 if(parent_xc){
1534                     if(x>>1 > parent_xc->x){
1535                         parent_xc++;
1536                     }
1537                     if(x>>1 == parent_xc->x){
1538                         p= parent_xc->coeff;
1539                     }
1540                 }
1541                 if(/*ll|*/l|lt|t|rt|p){
1542                     int context= av_log2(/*FFABS(ll) + */3*(l>>1) + (lt>>1) + (t&~1) + (rt>>1) + (p>>1));
1543
1544                     v=get_rac(&s->c, &b->state[0][context]);
1545                     if(v){
1546                         v= 2*(get_symbol2(&s->c, b->state[context + 2], context-4) + 1);
1547                         v+=get_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3bA[l&0xFF] + 3*quant3bA[t&0xFF]]);
1548
1549                         xc->x=x;
1550                         (xc++)->coeff= v;
1551                     }
1552                 }else{
1553                     if(!run){
1554                         if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
1555                         else           run= INT_MAX;
1556                         v= 2*(get_symbol2(&s->c, b->state[0 + 2], 0-4) + 1);
1557                         v+=get_rac(&s->c, &b->state[0][16 + 1 + 3]);
1558
1559                         xc->x=x;
1560                         (xc++)->coeff= v;
1561                     }else{
1562                         int max_run;
1563                         run--;
1564                         v=0;
1565
1566                         if(y) max_run= FFMIN(run, prev_xc->x - x - 2);
1567                         else  max_run= FFMIN(run, w-x-1);
1568                         if(parent_xc)
1569                             max_run= FFMIN(max_run, 2*parent_xc->x - x - 1);
1570                         x+= max_run;
1571                         run-= max_run;
1572                     }
1573                 }
1574             }
1575             (xc++)->x= w+1; //end marker
1576             prev_xc= prev2_xc;
1577             prev2_xc= xc;
1578
1579             if(parent_xc){
1580                 if(y&1){
1581                     while(parent_xc->x != parent->width+1)
1582                         parent_xc++;
1583                     parent_xc++;
1584                     prev_parent_xc= parent_xc;
1585                 }else{
1586                     parent_xc= prev_parent_xc;
1587                 }
1588             }
1589         }
1590
1591         (xc++)->x= w+1; //end marker
1592     }
1593 }
1594
1595 static inline void decode_subband_slice_buffered(SnowContext *s, SubBand *b, slice_buffer * sb, int start_y, int h, int save_state[1]){
1596     const int w= b->width;
1597     int y;
1598     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1599     int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1600     int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
1601     int new_index = 0;
1602
1603     START_TIMER
1604
1605     if(b->ibuf == s->spatial_idwt_buffer || s->qlog == LOSSLESS_QLOG){
1606         qadd= 0;
1607         qmul= 1<<QEXPSHIFT;
1608     }
1609
1610     /* If we are on the second or later slice, restore our index. */
1611     if (start_y != 0)
1612         new_index = save_state[0];
1613
1614
1615     for(y=start_y; y<h; y++){
1616         int x = 0;
1617         int v;
1618         IDWTELEM * line = slice_buffer_get_line(sb, y * b->stride_line + b->buf_y_offset) + b->buf_x_offset;
1619         memset(line, 0, b->width*sizeof(IDWTELEM));
1620         v = b->x_coeff[new_index].coeff;
1621         x = b->x_coeff[new_index++].x;
1622         while(x < w)
1623         {
1624             register int t= ( (v>>1)*qmul + qadd)>>QEXPSHIFT;
1625             register int u= -(v&1);
1626             line[x] = (t^u) - u;
1627
1628             v = b->x_coeff[new_index].coeff;
1629             x = b->x_coeff[new_index++].x;
1630         }
1631     }
1632     if(w > 200 && start_y != 0/*level+1 == s->spatial_decomposition_count*/){
1633         STOP_TIMER("decode_subband")
1634     }
1635
1636     /* Save our variables for the next slice. */
1637     save_state[0] = new_index;
1638
1639     return;
1640 }
1641
1642 static void reset_contexts(SnowContext *s){ //FIXME better initial contexts
1643     int plane_index, level, orientation;
1644
1645     for(plane_index=0; plane_index<3; plane_index++){
1646         for(level=0; level<MAX_DECOMPOSITIONS; level++){
1647             for(orientation=level ? 1:0; orientation<4; orientation++){
1648                 memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
1649             }
1650         }
1651     }
1652     memset(s->header_state, MID_STATE, sizeof(s->header_state));
1653     memset(s->block_state, MID_STATE, sizeof(s->block_state));
1654 }
1655
1656 static int alloc_blocks(SnowContext *s){
1657     int w= -((-s->avctx->width )>>LOG2_MB_SIZE);
1658     int h= -((-s->avctx->height)>>LOG2_MB_SIZE);
1659
1660     s->b_width = w;
1661     s->b_height= h;
1662
1663     s->block= av_mallocz(w * h * sizeof(BlockNode) << (s->block_max_depth*2));
1664     return 0;
1665 }
1666
1667 static inline void copy_rac_state(RangeCoder *d, RangeCoder *s){
1668     uint8_t *bytestream= d->bytestream;
1669     uint8_t *bytestream_start= d->bytestream_start;
1670     *d= *s;
1671     d->bytestream= bytestream;
1672     d->bytestream_start= bytestream_start;
1673 }
1674
1675 //near copy & paste from dsputil, FIXME
1676 static int pix_sum(uint8_t * pix, int line_size, int w)
1677 {
1678     int s, i, j;
1679
1680     s = 0;
1681     for (i = 0; i < w; i++) {
1682         for (j = 0; j < w; j++) {
1683             s += pix[0];
1684             pix ++;
1685         }
1686         pix += line_size - w;
1687     }
1688     return s;
1689 }
1690
1691 //near copy & paste from dsputil, FIXME
1692 static int pix_norm1(uint8_t * pix, int line_size, int w)
1693 {
1694     int s, i, j;
1695     uint32_t *sq = ff_squareTbl + 256;
1696
1697     s = 0;
1698     for (i = 0; i < w; i++) {
1699         for (j = 0; j < w; j ++) {
1700             s += sq[pix[0]];
1701             pix ++;
1702         }
1703         pix += line_size - w;
1704     }
1705     return s;
1706 }
1707
1708 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){
1709     const int w= s->b_width << s->block_max_depth;
1710     const int rem_depth= s->block_max_depth - level;
1711     const int index= (x + y*w) << rem_depth;
1712     const int block_w= 1<<rem_depth;
1713     BlockNode block;
1714     int i,j;
1715
1716     block.color[0]= l;
1717     block.color[1]= cb;
1718     block.color[2]= cr;
1719     block.mx= mx;
1720     block.my= my;
1721     block.ref= ref;
1722     block.type= type;
1723     block.level= level;
1724
1725     for(j=0; j<block_w; j++){
1726         for(i=0; i<block_w; i++){
1727             s->block[index + i + j*w]= block;
1728         }
1729     }
1730 }
1731
1732 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){
1733     const int offset[3]= {
1734           y*c->  stride + x,
1735         ((y*c->uvstride + x)>>1),
1736         ((y*c->uvstride + x)>>1),
1737     };
1738     int i;
1739     for(i=0; i<3; i++){
1740         c->src[0][i]= src [i];
1741         c->ref[0][i]= ref [i] + offset[i];
1742     }
1743     assert(!ref_index);
1744 }
1745
1746 static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
1747                            const BlockNode *left, const BlockNode *top, const BlockNode *tr){
1748     if(s->ref_frames == 1){
1749         *mx = mid_pred(left->mx, top->mx, tr->mx);
1750         *my = mid_pred(left->my, top->my, tr->my);
1751     }else{
1752         const int *scale = scale_mv_ref[ref];
1753         *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
1754                        (top ->mx * scale[top ->ref] + 128) >>8,
1755                        (tr  ->mx * scale[tr  ->ref] + 128) >>8);
1756         *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
1757                        (top ->my * scale[top ->ref] + 128) >>8,
1758                        (tr  ->my * scale[tr  ->ref] + 128) >>8);
1759     }
1760 }
1761
1762 //FIXME copy&paste
1763 #define P_LEFT P[1]
1764 #define P_TOP P[2]
1765 #define P_TOPRIGHT P[3]
1766 #define P_MEDIAN P[4]
1767 #define P_MV1 P[9]
1768 #define FLAG_QPEL   1 //must be 1
1769
1770 static int encode_q_branch(SnowContext *s, int level, int x, int y){
1771     uint8_t p_buffer[1024];
1772     uint8_t i_buffer[1024];
1773     uint8_t p_state[sizeof(s->block_state)];
1774     uint8_t i_state[sizeof(s->block_state)];
1775     RangeCoder pc, ic;
1776     uint8_t *pbbak= s->c.bytestream;
1777     uint8_t *pbbak_start= s->c.bytestream_start;
1778     int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
1779     const int w= s->b_width  << s->block_max_depth;
1780     const int h= s->b_height << s->block_max_depth;
1781     const int rem_depth= s->block_max_depth - level;
1782     const int index= (x + y*w) << rem_depth;
1783     const int block_w= 1<<(LOG2_MB_SIZE - level);
1784     int trx= (x+1)<<rem_depth;
1785     int try= (y+1)<<rem_depth;
1786     const BlockNode *left  = x ? &s->block[index-1] : &null_block;
1787     const BlockNode *top   = y ? &s->block[index-w] : &null_block;
1788     const BlockNode *right = trx<w ? &s->block[index+1] : &null_block;
1789     const BlockNode *bottom= try<h ? &s->block[index+w] : &null_block;
1790     const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;
1791     const BlockNode *tr    = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
1792     int pl = left->color[0];
1793     int pcb= left->color[1];
1794     int pcr= left->color[2];
1795     int pmx, pmy;
1796     int mx=0, my=0;
1797     int l,cr,cb;
1798     const int stride= s->current_picture.linesize[0];
1799     const int uvstride= s->current_picture.linesize[1];
1800     uint8_t *current_data[3]= { s->input_picture.data[0] + (x + y*  stride)*block_w,
1801                                 s->input_picture.data[1] + (x + y*uvstride)*block_w/2,
1802                                 s->input_picture.data[2] + (x + y*uvstride)*block_w/2};
1803     int P[10][2];
1804     int16_t last_mv[3][2];
1805     int qpel= !!(s->avctx->flags & CODEC_FLAG_QPEL); //unused
1806     const int shift= 1+qpel;
1807     MotionEstContext *c= &s->m.me;
1808     int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
1809     int mx_context= av_log2(2*FFABS(left->mx - top->mx));
1810     int my_context= av_log2(2*FFABS(left->my - top->my));
1811     int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
1812     int ref, best_ref, ref_score, ref_mx, ref_my;
1813
1814     assert(sizeof(s->block_state) >= 256);
1815     if(s->keyframe){
1816         set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
1817         return 0;
1818     }
1819
1820 //    clip predictors / edge ?
1821
1822     P_LEFT[0]= left->mx;
1823     P_LEFT[1]= left->my;
1824     P_TOP [0]= top->mx;
1825     P_TOP [1]= top->my;
1826     P_TOPRIGHT[0]= tr->mx;
1827     P_TOPRIGHT[1]= tr->my;
1828
1829     last_mv[0][0]= s->block[index].mx;
1830     last_mv[0][1]= s->block[index].my;
1831     last_mv[1][0]= right->mx;
1832     last_mv[1][1]= right->my;
1833     last_mv[2][0]= bottom->mx;
1834     last_mv[2][1]= bottom->my;
1835
1836     s->m.mb_stride=2;
1837     s->m.mb_x=
1838     s->m.mb_y= 0;
1839     c->skip= 0;
1840
1841     assert(c->  stride ==   stride);
1842     assert(c->uvstride == uvstride);
1843
1844     c->penalty_factor    = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
1845     c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
1846     c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);
1847     c->current_mv_penalty= c->mv_penalty[s->m.f_code=1] + MAX_MV;
1848
1849     c->xmin = - x*block_w - 16+2;
1850     c->ymin = - y*block_w - 16+2;
1851     c->xmax = - (x+1)*block_w + (w<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-2;
1852     c->ymax = - (y+1)*block_w + (h<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-2;
1853
1854     if(P_LEFT[0]     > (c->xmax<<shift)) P_LEFT[0]    = (c->xmax<<shift);
1855     if(P_LEFT[1]     > (c->ymax<<shift)) P_LEFT[1]    = (c->ymax<<shift);
1856     if(P_TOP[0]      > (c->xmax<<shift)) P_TOP[0]     = (c->xmax<<shift);
1857     if(P_TOP[1]      > (c->ymax<<shift)) P_TOP[1]     = (c->ymax<<shift);
1858     if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift);
1859     if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); //due to pmx no clip
1860     if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
1861
1862     P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
1863     P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
1864
1865     if (!y) {
1866         c->pred_x= P_LEFT[0];
1867         c->pred_y= P_LEFT[1];
1868     } else {
1869         c->pred_x = P_MEDIAN[0];
1870         c->pred_y = P_MEDIAN[1];
1871     }
1872
1873     score= INT_MAX;
1874     best_ref= 0;
1875     for(ref=0; ref<s->ref_frames; ref++){
1876         init_ref(c, current_data, s->last_picture[ref].data, NULL, block_w*x, block_w*y, 0);
1877
1878         ref_score= ff_epzs_motion_search(&s->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
1879                                          (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
1880
1881         assert(ref_mx >= c->xmin);
1882         assert(ref_mx <= c->xmax);
1883         assert(ref_my >= c->ymin);
1884         assert(ref_my <= c->ymax);
1885
1886         ref_score= c->sub_motion_search(&s->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
1887         ref_score= ff_get_mb_score(&s->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
1888         ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
1889         if(s->ref_mvs[ref]){
1890             s->ref_mvs[ref][index][0]= ref_mx;
1891             s->ref_mvs[ref][index][1]= ref_my;
1892             s->ref_scores[ref][index]= ref_score;
1893         }
1894         if(score > ref_score){
1895             score= ref_score;
1896             best_ref= ref;
1897             mx= ref_mx;
1898             my= ref_my;
1899         }
1900     }
1901     //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
1902
1903   //  subpel search
1904     base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
1905     pc= s->c;
1906     pc.bytestream_start=
1907     pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo
1908     memcpy(p_state, s->block_state, sizeof(s->block_state));
1909
1910     if(level!=s->block_max_depth)
1911         put_rac(&pc, &p_state[4 + s_context], 1);
1912     put_rac(&pc, &p_state[1 + left->type + top->type], 0);
1913     if(s->ref_frames > 1)
1914         put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
1915     pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
1916     put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
1917     put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
1918     p_len= pc.bytestream - pc.bytestream_start;
1919     score += (s->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;
1920
1921     block_s= block_w*block_w;
1922     sum = pix_sum(current_data[0], stride, block_w);
1923     l= (sum + block_s/2)/block_s;
1924     iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
1925
1926     block_s= block_w*block_w>>2;
1927     sum = pix_sum(current_data[1], uvstride, block_w>>1);
1928     cb= (sum + block_s/2)/block_s;
1929 //    iscore += pix_norm1(&current_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;
1930     sum = pix_sum(current_data[2], uvstride, block_w>>1);
1931     cr= (sum + block_s/2)/block_s;
1932 //    iscore += pix_norm1(&current_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
1933
1934     ic= s->c;
1935     ic.bytestream_start=
1936     ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo
1937     memcpy(i_state, s->block_state, sizeof(s->block_state));
1938     if(level!=s->block_max_depth)
1939         put_rac(&ic, &i_state[4 + s_context], 1);
1940     put_rac(&ic, &i_state[1 + left->type + top->type], 1);
1941     put_symbol(&ic, &i_state[32],  l-pl , 1);
1942     put_symbol(&ic, &i_state[64], cb-pcb, 1);
1943     put_symbol(&ic, &i_state[96], cr-pcr, 1);
1944     i_len= ic.bytestream - ic.bytestream_start;
1945     iscore += (s->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;
1946
1947 //    assert(score==256*256*256*64-1);
1948     assert(iscore < 255*255*256 + s->lambda2*10);
1949     assert(iscore >= 0);
1950     assert(l>=0 && l<=255);
1951     assert(pl>=0 && pl<=255);
1952
1953     if(level==0){
1954         int varc= iscore >> 8;
1955         int vard= score >> 8;
1956         if (vard <= 64 || vard < varc)
1957             c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
1958         else
1959             c->scene_change_score+= s->m.qscale;
1960     }
1961
1962     if(level!=s->block_max_depth){
1963         put_rac(&s->c, &s->block_state[4 + s_context], 0);
1964         score2 = encode_q_branch(s, level+1, 2*x+0, 2*y+0);
1965         score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+0);
1966         score2+= encode_q_branch(s, level+1, 2*x+0, 2*y+1);
1967         score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+1);
1968         score2+= s->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead
1969
1970         if(score2 < score && score2 < iscore)
1971             return score2;
1972     }
1973
1974     if(iscore < score){
1975         pred_mv(s, &pmx, &pmy, 0, left, top, tr);
1976         memcpy(pbbak, i_buffer, i_len);
1977         s->c= ic;
1978         s->c.bytestream_start= pbbak_start;
1979         s->c.bytestream= pbbak + i_len;
1980         set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0, BLOCK_INTRA);
1981         memcpy(s->block_state, i_state, sizeof(s->block_state));
1982         return iscore;
1983     }else{
1984         memcpy(pbbak, p_buffer, p_len);
1985         s->c= pc;
1986         s->c.bytestream_start= pbbak_start;
1987         s->c.bytestream= pbbak + p_len;
1988         set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
1989         memcpy(s->block_state, p_state, sizeof(s->block_state));
1990         return score;
1991     }
1992 }
1993
1994 static av_always_inline int same_block(BlockNode *a, BlockNode *b){
1995     if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
1996         return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
1997     }else{
1998         return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
1999     }
2000 }
2001
2002 static void encode_q_branch2(SnowContext *s, int level, int x, int y){
2003     const int w= s->b_width  << s->block_max_depth;
2004     const int rem_depth= s->block_max_depth - level;
2005     const int index= (x + y*w) << rem_depth;
2006     int trx= (x+1)<<rem_depth;
2007     BlockNode *b= &s->block[index];
2008     const BlockNode *left  = x ? &s->block[index-1] : &null_block;
2009     const BlockNode *top   = y ? &s->block[index-w] : &null_block;
2010     const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;
2011     const BlockNode *tr    = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
2012     int pl = left->color[0];
2013     int pcb= left->color[1];
2014     int pcr= left->color[2];
2015     int pmx, pmy;
2016     int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
2017     int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 16*!!b->ref;
2018     int my_context= av_log2(2*FFABS(left->my - top->my)) + 16*!!b->ref;
2019     int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
2020
2021     if(s->keyframe){
2022         set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
2023         return;
2024     }
2025
2026     if(level!=s->block_max_depth){
2027         if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){
2028             put_rac(&s->c, &s->block_state[4 + s_context], 1);
2029         }else{
2030             put_rac(&s->c, &s->block_state[4 + s_context], 0);
2031             encode_q_branch2(s, level+1, 2*x+0, 2*y+0);
2032             encode_q_branch2(s, level+1, 2*x+1, 2*y+0);
2033             encode_q_branch2(s, level+1, 2*x+0, 2*y+1);
2034             encode_q_branch2(s, level+1, 2*x+1, 2*y+1);
2035             return;
2036         }
2037     }
2038     if(b->type & BLOCK_INTRA){
2039         pred_mv(s, &pmx, &pmy, 0, left, top, tr);
2040         put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);
2041         put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);
2042         put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);
2043         put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);
2044         set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0, BLOCK_INTRA);
2045     }else{
2046         pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);
2047         put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);
2048         if(s->ref_frames > 1)
2049             put_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], b->ref, 0);
2050         put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);
2051         put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);
2052         set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, b->ref, 0);
2053     }
2054 }
2055
2056 static void decode_q_branch(SnowContext *s, int level, int x, int y){
2057     const int w= s->b_width << s->block_max_depth;
2058     const int rem_depth= s->block_max_depth - level;
2059     const int index= (x + y*w) << rem_depth;
2060     int trx= (x+1)<<rem_depth;
2061     const BlockNode *left  = x ? &s->block[index-1] : &null_block;
2062     const BlockNode *top   = y ? &s->block[index-w] : &null_block;
2063     const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;
2064     const BlockNode *tr    = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
2065     int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
2066
2067     if(s->keyframe){
2068         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);
2069         return;
2070     }
2071
2072     if(level==s->block_max_depth || get_rac(&s->c, &s->block_state[4 + s_context])){
2073         int type, mx, my;
2074         int l = left->color[0];
2075         int cb= left->color[1];
2076         int cr= left->color[2];
2077         int ref = 0;
2078         int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
2079         int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 0*av_log2(2*FFABS(tr->mx - top->mx));
2080         int my_context= av_log2(2*FFABS(left->my - top->my)) + 0*av_log2(2*FFABS(tr->my - top->my));
2081
2082         type= get_rac(&s->c, &s->block_state[1 + left->type + top->type]) ? BLOCK_INTRA : 0;
2083
2084         if(type){
2085             pred_mv(s, &mx, &my, 0, left, top, tr);
2086             l += get_symbol(&s->c, &s->block_state[32], 1);
2087             cb+= get_symbol(&s->c, &s->block_state[64], 1);
2088             cr+= get_symbol(&s->c, &s->block_state[96], 1);
2089         }else{
2090             if(s->ref_frames > 1)
2091                 ref= get_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], 0);
2092             pred_mv(s, &mx, &my, ref, left, top, tr);
2093             mx+= get_symbol(&s->c, &s->block_state[128 + 32*(mx_context + 16*!!ref)], 1);
2094             my+= get_symbol(&s->c, &s->block_state[128 + 32*(my_context + 16*!!ref)], 1);
2095         }
2096         set_blocks(s, level, x, y, l, cb, cr, mx, my, ref, type);
2097     }else{
2098         decode_q_branch(s, level+1, 2*x+0, 2*y+0);
2099         decode_q_branch(s, level+1, 2*x+1, 2*y+0);
2100         decode_q_branch(s, level+1, 2*x+0, 2*y+1);
2101         decode_q_branch(s, level+1, 2*x+1, 2*y+1);
2102     }
2103 }
2104
2105 static void encode_blocks(SnowContext *s, int search){
2106     int x, y;
2107     int w= s->b_width;
2108     int h= s->b_height;
2109
2110     if(s->avctx->me_method == ME_ITER && !s->keyframe && search)
2111         iterative_me(s);
2112
2113     for(y=0; y<h; y++){
2114         if(s->c.bytestream_end - s->c.bytestream < w*MB_SIZE*MB_SIZE*3){ //FIXME nicer limit
2115             av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2116             return;
2117         }
2118         for(x=0; x<w; x++){
2119             if(s->avctx->me_method == ME_ITER || !search)
2120                 encode_q_branch2(s, 0, x, y);
2121             else
2122                 encode_q_branch (s, 0, x, y);
2123         }
2124     }
2125 }
2126
2127 static void decode_blocks(SnowContext *s){
2128     int x, y;
2129     int w= s->b_width;
2130     int h= s->b_height;
2131
2132     for(y=0; y<h; y++){
2133         for(x=0; x<w; x++){
2134             decode_q_branch(s, 0, x, y);
2135         }
2136     }
2137 }
2138
2139 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){
2140     const static uint8_t weight[64]={
2141     8,7,6,5,4,3,2,1,
2142     7,7,0,0,0,0,0,1,
2143     6,0,6,0,0,0,2,0,
2144     5,0,0,5,0,3,0,0,
2145     4,0,0,0,4,0,0,0,
2146     3,0,0,5,0,3,0,0,
2147     2,0,6,0,0,0,2,0,
2148     1,7,0,0,0,0,0,1,
2149     };
2150
2151     const static uint8_t brane[256]={
2152     0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
2153     0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
2154     0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
2155     0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
2156     0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
2157     0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
2158     0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
2159     0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
2160     0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
2161     0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
2162     0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
2163     0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
2164     0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
2165     0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
2166     0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
2167     0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
2168     };
2169
2170     const static uint8_t needs[16]={
2171     0,1,0,0,
2172     2,4,2,0,
2173     0,1,0,0,
2174     15
2175     };
2176
2177     int x, y, b, r, l;
2178     int16_t tmpIt   [64*(32+HTAPS_MAX)];
2179     uint8_t tmp2t[3][stride*(32+HTAPS_MAX)];
2180     int16_t *tmpI= tmpIt;
2181     uint8_t *tmp2= tmp2t[0];
2182     uint8_t *hpel[11];
2183 START_TIMER
2184     assert(dx<16 && dy<16);
2185     r= brane[dx + 16*dy]&15;
2186     l= brane[dx + 16*dy]>>4;
2187
2188     b= needs[l] | needs[r];
2189     if(p && !p->diag_mc)
2190         b= 15;
2191
2192     if(b&5){
2193         for(y=0; y < b_h+HTAPS_MAX-1; y++){
2194             for(x=0; x < b_w; x++){
2195                 int a_1=src[x + HTAPS_MAX/2-4];
2196                 int a0= src[x + HTAPS_MAX/2-3];
2197                 int a1= src[x + HTAPS_MAX/2-2];
2198                 int a2= src[x + HTAPS_MAX/2-1];
2199                 int a3= src[x + HTAPS_MAX/2+0];
2200                 int a4= src[x + HTAPS_MAX/2+1];
2201                 int a5= src[x + HTAPS_MAX/2+2];
2202                 int a6= src[x + HTAPS_MAX/2+3];
2203                 int am=0;
2204                 if(!p || p->fast_mc){
2205                     am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
2206                     tmpI[x]= am;
2207                     am= (am+16)>>5;
2208                 }else{
2209                     am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
2210                     tmpI[x]= am;
2211                     am= (am+32)>>6;
2212                 }
2213
2214                 if(am&(~255)) am= ~(am>>31);
2215                 tmp2[x]= am;
2216             }
2217             tmpI+= 64;
2218             tmp2+= stride;
2219             src += stride;
2220         }
2221         src -= stride*y;
2222     }
2223     src += HTAPS_MAX/2 - 1;
2224     tmp2= tmp2t[1];
2225
2226     if(b&2){
2227         for(y=0; y < b_h; y++){
2228             for(x=0; x < b_w+1; x++){
2229                 int a_1=src[x + (HTAPS_MAX/2-4)*stride];
2230                 int a0= src[x + (HTAPS_MAX/2-3)*stride];
2231                 int a1= src[x + (HTAPS_MAX/2-2)*stride];
2232                 int a2= src[x + (HTAPS_MAX/2-1)*stride];
2233                 int a3= src[x + (HTAPS_MAX/2+0)*stride];
2234                 int a4= src[x + (HTAPS_MAX/2+1)*stride];
2235                 int a5= src[x + (HTAPS_MAX/2+2)*stride];
2236                 int a6= src[x + (HTAPS_MAX/2+3)*stride];
2237                 int am=0;
2238                 if(!p || p->fast_mc)
2239                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
2240                 else
2241                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
2242
2243                 if(am&(~255)) am= ~(am>>31);
2244                 tmp2[x]= am;
2245             }
2246             src += stride;
2247             tmp2+= stride;
2248         }
2249         src -= stride*y;
2250     }
2251     src += stride*(HTAPS_MAX/2 - 1);
2252     tmp2= tmp2t[2];
2253     tmpI= tmpIt;
2254     if(b&4){
2255         for(y=0; y < b_h; y++){
2256             for(x=0; x < b_w; x++){
2257                 int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
2258                 int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
2259                 int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
2260                 int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
2261                 int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
2262                 int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
2263                 int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
2264                 int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
2265                 int am=0;
2266                 if(!p || p->fast_mc)
2267                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
2268                 else
2269                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
2270                 if(am&(~255)) am= ~(am>>31);
2271                 tmp2[x]= am;
2272             }
2273             tmpI+= 64;
2274             tmp2+= stride;
2275         }
2276     }
2277
2278     hpel[ 0]= src;
2279     hpel[ 1]= tmp2t[0] + stride*(HTAPS_MAX/2-1);
2280     hpel[ 2]= src + 1;
2281
2282     hpel[ 4]= tmp2t[1];
2283     hpel[ 5]= tmp2t[2];
2284     hpel[ 6]= tmp2t[1] + 1;
2285
2286     hpel[ 8]= src + stride;
2287     hpel[ 9]= hpel[1] + stride;
2288     hpel[10]= hpel[8] + 1;
2289
2290     if(b==15){
2291         uint8_t *src1= hpel[dx/8 + dy/8*4  ];
2292         uint8_t *src2= hpel[dx/8 + dy/8*4+1];
2293         uint8_t *src3= hpel[dx/8 + dy/8*4+4];
2294         uint8_t *src4= hpel[dx/8 + dy/8*4+5];
2295         dx&=7;
2296         dy&=7;
2297         for(y=0; y < b_h; y++){
2298             for(x=0; x < b_w; x++){
2299                 dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
2300                          (8-dx)*   dy *src3[x] + dx*   dy *src4[x]+32)>>6;
2301             }
2302             src1+=stride;
2303             src2+=stride;
2304             src3+=stride;
2305             src4+=stride;
2306             dst +=stride;
2307         }
2308     }else{
2309         uint8_t *src1= hpel[l];
2310         uint8_t *src2= hpel[r];
2311         int a= weight[((dx&7) + (8*(dy&7)))];
2312         int b= 8-a;
2313         for(y=0; y < b_h; y++){
2314             for(x=0; x < b_w; x++){
2315                 dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
2316             }
2317             src1+=stride;
2318             src2+=stride;
2319             dst +=stride;
2320         }
2321     }
2322 STOP_TIMER("mc_block")
2323 }
2324
2325 #define mca(dx,dy,b_w)\
2326 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, int stride, int h){\
2327     uint8_t tmp[stride*(b_w+HTAPS_MAX-1)];\
2328     assert(h==b_w);\
2329     mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, tmp, stride, b_w, b_w, dx, dy);\
2330 }
2331
2332 mca( 0, 0,16)
2333 mca( 8, 0,16)
2334 mca( 0, 8,16)
2335 mca( 8, 8,16)
2336 mca( 0, 0,8)
2337 mca( 8, 0,8)
2338 mca( 0, 8,8)
2339 mca( 8, 8,8)
2340
2341 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){
2342     if(block->type & BLOCK_INTRA){
2343         int x, y;
2344         const int color = block->color[plane_index];
2345         const int color4= color*0x01010101;
2346         if(b_w==32){
2347             for(y=0; y < b_h; y++){
2348                 *(uint32_t*)&dst[0 + y*stride]= color4;
2349                 *(uint32_t*)&dst[4 + y*stride]= color4;
2350                 *(uint32_t*)&dst[8 + y*stride]= color4;
2351                 *(uint32_t*)&dst[12+ y*stride]= color4;
2352                 *(uint32_t*)&dst[16+ y*stride]= color4;
2353                 *(uint32_t*)&dst[20+ y*stride]= color4;
2354                 *(uint32_t*)&dst[24+ y*stride]= color4;
2355                 *(uint32_t*)&dst[28+ y*stride]= color4;
2356             }
2357         }else if(b_w==16){
2358             for(y=0; y < b_h; y++){
2359                 *(uint32_t*)&dst[0 + y*stride]= color4;
2360                 *(uint32_t*)&dst[4 + y*stride]= color4;
2361                 *(uint32_t*)&dst[8 + y*stride]= color4;
2362                 *(uint32_t*)&dst[12+ y*stride]= color4;
2363             }
2364         }else if(b_w==8){
2365             for(y=0; y < b_h; y++){
2366                 *(uint32_t*)&dst[0 + y*stride]= color4;
2367                 *(uint32_t*)&dst[4 + y*stride]= color4;
2368             }
2369         }else if(b_w==4){
2370             for(y=0; y < b_h; y++){
2371                 *(uint32_t*)&dst[0 + y*stride]= color4;
2372             }
2373         }else{
2374             for(y=0; y < b_h; y++){
2375                 for(x=0; x < b_w; x++){
2376                     dst[x + y*stride]= color;
2377                 }
2378             }
2379         }
2380     }else{
2381         uint8_t *src= s->last_picture[block->ref].data[plane_index];
2382         const int scale= plane_index ?  s->mv_scale : 2*s->mv_scale;
2383         int mx= block->mx*scale;
2384         int my= block->my*scale;
2385         const int dx= mx&15;
2386         const int dy= my&15;
2387         const int tab_index= 3 - (b_w>>2) + (b_w>>4);
2388         sx += (mx>>4) - (HTAPS_MAX/2-1);
2389         sy += (my>>4) - (HTAPS_MAX/2-1);
2390         src += sx + sy*stride;
2391         if(   (unsigned)sx >= w - b_w - (HTAPS_MAX-2)
2392            || (unsigned)sy >= h - b_h - (HTAPS_MAX-2)){
2393             ff_emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);
2394             src= tmp + MB_SIZE;
2395         }
2396 //        assert(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h);
2397 //        assert(!(b_w&(b_w-1)));
2398         assert(b_w>1 && b_h>1);
2399         assert(tab_index>=0 && tab_index<4 || b_w==32);
2400         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 )
2401             mc_block(&s->plane[plane_index], dst, src, tmp, stride, b_w, b_h, dx, dy);
2402         else if(b_w==32){
2403             int y;
2404             for(y=0; y<b_h; y+=16){
2405                 s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
2406                 s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
2407             }
2408         }else if(b_w==b_h)
2409             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
2410         else if(b_w==2*b_h){
2411             s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst    ,src + 3       + 3*stride,stride);
2412             s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
2413         }else{
2414             assert(2*b_w==b_h);
2415             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst           ,src + 3 + 3*stride           ,stride);
2416             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
2417         }
2418     }
2419 }
2420
2421 void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
2422                               int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){
2423     int y, x;
2424     IDWTELEM * dst;
2425     for(y=0; y<b_h; y++){
2426         //FIXME ugly misuse of obmc_stride
2427         const uint8_t *obmc1= obmc + y*obmc_stride;
2428         const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
2429         const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
2430         const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
2431         dst = slice_buffer_get_line(sb, src_y + y);
2432         for(x=0; x<b_w; x++){
2433             int v=   obmc1[x] * block[3][x + y*src_stride]
2434                     +obmc2[x] * block[2][x + y*src_stride]
2435                     +obmc3[x] * block[1][x + y*src_stride]
2436                     +obmc4[x] * block[0][x + y*src_stride];
2437
2438             v <<= 8 - LOG2_OBMC_MAX;
2439             if(FRAC_BITS != 8){
2440                 v >>= 8 - FRAC_BITS;
2441             }
2442             if(add){
2443                 v += dst[x + src_x];
2444                 v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
2445                 if(v&(~255)) v= ~(v>>31);
2446                 dst8[x + y*src_stride] = v;
2447             }else{
2448                 dst[x + src_x] -= v;
2449             }
2450         }
2451     }
2452 }
2453
2454 //FIXME name clenup (b_w, block_w, b_width stuff)
2455 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){
2456     const int b_width = s->b_width  << s->block_max_depth;
2457     const int b_height= s->b_height << s->block_max_depth;
2458     const int b_stride= b_width;
2459     BlockNode *lt= &s->block[b_x + b_y*b_stride];
2460     BlockNode *rt= lt+1;
2461     BlockNode *lb= lt+b_stride;
2462     BlockNode *rb= lb+1;
2463     uint8_t *block[4];
2464     int tmp_step= src_stride >= 7*MB_SIZE ? MB_SIZE : MB_SIZE*src_stride;
2465     uint8_t tmp[src_stride*7*MB_SIZE]; //FIXME align
2466     uint8_t *ptmp;
2467     int x,y;
2468
2469     if(b_x<0){
2470         lt= rt;
2471         lb= rb;
2472     }else if(b_x + 1 >= b_width){
2473         rt= lt;
2474         rb= lb;
2475     }
2476     if(b_y<0){
2477         lt= lb;
2478         rt= rb;
2479     }else if(b_y + 1 >= b_height){
2480         lb= lt;
2481         rb= rt;
2482     }
2483
2484     if(src_x<0){ //FIXME merge with prev & always round internal width upto *16
2485         obmc -= src_x;
2486         b_w += src_x;
2487         if(!sliced && !offset_dst)
2488             dst -= src_x;
2489         src_x=0;
2490     }else if(src_x + b_w > w){
2491         b_w = w - src_x;
2492     }
2493     if(src_y<0){
2494         obmc -= src_y*obmc_stride;
2495         b_h += src_y;
2496         if(!sliced && !offset_dst)
2497             dst -= src_y*dst_stride;
2498         src_y=0;
2499     }else if(src_y + b_h> h){
2500         b_h = h - src_y;
2501     }
2502
2503     if(b_w<=0 || b_h<=0) return;
2504
2505 assert(src_stride > 2*MB_SIZE + 5);
2506     if(!sliced && offset_dst)
2507         dst += src_x + src_y*dst_stride;
2508     dst8+= src_x + src_y*src_stride;
2509 //    src += src_x + src_y*src_stride;
2510
2511     ptmp= tmp + 3*tmp_step;
2512     block[0]= ptmp;
2513     ptmp+=tmp_step;
2514     pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
2515
2516     if(same_block(lt, rt)){
2517         block[1]= block[0];
2518     }else{
2519         block[1]= ptmp;
2520         ptmp+=tmp_step;
2521         pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
2522     }
2523
2524     if(same_block(lt, lb)){
2525         block[2]= block[0];
2526     }else if(same_block(rt, lb)){
2527         block[2]= block[1];
2528     }else{
2529         block[2]= ptmp;
2530         ptmp+=tmp_step;
2531         pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
2532     }
2533
2534     if(same_block(lt, rb) ){
2535         block[3]= block[0];
2536     }else if(same_block(rt, rb)){
2537         block[3]= block[1];
2538     }else if(same_block(lb, rb)){
2539         block[3]= block[2];
2540     }else{
2541         block[3]= ptmp;
2542         pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
2543     }
2544 #if 0
2545     for(y=0; y<b_h; y++){
2546         for(x=0; x<b_w; x++){
2547             int v=   obmc [x + y*obmc_stride] * block[3][x + y*src_stride] * (256/OBMC_MAX);
2548             if(add) dst[x + y*dst_stride] += v;
2549             else    dst[x + y*dst_stride] -= v;
2550         }
2551     }
2552     for(y=0; y<b_h; y++){
2553         uint8_t *obmc2= obmc + (obmc_stride>>1);
2554         for(x=0; x<b_w; x++){
2555             int v=   obmc2[x + y*obmc_stride] * block[2][x + y*src_stride] * (256/OBMC_MAX);
2556             if(add) dst[x + y*dst_stride] += v;
2557             else    dst[x + y*dst_stride] -= v;
2558         }
2559     }
2560     for(y=0; y<b_h; y++){
2561         uint8_t *obmc3= obmc + obmc_stride*(obmc_stride>>1);
2562         for(x=0; x<b_w; x++){
2563             int v=   obmc3[x + y*obmc_stride] * block[1][x + y*src_stride] * (256/OBMC_MAX);
2564             if(add) dst[x + y*dst_stride] += v;
2565             else    dst[x + y*dst_stride] -= v;
2566         }
2567     }
2568     for(y=0; y<b_h; y++){
2569         uint8_t *obmc3= obmc + obmc_stride*(obmc_stride>>1);
2570         uint8_t *obmc4= obmc3+ (obmc_stride>>1);
2571         for(x=0; x<b_w; x++){
2572             int v=   obmc4[x + y*obmc_stride] * block[0][x + y*src_stride] * (256/OBMC_MAX);
2573             if(add) dst[x + y*dst_stride] += v;
2574             else    dst[x + y*dst_stride] -= v;
2575         }
2576     }
2577 #else
2578     if(sliced){
2579         START_TIMER
2580
2581         s->dsp.inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
2582         STOP_TIMER("inner_add_yblock")
2583     }else
2584     for(y=0; y<b_h; y++){
2585         //FIXME ugly misuse of obmc_stride
2586         const uint8_t *obmc1= obmc + y*obmc_stride;
2587         const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
2588         const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
2589         const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
2590         for(x=0; x<b_w; x++){
2591             int v=   obmc1[x] * block[3][x + y*src_stride]
2592                     +obmc2[x] * block[2][x + y*src_stride]
2593                     +obmc3[x] * block[1][x + y*src_stride]
2594                     +obmc4[x] * block[0][x + y*src_stride];
2595
2596             v <<= 8 - LOG2_OBMC_MAX;
2597             if(FRAC_BITS != 8){
2598                 v >>= 8 - FRAC_BITS;
2599             }
2600             if(add){
2601                 v += dst[x + y*dst_stride];
2602                 v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
2603                 if(v&(~255)) v= ~(v>>31);
2604                 dst8[x + y*src_stride] = v;
2605             }else{
2606                 dst[x + y*dst_stride] -= v;
2607             }
2608         }
2609     }
2610 #endif /* 0 */
2611 }
2612
2613 static av_always_inline void predict_slice_buffered(SnowContext *s, slice_buffer * sb, IDWTELEM * old_buffer, int plane_index, int add, int mb_y){
2614     Plane *p= &s->plane[plane_index];
2615     const int mb_w= s->b_width  << s->block_max_depth;
2616     const int mb_h= s->b_height << s->block_max_depth;
2617     int x, y, mb_x;
2618     int block_size = MB_SIZE >> s->block_max_depth;
2619     int block_w    = plane_index ? block_size/2 : block_size;
2620     const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
2621     int obmc_stride= plane_index ? block_size : 2*block_size;
2622     int ref_stride= s->current_picture.linesize[plane_index];
2623     uint8_t *dst8= s->current_picture.data[plane_index];
2624     int w= p->width;
2625     int h= p->height;
2626     START_TIMER
2627
2628     if(s->keyframe || (s->avctx->debug&512)){
2629         if(mb_y==mb_h)
2630             return;
2631
2632         if(add){
2633             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++)
2634             {
2635 //                DWTELEM * line = slice_buffer_get_line(sb, y);
2636                 IDWTELEM * line = sb->line[y];
2637                 for(x=0; x<w; x++)
2638                 {
2639 //                    int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
2640                     int v= line[x] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
2641                     v >>= FRAC_BITS;
2642                     if(v&(~255)) v= ~(v>>31);
2643                     dst8[x + y*ref_stride]= v;
2644                 }
2645             }
2646         }else{
2647             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++)
2648             {
2649 //                DWTELEM * line = slice_buffer_get_line(sb, y);
2650                 IDWTELEM * line = sb->line[y];
2651                 for(x=0; x<w; x++)
2652                 {
2653                     line[x] -= 128 << FRAC_BITS;
2654 //                    buf[x + y*w]-= 128<<FRAC_BITS;
2655                 }
2656             }
2657         }
2658
2659         return;
2660     }
2661
2662         for(mb_x=0; mb_x<=mb_w; mb_x++){
2663             START_TIMER
2664
2665             add_yblock(s, 1, sb, old_buffer, dst8, obmc,
2666                        block_w*mb_x - block_w/2,
2667                        block_w*mb_y - block_w/2,
2668                        block_w, block_w,
2669                        w, h,
2670                        w, ref_stride, obmc_stride,
2671                        mb_x - 1, mb_y - 1,
2672                        add, 0, plane_index);
2673
2674             STOP_TIMER("add_yblock")
2675         }
2676
2677     STOP_TIMER("predict_slice")
2678 }
2679
2680 static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y){
2681     Plane *p= &s->plane[plane_index];
2682     const int mb_w= s->b_width  << s->block_max_depth;
2683     const int mb_h= s->b_height << s->block_max_depth;
2684     int x, y, mb_x;
2685     int block_size = MB_SIZE >> s->block_max_depth;
2686     int block_w    = plane_index ? block_size/2 : block_size;
2687     const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
2688     const int obmc_stride= plane_index ? block_size : 2*block_size;
2689     int ref_stride= s->current_picture.linesize[plane_index];
2690     uint8_t *dst8= s->current_picture.data[plane_index];
2691     int w= p->width;
2692     int h= p->height;
2693     START_TIMER
2694
2695     if(s->keyframe || (s->avctx->debug&512)){
2696         if(mb_y==mb_h)
2697             return;
2698
2699         if(add){
2700             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
2701                 for(x=0; x<w; x++){
2702                     int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
2703                     v >>= FRAC_BITS;
2704                     if(v&(~255)) v= ~(v>>31);
2705                     dst8[x + y*ref_stride]= v;
2706                 }
2707             }
2708         }else{
2709             for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
2710                 for(x=0; x<w; x++){
2711                     buf[x + y*w]-= 128<<FRAC_BITS;
2712                 }
2713             }
2714         }
2715
2716         return;
2717     }
2718
2719         for(mb_x=0; mb_x<=mb_w; mb_x++){
2720             START_TIMER
2721
2722             add_yblock(s, 0, NULL, buf, dst8, obmc,
2723                        block_w*mb_x - block_w/2,
2724                        block_w*mb_y - block_w/2,
2725                        block_w, block_w,
2726                        w, h,
2727                        w, ref_stride, obmc_stride,
2728                        mb_x - 1, mb_y - 1,
2729                        add, 1, plane_index);
2730
2731             STOP_TIMER("add_yblock")
2732         }
2733
2734     STOP_TIMER("predict_slice")
2735 }
2736
2737 static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add){
2738     const int mb_h= s->b_height << s->block_max_depth;
2739     int mb_y;
2740     for(mb_y=0; mb_y<=mb_h; mb_y++)
2741         predict_slice(s, buf, plane_index, add, mb_y);
2742 }
2743
2744 static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index){
2745     int i, x2, y2;
2746     Plane *p= &s->plane[plane_index];
2747     const int block_size = MB_SIZE >> s->block_max_depth;
2748     const int block_w    = plane_index ? block_size/2 : block_size;
2749     const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
2750     const int obmc_stride= plane_index ? block_size : 2*block_size;
2751     const int ref_stride= s->current_picture.linesize[plane_index];
2752     uint8_t *src= s-> input_picture.data[plane_index];
2753     IDWTELEM *dst= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
2754     const int b_stride = s->b_width << s->block_max_depth;
2755     const int w= p->width;
2756     const int h= p->height;
2757     int index= mb_x + mb_y*b_stride;
2758     BlockNode *b= &s->block[index];
2759     BlockNode backup= *b;
2760     int ab=0;
2761     int aa=0;
2762
2763     b->type|= BLOCK_INTRA;
2764     b->color[plane_index]= 0;
2765     memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));
2766
2767     for(i=0; i<4; i++){
2768         int mb_x2= mb_x + (i &1) - 1;
2769         int mb_y2= mb_y + (i>>1) - 1;
2770         int x= block_w*mb_x2 + block_w/2;
2771         int y= block_w*mb_y2 + block_w/2;
2772
2773         add_yblock(s, 0, NULL, dst + ((i&1)+(i>>1)*obmc_stride)*block_w, NULL, obmc,
2774                     x, y, block_w, block_w, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
2775
2776         for(y2= FFMAX(y, 0); y2<FFMIN(h, y+block_w); y2++){
2777             for(x2= FFMAX(x, 0); x2<FFMIN(w, x+block_w); x2++){
2778                 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_w*mb_y - block_w/2))*obmc_stride;
2779                 int obmc_v= obmc[index];
2780                 int d;
2781                 if(y<0) obmc_v += obmc[index + block_w*obmc_stride];
2782                 if(x<0) obmc_v += obmc[index + block_w];
2783                 if(y+block_w>h) obmc_v += obmc[index - block_w*obmc_stride];
2784                 if(x+block_w>w) obmc_v += obmc[index - block_w];
2785                 //FIXME precalc this or simplify it somehow else
2786
2787                 d = -dst[index] + (1<<(FRAC_BITS-1));
2788                 dst[index] = d;
2789                 ab += (src[x2 + y2*ref_stride] - (d>>FRAC_BITS)) * obmc_v;
2790                 aa += obmc_v * obmc_v; //FIXME precalclate this
2791             }
2792         }
2793     }
2794     *b= backup;
2795
2796     return av_clip(((ab<<LOG2_OBMC_MAX) + aa/2)/aa, 0, 255); //FIXME we should not need clipping
2797 }
2798
2799 static inline int get_block_bits(SnowContext *s, int x, int y, int w){
2800     const int b_stride = s->b_width << s->block_max_depth;
2801     const int b_height = s->b_height<< s->block_max_depth;
2802     int index= x + y*b_stride;
2803     const BlockNode *b     = &s->block[index];
2804     const BlockNode *left  = x ? &s->block[index-1] : &null_block;
2805     const BlockNode *top   = y ? &s->block[index-b_stride] : &null_block;
2806     const BlockNode *tl    = y && x ? &s->block[index-b_stride-1] : left;
2807     const BlockNode *tr    = y && x+w<b_stride ? &s->block[index-b_stride+w] : tl;
2808     int dmx, dmy;
2809 //  int mx_context= av_log2(2*FFABS(left->mx - top->mx));
2810 //  int my_context= av_log2(2*FFABS(left->my - top->my));
2811
2812     if(x<0 || x>=b_stride || y>=b_height)
2813         return 0;
2814 /*
2815 1            0      0
2816 01X          1-2    1
2817 001XX        3-6    2-3
2818 0001XXX      7-14   4-7
2819 00001XXXX   15-30   8-15
2820 */
2821 //FIXME try accurate rate
2822 //FIXME intra and inter predictors if surrounding blocks arent the same type
2823     if(b->type & BLOCK_INTRA){
2824         return 3+2*( av_log2(2*FFABS(left->color[0] - b->color[0]))
2825                    + av_log2(2*FFABS(left->color[1] - b->color[1]))
2826                    + av_log2(2*FFABS(left->color[2] - b->color[2])));
2827     }else{
2828         pred_mv(s, &dmx, &dmy, b->ref, left, top, tr);
2829         dmx-= b->mx;
2830         dmy-= b->my;
2831         return 2*(1 + av_log2(2*FFABS(dmx)) //FIXME kill the 2* can be merged in lambda
2832                     + av_log2(2*FFABS(dmy))
2833                     + av_log2(2*b->ref));
2834     }
2835 }
2836
2837 static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, const uint8_t *obmc_edged){
2838     Plane *p= &s->plane[plane_index];
2839     const int block_size = MB_SIZE >> s->block_max_depth;
2840     const int block_w    = plane_index ? block_size/2 : block_size;
2841     const int obmc_stride= plane_index ? block_size : 2*block_size;
2842     const int ref_stride= s->current_picture.linesize[plane_index];
2843     uint8_t *dst= s->current_picture.data[plane_index];
2844     uint8_t *src= s->  input_picture.data[plane_index];
2845     IDWTELEM *pred= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4;
2846     uint8_t cur[ref_stride*2*MB_SIZE]; //FIXME alignment
2847     uint8_t tmp[ref_stride*(2*MB_SIZE+HTAPS_MAX-1)];
2848     const int b_stride = s->b_width << s->block_max_depth;
2849     const int b_height = s->b_height<< s->block_max_depth;
2850     const int w= p->width;
2851     const int h= p->height;
2852     int distortion;
2853     int rate= 0;
2854     const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
2855     int sx= block_w*mb_x - block_w/2;
2856     int sy= block_w*mb_y - block_w/2;
2857     int x0= FFMAX(0,-sx);
2858     int y0= FFMAX(0,-sy);
2859     int x1= FFMIN(block_w*2, w-sx);
2860     int y1= FFMIN(block_w*2, h-sy);
2861     int i,x,y;
2862
2863     pred_block(s, cur, tmp, ref_stride, sx, sy, block_w*2, block_w*2, &s->block[mb_x + mb_y*b_stride], plane_index, w, h);
2864
2865     for(y=y0; y<y1; y++){
2866         const uint8_t *obmc1= obmc_edged + y*obmc_stride;
2867         const IDWTELEM *pred1 = pred + y*obmc_stride;
2868         uint8_t *cur1 = cur + y*ref_stride;
2869         uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
2870         for(x=x0; x<x1; x++){
2871 #if FRAC_BITS >= LOG2_OBMC_MAX
2872             int v = (cur1[x] * obmc1[x]) << (FRAC_BITS - LOG2_OBMC_MAX);
2873 #else
2874             int v = (cur1[x] * obmc1[x] + (1<<(LOG2_OBMC_MAX - FRAC_BITS-1))) >> (LOG2_OBMC_MAX - FRAC_BITS);
2875 #endif
2876             v = (v + pred1[x]) >> FRAC_BITS;
2877             if(v&(~255)) v= ~(v>>31);
2878             dst1[x] = v;
2879         }
2880     }
2881
2882     /* copy the regions where obmc[] = (uint8_t)256 */
2883     if(LOG2_OBMC_MAX == 8
2884         && (mb_x == 0 || mb_x == b_stride-1)
2885         && (mb_y == 0 || mb_y == b_height-1)){
2886         if(mb_x == 0)
2887             x1 = block_w;
2888         else
2889             x0 = block_w;
2890         if(mb_y == 0)
2891             y1 = block_w;
2892         else
2893             y0 = block_w;
2894         for(y=y0; y<y1; y++)
2895             memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
2896     }
2897
2898     if(block_w==16){
2899         /* FIXME rearrange dsputil to fit 32x32 cmp functions */
2900         /* FIXME check alignment of the cmp wavelet vs the encoding wavelet */
2901         /* FIXME cmps overlap but don't cover the wavelet's whole support,
2902          * so improving the score of one block is not strictly guaranteed to
2903          * improve the score of the whole frame, so iterative motion est
2904          * doesn't always converge. */
2905         if(s->avctx->me_cmp == FF_CMP_W97)
2906             distortion = w97_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
2907         else if(s->avctx->me_cmp == FF_CMP_W53)
2908             distortion = w53_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
2909         else{
2910             distortion = 0;
2911             for(i=0; i<4; i++){
2912                 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
2913                 distortion += s->dsp.me_cmp[0](&s->m, src + off, dst + off, ref_stride, 16);
2914             }
2915         }
2916     }else{
2917         assert(block_w==8);
2918         distortion = s->dsp.me_cmp[0](&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
2919     }
2920
2921     if(plane_index==0){
2922         for(i=0; i<4; i++){
2923 /* ..RRr
2924  * .RXx.
2925  * rxx..
2926  */
2927             rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
2928         }
2929         if(mb_x == b_stride-2)
2930             rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);
2931     }
2932     return distortion + rate*penalty_factor;
2933 }
2934
2935 static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){
2936     int i, y2;
2937     Plane *p= &s->plane[plane_index];
2938     const int block_size = MB_SIZE >> s->block_max_depth;
2939     const int block_w    = plane_index ? block_size/2 : block_size;
2940     const uint8_t *obmc  = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
2941     const int obmc_stride= plane_index ? block_size : 2*block_size;
2942     const int ref_stride= s->current_picture.linesize[plane_index];
2943     uint8_t *dst= s->current_picture.data[plane_index];
2944     uint8_t *src= s-> input_picture.data[plane_index];
2945     static const IDWTELEM zero_dst[4096]; //FIXME
2946     const int b_stride = s->b_width << s->block_max_depth;
2947     const int w= p->width;
2948     const int h= p->height;
2949     int distortion= 0;
2950     int rate= 0;
2951     const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
2952
2953     for(i=0; i<9; i++){
2954         int mb_x2= mb_x + (i%3) - 1;
2955         int mb_y2= mb_y + (i/3) - 1;
2956         int x= block_w*mb_x2 + block_w/2;
2957         int y= block_w*mb_y2 + block_w/2;
2958
2959         add_yblock(s, 0, NULL, zero_dst, dst, obmc,
2960                    x, y, block_w, block_w, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
2961
2962         //FIXME find a cleaner/simpler way to skip the outside stuff
2963         for(y2= y; y2<0; y2++)
2964             memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
2965         for(y2= h; y2<y+block_w; y2++)
2966             memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
2967         if(x<0){
2968             for(y2= y; y2<y+block_w; y2++)
2969                 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
2970         }
2971         if(x+block_w > w){
2972             for(y2= y; y2<y+block_w; y2++)
2973                 memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
2974         }
2975
2976         assert(block_w== 8 || block_w==16);
2977         distortion += s->dsp.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_w);
2978     }
2979
2980     if(plane_index==0){
2981         BlockNode *b= &s->block[mb_x+mb_y*b_stride];
2982         int merged= same_block(b,b+1) && same_block(b,b+b_stride) && same_block(b,b+b_stride+1);
2983
2984 /* ..RRRr
2985  * .RXXx.
2986  * .RXXx.
2987  * rxxx.
2988  */
2989         if(merged)
2990             rate = get_block_bits(s, mb_x, mb_y, 2);
2991         for(i=merged?4:0; i<9; i++){
2992             static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
2993             rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);
2994         }
2995     }
2996     return distortion + rate*penalty_factor;
2997 }
2998
2999 static av_always_inline int check_block(SnowContext *s, int mb_x, int mb_y, int p[3], int intra, const uint8_t *obmc_edged, int *best_rd){
3000     const int b_stride= s->b_width << s->block_max_depth;
3001     BlockNode *block= &s->block[mb_x + mb_y * b_stride];
3002     BlockNode backup= *block;
3003     int rd, index, value;
3004
3005     assert(mb_x>=0 && mb_y>=0);
3006     assert(mb_x<b_stride);
3007
3008     if(intra){
3009         block->color[0] = p[0];
3010         block->color[1] = p[1];
3011         block->color[2] = p[2];
3012         block->type |= BLOCK_INTRA;
3013     }else{
3014         index= (p[0] + 31*p[1]) & (ME_CACHE_SIZE-1);
3015         value= s->me_cache_generation + (p[0]>>10) + (p[1]<<6) + (block->ref<<12);
3016         if(s->me_cache[index] == value)
3017             return 0;
3018         s->me_cache[index]= value;
3019
3020         block->mx= p[0];
3021         block->my= p[1];
3022         block->type &= ~BLOCK_INTRA;
3023     }
3024
3025     rd= get_block_rd(s, mb_x, mb_y, 0, obmc_edged);
3026
3027 //FIXME chroma
3028     if(rd < *best_rd){
3029         *best_rd= rd;
3030         return 1;
3031     }else{
3032         *block= backup;
3033         return 0;
3034     }
3035 }
3036
3037 /* special case for int[2] args we discard afterward, fixes compilation prob with gcc 2.95 */
3038 static av_always_inline int check_block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, const uint8_t *obmc_edged, int *best_rd){
3039     int p[2] = {p0, p1};
3040     return check_block(s, mb_x, mb_y, p, 0, obmc_edged, best_rd);
3041 }
3042
3043 static av_always_inline int check_4block_inter(SnowContext *s, int mb_x, int mb_y, int p0, int p1, int ref, int *best_rd){
3044     const int b_stride= s->b_width << s->block_max_depth;
3045     BlockNode *block= &s->block[mb_x + mb_y * b_stride];
3046     BlockNode backup[4]= {block[0], block[1], block[b_stride], block[b_stride+1]};
3047     int rd, index, value;
3048
3049     assert(mb_x>=0 && mb_y>=0);
3050     assert(mb_x<b_stride);
3051     assert(((mb_x|mb_y)&1) == 0);
3052
3053     index= (p0 + 31*p1) & (ME_CACHE_SIZE-1);
3054     value= s->me_cache_generation + (p0>>10) + (p1<<6) + (block->ref<<12);
3055     if(s->me_cache[index] == value)
3056         return 0;
3057     s->me_cache[index]= value;
3058
3059     block->mx= p0;
3060     block->my= p1;
3061     block->ref= ref;
3062     block->type &= ~BLOCK_INTRA;
3063     block[1]= block[b_stride]= block[b_stride+1]= *block;
3064
3065     rd= get_4block_rd(s, mb_x, mb_y, 0);
3066
3067 //FIXME chroma
3068     if(rd < *best_rd){
3069         *best_rd= rd;
3070         return 1;
3071     }else{
3072         block[0]= backup[0];
3073         block[1]= backup[1];
3074         block[b_stride]= backup[2];
3075         block[b_stride+1]= backup[3];
3076         return 0;
3077     }
3078 }
3079
3080 static void iterative_me(SnowContext *s){
3081     int pass, mb_x, mb_y;
3082     const int b_width = s->b_width  << s->block_max_depth;
3083     const int b_height= s->b_height << s->block_max_depth;
3084     const int b_stride= b_width;
3085     int color[3];
3086
3087     {
3088         RangeCoder r = s->c;
3089         uint8_t state[sizeof(s->block_state)];
3090         memcpy(state, s->block_state, sizeof(s->block_state));
3091         for(mb_y= 0; mb_y<s->b_height; mb_y++)
3092             for(mb_x= 0; mb_x<s->b_width; mb_x++)
3093                 encode_q_branch(s, 0, mb_x, mb_y);
3094         s->c = r;
3095         memcpy(s->block_state, state, sizeof(s->block_state));
3096     }
3097
3098     for(pass=0; pass<25; pass++){
3099         int change= 0;
3100
3101         for(mb_y= 0; mb_y<b_height; mb_y++){
3102             for(mb_x= 0; mb_x<b_width; mb_x++){
3103                 int dia_change, i, j, ref;
3104                 int best_rd= INT_MAX, ref_rd;
3105                 BlockNode backup, ref_b;
3106                 const int index= mb_x + mb_y * b_stride;
3107                 BlockNode *block= &s->block[index];
3108                 BlockNode *tb =                   mb_y            ? &s->block[index-b_stride  ] : NULL;
3109                 BlockNode *lb = mb_x                              ? &s->block[index         -1] : NULL;
3110                 BlockNode *rb = mb_x+1<b_width                    ? &s->block[index         +1] : NULL;
3111                 BlockNode *bb =                   mb_y+1<b_height ? &s->block[index+b_stride  ] : NULL;
3112                 BlockNode *tlb= mb_x           && mb_y            ? &s->block[index-b_stride-1] : NULL;
3113                 BlockNode *trb= mb_x+1<b_width && mb_y            ? &s->block[index-b_stride+1] : NULL;
3114                 BlockNode *blb= mb_x           && mb_y+1<b_height ? &s->block[index+b_stride-1] : NULL;
3115                 BlockNode *brb= mb_x+1<b_width && mb_y+1<b_height ? &s->block[index+b_stride+1] : NULL;
3116                 const int b_w= (MB_SIZE >> s->block_max_depth);
3117                 uint8_t obmc_edged[b_w*2][b_w*2];
3118
3119                 if(pass && (block->type & BLOCK_OPT))
3120                     continue;
3121                 block->type |= BLOCK_OPT;
3122
3123                 backup= *block;
3124
3125                 if(!s->me_cache_generation)
3126                     memset(s->me_cache, 0, sizeof(s->me_cache));
3127                 s->me_cache_generation += 1<<22;
3128
3129                 //FIXME precalc
3130                 {
3131                     int x, y;
3132                     memcpy(obmc_edged, obmc_tab[s->block_max_depth], b_w*b_w*4);
3133                     if(mb_x==0)
3134                         for(y=0; y<b_w*2; y++)
3135                             memset(obmc_edged[y], obmc_edged[y][0] + obmc_edged[y][b_w-1], b_w);
3136                     if(mb_x==b_stride-1)
3137                         for(y=0; y<b_w*2; y++)
3138                             memset(obmc_edged[y]+b_w, obmc_edged[y][b_w] + obmc_edged[y][b_w*2-1], b_w);
3139                     if(mb_y==0){
3140                         for(x=0; x<b_w*2; x++)
3141                             obmc_edged[0][x] += obmc_edged[b_w-1][x];
3142                         for(y=1; y<b_w; y++)
3143                             memcpy(obmc_edged[y], obmc_edged[0], b_w*2);
3144                     }
3145                     if(mb_y==b_height-1){
3146                         for(x=0; x<b_w*2; x++)
3147                             obmc_edged[b_w*2-1][x] += obmc_edged[b_w][x];
3148                         for(y=b_w; y<b_w*2-1; y++)
3149                             memcpy(obmc_edged[y], obmc_edged[b_w*2-1], b_w*2);
3150                     }
3151                 }
3152
3153                 //skip stuff outside the picture
3154                 if(mb_x==0 || mb_y==0 || mb_x==b_width-1 || mb_y==b_height-1)
3155                 {
3156                     uint8_t *src= s->  input_picture.data[0];
3157                     uint8_t *dst= s->current_picture.data[0];
3158                     const int stride= s->current_picture.linesize[0];
3159                     const int block_w= MB_SIZE >> s->block_max_depth;
3160                     const int sx= block_w*mb_x - block_w/2;
3161                     const int sy= block_w*mb_y - block_w/2;
3162                     const int w= s->plane[0].width;
3163                     const int h= s->plane[0].height;
3164                     int y;
3165
3166                     for(y=sy; y<0; y++)
3167                         memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
3168                     for(y=h; y<sy+block_w*2; y++)
3169                         memcpy(dst + sx + y*stride, src + sx + y*stride, block_w*2);
3170                     if(sx<0){
3171                         for(y=sy; y<sy+block_w*2; y++)
3172                             memcpy(dst + sx + y*stride, src + sx + y*stride, -sx);
3173                     }
3174                     if(sx+block_w*2 > w){
3175                         for(y=sy; y<sy+block_w*2; y++)
3176                             memcpy(dst + w + y*stride, src + w + y*stride, sx+block_w*2 - w);
3177                     }
3178                 }
3179
3180                 // intra(black) = neighbors' contribution to the current block
3181                 for(i=0; i<3; i++)
3182                     color[i]= get_dc(s, mb_x, mb_y, i);
3183
3184                 // get previous score (cannot be cached due to OBMC)
3185                 if(pass > 0 && (block->type&BLOCK_INTRA)){
3186                     int color0[3]= {block->color[0], block->color[1], block->color[2]};
3187                     check_block(s, mb_x, mb_y, color0, 1, *obmc_edged, &best_rd);
3188                 }else
3189                     check_block_inter(s, mb_x, mb_y, block->mx, block->my, *obmc_edged, &best_rd);
3190
3191                 ref_b= *block;
3192                 ref_rd= best_rd;
3193                 for(ref=0; ref < s->ref_frames; ref++){
3194                     int16_t (*mvr)[2]= &s->ref_mvs[ref][index];
3195                     if(s->ref_scores[ref][index] > s->ref_scores[ref_b.ref][index]*3/2) //FIXME tune threshold
3196                         continue;
3197                     block->ref= ref;
3198                     best_rd= INT_MAX;
3199
3200                     check_block_inter(s, mb_x, mb_y, mvr[0][0], mvr[0][1], *obmc_edged, &best_rd);
3201                     check_block_inter(s, mb_x, mb_y, 0, 0, *obmc_edged, &best_rd);
3202                     if(tb)
3203                         check_block_inter(s, mb_x, mb_y, mvr[-b_stride][0], mvr[-b_stride][1], *obmc_edged, &best_rd);
3204                     if(lb)
3205                         check_block_inter(s, mb_x, mb_y, mvr[-1][0], mvr[-1][1], *obmc_edged, &best_rd);
3206                     if(rb)
3207                         check_block_inter(s, mb_x, mb_y, mvr[1][0], mvr[1][1], *obmc_edged, &best_rd);
3208                     if(bb)
3209                         check_block_inter(s, mb_x, mb_y, mvr[b_stride][0], mvr[b_stride][1], *obmc_edged, &best_rd);
3210
3211                     /* fullpel ME */
3212                     //FIXME avoid subpel interpol / round to nearest integer
3213                     do{
3214                         dia_change=0;
3215                         for(i=0; i<FFMAX(s->avctx->dia_size, 1); i++){
3216                             for(j=0; j<i; j++){
3217                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+4*(i-j), block->my+(4*j), *obmc_edged, &best_rd);
3218                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx-4*(i-j), block->my-(4*j), *obmc_edged, &best_rd);
3219                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+4*(i-j), block->my-(4*j), *obmc_edged, &best_rd);
3220                                 dia_change |= check_block_inter(s, mb_x, mb_y, block->mx-4*(i-j), block->my+(4*j), *obmc_edged, &best_rd);
3221                             }
3222                         }
3223                     }while(dia_change);
3224                     /* subpel ME */
3225                     do{
3226                         static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
3227                         dia_change=0;
3228                         for(i=0; i<8; i++)
3229                             dia_change |= check_block_inter(s, mb_x, mb_y, block->mx+square[i][0], block->my+square[i][1], *obmc_edged, &best_rd);
3230                     }while(dia_change);
3231                     //FIXME or try the standard 2 pass qpel or similar
3232
3233                     mvr[0][0]= block->mx;
3234                     mvr[0][1]= block->my;
3235                     if(ref_rd > best_rd){
3236                         ref_rd= best_rd;
3237                         ref_b= *block;
3238                     }
3239                 }
3240                 best_rd= ref_rd;
3241                 *block= ref_b;
3242 #if 1
3243                 check_block(s, mb_x, mb_y, color, 1, *obmc_edged, &best_rd);
3244                 //FIXME RD style color selection
3245 #endif
3246                 if(!same_block(block, &backup)){
3247                     if(tb ) tb ->type &= ~BLOCK_OPT;
3248                     if(lb ) lb ->type &= ~BLOCK_OPT;
3249                     if(rb ) rb ->type &= ~BLOCK_OPT;
3250                     if(bb ) bb ->type &= ~BLOCK_OPT;
3251                     if(tlb) tlb->type &= ~BLOCK_OPT;
3252                     if(trb) trb->type &= ~BLOCK_OPT;
3253                     if(blb) blb->type &= ~BLOCK_OPT;
3254                     if(brb) brb->type &= ~BLOCK_OPT;
3255                     change ++;
3256                 }
3257             }
3258         }
3259         av_log(NULL, AV_LOG_ERROR, "pass:%d changed:%d\n", pass, change);
3260         if(!change)
3261             break;
3262     }
3263
3264     if(s->block_max_depth == 1){
3265         int change= 0;
3266         for(mb_y= 0; mb_y<b_height; mb_y+=2){
3267             for(mb_x= 0; mb_x<b_width; mb_x+=2){
3268                 int i;
3269                 int best_rd, init_rd;
3270                 const int index= mb_x + mb_y * b_stride;
3271                 BlockNode *b[4];
3272
3273                 b[0]= &s->block[index];
3274                 b[1]= b[0]+1;
3275                 b[2]= b[0]+b_stride;
3276                 b[3]= b[2]+1;
3277                 if(same_block(b[0], b[1]) &&
3278                    same_block(b[0], b[2]) &&
3279                    same_block(b[0], b[3]))
3280                     continue;
3281
3282                 if(!s->me_cache_generation)
3283                     memset(s->me_cache, 0, sizeof(s->me_cache));
3284                 s->me_cache_generation += 1<<22;
3285
3286                 init_rd= best_rd= get_4block_rd(s, mb_x, mb_y, 0);
3287
3288                 //FIXME more multiref search?
3289                 check_4block_inter(s, mb_x, mb_y,
3290                                    (b[0]->mx + b[1]->mx + b[2]->mx + b[3]->mx + 2) >> 2,
3291                                    (b[0]->my + b[1]->my + b[2]->my + b[3]->my + 2) >> 2, 0, &best_rd);
3292
3293                 for(i=0; i<4; i++)
3294                     if(!(b[i]->type&BLOCK_INTRA))
3295                         check_4block_inter(s, mb_x, mb_y, b[i]->mx, b[i]->my, b[i]->ref, &best_rd);
3296
3297                 if(init_rd != best_rd)
3298                     change++;
3299             }
3300         }
3301         av_log(NULL, AV_LOG_ERROR, "pass:4mv changed:%d\n", change*4);
3302     }
3303 }
3304
3305 static void quantize(SnowContext *s, SubBand *b, IDWTELEM *dst, DWTELEM *src, int stride, int bias){
3306     const int level= b->level;
3307     const int w= b->width;
3308     const int h= b->height;
3309     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
3310     const int qmul= qexp[qlog&(QROOT-1)]<<((qlog>>QSHIFT) + ENCODER_EXTRA_BITS);
3311     int x,y, thres1, thres2;
3312 //    START_TIMER
3313
3314     if(s->qlog == LOSSLESS_QLOG){
3315         for(y=0; y<h; y++)
3316             for(x=0; x<w; x++)
3317                 dst[x + y*stride]= src[x + y*stride];
3318         return;
3319     }
3320
3321     bias= bias ? 0 : (3*qmul)>>3;
3322     thres1= ((qmul - bias)>>QEXPSHIFT) - 1;
3323     thres2= 2*thres1;
3324
3325     if(!bias){
3326         for(y=0; y<h; y++){
3327             for(x=0; x<w; x++){
3328                 int i= src[x + y*stride];
3329
3330                 if((unsigned)(i+thres1) > thres2){
3331                     if(i>=0){
3332                         i<<= QEXPSHIFT;
3333                         i/= qmul; //FIXME optimize
3334                         dst[x + y*stride]=  i;
3335                     }else{
3336                         i= -i;
3337                         i<<= QEXPSHIFT;
3338                         i/= qmul; //FIXME optimize
3339                         dst[x + y*stride]= -i;
3340                     }
3341                 }else
3342                     dst[x + y*stride]= 0;
3343             }
3344         }
3345     }else{
3346         for(y=0; y<h; y++){
3347             for(x=0; x<w; x++){
3348                 int i= src[x + y*stride];
3349
3350                 if((unsigned)(i+thres1) > thres2){
3351                     if(i>=0){
3352                         i<<= QEXPSHIFT;
3353                         i= (i + bias) / qmul; //FIXME optimize
3354                         dst[x + y*stride]=  i;
3355                     }else{
3356                         i= -i;
3357                         i<<= QEXPSHIFT;
3358                         i= (i + bias) / qmul; //FIXME optimize
3359                         dst[x + y*stride]= -i;
3360                     }
3361                 }else
3362                     dst[x + y*stride]= 0;
3363             }
3364         }
3365     }
3366     if(level+1 == s->spatial_decomposition_count){
3367 //        STOP_TIMER("quantize")
3368     }
3369 }
3370
3371 static void dequantize_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, IDWTELEM *src, int stride, int start_y, int end_y){
3372     const int w= b->width;
3373     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
3374     const int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
3375     const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
3376     int x,y;
3377     START_TIMER
3378
3379     if(s->qlog == LOSSLESS_QLOG) return;
3380
3381     for(y=start_y; y<end_y; y++){
3382 //        DWTELEM * line = slice_buffer_get_line_from_address(sb, src + (y * stride));
3383         IDWTELEM * line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
3384         for(x=0; x<w; x++){
3385             int i= line[x];
3386             if(i<0){
3387                 line[x]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
3388             }else if(i>0){
3389                 line[x]=  (( i*qmul + qadd)>>(QEXPSHIFT));
3390             }
3391         }
3392     }
3393     if(w > 200 /*level+1 == s->spatial_decomposition_count*/){
3394         STOP_TIMER("dquant")
3395     }
3396 }
3397
3398 static void dequantize(SnowContext *s, SubBand *b, IDWTELEM *src, int stride){
3399     const int w= b->width;
3400     const int h= b->height;
3401     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
3402     const int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
3403     const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
3404     int x,y;
3405     START_TIMER
3406
3407     if(s->qlog == LOSSLESS_QLOG) return;
3408
3409     for(y=0; y<h; y++){
3410         for(x=0; x<w; x++){
3411             int i= src[x + y*stride];
3412             if(i<0){
3413                 src[x + y*stride]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
3414             }else if(i>0){
3415                 src[x + y*stride]=  (( i*qmul + qadd)>>(QEXPSHIFT));
3416             }
3417         }
3418     }
3419     if(w > 200 /*level+1 == s->spatial_decomposition_count*/){
3420         STOP_TIMER("dquant")
3421     }
3422 }
3423
3424 static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
3425     const int w= b->width;
3426     const int h= b->height;
3427     int x,y;
3428
3429     for(y=h-1; y>=0; y--){
3430         for(x=w-1; x>=0; x--){
3431             int i= x + y*stride;
3432
3433             if(x){
3434                 if(use_median){
3435                     if(y && x+1<w) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
3436                     else  src[i] -= src[i - 1];
3437                 }else{
3438                     if(y) src[i] -= mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
3439                     else  src[i] -= src[i - 1];
3440                 }
3441             }else{
3442                 if(y) src[i] -= src[i - stride];
3443             }
3444         }
3445     }
3446 }
3447
3448 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){
3449     const int w= b->width;
3450     int x,y;
3451
3452 //    START_TIMER
3453
3454     IDWTELEM * line=0; // silence silly "could be used without having been initialized" warning
3455     IDWTELEM * prev;
3456
3457     if (start_y != 0)
3458         line = slice_buffer_get_line(sb, ((start_y - 1) * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
3459
3460     for(y=start_y; y<end_y; y++){
3461         prev = line;
3462 //        line = slice_buffer_get_line_from_address(sb, src + (y * stride));
3463         line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
3464         for(x=0; x<w; x++){
3465             if(x){
3466                 if(use_median){
3467                     if(y && x+1<w) line[x] += mid_pred(line[x - 1], prev[x], prev[x + 1]);
3468                     else  line[x] += line[x - 1];
3469                 }else{
3470                     if(y) line[x] += mid_pred(line[x - 1], prev[x], line[x - 1] + prev[x] - prev[x - 1]);
3471                     else  line[x] += line[x - 1];
3472                 }
3473             }else{
3474                 if(y) line[x] += prev[x];
3475             }
3476         }
3477     }
3478
3479 //    STOP_TIMER("correlate")
3480 }
3481
3482 static void correlate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median){
3483     const int w= b->width;
3484     const int h= b->height;
3485     int x,y;
3486
3487     for(y=0; y<h; y++){
3488         for(x=0; x<w; x++){
3489             int i= x + y*stride;
3490
3491             if(x){
3492                 if(use_median){
3493                     if(y && x+1<w) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - stride + 1]);
3494                     else  src[i] += src[i - 1];
3495                 }else{
3496                     if(y) src[i] += mid_pred(src[i - 1], src[i - stride], src[i - 1] + src[i - stride] - src[i - 1 - stride]);
3497                     else  src[i] += src[i - 1];
3498                 }
3499             }else{
3500                 if(y) src[i] += src[i - stride];
3501             }
3502         }
3503     }
3504 }
3505
3506 static void encode_qlogs(SnowContext *s){
3507     int plane_index, level, orientation;
3508
3509     for(plane_index=0; plane_index<2; plane_index++){
3510         for(level=0; level<s->spatial_decomposition_count; level++){
3511             for(orientation=level ? 1:0; orientation<4; orientation++){
3512                 if(orientation==2) continue;
3513                 put_symbol(&s->c, s->header_state, s->plane[plane_index].band[level][orientation].qlog, 1);
3514             }
3515         }
3516     }
3517 }
3518
3519 static void encode_header(SnowContext *s){
3520     int plane_index, i;
3521     uint8_t kstate[32];
3522
3523     memset(kstate, MID_STATE, sizeof(kstate));
3524
3525     put_rac(&s->c, kstate, s->keyframe);
3526     if(s->keyframe || s->always_reset){
3527         reset_contexts(s);
3528         s->last_spatial_decomposition_type=
3529         s->last_qlog=
3530         s->last_qbias=
3531         s->last_mv_scale=
3532         s->last_block_max_depth= 0;
3533         for(plane_index=0; plane_index<2; plane_index++){
3534             Plane *p= &s->plane[plane_index];
3535             p->last_htaps=0;
3536             p->last_diag_mc=0;
3537             memset(p->last_hcoeff, 0, sizeof(p->last_hcoeff));
3538         }
3539     }
3540     if(s->keyframe){
3541         put_symbol(&s->c, s->header_state, s->version, 0);
3542         put_rac(&s->c, s->header_state, s->always_reset);
3543         put_symbol(&s->c, s->header_state, s->temporal_decomposition_type, 0);
3544         put_symbol(&s->c, s->header_state, s->temporal_decomposition_count, 0);
3545         put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
3546         put_symbol(&s->c, s->header_state, s->colorspace_type, 0);
3547         put_symbol(&s->c, s->header_state, s->chroma_h_shift, 0);
3548         put_symbol(&s->c, s->header_state, s->chroma_v_shift, 0);
3549         put_rac(&s->c, s->header_state, s->spatial_scalability);
3550 //        put_rac(&s->c, s->header_state, s->rate_scalability);
3551         put_symbol(&s->c, s->header_state, s->max_ref_frames-1, 0);
3552
3553         encode_qlogs(s);
3554     }
3555
3556     if(!s->keyframe){
3557         int update_mc=0;
3558         for(plane_index=0; plane_index<2; plane_index++){
3559             Plane *p= &s->plane[plane_index];
3560             update_mc |= p->last_htaps   != p->htaps;
3561             update_mc |= p->last_diag_mc != p->diag_mc;
3562             update_mc |= !!memcmp(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
3563         }
3564         put_rac(&s->c, s->header_state, update_mc);
3565         if(update_mc){
3566             for(plane_index=0; plane_index<2; plane_index++){
3567                 Plane *p= &s->plane[plane_index];
3568                 put_rac(&s->c, s->header_state, p->diag_mc);
3569                 put_symbol(&s->c, s->header_state, p->htaps/2-1, 0);
3570                 for(i= p->htaps/2; i; i--)
3571                     put_symbol(&s->c, s->header_state, FFABS(p->hcoeff[i]), 0);
3572
3573                 p->last_diag_mc= p->diag_mc;
3574                 p->last_htaps= p->htaps;
3575                 memcpy(p->last_hcoeff, p->hcoeff, sizeof(p->hcoeff));
3576             }
3577         }
3578         if(s->last_spatial_decomposition_count != s->spatial_decomposition_count){
3579             put_rac(&s->c, s->header_state, 1);
3580             put_symbol(&s->c, s->header_state, s->spatial_decomposition_count, 0);
3581             encode_qlogs(s);
3582         }else
3583             put_rac(&s->c, s->header_state, 0);
3584     }
3585
3586     put_symbol(&s->c, s->header_state, s->spatial_decomposition_type - s->last_spatial_decomposition_type, 1);
3587     put_symbol(&s->c, s->header_state, s->qlog            - s->last_qlog    , 1);
3588     put_symbol(&s->c, s->header_state, s->mv_scale        - s->last_mv_scale, 1);
3589     put_symbol(&s->c, s->header_state, s->qbias           - s->last_qbias   , 1);
3590     put_symbol(&s->c, s->header_state, s->block_max_depth - s->last_block_max_depth, 1);
3591
3592     s->last_spatial_decomposition_type= s->spatial_decomposition_type;
3593     s->last_qlog                      = s->qlog;
3594     s->last_qbias                     = s->qbias;
3595     s->last_mv_scale                  = s->mv_scale;
3596     s->last_block_max_depth           = s->block_max_depth;
3597     s->last_spatial_decomposition_count= s->spatial_decomposition_count;
3598 }
3599
3600 static void decode_qlogs(SnowContext *s){
3601     int plane_index, level, orientation;
3602
3603     for(plane_index=0; plane_index<3; plane_index++){
3604         for(level=0; level<s->spatial_decomposition_count; level++){
3605             for(orientation=level ? 1:0; orientation<4; orientation++){
3606                 int q;
3607                 if     (plane_index==2) q= s->plane[1].band[level][orientation].qlog;
3608                 else if(orientation==2) q= s->plane[plane_index].band[level][1].qlog;
3609                 else                    q= get_symbol(&s->c, s->header_state, 1);
3610                 s->plane[plane_index].band[level][orientation].qlog= q;
3611             }
3612         }
3613     }
3614 }
3615
3616 static int decode_header(SnowContext *s){
3617     int plane_index;
3618     uint8_t kstate[32];
3619
3620     memset(kstate, MID_STATE, sizeof(kstate));
3621
3622     s->keyframe= get_rac(&s->c, kstate);
3623     if(s->keyframe || s->always_reset){
3624         reset_contexts(s);
3625         s->spatial_decomposition_type=
3626         s->qlog=
3627         s->qbias=
3628         s->mv_scale=
3629         s->block_max_depth= 0;
3630     }
3631     if(s->keyframe){
3632         s->version= get_symbol(&s->c, s->header_state, 0);
3633         if(s->version>0){
3634             av_log(s->avctx, AV_LOG_ERROR, "version %d not supported", s->version);
3635             return -1;
3636         }
3637         s->always_reset= get_rac(&s->c, s->header_state);
3638         s->temporal_decomposition_type= get_symbol(&s->c, s->header_state, 0);
3639         s->temporal_decomposition_count= get_symbol(&s->c, s->header_state, 0);
3640         s->spatial_decomposition_count= get_symbol(&s->c, s->header_state, 0);
3641         s->colorspace_type= get_symbol(&s->c, s->header_state, 0);
3642         s->chroma_h_shift= get_symbol(&s->c, s->header_state, 0);
3643         s->chroma_v_shift= get_symbol(&s->c, s->header_state, 0);
3644         s->spatial_scalability= get_rac(&s->c, s->header_state);
3645 //        s->rate_scalability= get_rac(&s->c, s->header_state);
3646         s->max_ref_frames= get_symbol(&s->c, s->header_state, 0)+1;
3647
3648         decode_qlogs(s);
3649     }
3650
3651     if(!s->keyframe){
3652         if(get_rac(&s->c, s->header_state)){
3653             for(plane_index=0; plane_index<2; plane_index++){
3654                 int htaps, i, sum=0;
3655                 Plane *p= &s->plane[plane_index];
3656                 p->diag_mc= get_rac(&s->c, s->header_state);
3657                 htaps= get_symbol(&s->c, s->header_state, 0)*2 + 2;
3658                 if((unsigned)htaps > HTAPS_MAX || htaps==0)
3659                     return -1;
3660                 p->htaps= htaps;
3661                 for(i= htaps/2; i; i--){
3662                     p->hcoeff[i]= get_symbol(&s->c, s->header_state, 0) * (1-2*(i&1));
3663                     sum += p->hcoeff[i];
3664                 }
3665                 p->hcoeff[0]= 32-sum;
3666             }
3667             s->plane[2].diag_mc= s->plane[1].diag_mc;
3668             s->plane[2].htaps  = s->plane[1].htaps;
3669             memcpy(s->plane[2].hcoeff, s->plane[1].hcoeff, sizeof(s->plane[1].hcoeff));
3670         }
3671         if(get_rac(&s->c, s->header_state)){
3672             s->spatial_decomposition_count= get_symbol(&s->c, s->header_state, 0);
3673             decode_qlogs(s);
3674         }
3675     }
3676
3677     s->spatial_decomposition_type+= get_symbol(&s->c, s->header_state, 1);
3678     if(s->spatial_decomposition_type > 1){
3679         av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_type %d not supported", s->spatial_decomposition_type);
3680         return -1;
3681     }
3682
3683     s->qlog           += get_symbol(&s->c, s->header_state, 1);
3684     s->mv_scale       += get_symbol(&s->c, s->header_state, 1);
3685     s->qbias          += get_symbol(&s->c, s->header_state, 1);
3686     s->block_max_depth+= get_symbol(&s->c, s->header_state, 1);
3687     if(s->block_max_depth > 1 || s->block_max_depth < 0){
3688         av_log(s->avctx, AV_LOG_ERROR, "block_max_depth= %d is too large", s->block_max_depth);
3689         s->block_max_depth= 0;
3690         return -1;
3691     }
3692
3693     return 0;
3694 }
3695
3696 static void init_qexp(void){
3697     int i;
3698     double v=128;
3699
3700     for(i=0; i<QROOT; i++){
3701         qexp[i]= lrintf(v);
3702         v *= pow(2, 1.0 / QROOT);
3703     }
3704 }
3705
3706 static int common_init(AVCodecContext *avctx){
3707     SnowContext *s = avctx->priv_data;
3708     int width, height;
3709     int i, j;
3710
3711     s->avctx= avctx;
3712
3713     dsputil_init(&s->dsp, avctx);
3714
3715 #define mcf(dx,dy)\
3716     s->dsp.put_qpel_pixels_tab       [0][dy+dx/4]=\
3717     s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
3718         s->dsp.put_h264_qpel_pixels_tab[0][dy+dx/4];\
3719     s->dsp.put_qpel_pixels_tab       [1][dy+dx/4]=\
3720     s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
3721         s->dsp.put_h264_qpel_pixels_tab[1][dy+dx/4];
3722
3723     mcf( 0, 0)
3724     mcf( 4, 0)
3725     mcf( 8, 0)
3726     mcf(12, 0)
3727     mcf( 0, 4)
3728     mcf( 4, 4)
3729     mcf( 8, 4)
3730     mcf(12, 4)
3731     mcf( 0, 8)
3732     mcf( 4, 8)
3733     mcf( 8, 8)
3734     mcf(12, 8)
3735     mcf( 0,12)
3736     mcf( 4,12)
3737     mcf( 8,12)
3738     mcf(12,12)
3739
3740 #define mcfh(dx,dy)\
3741     s->dsp.put_pixels_tab       [0][dy/4+dx/8]=\
3742     s->dsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
3743         mc_block_hpel ## dx ## dy ## 16;\
3744     s->dsp.put_pixels_tab       [1][dy/4+dx/8]=\
3745     s->dsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
3746         mc_block_hpel ## dx ## dy ## 8;
3747
3748     mcfh(0, 0)
3749     mcfh(8, 0)
3750     mcfh(0, 8)
3751     mcfh(8, 8)
3752
3753     if(!qexp[0])
3754         init_qexp();
3755
3756 //    dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
3757
3758     width= s->avctx->width;
3759     height= s->avctx->height;
3760
3761     s->spatial_idwt_buffer= av_mallocz(width*height*sizeof(IDWTELEM));
3762     s->spatial_dwt_buffer= av_mallocz(width*height*sizeof(DWTELEM)); //FIXME this doesnt belong here
3763
3764     for(i=0; i<MAX_REF_FRAMES; i++)
3765         for(j=0; j<MAX_REF_FRAMES; j++)
3766             scale_mv_ref[i][j] = 256*(i+1)/(j+1);
3767
3768     s->avctx->get_buffer(s->avctx, &s->mconly_picture);
3769
3770     return 0;
3771 }
3772
3773 static int common_init_after_header(AVCodecContext *avctx){
3774     SnowContext *s = avctx->priv_data;
3775     int plane_index, level, orientation;
3776
3777     for(plane_index=0; plane_index<3; plane_index++){
3778         int w= s->avctx->width;
3779         int h= s->avctx->height;
3780
3781         if(plane_index){
3782             w>>= s->chroma_h_shift;
3783             h>>= s->chroma_v_shift;
3784         }
3785         s->plane[plane_index].width = w;
3786         s->plane[plane_index].height= h;
3787
3788 //av_log(NULL, AV_LOG_DEBUG, "%d %d\n", w, h);
3789         for(level=s->spatial_decomposition_count-1; level>=0; level--){
3790             for(orientation=level ? 1 : 0; orientation<4; orientation++){
3791                 SubBand *b= &s->plane[plane_index].band[level][orientation];
3792
3793                 b->buf= s->spatial_dwt_buffer;
3794                 b->level= level;
3795                 b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
3796                 b->width = (w + !(orientation&1))>>1;
3797                 b->height= (h + !(orientation>1))>>1;
3798
3799                 b->stride_line = 1 << (s->spatial_decomposition_count - level);
3800                 b->buf_x_offset = 0;
3801                 b->buf_y_offset = 0;
3802
3803                 if(orientation&1){
3804                     b->buf += (w+1)>>1;
3805                     b->buf_x_offset = (w+1)>>1;
3806                 }
3807                 if(orientation>1){
3808                     b->buf += b->stride>>1;
3809                     b->buf_y_offset = b->stride_line >> 1;
3810                 }
3811                 b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
3812
3813                 if(level)
3814                     b->parent= &s->plane[plane_index].band[level-1][orientation];
3815                 //FIXME avoid this realloc
3816                 av_freep(&b->x_coeff);
3817                 b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
3818             }
3819             w= (w+1)>>1;
3820             h= (h+1)>>1;
3821         }
3822     }
3823
3824     return 0;
3825 }
3826
3827 static int qscale2qlog(int qscale){
3828     return rint(QROOT*log(qscale / (float)FF_QP2LAMBDA)/log(2))
3829            + 61*QROOT/8; //<64 >60
3830 }
3831
3832 static int ratecontrol_1pass(SnowContext *s, AVFrame *pict)
3833 {
3834     /* estimate the frame's complexity as a sum of weighted dwt coefs.
3835      * FIXME we know exact mv bits at this point,
3836      * but ratecontrol isn't set up to include them. */
3837     uint32_t coef_sum= 0;
3838     int level, orientation, delta_qlog;
3839
3840     for(level=0; level<s->spatial_decomposition_count; level++){
3841         for(orientation=level ? 1 : 0; orientation<4; orientation++){
3842             SubBand *b= &s->plane[0].band[level][orientation];
3843             IDWTELEM *buf= b->ibuf;
3844             const int w= b->width;
3845             const int h= b->height;
3846             const int stride= b->stride;
3847             const int qlog= av_clip(2*QROOT + b->qlog, 0, QROOT*16);
3848             const int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
3849             const int qdiv= (1<<16)/qmul;
3850             int x, y;
3851             //FIXME this is ugly
3852             for(y=0; y<h; y++)
3853                 for(x=0; x<w; x++)
3854                     buf[x+y*stride]= b->buf[x+y*stride];
3855             if(orientation==0)
3856                 decorrelate(s, b, buf, stride, 1, 0);
3857             for(y=0; y<h; y++)
3858                 for(x=0; x<w; x++)
3859                     coef_sum+= abs(buf[x+y*stride]) * qdiv >> 16;
3860         }
3861     }
3862
3863     /* ugly, ratecontrol just takes a sqrt again */
3864     coef_sum = (uint64_t)coef_sum * coef_sum >> 16;
3865     assert(coef_sum < INT_MAX);
3866
3867     if(pict->pict_type == I_TYPE){
3868         s->m.current_picture.mb_var_sum= coef_sum;
3869         s->m.current_picture.mc_mb_var_sum= 0;
3870     }else{
3871         s->m.current_picture.mc_mb_var_sum= coef_sum;
3872         s->m.current_picture.mb_var_sum= 0;
3873     }
3874
3875     pict->quality= ff_rate_estimate_qscale(&s->m, 1);
3876     if (pict->quality < 0)
3877         return INT_MIN;
3878     s->lambda= pict->quality * 3/2;
3879     delta_qlog= qscale2qlog(pict->quality) - s->qlog;
3880     s->qlog+= delta_qlog;
3881     return delta_qlog;
3882 }
3883
3884 static void calculate_visual_weight(SnowContext *s, Plane *p){
3885     int width = p->width;
3886     int height= p->height;
3887     int level, orientation, x, y;
3888
3889     for(level=0; level<s->spatial_decomposition_count; level++){
3890         for(orientation=level ? 1 : 0; orientation<4; orientation++){
3891             SubBand *b= &p->band[level][orientation];
3892             IDWTELEM *ibuf= b->ibuf;
3893             int64_t error=0;
3894
3895             memset(s->spatial_idwt_buffer, 0, sizeof(*s->spatial_idwt_buffer)*width*height);
3896             ibuf[b->width/2 + b->height/2*b->stride]= 256*16;
3897             ff_spatial_idwt(s->spatial_idwt_buffer, width, height, width, s->spatial_decomposition_type, s->spatial_decomposition_count);
3898             for(y=0; y<height; y++){
3899                 for(x=0; x<width; x++){
3900                     int64_t d= s->spatial_idwt_buffer[x + y*width]*16;
3901                     error += d*d;
3902                 }
3903             }
3904
3905             b->qlog= (int)(log(352256.0/sqrt(error)) / log(pow(2.0, 1.0/QROOT))+0.5);
3906 //            av_log(NULL, AV_LOG_DEBUG, "%d %d %d\n", level, orientation, b->qlog/*, sqrt(error)*/);
3907         }
3908     }
3909 }
3910
3911 #define QUANTIZE2 0
3912
3913 #if QUANTIZE2==1
3914 #define Q2_STEP 8
3915
3916 static void find_sse(SnowContext *s, Plane *p, int *score, int score_stride, IDWTELEM *r0, IDWTELEM *r1, int level, int orientation){
3917     SubBand *b= &p->band[level][orientation];
3918     int x, y;
3919     int xo=0;
3920     int yo=0;
3921     int step= 1 << (s->spatial_decomposition_count - level);
3922
3923     if(orientation&1)
3924         xo= step>>1;
3925     if(orientation&2)
3926         yo= step>>1;
3927
3928     //FIXME bias for non zero ?
3929     //FIXME optimize
3930     memset(score, 0, sizeof(*score)*score_stride*((p->height + Q2_STEP-1)/Q2_STEP));
3931     for(y=0; y<p->height; y++){
3932         for(x=0; x<p->width; x++){
3933             int sx= (x-xo + step/2) / step / Q2_STEP;
3934             int sy= (y-yo + step/2) / step / Q2_STEP;
3935             int v= r0[x + y*p->width] - r1[x + y*p->width];
3936             assert(sx>=0 && sy>=0 && sx < score_stride);
3937             v= ((v+8)>>4)<<4;
3938             score[sx + sy*score_stride] += v*v;
3939             assert(score[sx + sy*score_stride] >= 0);
3940         }
3941     }
3942 }
3943
3944 static void dequantize_all(SnowContext *s, Plane *p, IDWTELEM *buffer, int width, int height){
3945     int level, orientation;
3946
3947     for(level=0; level<s->spatial_decomposition_count; level++){
3948         for(orientation=level ? 1 : 0; orientation<4; orientation++){
3949             SubBand *b= &p->band[level][orientation];
3950             IDWTELEM *dst= buffer + (b->ibuf - s->spatial_idwt_buffer);
3951
3952             dequantize(s, b, dst, b->stride);
3953         }
3954     }
3955 }
3956
3957 static void dwt_quantize(SnowContext *s, Plane *p, DWTELEM *buffer, int width, int height, int stride, int type){
3958     int level, orientation, ys, xs, x, y, pass;
3959     IDWTELEM best_dequant[height * stride];
3960     IDWTELEM idwt2_buffer[height * stride];
3961     const int score_stride= (width + 10)/Q2_STEP;
3962     int best_score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP]; //FIXME size
3963     int score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP]; //FIXME size
3964     int threshold= (s->m.lambda * s->m.lambda) >> 6;
3965
3966     //FIXME pass the copy cleanly ?
3967
3968 //    memcpy(dwt_buffer, buffer, height * stride * sizeof(DWTELEM));
3969     ff_spatial_dwt(buffer, width, height, stride, type, s->spatial_decomposition_count);
3970
3971     for(level=0; level<s->spatial_decomposition_count; level++){
3972         for(orientation=level ? 1 : 0; orientation<4; orientation++){
3973             SubBand *b= &p->band[level][orientation];
3974             IDWTELEM *dst= best_dequant + (b->ibuf - s->spatial_idwt_buffer);
3975              DWTELEM *src=       buffer + (b-> buf - s->spatial_dwt_buffer);
3976             assert(src == b->buf); // code doesnt depen on this but its true currently
3977
3978             quantize(s, b, dst, src, b->stride, s->qbias);
3979         }
3980     }
3981     for(pass=0; pass<1; pass++){
3982         if(s->qbias == 0) //keyframe
3983             continue;
3984         for(level=0; level<s->spatial_decomposition_count; level++){
3985             for(orientation=level ? 1 : 0; orientation<4; orientation++){
3986                 SubBand *b= &p->band[level][orientation];
3987                 IDWTELEM *dst= idwt2_buffer + (b->ibuf - s->spatial_idwt_buffer);
3988                 IDWTELEM *best_dst= best_dequant + (b->ibuf - s->spatial_idwt_buffer);
3989
3990                 for(ys= 0; ys<Q2_STEP; ys++){
3991                     for(xs= 0; xs<Q2_STEP; xs++){
3992                         memcpy(idwt2_buffer, best_dequant, height * stride * sizeof(IDWTELEM));
3993                         dequantize_all(s, p, idwt2_buffer, width, height);
3994                         ff_spatial_idwt(idwt2_buffer, width, height, stride, type, s->spatial_decomposition_count);
3995                         find_sse(s, p, best_score, score_stride, idwt2_buffer, s->spatial_idwt_buffer, level, orientation);
3996                         memcpy(idwt2_buffer, best_dequant, height * stride * sizeof(IDWTELEM));
3997                         for(y=ys; y<b->height; y+= Q2_STEP){
3998                             for(x=xs; x<b->width; x+= Q2_STEP){
3999                                 if(dst[x + y*b->stride]<0) dst[x + y*b->stride]++;
4000                                 if(dst[x + y*b->stride]>0) dst[x + y*b->stride]--;
4001                                 //FIXME try more then just --
4002                             }
4003                         }
4004                         dequantize_all(s, p, idwt2_buffer, width, height);
4005                         ff_spatial_idwt(idwt2_buffer, width, height, stride, type, s->spatial_decomposition_count);
4006                         find_sse(s, p, score, score_stride, idwt2_buffer, s->spatial_idwt_buffer, level, orientation);
4007                         for(y=ys; y<b->height; y+= Q2_STEP){
4008                             for(x=xs; x<b->width; x+= Q2_STEP){
4009                                 int score_idx= x/Q2_STEP + (y/Q2_STEP)*score_stride;
4010                                 if(score[score_idx] <= best_score[score_idx] + threshold){
4011                                     best_score[score_idx]= score[score_idx];
4012                                     if(best_dst[x + y*b->stride]<0) best_dst[x + y*b->stride]++;
4013                                     if(best_dst[x + y*b->stride]>0) best_dst[x + y*b->stride]--;
4014                                     //FIXME copy instead
4015                                 }
4016                             }
4017                         }
4018                     }
4019                 }
4020             }
4021         }
4022     }
4023     memcpy(s->spatial_idwt_buffer, best_dequant, height * stride * sizeof(IDWTELEM)); //FIXME work with that directly insteda of copy at the end
4024 }
4025
4026 #endif /* QUANTIZE2==1 */
4027
4028 static int encode_init(AVCodecContext *avctx)
4029 {
4030     SnowContext *s = avctx->priv_data;
4031     int plane_index;
4032
4033     if(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
4034         av_log(avctx, AV_LOG_ERROR, "this codec is under development, files encoded with it may not be decodable with future versions!!!\n"
4035                "use vstrict=-2 / -strict -2 to use it anyway\n");
4036         return -1;
4037     }
4038
4039     if(avctx->prediction_method == DWT_97
4040        && (avctx->flags & CODEC_FLAG_QSCALE)
4041        && avctx->global_quality == 0){
4042         av_log(avctx, AV_LOG_ERROR, "the 9/7 wavelet is incompatible with lossless mode\n");
4043         return -1;
4044     }
4045
4046     s->spatial_decomposition_type= avctx->prediction_method; //FIXME add decorrelator type r transform_type
4047
4048     s->chroma_h_shift= 1; //FIXME XXX
4049     s->chroma_v_shift= 1;
4050
4051     s->mv_scale       = (avctx->flags & CODEC_FLAG_QPEL) ? 2 : 4;
4052     s->block_max_depth= (avctx->flags & CODEC_FLAG_4MV ) ? 1 : 0;
4053
4054     for(plane_index=0; plane_index<3; plane_index++){
4055         s->plane[plane_index].diag_mc= 1;
4056         s->plane[plane_index].htaps= 6;
4057         s->plane[plane_index].hcoeff[0]=  40;
4058         s->plane[plane_index].hcoeff[1]= -10;
4059         s->plane[plane_index].hcoeff[2]=   2;
4060         s->plane[plane_index].fast_mc= 1;
4061     }
4062
4063     common_init(avctx);
4064     alloc_blocks(s);
4065
4066     s->version=0;
4067
4068     s->m.avctx   = avctx;
4069     s->m.flags   = avctx->flags;
4070     s->m.bit_rate= avctx->bit_rate;
4071
4072     s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
4073     s->m.me.map       = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
4074     s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
4075     s->m.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));
4076     h263_encode_init(&s->m); //mv_penalty
4077
4078     s->max_ref_frames = FFMAX(FFMIN(avctx->refs, MAX_REF_FRAMES), 1);
4079
4080     if(avctx->flags&CODEC_FLAG_PASS1){
4081         if(!avctx->stats_out)
4082             avctx->stats_out = av_mallocz(256);
4083     }
4084     if((avctx->flags&CODEC_FLAG_PASS2) || !(avctx->flags&CODEC_FLAG_QSCALE)){
4085         if(ff_rate_control_init(&s->m) < 0)
4086             return -1;
4087     }
4088     s->pass1_rc= !(avctx->flags & (CODEC_FLAG_QSCALE|CODEC_FLAG_PASS2));
4089
4090     avctx->coded_frame= &s->current_picture;
4091     switch(avctx->pix_fmt){
4092 //    case PIX_FMT_YUV444P:
4093 //    case PIX_FMT_YUV422P:
4094     case PIX_FMT_YUV420P:
4095     case PIX_FMT_GRAY8:
4096 //    case PIX_FMT_YUV411P:
4097 //    case PIX_FMT_YUV410P:
4098         s->colorspace_type= 0;
4099         break;
4100 /*    case PIX_FMT_RGB32:
4101         s->colorspace= 1;
4102         break;*/
4103     default:
4104         av_log(avctx, AV_LOG_ERROR, "pixel format not supported\n");
4105         return -1;
4106     }
4107 //    avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
4108     s->chroma_h_shift= 1;
4109     s->chroma_v_shift= 1;
4110
4111     ff_set_cmp(&s->dsp, s->dsp.me_cmp, s->avctx->me_cmp);
4112     ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, s->avctx->me_sub_cmp);
4113
4114     s->avctx->get_buffer(s->avctx, &s->input_picture);
4115
4116     if(s->avctx->me_method == ME_ITER){
4117         int i;
4118         int size= s->b_width * s->b_height << 2*s->block_max_depth;
4119         for(i=0; i<s->max_ref_frames; i++){
4120             s->ref_mvs[i]= av_mallocz(size*sizeof(int16_t[2]));
4121             s->ref_scores[i]= av_mallocz(size*sizeof(uint32_t));
4122         }
4123     }
4124
4125     return 0;
4126 }
4127
4128 #define USE_HALFPEL_PLANE 0
4129
4130 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
4131     int p,x,y;
4132
4133     assert(!(s->avctx->flags & CODEC_FLAG_EMU_EDGE));
4134
4135     for(p=0; p<3; p++){
4136         int is_chroma= !!p;
4137         int w= s->avctx->width  >>is_chroma;
4138         int h= s->avctx->height >>is_chroma;
4139         int ls= frame->linesize[p];
4140         uint8_t *src= frame->data[p];
4141
4142         halfpel[1][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
4143         halfpel[2][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
4144         halfpel[3][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
4145
4146         halfpel[0][p]= src;
4147         for(y=0; y<h; y++){
4148             for(x=0; x<w; x++){
4149                 int i= y*ls + x;
4150
4151                 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;
4152             }
4153         }
4154         for(y=0; y<h; y++){
4155             for(x=0; x<w; x++){
4156                 int i= y*ls + x;
4157
4158                 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;
4159             }
4160       &nbs