2 * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
4 * This file is part of FFmpeg.
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.
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.
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
25 #include "rangecoder.h"
28 #include "mpegvideo.h"
33 static const int8_t quant3[256]={
34 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
35 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
36 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
37 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
38 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
39 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
40 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
41 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
42 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
43 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
44 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
45 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
46 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
47 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
48 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
49 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
51 static const int8_t quant3b[256]={
52 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
53 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
54 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
55 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
56 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
57 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
58 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
59 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
60 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
61 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
62 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
63 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
64 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
65 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
66 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
67 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
69 static const int8_t quant3bA[256]={
70 0, 0, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
71 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
72 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
73 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
74 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
75 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
76 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
77 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
78 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
79 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
80 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
81 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
82 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
83 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
84 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
85 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1, 1,-1,
87 static const int8_t quant5[256]={
88 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
89 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
90 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
91 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
92 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
93 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
94 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
95 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
96 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
97 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
98 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
99 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
100 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
101 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
102 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
103 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
105 static const int8_t quant7[256]={
106 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
107 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
108 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
109 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
110 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
111 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
112 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
113 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
114 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
115 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
116 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
117 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
118 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
119 -3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
120 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
121 -2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
123 static const int8_t quant9[256]={
124 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
125 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
126 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
127 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
128 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
129 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
130 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
131 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
132 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
133 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
134 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
135 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
136 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
137 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
138 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
139 -3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
141 static const int8_t quant11[256]={
142 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
143 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
144 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
145 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
146 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
147 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
148 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
149 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
150 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
151 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
152 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
153 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
154 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
155 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-4,-4,
156 -4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
157 -4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
159 static const int8_t quant13[256]={
160 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
161 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
162 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
163 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
164 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
165 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
166 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
167 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
168 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
169 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
170 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
171 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
172 -6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
173 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
174 -5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
175 -4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
179 static const uint8_t obmc32[1024]={
180 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
181 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0,
182 0, 0, 0, 4, 4, 4, 4, 8, 8, 12, 12, 12, 16, 16, 16, 16, 16, 16, 16, 16, 12, 12, 12, 8, 8, 4, 4, 4, 4, 0, 0, 0,
183 0, 0, 4, 4, 8, 8, 12, 16, 16, 20, 24, 24, 28, 28, 32, 32, 32, 32, 28, 28, 24, 24, 20, 16, 16, 12, 8, 8, 4, 4, 0, 0,
184 0, 0, 4, 8, 8, 12, 16, 24, 28, 32, 36, 40, 44, 48, 48, 48, 48, 48, 48, 44, 40, 36, 32, 28, 24, 16, 12, 8, 8, 4, 0, 0,
185 0, 4, 4, 8, 12, 20, 24, 32, 40, 44, 52, 56, 60, 64, 68, 72, 72, 68, 64, 60, 56, 52, 44, 40, 32, 24, 20, 12, 8, 4, 4, 0,
186 0, 4, 4, 12, 16, 24, 32, 40, 52, 60, 68, 76, 80, 88, 88, 92, 92, 88, 88, 80, 76, 68, 60, 52, 40, 32, 24, 16, 12, 4, 4, 0,
187 0, 4, 8, 16, 24, 32, 40, 52, 64, 76, 84, 92,100,108,112,116,116,112,108,100, 92, 84, 76, 64, 52, 40, 32, 24, 16, 8, 4, 0,
188 0, 4, 8, 16, 28, 40, 52, 64, 76, 88,100,112,124,132,136,140,140,136,132,124,112,100, 88, 76, 64, 52, 40, 28, 16, 8, 4, 0,
189 0, 4, 12, 20, 32, 44, 60, 76, 88,104,120,132,144,152,160,164,164,160,152,144,132,120,104, 88, 76, 60, 44, 32, 20, 12, 4, 0,
190 0, 4, 12, 24, 36, 48, 68, 84,100,120,136,152,164,176,180,184,184,180,176,164,152,136,120,100, 84, 68, 48, 36, 24, 12, 4, 0,
191 0, 4, 12, 24, 40, 56, 76, 92,112,132,152,168,180,192,204,208,208,204,192,180,168,152,132,112, 92, 76, 56, 40, 24, 12, 4, 0,
192 0, 4, 16, 28, 44, 60, 80,100,124,144,164,180,196,208,220,224,224,220,208,196,180,164,144,124,100, 80, 60, 44, 28, 16, 4, 0,
193 0, 8, 16, 28, 48, 64, 88,108,132,152,176,192,208,224,232,240,240,232,224,208,192,176,152,132,108, 88, 64, 48, 28, 16, 8, 0,
194 0, 4, 16, 32, 48, 68, 88,112,136,160,180,204,220,232,244,248,248,244,232,220,204,180,160,136,112, 88, 68, 48, 32, 16, 4, 0,
195 1, 8, 16, 32, 48, 72, 92,116,140,164,184,208,224,240,248,255,255,248,240,224,208,184,164,140,116, 92, 72, 48, 32, 16, 8, 1,
196 1, 8, 16, 32, 48, 72, 92,116,140,164,184,208,224,240,248,255,255,248,240,224,208,184,164,140,116, 92, 72, 48, 32, 16, 8, 1,
197 0, 4, 16, 32, 48, 68, 88,112,136,160,180,204,220,232,244,248,248,244,232,220,204,180,160,136,112, 88, 68, 48, 32, 16, 4, 0,
198 0, 8, 16, 28, 48, 64, 88,108,132,152,176,192,208,224,232,240,240,232,224,208,192,176,152,132,108, 88, 64, 48, 28, 16, 8, 0,
199 0, 4, 16, 28, 44, 60, 80,100,124,144,164,180,196,208,220,224,224,220,208,196,180,164,144,124,100, 80, 60, 44, 28, 16, 4, 0,
200 0, 4, 12, 24, 40, 56, 76, 92,112,132,152,168,180,192,204,208,208,204,192,180,168,152,132,112, 92, 76, 56, 40, 24, 12, 4, 0,
201 0, 4, 12, 24, 36, 48, 68, 84,100,120,136,152,164,176,180,184,184,180,176,164,152,136,120,100, 84, 68, 48, 36, 24, 12, 4, 0,
202 0, 4, 12, 20, 32, 44, 60, 76, 88,104,120,132,144,152,160,164,164,160,152,144,132,120,104, 88, 76, 60, 44, 32, 20, 12, 4, 0,
203 0, 4, 8, 16, 28, 40, 52, 64, 76, 88,100,112,124,132,136,140,140,136,132,124,112,100, 88, 76, 64, 52, 40, 28, 16, 8, 4, 0,
204 0, 4, 8, 16, 24, 32, 40, 52, 64, 76, 84, 92,100,108,112,116,116,112,108,100, 92, 84, 76, 64, 52, 40, 32, 24, 16, 8, 4, 0,
205 0, 4, 4, 12, 16, 24, 32, 40, 52, 60, 68, 76, 80, 88, 88, 92, 92, 88, 88, 80, 76, 68, 60, 52, 40, 32, 24, 16, 12, 4, 4, 0,
206 0, 4, 4, 8, 12, 20, 24, 32, 40, 44, 52, 56, 60, 64, 68, 72, 72, 68, 64, 60, 56, 52, 44, 40, 32, 24, 20, 12, 8, 4, 4, 0,
207 0, 0, 4, 8, 8, 12, 16, 24, 28, 32, 36, 40, 44, 48, 48, 48, 48, 48, 48, 44, 40, 36, 32, 28, 24, 16, 12, 8, 8, 4, 0, 0,
208 0, 0, 4, 4, 8, 8, 12, 16, 16, 20, 24, 24, 28, 28, 32, 32, 32, 32, 28, 28, 24, 24, 20, 16, 16, 12, 8, 8, 4, 4, 0, 0,
209 0, 0, 0, 4, 4, 4, 4, 8, 8, 12, 12, 12, 16, 16, 16, 16, 16, 16, 16, 16, 12, 12, 12, 8, 8, 4, 4, 4, 4, 0, 0, 0,
210 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0,
211 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
214 static const uint8_t obmc16[256]={
215 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0,
216 0, 4, 4, 8, 16, 20, 20, 24, 24, 20, 20, 16, 8, 4, 4, 0,
217 0, 4, 16, 24, 36, 44, 52, 60, 60, 52, 44, 36, 24, 16, 4, 0,
218 0, 8, 24, 44, 60, 80, 96,104,104, 96, 80, 60, 44, 24, 8, 0,
219 0, 16, 36, 60, 92,116,136,152,152,136,116, 92, 60, 36, 16, 0,
220 0, 20, 44, 80,116,152,180,196,196,180,152,116, 80, 44, 20, 0,
221 4, 20, 52, 96,136,180,212,228,228,212,180,136, 96, 52, 20, 4,
222 4, 24, 60,104,152,196,228,248,248,228,196,152,104, 60, 24, 4,
223 4, 24, 60,104,152,196,228,248,248,228,196,152,104, 60, 24, 4,
224 4, 20, 52, 96,136,180,212,228,228,212,180,136, 96, 52, 20, 4,
225 0, 20, 44, 80,116,152,180,196,196,180,152,116, 80, 44, 20, 0,
226 0, 16, 36, 60, 92,116,136,152,152,136,116, 92, 60, 36, 16, 0,
227 0, 8, 24, 44, 60, 80, 96,104,104, 96, 80, 60, 44, 24, 8, 0,
228 0, 4, 16, 24, 36, 44, 52, 60, 60, 52, 44, 36, 24, 16, 4, 0,
229 0, 4, 4, 8, 16, 20, 20, 24, 24, 20, 20, 16, 8, 4, 4, 0,
230 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0,
234 static const uint8_t obmc32[1024]={
235 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0,
236 0, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12, 8, 8, 8, 4, 4, 4, 0,
237 0, 4, 8, 8, 12, 12, 16, 20, 20, 24, 28, 28, 32, 32, 36, 40, 40, 36, 32, 32, 28, 28, 24, 20, 20, 16, 12, 12, 8, 8, 4, 0,
238 0, 4, 8, 12, 16, 20, 24, 28, 28, 32, 36, 40, 44, 48, 52, 56, 56, 52, 48, 44, 40, 36, 32, 28, 28, 24, 20, 16, 12, 8, 4, 0,
239 4, 8, 12, 16, 20, 24, 28, 32, 40, 44, 48, 52, 56, 60, 64, 68, 68, 64, 60, 56, 52, 48, 44, 40, 32, 28, 24, 20, 16, 12, 8, 4,
240 4, 8, 12, 20, 24, 32, 36, 40, 48, 52, 56, 64, 68, 76, 80, 84, 84, 80, 76, 68, 64, 56, 52, 48, 40, 36, 32, 24, 20, 12, 8, 4,
241 4, 8, 16, 24, 28, 36, 44, 48, 56, 60, 68, 76, 80, 88, 96,100,100, 96, 88, 80, 76, 68, 60, 56, 48, 44, 36, 28, 24, 16, 8, 4,
242 4, 12, 20, 28, 32, 40, 48, 56, 64, 72, 80, 88, 92,100,108,116,116,108,100, 92, 88, 80, 72, 64, 56, 48, 40, 32, 28, 20, 12, 4,
243 4, 12, 20, 28, 40, 48, 56, 64, 72, 80, 88, 96,108,116,124,132,132,124,116,108, 96, 88, 80, 72, 64, 56, 48, 40, 28, 20, 12, 4,
244 4, 16, 24, 32, 44, 52, 60, 72, 80, 92,100,108,120,128,136,148,148,136,128,120,108,100, 92, 80, 72, 60, 52, 44, 32, 24, 16, 4,
245 4, 16, 28, 36, 48, 56, 68, 80, 88,100,112,120,132,140,152,164,164,152,140,132,120,112,100, 88, 80, 68, 56, 48, 36, 28, 16, 4,
246 4, 16, 28, 40, 52, 64, 76, 88, 96,108,120,132,144,156,168,180,180,168,156,144,132,120,108, 96, 88, 76, 64, 52, 40, 28, 16, 4,
247 8, 20, 32, 44, 56, 68, 80, 92,108,120,132,144,156,168,180,192,192,180,168,156,144,132,120,108, 92, 80, 68, 56, 44, 32, 20, 8,
248 8, 20, 32, 48, 60, 76, 88,100,116,128,140,156,168,184,196,208,208,196,184,168,156,140,128,116,100, 88, 76, 60, 48, 32, 20, 8,
249 8, 20, 36, 52, 64, 80, 96,108,124,136,152,168,180,196,212,224,224,212,196,180,168,152,136,124,108, 96, 80, 64, 52, 36, 20, 8,
250 8, 24, 40, 56, 68, 84,100,116,132,148,164,180,192,208,224,240,240,224,208,192,180,164,148,132,116,100, 84, 68, 56, 40, 24, 8,
251 8, 24, 40, 56, 68, 84,100,116,132,148,164,180,192,208,224,240,240,224,208,192,180,164,148,132,116,100, 84, 68, 56, 40, 24, 8,
252 8, 20, 36, 52, 64, 80, 96,108,124,136,152,168,180,196,212,224,224,212,196,180,168,152,136,124,108, 96, 80, 64, 52, 36, 20, 8,
253 8, 20, 32, 48, 60, 76, 88,100,116,128,140,156,168,184,196,208,208,196,184,168,156,140,128,116,100, 88, 76, 60, 48, 32, 20, 8,
254 8, 20, 32, 44, 56, 68, 80, 92,108,120,132,144,156,168,180,192,192,180,168,156,144,132,120,108, 92, 80, 68, 56, 44, 32, 20, 8,
255 4, 16, 28, 40, 52, 64, 76, 88, 96,108,120,132,144,156,168,180,180,168,156,144,132,120,108, 96, 88, 76, 64, 52, 40, 28, 16, 4,
256 4, 16, 28, 36, 48, 56, 68, 80, 88,100,112,120,132,140,152,164,164,152,140,132,120,112,100, 88, 80, 68, 56, 48, 36, 28, 16, 4,
257 4, 16, 24, 32, 44, 52, 60, 72, 80, 92,100,108,120,128,136,148,148,136,128,120,108,100, 92, 80, 72, 60, 52, 44, 32, 24, 16, 4,
258 4, 12, 20, 28, 40, 48, 56, 64, 72, 80, 88, 96,108,116,124,132,132,124,116,108, 96, 88, 80, 72, 64, 56, 48, 40, 28, 20, 12, 4,
259 4, 12, 20, 28, 32, 40, 48, 56, 64, 72, 80, 88, 92,100,108,116,116,108,100, 92, 88, 80, 72, 64, 56, 48, 40, 32, 28, 20, 12, 4,
260 4, 8, 16, 24, 28, 36, 44, 48, 56, 60, 68, 76, 80, 88, 96,100,100, 96, 88, 80, 76, 68, 60, 56, 48, 44, 36, 28, 24, 16, 8, 4,
261 4, 8, 12, 20, 24, 32, 36, 40, 48, 52, 56, 64, 68, 76, 80, 84, 84, 80, 76, 68, 64, 56, 52, 48, 40, 36, 32, 24, 20, 12, 8, 4,
262 4, 8, 12, 16, 20, 24, 28, 32, 40, 44, 48, 52, 56, 60, 64, 68, 68, 64, 60, 56, 52, 48, 44, 40, 32, 28, 24, 20, 16, 12, 8, 4,
263 0, 4, 8, 12, 16, 20, 24, 28, 28, 32, 36, 40, 44, 48, 52, 56, 56, 52, 48, 44, 40, 36, 32, 28, 28, 24, 20, 16, 12, 8, 4, 0,
264 0, 4, 8, 8, 12, 12, 16, 20, 20, 24, 28, 28, 32, 32, 36, 40, 40, 36, 32, 32, 28, 28, 24, 20, 20, 16, 12, 12, 8, 8, 4, 0,
265 0, 4, 4, 4, 8, 8, 8, 12, 12, 16, 16, 16, 20, 20, 20, 24, 24, 20, 20, 20, 16, 16, 16, 12, 12, 8, 8, 8, 4, 4, 4, 0,
266 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0,
269 static const uint8_t obmc16[256]={
270 0, 4, 4, 8, 8, 12, 12, 16, 16, 12, 12, 8, 8, 4, 4, 0,
271 4, 8, 16, 20, 28, 32, 40, 44, 44, 40, 32, 28, 20, 16, 8, 4,
272 4, 16, 24, 36, 44, 56, 64, 76, 76, 64, 56, 44, 36, 24, 16, 4,
273 8, 20, 36, 48, 64, 76, 92,104,104, 92, 76, 64, 48, 36, 20, 8,
274 8, 28, 44, 64, 80,100,116,136,136,116,100, 80, 64, 44, 28, 8,
275 12, 32, 56, 76,100,120,144,164,164,144,120,100, 76, 56, 32, 12,
276 12, 40, 64, 92,116,144,168,196,196,168,144,116, 92, 64, 40, 12,
277 16, 44, 76,104,136,164,196,224,224,196,164,136,104, 76, 44, 16,
278 16, 44, 76,104,136,164,196,224,224,196,164,136,104, 76, 44, 16,
279 12, 40, 64, 92,116,144,168,196,196,168,144,116, 92, 64, 40, 12,
280 12, 32, 56, 76,100,120,144,164,164,144,120,100, 76, 56, 32, 12,
281 8, 28, 44, 64, 80,100,116,136,136,116,100, 80, 64, 44, 28, 8,
282 8, 20, 36, 48, 64, 76, 92,104,104, 92, 76, 64, 48, 36, 20, 8,
283 4, 16, 24, 36, 44, 56, 64, 76, 76, 64, 56, 44, 36, 24, 16, 4,
284 4, 8, 16, 20, 28, 32, 40, 44, 44, 40, 32, 28, 20, 16, 8, 4,
285 0, 4, 4, 8, 8, 12, 12, 16, 16, 12, 12, 8, 8, 4, 4, 0,
289 static const uint8_t obmc32[1024]={
290 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
291 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0,
292 0, 0, 0, 4, 4, 4, 4, 8, 8, 12, 12, 12, 12, 16, 16, 16, 16, 16, 16, 12, 12, 12, 12, 8, 8, 4, 4, 4, 4, 0, 0, 0,
293 0, 0, 4, 4, 4, 8, 8, 12, 16, 20, 20, 24, 28, 28, 28, 28, 28, 28, 28, 28, 24, 20, 20, 16, 12, 8, 8, 4, 4, 4, 0, 0,
294 0, 0, 4, 4, 8, 12, 16, 20, 24, 28, 36, 40, 44, 44, 48, 48, 48, 48, 44, 44, 40, 36, 28, 24, 20, 16, 12, 8, 4, 4, 0, 0,
295 0, 0, 4, 8, 12, 20, 24, 32, 36, 44, 48, 56, 60, 64, 68, 68, 68, 68, 64, 60, 56, 48, 44, 36, 32, 24, 20, 12, 8, 4, 0, 0,
296 0, 4, 4, 8, 16, 24, 32, 40, 48, 60, 68, 76, 80, 84, 88, 92, 92, 88, 84, 80, 76, 68, 60, 48, 40, 32, 24, 16, 8, 4, 4, 0,
297 0, 4, 8, 12, 20, 32, 40, 52, 64, 76, 84, 96,104,108,112,116,116,112,108,104, 96, 84, 76, 64, 52, 40, 32, 20, 12, 8, 4, 0,
298 0, 4, 8, 16, 24, 36, 48, 64, 76, 92,104,116,124,132,136,140,140,136,132,124,116,104, 92, 76, 64, 48, 36, 24, 16, 8, 4, 0,
299 0, 4, 12, 20, 28, 44, 60, 76, 92,104,120,136,148,156,160,164,164,160,156,148,136,120,104, 92, 76, 60, 44, 28, 20, 12, 4, 0,
300 0, 4, 12, 20, 36, 48, 68, 84,104,120,140,152,168,176,184,188,188,184,176,168,152,140,120,104, 84, 68, 48, 36, 20, 12, 4, 0,
301 0, 4, 12, 24, 36, 56, 76, 96,116,136,152,172,184,196,204,208,208,204,196,184,172,152,136,116, 96, 76, 56, 36, 24, 12, 4, 0,
302 0, 4, 12, 24, 44, 60, 80,104,124,148,168,184,200,212,224,228,228,224,212,200,184,168,148,124,104, 80, 60, 44, 24, 12, 4, 0,
303 0, 4, 12, 28, 44, 64, 84,108,132,156,176,196,212,228,236,240,240,236,228,212,196,176,156,132,108, 84, 64, 44, 28, 12, 4, 0,
304 0, 4, 16, 28, 48, 68, 88,112,136,160,184,204,224,236,244,252,252,244,236,224,204,184,160,136,112, 88, 68, 48, 28, 16, 4, 0,
305 1, 4, 16, 28, 48, 68, 92,116,140,164,188,208,228,240,252,255,255,252,240,228,208,188,164,140,116, 92, 68, 48, 28, 16, 4, 1,
306 1, 4, 16, 28, 48, 68, 92,116,140,164,188,208,228,240,252,255,255,252,240,228,208,188,164,140,116, 92, 68, 48, 28, 16, 4, 1,
307 0, 4, 16, 28, 48, 68, 88,112,136,160,184,204,224,236,244,252,252,244,236,224,204,184,160,136,112, 88, 68, 48, 28, 16, 4, 0,
308 0, 4, 12, 28, 44, 64, 84,108,132,156,176,196,212,228,236,240,240,236,228,212,196,176,156,132,108, 84, 64, 44, 28, 12, 4, 0,
309 0, 4, 12, 24, 44, 60, 80,104,124,148,168,184,200,212,224,228,228,224,212,200,184,168,148,124,104, 80, 60, 44, 24, 12, 4, 0,
310 0, 4, 12, 24, 36, 56, 76, 96,116,136,152,172,184,196,204,208,208,204,196,184,172,152,136,116, 96, 76, 56, 36, 24, 12, 4, 0,
311 0, 4, 12, 20, 36, 48, 68, 84,104,120,140,152,168,176,184,188,188,184,176,168,152,140,120,104, 84, 68, 48, 36, 20, 12, 4, 0,
312 0, 4, 12, 20, 28, 44, 60, 76, 92,104,120,136,148,156,160,164,164,160,156,148,136,120,104, 92, 76, 60, 44, 28, 20, 12, 4, 0,
313 0, 4, 8, 16, 24, 36, 48, 64, 76, 92,104,116,124,132,136,140,140,136,132,124,116,104, 92, 76, 64, 48, 36, 24, 16, 8, 4, 0,
314 0, 4, 8, 12, 20, 32, 40, 52, 64, 76, 84, 96,104,108,112,116,116,112,108,104, 96, 84, 76, 64, 52, 40, 32, 20, 12, 8, 4, 0,
315 0, 4, 4, 8, 16, 24, 32, 40, 48, 60, 68, 76, 80, 84, 88, 92, 92, 88, 84, 80, 76, 68, 60, 48, 40, 32, 24, 16, 8, 4, 4, 0,
316 0, 0, 4, 8, 12, 20, 24, 32, 36, 44, 48, 56, 60, 64, 68, 68, 68, 68, 64, 60, 56, 48, 44, 36, 32, 24, 20, 12, 8, 4, 0, 0,
317 0, 0, 4, 4, 8, 12, 16, 20, 24, 28, 36, 40, 44, 44, 48, 48, 48, 48, 44, 44, 40, 36, 28, 24, 20, 16, 12, 8, 4, 4, 0, 0,
318 0, 0, 4, 4, 4, 8, 8, 12, 16, 20, 20, 24, 28, 28, 28, 28, 28, 28, 28, 28, 24, 20, 20, 16, 12, 8, 8, 4, 4, 4, 0, 0,
319 0, 0, 0, 4, 4, 4, 4, 8, 8, 12, 12, 12, 12, 16, 16, 16, 16, 16, 16, 12, 12, 12, 12, 8, 8, 4, 4, 4, 4, 0, 0, 0,
320 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 8, 4, 4, 8, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0,
321 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
324 static const uint8_t obmc16[256]={
325 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0,
326 0, 0, 4, 8, 12, 16, 20, 20, 20, 20, 16, 12, 8, 4, 0, 0,
327 0, 4, 12, 24, 32, 44, 52, 56, 56, 52, 44, 32, 24, 12, 4, 0,
328 0, 8, 24, 40, 60, 80, 96,104,104, 96, 80, 60, 40, 24, 8, 0,
329 0, 12, 32, 64, 92,120,140,152,152,140,120, 92, 64, 32, 12, 0,
330 4, 16, 44, 80,120,156,184,196,196,184,156,120, 80, 44, 16, 4,
331 4, 20, 52, 96,140,184,216,232,232,216,184,140, 96, 52, 20, 4,
332 0, 20, 56,104,152,196,232,252,252,232,196,152,104, 56, 20, 0,
333 0, 20, 56,104,152,196,232,252,252,232,196,152,104, 56, 20, 0,
334 4, 20, 52, 96,140,184,216,232,232,216,184,140, 96, 52, 20, 4,
335 4, 16, 44, 80,120,156,184,196,196,184,156,120, 80, 44, 16, 4,
336 0, 12, 32, 64, 92,120,140,152,152,140,120, 92, 64, 32, 12, 0,
337 0, 8, 24, 40, 60, 80, 96,104,104, 96, 80, 60, 40, 24, 8, 0,
338 0, 4, 12, 24, 32, 44, 52, 56, 56, 52, 44, 32, 24, 12, 4, 0,
339 0, 0, 4, 8, 12, 16, 20, 20, 20, 20, 16, 12, 8, 4, 0, 0,
340 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0,
346 static const uint8_t obmc8[64]={
347 4, 12, 20, 28, 28, 20, 12, 4,
348 12, 36, 60, 84, 84, 60, 36, 12,
349 20, 60,100,140,140,100, 60, 20,
350 28, 84,140,196,196,140, 84, 28,
351 28, 84,140,196,196,140, 84, 28,
352 20, 60,100,140,140,100, 60, 20,
353 12, 36, 60, 84, 84, 60, 36, 12,
354 4, 12, 20, 28, 28, 20, 12, 4,
359 static const uint8_t obmc4[16]={
367 static const uint8_t * const obmc_tab[4]={
368 obmc32, obmc16, obmc8, obmc4
371 static int scale_mv_ref[MAX_REF_FRAMES][MAX_REF_FRAMES];
373 typedef struct BlockNode{
379 //#define TYPE_SPLIT 1
380 #define BLOCK_INTRA 1
382 //#define TYPE_NOCOLOR 4
383 uint8_t level; //FIXME merge into type?
386 static const BlockNode null_block= { //FIXME add border maybe
387 .color= {128,128,128},
395 #define LOG2_MB_SIZE 4
396 #define MB_SIZE (1<<LOG2_MB_SIZE)
397 #define ENCODER_EXTRA_BITS 4
400 typedef struct x_and_coeff{
405 typedef struct SubBand{
410 int qlog; ///< log(qscale)/log[2^(1/6)]
415 int stride_line; ///< Stride measured in lines, not pixels.
416 x_and_coeff * x_coeff;
417 struct SubBand *parent;
418 uint8_t state[/*7*2*/ 7 + 512][32];
421 typedef struct Plane{
424 SubBand band[MAX_DECOMPOSITIONS][4];
427 int8_t hcoeff[HTAPS_MAX/2];
432 int8_t last_hcoeff[HTAPS_MAX/2];
436 typedef struct SnowContext{
438 AVCodecContext *avctx;
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];
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;
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;
468 int spatial_scalability;
478 #define QBIAS_SHIFT 3
482 int last_block_max_depth;
483 Plane plane[MAX_PLANES];
485 #define ME_CACHE_SIZE 1024
486 int me_cache[ME_CACHE_SIZE];
487 int me_cache_generation;
490 MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to eventually make the motion estimation independent of MpegEncContext, so this will be removed then (FIXME/XXX)
503 #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)))
504 //#define slice_buffer_get_line(slice_buf, line_num) (slice_buffer_load_line((slice_buf), (line_num)))
506 static void slice_buffer_init(slice_buffer * buf, int line_count, int max_allocated_lines, int line_width, IDWTELEM * base_buffer)
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);
517 for(i = 0; i < max_allocated_lines; i++){
518 buf->data_stack[i] = av_malloc (sizeof(IDWTELEM) * line_width);
521 buf->data_stack_top = max_allocated_lines - 1;
524 static IDWTELEM * slice_buffer_load_line(slice_buffer * buf, int line)
528 assert(buf->data_stack_top >= 0);
529 // assert(!buf->line[line]);
531 return buf->line[line];
533 buffer = buf->data_stack[buf->data_stack_top];
534 buf->data_stack_top--;
535 buf->line[line] = buffer;
540 static void slice_buffer_release(slice_buffer * buf, int line)
544 assert(line >= 0 && line < buf->line_count);
545 assert(buf->line[line]);
547 buffer = buf->line[line];
548 buf->data_stack_top++;
549 buf->data_stack[buf->data_stack_top] = buffer;
550 buf->line[line] = NULL;
553 static void slice_buffer_flush(slice_buffer * buf)
556 for(i = 0; i < buf->line_count; i++){
558 slice_buffer_release(buf, i);
562 static void slice_buffer_destroy(slice_buffer * buf)
565 slice_buffer_flush(buf);
567 for(i = buf->data_count - 1; i >= 0; i--){
568 av_freep(&buf->data_stack[i]);
570 av_freep(&buf->data_stack);
571 av_freep(&buf->line);
575 // Avoid a name clash on SGI IRIX
578 #define QEXPSHIFT (7-FRAC_BITS+8) //FIXME try to change this to 0
579 static uint8_t qexp[QROOT];
581 static inline int mirror(int v, int m){
582 while((unsigned)v > (unsigned)m){
589 static inline void put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
593 const int a= FFABS(v);
594 const int e= av_log2(a);
596 const int el= FFMIN(e, 10);
597 put_rac(c, state+0, 0);
600 put_rac(c, state+1+i, 1); //1..10
603 put_rac(c, state+1+9, 1); //1..10
605 put_rac(c, state+1+FFMIN(i,9), 0);
607 for(i=e-1; i>=el; i--){
608 put_rac(c, state+22+9, (a>>i)&1); //22..31
611 put_rac(c, state+22+i, (a>>i)&1); //22..31
615 put_rac(c, state+11 + el, v < 0); //11..21
618 put_rac(c, state+0, 0);
621 put_rac(c, state+1+i, 1); //1..10
623 put_rac(c, state+1+i, 0);
625 for(i=e-1; i>=0; i--){
626 put_rac(c, state+22+i, (a>>i)&1); //22..31
630 put_rac(c, state+11 + e, v < 0); //11..21
633 put_rac(c, state+1+FFMIN(i,9), 1); //1..10
635 put_rac(c, state+1+9, 0);
637 for(i=e-1; i>=0; i--){
638 put_rac(c, state+22+FFMIN(i,9), (a>>i)&1); //22..31
642 put_rac(c, state+11 + 10, v < 0); //11..21
646 put_rac(c, state+0, 1);
650 static inline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed){
651 if(get_rac(c, state+0))
656 while(get_rac(c, state+1 + FFMIN(e,9))){ //1..10
661 for(i=e-1; i>=0; i--){
662 a += a + get_rac(c, state+22 + FFMIN(i,9)); //22..31
665 e= -(is_signed && get_rac(c, state+11 + FFMIN(e,10))); //11..21
670 static inline void put_symbol2(RangeCoder *c, uint8_t *state, int v, int log2){
672 int r= log2>=0 ? 1<<log2 : 1;
678 put_rac(c, state+4+log2, 1);
683 put_rac(c, state+4+log2, 0);
685 for(i=log2-1; i>=0; i--){
686 put_rac(c, state+31-i, (v>>i)&1);
690 static inline int get_symbol2(RangeCoder *c, uint8_t *state, int log2){
692 int r= log2>=0 ? 1<<log2 : 1;
697 while(get_rac(c, state+4+log2)){
703 for(i=log2-1; i>=0; i--){
704 v+= get_rac(c, state+31-i)<<i;
710 static av_always_inline void
711 lift(DWTELEM *dst, DWTELEM *src, DWTELEM *ref,
712 int dst_step, int src_step, int ref_step,
713 int width, int mul, int add, int shift,
714 int highpass, int inverse){
715 const int mirror_left= !highpass;
716 const int mirror_right= (width&1) ^ highpass;
717 const int w= (width>>1) - 1 + (highpass & width);
720 #define LIFT(src, ref, inv) ((src) + ((inv) ? - (ref) : + (ref)))
722 dst[0] = LIFT(src[0], ((mul*2*ref[0]+add)>>shift), inverse);
729 LIFT(src[i*src_step],
730 ((mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add)>>shift),
736 LIFT(src[w*src_step],
737 ((mul*2*ref[w*ref_step]+add)>>shift),
742 static av_always_inline void
743 inv_lift(IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref,
744 int dst_step, int src_step, int ref_step,
745 int width, int mul, int add, int shift,
746 int highpass, int inverse){
747 const int mirror_left= !highpass;
748 const int mirror_right= (width&1) ^ highpass;
749 const int w= (width>>1) - 1 + (highpass & width);
752 #define LIFT(src, ref, inv) ((src) + ((inv) ? - (ref) : + (ref)))
754 dst[0] = LIFT(src[0], ((mul*2*ref[0]+add)>>shift), inverse);
761 LIFT(src[i*src_step],
762 ((mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add)>>shift),
768 LIFT(src[w*src_step],
769 ((mul*2*ref[w*ref_step]+add)>>shift),
775 static av_always_inline void
776 liftS(DWTELEM *dst, DWTELEM *src, DWTELEM *ref,
777 int dst_step, int src_step, int ref_step,
778 int width, int mul, int add, int shift,
779 int highpass, int inverse){
780 const int mirror_left= !highpass;
781 const int mirror_right= (width&1) ^ highpass;
782 const int w= (width>>1) - 1 + (highpass & width);
786 #define LIFTS(src, ref, inv) \
788 (src) + (((ref) + 4*(src))>>shift): \
789 -((-16*(src) + (ref) + add/4 + 1 + (5<<25))/(5*4) - (1<<23)))
791 dst[0] = LIFTS(src[0], mul*2*ref[0]+add, inverse);
798 LIFTS(src[i*src_step],
799 mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add,
805 LIFTS(src[w*src_step], mul*2*ref[w*ref_step]+add, inverse);
808 static av_always_inline void
809 inv_liftS(IDWTELEM *dst, IDWTELEM *src, IDWTELEM *ref,
810 int dst_step, int src_step, int ref_step,
811 int width, int mul, int add, int shift,
812 int highpass, int inverse){
813 const int mirror_left= !highpass;
814 const int mirror_right= (width&1) ^ highpass;
815 const int w= (width>>1) - 1 + (highpass & width);
819 #define LIFTS(src, ref, inv) \
821 (src) + (((ref) + 4*(src))>>shift): \
822 -((-16*(src) + (ref) + add/4 + 1 + (5<<25))/(5*4) - (1<<23)))
824 dst[0] = LIFTS(src[0], mul*2*ref[0]+add, inverse);
831 LIFTS(src[i*src_step],
832 mul*(ref[i*ref_step] + ref[(i+1)*ref_step])+add,
838 LIFTS(src[w*src_step], mul*2*ref[w*ref_step]+add, inverse);
843 static void horizontal_decompose53i(DWTELEM *b, int width){
845 const int width2= width>>1;
847 const int w2= (width+1)>>1;
849 for(x=0; x<width2; x++){
851 temp[x+w2]= b[2*x + 1];
865 for(x=1; x+1<width2; x+=2){
869 A2 += (A1 + A3 + 2)>>2;
873 A1= temp[x+1+width2];
876 A4 += (A1 + A3 + 2)>>2;
882 A2 += (A1 + A3 + 2)>>2;
887 lift(b+w2, temp+w2, temp, 1, 1, 1, width, -1, 0, 1, 1, 0);
888 lift(b , temp , b+w2, 1, 1, 1, width, 1, 2, 2, 0, 0);
892 static void vertical_decompose53iH0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
895 for(i=0; i<width; i++){
896 b1[i] -= (b0[i] + b2[i])>>1;
900 static void vertical_decompose53iL0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
903 for(i=0; i<width; i++){
904 b1[i] += (b0[i] + b2[i] + 2)>>2;
908 static void spatial_decompose53i(DWTELEM *buffer, int width, int height, int stride){
910 DWTELEM *b0= buffer + mirror(-2-1, height-1)*stride;
911 DWTELEM *b1= buffer + mirror(-2 , height-1)*stride;
913 for(y=-2; y<height; y+=2){
914 DWTELEM *b2= buffer + mirror(y+1, height-1)*stride;
915 DWTELEM *b3= buffer + mirror(y+2, height-1)*stride;
917 if(y+1<(unsigned)height) horizontal_decompose53i(b2, width);
918 if(y+2<(unsigned)height) horizontal_decompose53i(b3, width);
920 if(y+1<(unsigned)height) vertical_decompose53iH0(b1, b2, b3, width);
921 if(y+0<(unsigned)height) vertical_decompose53iL0(b0, b1, b2, width);
928 static void horizontal_decompose97i(DWTELEM *b, int width){
930 const int w2= (width+1)>>1;
932 lift (temp+w2, b +1, b , 1, 2, 2, width, W_AM, W_AO, W_AS, 1, 1);
933 liftS(temp , b , temp+w2, 1, 2, 1, width, W_BM, W_BO, W_BS, 0, 0);
934 lift (b +w2, temp+w2, temp , 1, 1, 1, width, W_CM, W_CO, W_CS, 1, 0);
935 lift (b , temp , b +w2, 1, 1, 1, width, W_DM, W_DO, W_DS, 0, 0);
939 static void vertical_decompose97iH0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
942 for(i=0; i<width; i++){
943 b1[i] -= (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
947 static void vertical_decompose97iH1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
950 for(i=0; i<width; i++){
951 b1[i] += (W_CM*(b0[i] + b2[i])+W_CO)>>W_CS;
955 static void vertical_decompose97iL0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
958 for(i=0; i<width; i++){
960 b1[i] -= (W_BM*(b0[i] + b2[i])+W_BO)>>W_BS;
962 b1[i] = (16*4*b1[i] - 4*(b0[i] + b2[i]) + W_BO*5 + (5<<27)) / (5*16) - (1<<23);
967 static void vertical_decompose97iL1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int width){
970 for(i=0; i<width; i++){
971 b1[i] += (W_DM*(b0[i] + b2[i])+W_DO)>>W_DS;
975 static void spatial_decompose97i(DWTELEM *buffer, int width, int height, int stride){
977 DWTELEM *b0= buffer + mirror(-4-1, height-1)*stride;
978 DWTELEM *b1= buffer + mirror(-4 , height-1)*stride;
979 DWTELEM *b2= buffer + mirror(-4+1, height-1)*stride;
980 DWTELEM *b3= buffer + mirror(-4+2, height-1)*stride;
982 for(y=-4; y<height; y+=2){
983 DWTELEM *b4= buffer + mirror(y+3, height-1)*stride;
984 DWTELEM *b5= buffer + mirror(y+4, height-1)*stride;
986 if(y+3<(unsigned)height) horizontal_decompose97i(b4, width);
987 if(y+4<(unsigned)height) horizontal_decompose97i(b5, width);
989 if(y+3<(unsigned)height) vertical_decompose97iH0(b3, b4, b5, width);
990 if(y+2<(unsigned)height) vertical_decompose97iL0(b2, b3, b4, width);
991 if(y+1<(unsigned)height) vertical_decompose97iH1(b1, b2, b3, width);
992 if(y+0<(unsigned)height) vertical_decompose97iL1(b0, b1, b2, width);
1001 void ff_spatial_dwt(DWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count){
1004 for(level=0; level<decomposition_count; level++){
1006 case DWT_97: spatial_decompose97i(buffer, width>>level, height>>level, stride<<level); break;
1007 case DWT_53: spatial_decompose53i(buffer, width>>level, height>>level, stride<<level); break;
1012 static void horizontal_compose53i(IDWTELEM *b, int width){
1013 IDWTELEM temp[width];
1014 const int width2= width>>1;
1015 const int w2= (width+1)>>1;
1018 for(x=0; x<width2; x++){
1020 temp[2*x + 1]= b[x+w2];
1025 b[0] = temp[0] - ((temp[1]+1)>>1);
1026 for(x=2; x<width-1; x+=2){
1027 b[x ] = temp[x ] - ((temp[x-1] + temp[x+1]+2)>>2);
1028 b[x-1] = temp[x-1] + ((b [x-2] + b [x ]+1)>>1);
1031 b[x ] = temp[x ] - ((temp[x-1]+1)>>1);
1032 b[x-1] = temp[x-1] + ((b [x-2] + b [x ]+1)>>1);
1034 b[x-1] = temp[x-1] + b[x-2];
1037 static void vertical_compose53iH0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1040 for(i=0; i<width; i++){
1041 b1[i] += (b0[i] + b2[i])>>1;
1045 static void vertical_compose53iL0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1048 for(i=0; i<width; i++){
1049 b1[i] -= (b0[i] + b2[i] + 2)>>2;
1053 static void spatial_compose53i_buffered_init(DWTCompose *cs, slice_buffer * sb, int height, int stride_line){
1054 cs->b0 = slice_buffer_get_line(sb, mirror(-1-1, height-1) * stride_line);
1055 cs->b1 = slice_buffer_get_line(sb, mirror(-1 , height-1) * stride_line);
1059 static void spatial_compose53i_init(DWTCompose *cs, IDWTELEM *buffer, int height, int stride){
1060 cs->b0 = buffer + mirror(-1-1, height-1)*stride;
1061 cs->b1 = buffer + mirror(-1 , height-1)*stride;
1065 static void spatial_compose53i_dy_buffered(DWTCompose *cs, slice_buffer * sb, int width, int height, int stride_line){
1068 IDWTELEM *b0= cs->b0;
1069 IDWTELEM *b1= cs->b1;
1070 IDWTELEM *b2= slice_buffer_get_line(sb, mirror(y+1, height-1) * stride_line);
1071 IDWTELEM *b3= slice_buffer_get_line(sb, mirror(y+2, height-1) * stride_line);
1073 if(y+1<(unsigned)height && y<(unsigned)height){
1076 for(x=0; x<width; x++){
1077 b2[x] -= (b1[x] + b3[x] + 2)>>2;
1078 b1[x] += (b0[x] + b2[x])>>1;
1081 if(y+1<(unsigned)height) vertical_compose53iL0(b1, b2, b3, width);
1082 if(y+0<(unsigned)height) vertical_compose53iH0(b0, b1, b2, width);
1085 if(y-1<(unsigned)height) horizontal_compose53i(b0, width);
1086 if(y+0<(unsigned)height) horizontal_compose53i(b1, width);
1093 static void spatial_compose53i_dy(DWTCompose *cs, IDWTELEM *buffer, int width, int height, int stride){
1095 IDWTELEM *b0= cs->b0;
1096 IDWTELEM *b1= cs->b1;
1097 IDWTELEM *b2= buffer + mirror(y+1, height-1)*stride;
1098 IDWTELEM *b3= buffer + mirror(y+2, height-1)*stride;
1100 if(y+1<(unsigned)height) vertical_compose53iL0(b1, b2, b3, width);
1101 if(y+0<(unsigned)height) vertical_compose53iH0(b0, b1, b2, width);
1103 if(y-1<(unsigned)height) horizontal_compose53i(b0, width);
1104 if(y+0<(unsigned)height) horizontal_compose53i(b1, width);
1111 static void av_unused spatial_compose53i(IDWTELEM *buffer, int width, int height, int stride){
1113 spatial_compose53i_init(&cs, buffer, height, stride);
1114 while(cs.y <= height)
1115 spatial_compose53i_dy(&cs, buffer, width, height, stride);
1119 void ff_snow_horizontal_compose97i(IDWTELEM *b, int width){
1120 IDWTELEM temp[width];
1121 const int w2= (width+1)>>1;
1123 inv_lift (temp , b , b +w2, 1, 1, 1, width, W_DM, W_DO, W_DS, 0, 1);
1124 inv_lift (temp+w2, b +w2, temp , 1, 1, 1, width, W_CM, W_CO, W_CS, 1, 1);
1125 inv_liftS(b , temp , temp+w2, 2, 1, 1, width, W_BM, W_BO, W_BS, 0, 1);
1126 inv_lift (b+1 , temp+w2, b , 2, 1, 2, width, W_AM, W_AO, W_AS, 1, 0);
1129 static void vertical_compose97iH0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1132 for(i=0; i<width; i++){
1133 b1[i] += (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
1137 static void vertical_compose97iH1(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1140 for(i=0; i<width; i++){
1141 b1[i] -= (W_CM*(b0[i] + b2[i])+W_CO)>>W_CS;
1145 static void vertical_compose97iL0(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1148 for(i=0; i<width; i++){
1150 b1[i] += (W_BM*(b0[i] + b2[i])+W_BO)>>W_BS;
1152 b1[i] += (W_BM*(b0[i] + b2[i])+4*b1[i]+W_BO)>>W_BS;
1157 static void vertical_compose97iL1(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, int width){
1160 for(i=0; i<width; i++){
1161 b1[i] -= (W_DM*(b0[i] + b2[i])+W_DO)>>W_DS;
1165 void ff_snow_vertical_compose97i(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5, int width){
1168 for(i=0; i<width; i++){
1169 b4[i] -= (W_DM*(b3[i] + b5[i])+W_DO)>>W_DS;
1170 b3[i] -= (W_CM*(b2[i] + b4[i])+W_CO)>>W_CS;
1172 b2[i] += (W_BM*(b1[i] + b3[i])+W_BO)>>W_BS;
1174 b2[i] += (W_BM*(b1[i] + b3[i])+4*b2[i]+W_BO)>>W_BS;
1176 b1[i] += (W_AM*(b0[i] + b2[i])+W_AO)>>W_AS;
1180 static void spatial_compose97i_buffered_init(DWTCompose *cs, slice_buffer * sb, int height, int stride_line){
1181 cs->b0 = slice_buffer_get_line(sb, mirror(-3-1, height-1) * stride_line);
1182 cs->b1 = slice_buffer_get_line(sb, mirror(-3 , height-1) * stride_line);
1183 cs->b2 = slice_buffer_get_line(sb, mirror(-3+1, height-1) * stride_line);
1184 cs->b3 = slice_buffer_get_line(sb, mirror(-3+2, height-1) * stride_line);
1188 static void spatial_compose97i_init(DWTCompose *cs, IDWTELEM *buffer, int height, int stride){
1189 cs->b0 = buffer + mirror(-3-1, height-1)*stride;
1190 cs->b1 = buffer + mirror(-3 , height-1)*stride;
1191 cs->b2 = buffer + mirror(-3+1, height-1)*stride;
1192 cs->b3 = buffer + mirror(-3+2, height-1)*stride;
1196 static void spatial_compose97i_dy_buffered(DSPContext *dsp, DWTCompose *cs, slice_buffer * sb, int width, int height, int stride_line){
1199 IDWTELEM *b0= cs->b0;
1200 IDWTELEM *b1= cs->b1;
1201 IDWTELEM *b2= cs->b2;
1202 IDWTELEM *b3= cs->b3;
1203 IDWTELEM *b4= slice_buffer_get_line(sb, mirror(y + 3, height - 1) * stride_line);
1204 IDWTELEM *b5= slice_buffer_get_line(sb, mirror(y + 4, height - 1) * stride_line);
1206 if(y>0 && y+4<height){
1207 dsp->vertical_compose97i(b0, b1, b2, b3, b4, b5, width);
1209 if(y+3<(unsigned)height) vertical_compose97iL1(b3, b4, b5, width);
1210 if(y+2<(unsigned)height) vertical_compose97iH1(b2, b3, b4, width);
1211 if(y+1<(unsigned)height) vertical_compose97iL0(b1, b2, b3, width);
1212 if(y+0<(unsigned)height) vertical_compose97iH0(b0, b1, b2, width);
1215 if(y-1<(unsigned)height) dsp->horizontal_compose97i(b0, width);
1216 if(y+0<(unsigned)height) dsp->horizontal_compose97i(b1, width);
1225 static void spatial_compose97i_dy(DWTCompose *cs, IDWTELEM *buffer, int width, int height, int stride){
1227 IDWTELEM *b0= cs->b0;
1228 IDWTELEM *b1= cs->b1;
1229 IDWTELEM *b2= cs->b2;
1230 IDWTELEM *b3= cs->b3;
1231 IDWTELEM *b4= buffer + mirror(y+3, height-1)*stride;
1232 IDWTELEM *b5= buffer + mirror(y+4, height-1)*stride;
1234 if(y+3<(unsigned)height) vertical_compose97iL1(b3, b4, b5, width);
1235 if(y+2<(unsigned)height) vertical_compose97iH1(b2, b3, b4, width);
1236 if(y+1<(unsigned)height) vertical_compose97iL0(b1, b2, b3, width);
1237 if(y+0<(unsigned)height) vertical_compose97iH0(b0, b1, b2, width);
1239 if(y-1<(unsigned)height) ff_snow_horizontal_compose97i(b0, width);
1240 if(y+0<(unsigned)height) ff_snow_horizontal_compose97i(b1, width);
1249 static void av_unused spatial_compose97i(IDWTELEM *buffer, int width, int height, int stride){
1251 spatial_compose97i_init(&cs, buffer, height, stride);
1252 while(cs.y <= height)
1253 spatial_compose97i_dy(&cs, buffer, width, height, stride);
1256 static void ff_spatial_idwt_buffered_init(DWTCompose *cs, slice_buffer * sb, int width, int height, int stride_line, int type, int decomposition_count){
1258 for(level=decomposition_count-1; level>=0; level--){
1260 case DWT_97: spatial_compose97i_buffered_init(cs+level, sb, height>>level, stride_line<<level); break;
1261 case DWT_53: spatial_compose53i_buffered_init(cs+level, sb, height>>level, stride_line<<level); break;
1266 static void ff_spatial_idwt_buffered_slice(DSPContext *dsp, DWTCompose *cs, slice_buffer * slice_buf, int width, int height, int stride_line, int type, int decomposition_count, int y){
1267 const int support = type==1 ? 3 : 5;
1271 for(level=decomposition_count-1; level>=0; level--){
1272 while(cs[level].y <= FFMIN((y>>level)+support, height>>level)){
1274 case DWT_97: spatial_compose97i_dy_buffered(dsp, cs+level, slice_buf, width>>level, height>>level, stride_line<<level);
1276 case DWT_53: spatial_compose53i_dy_buffered(cs+level, slice_buf, width>>level, height>>level, stride_line<<level);
1283 static inline void unpack_coeffs(SnowContext *s, SubBand *b, SubBand * parent, int orientation){
1284 const int w= b->width;
1285 const int h= b->height;
1289 x_and_coeff *xc= b->x_coeff;
1290 x_and_coeff *prev_xc= NULL;
1291 x_and_coeff *prev2_xc= xc;
1292 x_and_coeff *parent_xc= parent ? parent->x_coeff : NULL;
1293 x_and_coeff *prev_parent_xc= parent_xc;
1295 runs= get_symbol2(&s->c, b->state[30], 0);
1296 if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
1301 int lt=0, t=0, rt=0;
1303 if(y && prev_xc->x == 0){
1315 if(prev_xc->x == x + 1)
1321 if(x>>1 > parent_xc->x){
1324 if(x>>1 == parent_xc->x){
1325 p= parent_xc->coeff;
1328 if(/*ll|*/l|lt|t|rt|p){
1329 int context= av_log2(/*FFABS(ll) + */3*(l>>1) + (lt>>1) + (t&~1) + (rt>>1) + (p>>1));
1331 v=get_rac(&s->c, &b->state[0][context]);
1333 v= 2*(get_symbol2(&s->c, b->state[context + 2], context-4) + 1);
1334 v+=get_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3bA[l&0xFF] + 3*quant3bA[t&0xFF]]);
1341 if(runs-- > 0) run= get_symbol2(&s->c, b->state[1], 3);
1343 v= 2*(get_symbol2(&s->c, b->state[0 + 2], 0-4) + 1);
1344 v+=get_rac(&s->c, &b->state[0][16 + 1 + 3]);
1353 if(y) max_run= FFMIN(run, prev_xc->x - x - 2);
1354 else max_run= FFMIN(run, w-x-1);
1356 max_run= FFMIN(max_run, 2*parent_xc->x - x - 1);
1362 (xc++)->x= w+1; //end marker
1368 while(parent_xc->x != parent->width+1)
1371 prev_parent_xc= parent_xc;
1373 parent_xc= prev_parent_xc;
1378 (xc++)->x= w+1; //end marker
1381 static inline void decode_subband_slice_buffered(SnowContext *s, SubBand *b, slice_buffer * sb, int start_y, int h, int save_state[1]){
1382 const int w= b->width;
1384 const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
1385 int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
1386 int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
1389 if(b->ibuf == s->spatial_idwt_buffer || s->qlog == LOSSLESS_QLOG){
1394 /* If we are on the second or later slice, restore our index. */
1396 new_index = save_state[0];
1399 for(y=start_y; y<h; y++){
1402 IDWTELEM * line = slice_buffer_get_line(sb, y * b->stride_line + b->buf_y_offset) + b->buf_x_offset;
1403 memset(line, 0, b->width*sizeof(IDWTELEM));
1404 v = b->x_coeff[new_index].coeff;
1405 x = b->x_coeff[new_index++].x;
1407 register int t= ( (v>>1)*qmul + qadd)>>QEXPSHIFT;
1408 register int u= -(v&1);
1409 line[x] = (t^u) - u;
1411 v = b->x_coeff[new_index].coeff;
1412 x = b->x_coeff[new_index++].x;
1416 /* Save our variables for the next slice. */
1417 save_state[0] = new_index;
1422 static void reset_contexts(SnowContext *s){ //FIXME better initial contexts
1423 int plane_index, level, orientation;
1425 for(plane_index=0; plane_index<3; plane_index++){
1426 for(level=0; level<MAX_DECOMPOSITIONS; level++){
1427 for(orientation=level ? 1:0; orientation<4; orientation++){
1428 memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
1432 memset(s->header_state, MID_STATE, sizeof(s->header_state));
1433 memset(s->block_state, MID_STATE, sizeof(s->block_state));
1436 static int alloc_blocks(SnowContext *s){
1437 int w= -((-s->avctx->width )>>LOG2_MB_SIZE);
1438 int h= -((-s->avctx->height)>>LOG2_MB_SIZE);
1444 s->block= av_mallocz(w * h * sizeof(BlockNode) << (s->block_max_depth*2));
1448 static inline void copy_rac_state(RangeCoder *d, RangeCoder *s){
1449 uint8_t *bytestream= d->bytestream;
1450 uint8_t *bytestream_start= d->bytestream_start;
1452 d->bytestream= bytestream;
1453 d->bytestream_start= bytestream_start;
1456 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){
1457 const int w= s->b_width << s->block_max_depth;
1458 const int rem_depth= s->block_max_depth - level;
1459 const int index= (x + y*w) << rem_depth;
1460 const int block_w= 1<<rem_depth;
1473 for(j=0; j<block_w; j++){
1474 for(i=0; i<block_w; i++){
1475 s->block[index + i + j*w]= block;
1480 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){
1481 const int offset[3]= {
1483 ((y*c->uvstride + x)>>1),
1484 ((y*c->uvstride + x)>>1),
1488 c->src[0][i]= src [i];
1489 c->ref[0][i]= ref [i] + offset[i];
1494 static inline void pred_mv(SnowContext *s, int *mx, int *my, int ref,
1495 const BlockNode *left, const BlockNode *top, const BlockNode *tr){
1496 if(s->ref_frames == 1){
1497 *mx = mid_pred(left->mx, top->mx, tr->mx);
1498 *my = mid_pred(left->my, top->my, tr->my);
1500 const int *scale = scale_mv_ref[ref];
1501 *mx = mid_pred((left->mx * scale[left->ref] + 128) >>8,
1502 (top ->mx * scale[top ->ref] + 128) >>8,
1503 (tr ->mx * scale[tr ->ref] + 128) >>8);
1504 *my = mid_pred((left->my * scale[left->ref] + 128) >>8,
1505 (top ->my * scale[top ->ref] + 128) >>8,
1506 (tr ->my * scale[tr ->ref] + 128) >>8);
1510 static av_always_inline int same_block(BlockNode *a, BlockNode *b){
1511 if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
1512 return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
1514 return !((a->mx - b->mx) | (a->my - b->my) | (a->ref - b->ref) | ((a->type ^ b->type)&BLOCK_INTRA));
1518 static void decode_q_branch(SnowContext *s, int level, int x, int y){
1519 const int w= s->b_width << s->block_max_depth;
1520 const int rem_depth= s->block_max_depth - level;
1521 const int index= (x + y*w) << rem_depth;
1522 int trx= (x+1)<<rem_depth;
1523 const BlockNode *left = x ? &s->block[index-1] : &null_block;
1524 const BlockNode *top = y ? &s->block[index-w] : &null_block;
1525 const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
1526 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
1527 int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
1530 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);
1534 if(level==s->block_max_depth || get_rac(&s->c, &s->block_state[4 + s_context])){
1536 int l = left->color[0];
1537 int cb= left->color[1];
1538 int cr= left->color[2];
1540 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
1541 int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 0*av_log2(2*FFABS(tr->mx - top->mx));
1542 int my_context= av_log2(2*FFABS(left->my - top->my)) + 0*av_log2(2*FFABS(tr->my - top->my));
1544 type= get_rac(&s->c, &s->block_state[1 + left->type + top->type]) ? BLOCK_INTRA : 0;
1547 pred_mv(s, &mx, &my, 0, left, top, tr);
1548 l += get_symbol(&s->c, &s->block_state[32], 1);
1549 cb+= get_symbol(&s->c, &s->block_state[64], 1);
1550 cr+= get_symbol(&s->c, &s->block_state[96], 1);
1552 if(s->ref_frames > 1)
1553 ref= get_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], 0);
1554 pred_mv(s, &mx, &my, ref, left, top, tr);
1555 mx+= get_symbol(&s->c, &s->block_state[128 + 32*(mx_context + 16*!!ref)], 1);
1556 my+= get_symbol(&s->c, &s->block_state[128 + 32*(my_context + 16*!!ref)], 1);
1558 set_blocks(s, level, x, y, l, cb, cr, mx, my, ref, type);
1560 decode_q_branch(s, level+1, 2*x+0, 2*y+0);
1561 decode_q_branch(s, level+1, 2*x+1, 2*y+0);
1562 decode_q_branch(s, level+1, 2*x+0, 2*y+1);
1563 decode_q_branch(s, level+1, 2*x+1, 2*y+1);
1567 static void decode_blocks(SnowContext *s){
1574 decode_q_branch(s, 0, x, y);
1579 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){
1580 static const uint8_t weight[64]={
1591 static const uint8_t brane[256]={
1592 0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
1593 0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
1594 0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
1595 0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
1596 0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
1597 0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
1598 0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
1599 0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
1600 0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
1601 0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
1602 0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
1603 0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
1604 0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
1605 0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
1606 0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
1607 0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
1610 static const uint8_t needs[16]={
1618 int16_t tmpIt [64*(32+HTAPS_MAX)];
1619 uint8_t tmp2t[3][stride*(32+HTAPS_MAX)];
1620 int16_t *tmpI= tmpIt;
1621 uint8_t *tmp2= tmp2t[0];
1622 const uint8_t *hpel[11];
1623 assert(dx<16 && dy<16);
1624 r= brane[dx + 16*dy]&15;
1625 l= brane[dx + 16*dy]>>4;
1627 b= needs[l] | needs[r];
1628 if(p && !p->diag_mc)
1632 for(y=0; y < b_h+HTAPS_MAX-1; y++){
1633 for(x=0; x < b_w; x++){
1634 int a_1=src[x + HTAPS_MAX/2-4];
1635 int a0= src[x + HTAPS_MAX/2-3];
1636 int a1= src[x + HTAPS_MAX/2-2];
1637 int a2= src[x + HTAPS_MAX/2-1];
1638 int a3= src[x + HTAPS_MAX/2+0];
1639 int a4= src[x + HTAPS_MAX/2+1];
1640 int a5= src[x + HTAPS_MAX/2+2];
1641 int a6= src[x + HTAPS_MAX/2+3];
1643 if(!p || p->fast_mc){
1644 am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
1648 am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
1653 if(am&(~255)) am= ~(am>>31);
1662 src += HTAPS_MAX/2 - 1;
1666 for(y=0; y < b_h; y++){
1667 for(x=0; x < b_w+1; x++){
1668 int a_1=src[x + (HTAPS_MAX/2-4)*stride];
1669 int a0= src[x + (HTAPS_MAX/2-3)*stride];
1670 int a1= src[x + (HTAPS_MAX/2-2)*stride];
1671 int a2= src[x + (HTAPS_MAX/2-1)*stride];
1672 int a3= src[x + (HTAPS_MAX/2+0)*stride];
1673 int a4= src[x + (HTAPS_MAX/2+1)*stride];
1674 int a5= src[x + (HTAPS_MAX/2+2)*stride];
1675 int a6= src[x + (HTAPS_MAX/2+3)*stride];
1677 if(!p || p->fast_mc)
1678 am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
1680 am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
1682 if(am&(~255)) am= ~(am>>31);
1690 src += stride*(HTAPS_MAX/2 - 1);
1694 for(y=0; y < b_h; y++){
1695 for(x=0; x < b_w; x++){
1696 int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
1697 int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
1698 int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
1699 int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
1700 int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
1701 int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
1702 int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
1703 int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
1705 if(!p || p->fast_mc)
1706 am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
1708 am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
1709 if(am&(~255)) am= ~(am>>31);
1718 hpel[ 1]= tmp2t[0] + stride*(HTAPS_MAX/2-1);
1723 hpel[ 6]= tmp2t[1] + 1;
1725 hpel[ 8]= src + stride;
1726 hpel[ 9]= hpel[1] + stride;
1727 hpel[10]= hpel[8] + 1;
1730 const uint8_t *src1= hpel[dx/8 + dy/8*4 ];
1731 const uint8_t *src2= hpel[dx/8 + dy/8*4+1];
1732 const uint8_t *src3= hpel[dx/8 + dy/8*4+4];
1733 const uint8_t *src4= hpel[dx/8 + dy/8*4+5];
1736 for(y=0; y < b_h; y++){
1737 for(x=0; x < b_w; x++){
1738 dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
1739 (8-dx)* dy *src3[x] + dx* dy *src4[x]+32)>>6;
1748 const uint8_t *src1= hpel[l];
1749 const uint8_t *src2= hpel[r];
1750 int a= weight[((dx&7) + (8*(dy&7)))];
1752 for(y=0; y < b_h; y++){
1753 for(x=0; x < b_w; x++){
1754 dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
1763 #define mca(dx,dy,b_w)\
1764 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, int stride, int h){\
1765 uint8_t tmp[stride*(b_w+HTAPS_MAX-1)];\
1767 mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, tmp, stride, b_w, b_w, dx, dy);\
1779 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){
1780 if(block->type & BLOCK_INTRA){
1782 const int color = block->color[plane_index];
1783 const int color4= color*0x01010101;
1785 for(y=0; y < b_h; y++){
1786 *(uint32_t*)&dst[0 + y*stride]= color4;
1787 *(uint32_t*)&dst[4 + y*stride]= color4;
1788 *(uint32_t*)&dst[8 + y*stride]= color4;
1789 *(uint32_t*)&dst[12+ y*stride]= color4;
1790 *(uint32_t*)&dst[16+ y*stride]= color4;
1791 *(uint32_t*)&dst[20+ y*stride]= color4;
1792 *(uint32_t*)&dst[24+ y*stride]= color4;
1793 *(uint32_t*)&dst[28+ y*stride]= color4;
1796 for(y=0; y < b_h; y++){
1797 *(uint32_t*)&dst[0 + y*stride]= color4;
1798 *(uint32_t*)&dst[4 + y*stride]= color4;
1799 *(uint32_t*)&dst[8 + y*stride]= color4;
1800 *(uint32_t*)&dst[12+ y*stride]= color4;
1803 for(y=0; y < b_h; y++){
1804 *(uint32_t*)&dst[0 + y*stride]= color4;
1805 *(uint32_t*)&dst[4 + y*stride]= color4;
1808 for(y=0; y < b_h; y++){
1809 *(uint32_t*)&dst[0 + y*stride]= color4;
1812 for(y=0; y < b_h; y++){
1813 for(x=0; x < b_w; x++){
1814 dst[x + y*stride]= color;
1819 uint8_t *src= s->last_picture[block->ref].data[plane_index];
1820 const int scale= plane_index ? s->mv_scale : 2*s->mv_scale;
1821 int mx= block->mx*scale;
1822 int my= block->my*scale;
1823 const int dx= mx&15;
1824 const int dy= my&15;
1825 const int tab_index= 3 - (b_w>>2) + (b_w>>4);
1826 sx += (mx>>4) - (HTAPS_MAX/2-1);
1827 sy += (my>>4) - (HTAPS_MAX/2-1);
1828 src += sx + sy*stride;
1829 if( (unsigned)sx >= w - b_w - (HTAPS_MAX-2)
1830 || (unsigned)sy >= h - b_h - (HTAPS_MAX-2)){
1831 ff_emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);
1834 // assert(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h);
1835 // assert(!(b_w&(b_w-1)));
1836 assert(b_w>1 && b_h>1);
1837 assert((tab_index>=0 && tab_index<4) || b_w==32);
1838 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 )
1839 mc_block(&s->plane[plane_index], dst, src, tmp, stride, b_w, b_h, dx, dy);
1842 for(y=0; y<b_h; y+=16){
1843 s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
1844 s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
1847 s->dsp.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
1848 else if(b_w==2*b_h){
1849 s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst ,src + 3 + 3*stride,stride);
1850 s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
1853 s->dsp.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst ,src + 3 + 3*stride ,stride);
1854 s->dsp.put_h264_qpel_pixels_tab[tab_index ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
1859 void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
1860 int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){
1863 for(y=0; y<b_h; y++){
1864 //FIXME ugly misuse of obmc_stride
1865 const uint8_t *obmc1= obmc + y*obmc_stride;
1866 const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
1867 const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
1868 const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
1869 dst = slice_buffer_get_line(sb, src_y + y);
1870 for(x=0; x<b_w; x++){
1871 int v= obmc1[x] * block[3][x + y*src_stride]
1872 +obmc2[x] * block[2][x + y*src_stride]
1873 +obmc3[x] * block[1][x + y*src_stride]
1874 +obmc4[x] * block[0][x + y*src_stride];
1876 v <<= 8 - LOG2_OBMC_MAX;
1878 v >>= 8 - FRAC_BITS;
1881 v += dst[x + src_x];
1882 v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
1883 if(v&(~255)) v= ~(v>>31);
1884 dst8[x + y*src_stride] = v;
1886 dst[x + src_x] -= v;
1892 //FIXME name cleanup (b_w, block_w, b_width stuff)
1893 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){
1894 const int b_width = s->b_width << s->block_max_depth;
1895 const int b_height= s->b_height << s->block_max_depth;
1896 const int b_stride= b_width;
1897 BlockNode *lt= &s->block[b_x + b_y*b_stride];
1898 BlockNode *rt= lt+1;
1899 BlockNode *lb= lt+b_stride;
1900 BlockNode *rb= lb+1;
1902 int tmp_step= src_stride >= 7*MB_SIZE ? MB_SIZE : MB_SIZE*src_stride;
1903 uint8_t *tmp = s->scratchbuf;
1910 }else if(b_x + 1 >= b_width){
1917 }else if(b_y + 1 >= b_height){
1922 if(src_x<0){ //FIXME merge with prev & always round internal width up to *16
1925 if(!sliced && !offset_dst)
1928 }else if(src_x + b_w > w){
1932 obmc -= src_y*obmc_stride;
1934 if(!sliced && !offset_dst)
1935 dst -= src_y*dst_stride;
1937 }else if(src_y + b_h> h){
1941 if(b_w<=0 || b_h<=0) return;
1943 assert(src_stride > 2*MB_SIZE + 5);
1945 if(!sliced && offset_dst)
1946 dst += src_x + src_y*dst_stride;
1947 dst8+= src_x + src_y*src_stride;
1948 // src += src_x + src_y*src_stride;
1950 ptmp= tmp + 3*tmp_step;
1953 pred_block(s, block[0], tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h);
1955 if(same_block(lt, rt)){
1960 pred_block(s, block[1], tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h);
1963 if(same_block(lt, lb)){
1965 }else if(same_block(rt, lb)){
1970 pred_block(s, block[2], tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h);
1973 if(same_block(lt, rb) ){
1975 }else if(same_block(rt, rb)){
1977 }else if(same_block(lb, rb)){
1981 pred_block(s, block[3], tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h);
1984 for(y=0; y<b_h; y++){
1985 for(x=0; x<b_w; x++){
1986 int v= obmc [x + y*obmc_stride] * block[3][x + y*src_stride] * (256/OBMC_MAX);
1987 if(add) dst[x + y*dst_stride] += v;
1988 else dst[x + y*dst_stride] -= v;
1991 for(y=0; y<b_h; y++){
1992 uint8_t *obmc2= obmc + (obmc_stride>>1);
1993 for(x=0; x<b_w; x++){
1994 int v= obmc2[x + y*obmc_stride] * block[2][x + y*src_stride] * (256/OBMC_MAX);
1995 if(add) dst[x + y*dst_stride] += v;
1996 else dst[x + y*dst_stride] -= v;
1999 for(y=0; y<b_h; y++){
2000 uint8_t *obmc3= obmc + obmc_stride*(obmc_stride>>1);
2001 for(x=0; x<b_w; x++){
2002 int v= obmc3[x + y*obmc_stride] * block[1][x + y*src_stride] * (256/OBMC_MAX);
2003 if(add) dst[x + y*dst_stride] += v;
2004 else dst[x + y*dst_stride] -= v;
2007 for(y=0; y<b_h; y++){
2008 uint8_t *obmc3= obmc + obmc_stride*(obmc_stride>>1);
2009 uint8_t *obmc4= obmc3+ (obmc_stride>>1);
2010 for(x=0; x<b_w; x++){
2011 int v= obmc4[x + y*obmc_stride] * block[0][x + y*src_stride] * (256/OBMC_MAX);
2012 if(add) dst[x + y*dst_stride] += v;
2013 else dst[x + y*dst_stride] -= v;
2018 s->dsp.inner_add_yblock(obmc, obmc_stride, block, b_w, b_h, src_x,src_y, src_stride, sb, add, dst8);
2020 for(y=0; y<b_h; y++){
2021 //FIXME ugly misuse of obmc_stride
2022 const uint8_t *obmc1= obmc + y*obmc_stride;
2023 const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
2024 const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
2025 const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
2026 for(x=0; x<b_w; x++){
2027 int v= obmc1[x] * block[3][x + y*src_stride]
2028 +obmc2[x] * block[2][x + y*src_stride]
2029 +obmc3[x] * block[1][x + y*src_stride]
2030 +obmc4[x] * block[0][x + y*src_stride];
2032 v <<= 8 - LOG2_OBMC_MAX;
2034 v >>= 8 - FRAC_BITS;
2037 v += dst[x + y*dst_stride];
2038 v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
2039 if(v&(~255)) v= ~(v>>31);
2040 dst8[x + y*src_stride] = v;
2042 dst[x + y*dst_stride] -= v;
2050 static av_always_inline void predict_slice_buffered(SnowContext *s, slice_buffer * sb, IDWTELEM * old_buffer, int plane_index, int add, int mb_y){
2051 Plane *p= &s->plane[plane_index];
2052 const int mb_w= s->b_width << s->block_max_depth;
2053 const int mb_h= s->b_height << s->block_max_depth;
2055 int block_size = MB_SIZE >> s->block_max_depth;
2056 int block_w = plane_index ? block_size/2 : block_size;
2057 const uint8_t *obmc = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
2058 int obmc_stride= plane_index ? block_size : 2*block_size;
2059 int ref_stride= s->current_picture.linesize[plane_index];
2060 uint8_t *dst8= s->current_picture.data[plane_index];
2064 if(s->keyframe || (s->avctx->debug&512)){
2069 for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
2070 // DWTELEM * line = slice_buffer_get_line(sb, y);
2071 IDWTELEM * line = sb->line[y];
2073 // int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
2074 int v= line[x] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
2076 if(v&(~255)) v= ~(v>>31);
2077 dst8[x + y*ref_stride]= v;
2081 for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
2082 // DWTELEM * line = slice_buffer_get_line(sb, y);
2083 IDWTELEM * line = sb->line[y];
2085 line[x] -= 128 << FRAC_BITS;
2086 // buf[x + y*w]-= 128<<FRAC_BITS;
2094 for(mb_x=0; mb_x<=mb_w; mb_x++){
2095 add_yblock(s, 1, sb, old_buffer, dst8, obmc,
2096 block_w*mb_x - block_w/2,
2097 block_w*mb_y - block_w/2,
2100 w, ref_stride, obmc_stride,
2102 add, 0, plane_index);
2106 static av_always_inline void predict_slice(SnowContext *s, IDWTELEM *buf, int plane_index, int add, int mb_y){
2107 Plane *p= &s->plane[plane_index];
2108 const int mb_w= s->b_width << s->block_max_depth;
2109 const int mb_h= s->b_height << s->block_max_depth;
2111 int block_size = MB_SIZE >> s->block_max_depth;
2112 int block_w = plane_index ? block_size/2 : block_size;
2113 const uint8_t *obmc = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
2114 const int obmc_stride= plane_index ? block_size : 2*block_size;
2115 int ref_stride= s->current_picture.linesize[plane_index];
2116 uint8_t *dst8= s->current_picture.data[plane_index];
2120 if(s->keyframe || (s->avctx->debug&512)){
2125 for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
2127 int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
2129 if(v&(~255)) v= ~(v>>31);
2130 dst8[x + y*ref_stride]= v;
2134 for(y=block_w*mb_y; y<FFMIN(h,block_w*(mb_y+1)); y++){
2136 buf[x + y*w]-= 128<<FRAC_BITS;
2144 for(mb_x=0; mb_x<=mb_w; mb_x++){
2145 add_yblock(s, 0, NULL, buf, dst8, obmc,
2146 block_w*mb_x - block_w/2,
2147 block_w*mb_y - block_w/2,
2150 w, ref_stride, obmc_stride,
2152 add, 1, plane_index);
2156 static av_always_inline void predict_plane(SnowContext *s, IDWTELEM *buf, int plane_index, int add){
2157 const int mb_h= s->b_height << s->block_max_depth;
2159 for(mb_y=0; mb_y<=mb_h; mb_y++)
2160 predict_slice(s, buf, plane_index, add, mb_y);
2163 static void dequantize_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, IDWTELEM *src, int stride, int start_y, int end_y){
2164 const int w= b->width;
2165 const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
2166 const int qmul= qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
2167 const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
2170 if(s->qlog == LOSSLESS_QLOG) return;
2172 for(y=start_y; y<end_y; y++){
2173 // DWTELEM * line = slice_buffer_get_line_from_address(sb, src + (y * stride));
2174 IDWTELEM * line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
2178 line[x]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
2180 line[x]= (( i*qmul + qadd)>>(QEXPSHIFT));
2186 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){
2187 const int w= b->width;
2190 IDWTELEM * line=0; // silence silly "could be used without having been initialized" warning
2194 line = slice_buffer_get_line(sb, ((start_y - 1) * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
2196 for(y=start_y; y<end_y; y++){
2198 // line = slice_buffer_get_line_from_address(sb, src + (y * stride));
2199 line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
2203 if(y && x+1<w) line[x] += mid_pred(line[x - 1], prev[x], prev[x + 1]);
2204 else line[x] += line[x - 1];
2206 if(y) line[x] += mid_pred(line[x - 1], prev[x], line[x - 1] + prev[x] - prev[x - 1]);
2207 else line[x] += line[x - 1];
2210 if(y) line[x] += prev[x];
2216 static void decode_qlogs(SnowContext *s){
2217 int plane_index, level, orientation;
2219 for(plane_index=0; plane_index<3; plane_index++){
2220 for(level=0; level<s->spatial_decomposition_count; level++){
2221 for(orientation=level ? 1:0; orientation<4; orientation++){
2223 if (plane_index==2) q= s->plane[1].band[level][orientation].qlog;
2224 else if(orientation==2) q= s->plane[plane_index].band[level][1].qlog;
2225 else q= get_symbol(&s->c, s->header_state, 1);
2226 s->plane[plane_index].band[level][orientation].qlog= q;
2232 #define GET_S(dst, check) \
2233 tmp= get_symbol(&s->c, s->header_state, 0);\
2235 av_log(s->avctx, AV_LOG_ERROR, "Error " #dst " is %d\n", tmp);\
2240 static int decode_header(SnowContext *s){
2241 int plane_index, tmp;
2244 memset(kstate, MID_STATE, sizeof(kstate));
2246 s->keyframe= get_rac(&s->c, kstate);
2247 if(s->keyframe || s->always_reset){
2249 s->spatial_decomposition_type=
2253 s->block_max_depth= 0;
2256 GET_S(s->version, tmp <= 0U)
2257 s->always_reset= get_rac(&s->c, s->header_state);
2258 s->temporal_decomposition_type= get_symbol(&s->c, s->header_state, 0);
2259 s->temporal_decomposition_count= get_symbol(&s->c, s->header_state, 0);
2260 GET_S(s->spatial_decomposition_count, 0 < tmp && tmp <= MAX_DECOMPOSITIONS)
2261 s->colorspace_type= get_symbol(&s->c, s->header_state, 0);
2262 s->chroma_h_shift= get_symbol(&s->c, s->header_state, 0);
2263 s->chroma_v_shift= get_symbol(&s->c, s->header_state, 0);
2264 s->spatial_scalability= get_rac(&s->c, s->header_state);
2265 // s->rate_scalability= get_rac(&s->c, s->header_state);
2266 GET_S(s->max_ref_frames, tmp < (unsigned)MAX_REF_FRAMES)
2267 s->max_ref_frames++;
2273 if(get_rac(&s->c, s->header_state)){
2274 for(plane_index=0; plane_index<2; plane_index++){
2275 int htaps, i, sum=0;
2276 Plane *p= &s->plane[plane_index];
2277 p->diag_mc= get_rac(&s->c, s->header_state);
2278 htaps= get_symbol(&s->c, s->header_state, 0)*2 + 2;
2279 if((unsigned)htaps > HTAPS_MAX || htaps==0)
2282 for(i= htaps/2; i; i--){
2283 p->hcoeff[i]= get_symbol(&s->c, s->header_state, 0) * (1-2*(i&1));
2284 sum += p->hcoeff[i];
2286 p->hcoeff[0]= 32-sum;
2288 s->plane[2].diag_mc= s->plane[1].diag_mc;
2289 s->plane[2].htaps = s->plane[1].htaps;
2290 memcpy(s->plane[2].hcoeff, s->plane[1].hcoeff, sizeof(s->plane[1].hcoeff));
2292 if(get_rac(&s->c, s->header_state)){
2293 GET_S(s->spatial_decomposition_count, 0 < tmp && tmp <= MAX_DECOMPOSITIONS)
2298 s->spatial_decomposition_type+= get_symbol(&s->c, s->header_state, 1);
2299 if(s->spatial_decomposition_type > 1U){
2300 av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_type %d not supported", s->spatial_decomposition_type);
2303 if(FFMIN(s->avctx-> width>>s->chroma_h_shift,
2304 s->avctx->height>>s->chroma_v_shift) >> (s->spatial_decomposition_count-1) <= 0){
2305 av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_count %d too large for size", s->spatial_decomposition_count);
2309 s->qlog += get_symbol(&s->c, s->header_state, 1);
2310 s->mv_scale += get_symbol(&s->c, s->header_state, 1);
2311 s->qbias += get_symbol(&s->c, s->header_state, 1);
2312 s->block_max_depth+= get_symbol(&s->c, s->header_state, 1);
2313 if(s->block_max_depth > 1 || s->block_max_depth < 0){
2314 av_log(s->avctx, AV_LOG_ERROR, "block_max_depth= %d is too large", s->block_max_depth);
2315 s->block_max_depth= 0;
2322 static void init_qexp(void){
2326 for(i=0; i<QROOT; i++){
2328 v *= pow(2, 1.0 / QROOT);
2332 static av_cold int common_init(AVCodecContext *avctx){
2333 SnowContext *s = avctx->priv_data;
2338 s->max_ref_frames=1; //just make sure its not an invalid value in case of no initial keyframe
2340 dsputil_init(&s->dsp, avctx);
2343 s->dsp.put_qpel_pixels_tab [0][dy+dx/4]=\
2344 s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
2345 s->dsp.put_h264_qpel_pixels_tab[0][dy+dx/4];\
2346 s->dsp.put_qpel_pixels_tab [1][dy+dx/4]=\
2347 s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
2348 s->dsp.put_h264_qpel_pixels_tab[1][dy+dx/4];
2367 #define mcfh(dx,dy)\
2368 s->dsp.put_pixels_tab [0][dy/4+dx/8]=\
2369 s->dsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
2370 mc_block_hpel ## dx ## dy ## 16;\
2371 s->dsp.put_pixels_tab [1][dy/4+dx/8]=\
2372 s->dsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
2373 mc_block_hpel ## dx ## dy ## 8;
2383 // dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
2385 width= s->avctx->width;
2386 height= s->avctx->height;
2388 s->spatial_idwt_buffer= av_mallocz(width*height*sizeof(IDWTELEM));
2389 s->spatial_dwt_buffer= av_mallocz(width*height*sizeof(DWTELEM)); //FIXME this does not belong here
2391 for(i=0; i<MAX_REF_FRAMES; i++)
2392 for(j=0; j<MAX_REF_FRAMES; j++)
2393 scale_mv_ref[i][j] = 256*(i+1)/(j+1);
2395 s->avctx->get_buffer(s->avctx, &s->mconly_picture);
2396 s->scratchbuf = av_malloc(s->mconly_picture.linesize[0]*7*MB_SIZE);
2401 static int common_init_after_header(AVCodecContext *avctx){
2402 SnowContext *s = avctx->priv_data;
2403 int plane_index, level, orientation;
2405 for(plane_index=0; plane_index<3; plane_index++){
2406 int w= s->avctx->width;
2407 int h= s->avctx->height;
2410 w>>= s->chroma_h_shift;
2411 h>>= s->chroma_v_shift;
2413 s->plane[plane_index].width = w;
2414 s->plane[plane_index].height= h;
2416 for(level=s->spatial_decomposition_count-1; level>=0; level--){
2417 for(orientation=level ? 1 : 0; orientation<4; orientation++){
2418 SubBand *b= &s->plane[plane_index].band[level][orientation];
2420 b->buf= s->spatial_dwt_buffer;
2422 b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
2423 b->width = (w + !(orientation&1))>>1;
2424 b->height= (h + !(orientation>1))>>1;
2426 b->stride_line = 1 << (s->spatial_decomposition_count - level);
2427 b->buf_x_offset = 0;
2428 b->buf_y_offset = 0;
2432 b->buf_x_offset = (w+1)>>1;
2435 b->buf += b->stride>>1;
2436 b->buf_y_offset = b->stride_line >> 1;
2438 b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
2441 b->parent= &s->plane[plane_index].band[level-1][orientation];
2442 //FIXME avoid this realloc
2443 av_freep(&b->x_coeff);
2444 b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
2459 static void find_sse(SnowContext *s, Plane *p, int *score, int score_stride, IDWTELEM *r0, IDWTELEM *r1, int level, int orientation){
2460 SubBand *b= &p->band[level][orientation];
2464 int step= 1 << (s->spatial_decomposition_count - level);
2471 //FIXME bias for nonzero ?
2473 memset(score, 0, sizeof(*score)*score_stride*((p->height + Q2_STEP-1)/Q2_STEP));
2474 for(y=0; y<p->height; y++){
2475 for(x=0; x<p->width; x++){
2476 int sx= (x-xo + step/2) / step / Q2_STEP;
2477 int sy= (y-yo + step/2) / step / Q2_STEP;
2478 int v= r0[x + y*p->width] - r1[x + y*p->width];
2479 assert(sx>=0 && sy>=0 && sx < score_stride);
2481 score[sx + sy*score_stride] += v*v;
2482 assert(score[sx + sy*score_stride] >= 0);
2487 static void dequantize_all(SnowContext *s, Plane *p, IDWTELEM *buffer, int width, int height){
2488 int level, orientation;
2490 for(level=0; level<s->spatial_decomposition_count; level++){
2491 for(orientation=level ? 1 : 0; orientation<4; orientation++){
2492 SubBand *b= &p->band[level][orientation];
2493 IDWTELEM *dst= buffer + (b->ibuf - s->spatial_idwt_buffer);
2495 dequantize(s, b, dst, b->stride);
2500 static void dwt_quantize(SnowContext *s, Plane *p, DWTELEM *buffer, int width, int height, int stride, int type){
2501 int level, orientation, ys, xs, x, y, pass;
2502 IDWTELEM best_dequant[height * stride];
2503 IDWTELEM idwt2_buffer[height * stride];
2504 const int score_stride= (width + 10)/Q2_STEP;
2505 int best_score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP]; //FIXME size
2506 int score[(width + 10)/Q2_STEP * (height + 10)/Q2_STEP]; //FIXME size
2507 int threshold= (s->m.lambda * s->m.lambda) >> 6;
2509 //FIXME pass the copy cleanly ?
2511 // memcpy(dwt_buffer, buffer, height * stride * sizeof(DWTELEM));
2512 ff_spatial_dwt(buffer, width, height, stride, type, s->spatial_decomposition_count);
2514 for(level=0; level<s->spatial_decomposition_count; level++){
2515 for(orientation=level ? 1 : 0; orientation<4; orientation++){
2516 SubBand *b= &p->band[level][orientation];
2517 IDWTELEM *dst= best_dequant + (b->ibuf - s->spatial_idwt_buffer);
2518 DWTELEM *src= buffer + (b-> buf - s->spatial_dwt_buffer);
2519 assert(src == b->buf); // code does not depend on this but it is true currently
2521 quantize(s, b, dst, src, b->stride, s->qbias);
2524 for(pass=0; pass<1; pass++){
2525 if(s->qbias == 0) //keyframe
2527 for(level=0; level<s->spatial_decomposition_count; level++){
2528 for(orientation=level ? 1 : 0; orientation<4; orientation++){
2529 SubBand *b= &p->band[level][orientation];
2530 IDWTELEM *dst= idwt2_buffer + (b->ibuf - s->spatial_idwt_buffer);
2531 IDWTELEM *best_dst= best_dequant + (b->ibuf - s->spatial_idwt_buffer);
2533 for(ys= 0; ys<Q2_STEP; ys++){
2534 for(xs= 0; xs<Q2_STEP; xs++){
2535 memcpy(idwt2_buffer, best_dequant, height * stride * sizeof(IDWTELEM));
2536 dequantize_all(s, p, idwt2_buffer, width, height);
2537 ff_spatial_idwt(idwt2_buffer, width, height, stride, type, s->spatial_decomposition_count);
2538 find_sse(s, p, best_score, score_stride, idwt2_buffer, s->spatial_idwt_buffer, level, orientation);
2539 memcpy(idwt2_buffer, best_dequant, height * stride * sizeof(IDWTELEM));
2540 for(y=ys; y<b->height; y+= Q2_STEP){
2541 for(x=xs; x<b->width; x+= Q2_STEP){
2542 if(dst[x + y*b->stride]<0) dst[x + y*b->stride]++;
2543 if(dst[x + y*b->stride]>0) dst[x + y*b->stride]--;
2544 //FIXME try more than just --
2547 dequantize_all(s, p, idwt2_buffer, width, height);
2548 ff_spatial_idwt(idwt2_buffer, width, height, stride, type, s->spatial_decomposition_count);
2549 find_sse(s, p, score, score_stride, idwt2_buffer, s->spatial_idwt_buffer, level, orientation);
2550 for(y=ys; y<b->height; y+= Q2_STEP){
2551 for(x=xs; x<b->width; x+= Q2_STEP){
2552 int score_idx= x/Q2_STEP + (y/Q2_STEP)*score_stride;
2553 if(score[score_idx] <= best_score[score_idx] + threshold){
2554 best_score[score_idx]= score[score_idx];
2555 if(best_dst[x + y*b->stride]<0) best_dst[x + y*b->stride]++;
2556 if(best_dst[x + y*b->stride]>0) best_dst[x + y*b->stride]--;
2557 //FIXME copy instead
2566 memcpy(s->spatial_idwt_buffer, best_dequant, height * stride * sizeof(IDWTELEM)); //FIXME work with that directly instead of copy at the end
2569 #endif /* QUANTIZE2==1 */
2571 #define USE_HALFPEL_PLANE 0
2573 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
2576 assert(!(s->avctx->flags & CODEC_FLAG_EMU_EDGE));
2580 int w= s->avctx->width >>is_chroma;
2581 int h= s->avctx->height >>is_chroma;
2582 int ls= frame->linesize[p];
2583 uint8_t *src= frame->data[p];
2585 halfpel[1][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
2586 halfpel[2][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
2587 halfpel[3][p]= (uint8_t*)av_malloc(ls * (h+2*EDGE_WIDTH)) + EDGE_WIDTH*(1+ls);
2594 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;
2601 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;
2609 halfpel[3][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
2617 static void release_buffer(AVCodecContext *avctx){
2618 SnowContext *s = avctx->priv_data;
2621 if(s->last_picture[s->max_ref_frames-1].data[0]){
2622 avctx->release_buffer(avctx, &s->last_picture[s->max_ref_frames-1]);
2624 if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
2625 av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture.linesize[i%3]));
2629 static int frame_start(SnowContext *s){
2631 int w= s->avctx->width; //FIXME round up to x16 ?
2632 int h= s->avctx->height;
2634 if(s->current_picture.data[0]){
2635 s->dsp.draw_edges(s->current_picture.data[0], s->current_picture.linesize[0], w , h , EDGE_WIDTH );
2636 s->dsp.draw_edges(s->current_picture.data[1], s->current_picture.linesize[1], w>>1, h>>1, EDGE_WIDTH/2);
2637 s->dsp.draw_edges(s->current_picture.data[2], s->current_picture.linesize[2], w>>1, h>>1, EDGE_WIDTH/2);
2640 release_buffer(s->avctx);
2642 tmp= s->last_picture[s->max_ref_frames-1];
2643 memmove(s->last_picture+1, s->last_picture, (s->max_ref_frames-1)*sizeof(AVFrame));
2644 memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
2645 if(USE_HALFPEL_PLANE && s->current_picture.data[0])
2646 halfpel_interpol(s, s->halfpel_plane[0], &s->current_picture);
2647 s->last_picture[0]= s->current_picture;
2648 s->current_picture= tmp;
2654 for(i=0; i<s->max_ref_frames && s->last_picture[i].data[0]; i++)
2655 if(i && s->last_picture[i-1].key_frame)
2658 if(s->ref_frames==0){
2659 av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
2664 s->current_picture.reference= 1;
2665 if(s->avctx->get_buffer(s->avctx, &s->current_picture) < 0){
2666 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
2670 s->current_picture.key_frame= s->keyframe;
2675 static av_cold void common_end(SnowContext *s){
2676 int plane_index, level, orientation, i;
2678 av_freep(&s->spatial_dwt_buffer);
2679 av_freep(&s->spatial_idwt_buffer);
2682 av_freep(&s->m.me.scratchpad);
2683 av_freep(&s->m.me.map);
2684 av_freep(&s->m.me.score_map);
2685 av_freep(&s->m.obmc_scratchpad);
2687 av_freep(&s->block);
2688 av_freep(&s->scratchbuf);
2690 for(i=0; i<MAX_REF_FRAMES; i++){
2691 av_freep(&s->ref_mvs[i]);
2692 av_freep(&s->ref_scores[i]);
2693 if(s->last_picture[i].data[0])
2694 s->avctx->release_buffer(s->avctx, &s->last_picture[i]);
2697 for(plane_index=0; plane_index<3; plane_index++){
2698 for(level=s->spatial_decomposition_count-1; level>=0; level--){
2699 for(orientation=level ? 1 : 0; orientation<4; orientation++){
2700 SubBand *b= &s->plane[plane_index].band[level][orientation];
2702 av_freep(&b->x_coeff);
2706 if (s->mconly_picture.data[0])
2707 s->avctx->release_buffer(s->avctx, &s->mconly_picture);
2708 if (s->current_picture.data[0])
2709 s->avctx->release_buffer(s->avctx, &s->current_picture);
2712 static av_cold int decode_init(AVCodecContext *avctx)
2714 avctx->pix_fmt= PIX_FMT_YUV420P;
2721 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
2722 const uint8_t *buf = avpkt->data;
2723 int buf_size = avpkt->size;
2724 SnowContext *s = avctx->priv_data;
2725 RangeCoder * const c= &s->c;
2727 AVFrame *picture = data;
2728 int level, orientation, plane_index;
2730 ff_init_range_decoder(c, buf, buf_size);
2731 ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
2733 s->current_picture.pict_type= FF_I_TYPE; //FIXME I vs. P
2734 if(decode_header(s)<0)
2736 common_init_after_header(avctx);
2738 // realloc slice buffer for the case that spatial_decomposition_count changed
2739 slice_buffer_destroy(&s->sb);
2740 slice_buffer_init(&s->sb, s->plane[0].height, (MB_SIZE >> s->block_max_depth) + s->spatial_decomposition_count * 8 + 1, s->plane[0].width, s->spatial_idwt_buffer);
2742 for(plane_index=0; plane_index<3; plane_index++){
2743 Plane *p= &s->plane[plane_index];
2744 p->fast_mc= p->diag_mc && p->htaps==6 && p->hcoeff[0]==40
2745 && p->hcoeff[1]==-10
2751 if(frame_start(s) < 0)
2753 //keyframe flag duplication mess FIXME
2754 if(avctx->debug&FF_DEBUG_PICT_INFO)
2755 av_log(avctx, AV_LOG_ERROR, "keyframe:%d qlog:%d\n", s->keyframe, s->qlog);
2759 for(plane_index=0; plane_index<3; plane_index++){
2760 Plane *p= &s->plane[plane_index];
2764 int decode_state[MAX_DECOMPOSITIONS][4][1]; /* Stored state info for unpack_coeffs. 1 variable per instance. */
2766 if(s->avctx->debug&2048){
2767 memset(s->spatial_dwt_buffer, 0, sizeof(DWTELEM)*w*h);
2768 predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
2772 int v= s->current_picture.data[plane_index][y*s->current_picture.linesize[plane_index] + x];
2773 s->mconly_picture.data[plane_index][y*s->mconly_picture.linesize[plane_index] + x]= v;
2779 for(level=0; level<s->spatial_decomposition_count; level++){
2780 for(orientation=level ? 1 : 0; orientation<4; orientation++){
2781 SubBand *b= &p->band[level][orientation];
2782 unpack_coeffs(s, b, b->parent, orientation);
2788 const int mb_h= s->b_height << s->block_max_depth;
2789 const int block_size = MB_SIZE >> s->block_max_depth;
2790 const int block_w = plane_index ? block_size/2 : block_size;
2792 DWTCompose cs[MAX_DECOMPOSITIONS];
2797 ff_spatial_idwt_buffered_init(cs, &s->sb, w, h, 1, s->spatial_decomposition_type, s->spatial_decomposition_count);
2798 for(mb_y=0; mb_y<=mb_h; mb_y++){
2800 int slice_starty = block_w*mb_y;
2801 int slice_h = block_w*(mb_y+1);
2802 if (!(s->keyframe || s->avctx->debug&512)){
2803 slice_starty = FFMAX(0, slice_starty - (block_w >> 1));
2804 slice_h -= (block_w >> 1);
2807 for(level=0; level<s->spatial_decomposition_count; level++){
2808 for(orientation=level ? 1 : 0; orientation<4; orientation++){
2809 SubBand *b= &p->band[level][orientation];
2812 int our_mb_start = mb_y;
2813 int our_mb_end = (mb_y + 1);
2815 start_y = (mb_y ? ((block_w * our_mb_start) >> (s->spatial_decomposition_count - level)) + s->spatial_decomposition_count - level + extra: 0);
2816 end_y = (((block_w * our_mb_end) >> (s->spatial_decomposition_count - level)) + s->spatial_decomposition_count - level + extra);
2817 if (!(s->keyframe || s->avctx->debug&512)){
2818 start_y = FFMAX(0, start_y - (block_w >> (1+s->spatial_decomposition_count - level)));
2819 end_y = FFMAX(0, end_y - (block_w >> (1+s->spatial_decomposition_count - level)));
2821 start_y = FFMIN(b->height, start_y);
2822 end_y = FFMIN(b->height, end_y);
2824 if (start_y != end_y){
2825 if (orientation == 0){
2826 SubBand * correlate_band = &p->band[0][0];
2827 int correlate_end_y = FFMIN(b->height, end_y + 1);
2828 int correlate_start_y = FFMIN(b->height, (start_y ? start_y + 1 : 0));
2829 decode_subband_slice_buffered(s, correlate_band, &s->sb, correlate_start_y, correlate_end_y, decode_state[0][0]);
2830 correlate_slice_buffered(s, &s->sb, correlate_band, correlate_band->ibuf, correlate_band->stride, 1, 0, correlate_start_y, correlate_end_y);
2831 dequantize_slice_buffered(s, &s->sb, correlate_band, correlate_band->ibuf, correlate_band->stride, start_y, end_y);
2834 decode_subband_slice_buffered(s, b, &s->sb, start_y, end_y, decode_state[level][orientation]);
2839 for(; yd<slice_h; yd+=4){
2840 ff_spatial_idwt_buffered_slice(&s->dsp, cs, &s->sb, w, h, 1, s->spatial_decomposition_type, s->spatial_decomposition_count, yd);
2843 if(s->qlog == LOSSLESS_QLOG){
2844 for(; yq<slice_h && yq<h; yq++){
2845 IDWTELEM * line = slice_buffer_get_line(&s->sb, yq);
2847 line[x] <<= FRAC_BITS;
2852 predict_slice_buffered(s, &s->sb, s->spatial_idwt_buffer, plane_index, 1, mb_y);
2854 y = FFMIN(p->height, slice_starty);
2855 end_y = FFMIN(p->height, slice_h);
2857 slice_buffer_release(&s->sb, y++);
2860 slice_buffer_flush(&s->sb);
2867 release_buffer(avctx);
2869 if(!(s->avctx->debug&2048))
2870 *picture= s->current_picture;
2872 *picture= s->mconly_picture;
2874 *data_size = sizeof(AVFrame);
2876 bytes_read= c->bytestream - c->bytestream_start;
2877 if(bytes_read ==0) av_log(s->avctx, AV_LOG_ERROR, "error at end of frame\n"); //FIXME
2882 static av_cold int decode_end(AVCodecContext *avctx)
2884 SnowContext *s = avctx->priv_data;
2886 slice_buffer_destroy(&s->sb);
2893 AVCodec snow_decoder = {
2897 sizeof(SnowContext),
2902 CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
2904 .long_name = NULL_IF_CONFIG_SMALL("Snow"),
2907 #if CONFIG_SNOW_ENCODER
2908 static av_cold int encode_init(AVCodecContext *avctx)
2910 SnowContext *s = avctx->priv_data;
2913 if(avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL){
2914 av_log(avctx, AV_LOG_ERROR, "This codec is under development, files encoded with it may not be decodable with future versions!!!\n"
2915 "Use vstrict=-2 / -strict -2 to use it anyway.\n");
2919 if(avctx->prediction_method == DWT_97
2920 && (avctx->flags & CODEC_FLAG_QSCALE)
2921 && avctx->global_quality == 0){
2922 av_log(avctx, AV_LOG_ERROR, "The 9/7 wavelet is incompatible with lossless mode.\n");
2926 s->spatial_decomposition_type= avctx->prediction_method; //FIXME add decorrelator type r transform_type
2928 s->mv_scale = (avctx->flags & CODEC_FLAG_QPEL) ? 2 : 4;
2929 s->block_max_depth= (avctx->flags & CODEC_FLAG_4MV ) ? 1 : 0;
2931 for(plane_index=0; plane_index<3; plane_index++){
2932 s->plane[plane_index].diag_mc= 1;
2933 s->plane[plane_index].htaps= 6;
2934 s->plane[plane_index].hcoeff[0]= 40;
2935 s->plane[plane_index].hcoeff[1]= -10;
2936 s->plane[plane_index].hcoeff[2]= 2;
2937 s->plane[plane_index].fast_mc= 1;
2946 s->m.flags = avctx->flags;
2947 s->m.bit_rate= avctx->bit_rate;
2950 s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
2951 s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
2952 s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
2953 s->m.obmc_scratchpad= av_mallocz(MB_SIZE*MB_SIZE*12*sizeof(uint32_t));
2954 h263_encode_init(&s->m); //mv_penalty
2956 s->max_ref_frames = FFMAX(FFMIN(avctx->refs, MAX_REF_FRAMES), 1);
2958 if(avctx->flags&CODEC_FLAG_PASS1){
2959 if(!avctx->stats_out)
2960 avctx->stats_out = av_mallocz(256);
2962 if((avctx->flags&CODEC_FLAG_PASS2) || !(avctx->flags&CODEC_FLAG_QSCALE)){
2963 if(ff_rate_control_init(&s->m) < 0)
2966 s->pass1_rc= !(avctx->flags & (CODEC_FLAG_QSCALE|CODEC_FLAG_PASS2));
2968 avctx->coded_frame= &s->current_picture;
2969 switch(avctx->pix_fmt){
2970 // case PIX_FMT_YUV444P:
2971 // case PIX_FMT_YUV422P:
2972 case PIX_FMT_YUV420P:
2974 // case PIX_FMT_YUV411P:
2975 // case PIX_FMT_YUV410P:
2976 s->colorspace_type= 0;
2978 /* case PIX_FMT_RGB32:
2982 av_log(avctx, AV_LOG_ERROR, "pixel format not supported\n");
2985 // avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
2986 s->chroma_h_shift= 1;
2987 s->chroma_v_shift= 1;
2989 ff_set_cmp(&s->dsp, s->dsp.me_cmp, s->avctx->me_cmp);
2990 ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, s->avctx->me_sub_cmp);
2992 s->avctx->get_buffer(s->avctx, &s->input_picture);
2994 if(s->avctx->me_method == ME_ITER){
2996 int size= s->b_width * s->b_height << 2*s->block_max_depth;
2997 for(i=0; i<s->max_ref_frames; i++){
2998 s->ref_mvs[i]= av_mallocz(size*sizeof(int16_t[2]));
2999 s->ref_scores[i]= av_mallocz(size*sizeof(uint32_t));
3006 //near copy & paste from dsputil, FIXME
3007 static int pix_sum(uint8_t * pix, int line_size, int w)
3012 for (i = 0; i < w; i++) {
3013 for (j = 0; j < w; j++) {
3017 pix += line_size - w;
3022 //near copy & paste from dsputil, FIXME
3023 static int pix_norm1(uint8_t * pix, int line_size, int w)
3026 uint32_t *sq = ff_squareTbl + 256;
3029 for (i = 0; i < w; i++) {
3030 for (j = 0; j < w; j ++) {
3034 pix += line_size - w;
3042 #define P_TOPRIGHT P[3]
3043 #define P_MEDIAN P[4]
3045 #define FLAG_QPEL 1 //must be 1
3047 static int encode_q_branch(SnowContext *s, int level, int x, int y){
3048 uint8_t p_buffer[1024];
3049 uint8_t i_buffer[1024];
3050 uint8_t p_state[sizeof(s->block_state)];
3051 uint8_t i_state[sizeof(s->block_state)];
3053 uint8_t *pbbak= s->c.bytestream;
3054 uint8_t *pbbak_start= s->c.bytestream_start;
3055 int score, score2, iscore, i_len, p_len, block_s, sum, base_bits;
3056 const int w= s->b_width << s->block_max_depth;
3057 const int h= s->b_height << s->block_max_depth;
3058 const int rem_depth= s->block_max_depth - level;
3059 const int index= (x + y*w) << rem_depth;
3060 const int block_w= 1<<(LOG2_MB_SIZE - level);
3061 int trx= (x+1)<<rem_depth;
3062 int try= (y+1)<<rem_depth;
3063 const BlockNode *left = x ? &s->block[index-1] : &null_block;
3064 const BlockNode *top = y ? &s->block[index-w] : &null_block;
3065 const BlockNode *right = trx<w ? &s->block[index+1] : &null_block;
3066 const BlockNode *bottom= try<h ? &s->block[index+w] : &null_block;
3067 const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
3068 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
3069 int pl = left->color[0];
3070 int pcb= left->color[1];
3071 int pcr= left->color[2];
3075 const int stride= s->current_picture.linesize[0];
3076 const int uvstride= s->current_picture.linesize[1];
3077 uint8_t *current_data[3]= { s->input_picture.data[0] + (x + y* stride)*block_w,
3078 s->input_picture.data[1] + (x + y*uvstride)*block_w/2,
3079 s->input_picture.data[2] + (x + y*uvstride)*block_w/2};
3081 int16_t last_mv[3][2];
3082 int qpel= !!(s->avctx->flags & CODEC_FLAG_QPEL); //unused
3083 const int shift= 1+qpel;
3084 MotionEstContext *c= &s->m.me;
3085 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
3086 int mx_context= av_log2(2*FFABS(left->mx - top->mx));
3087 int my_context= av_log2(2*FFABS(left->my - top->my));
3088 int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
3089 int ref, best_ref, ref_score, ref_mx, ref_my;
3091 assert(sizeof(s->block_state) >= 256);
3093 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
3097 // clip predictors / edge ?
3099 P_LEFT[0]= left->mx;
3100 P_LEFT[1]= left->my;
3103 P_TOPRIGHT[0]= tr->mx;
3104 P_TOPRIGHT[1]= tr->my;
3106 last_mv[0][0]= s->block[index].mx;
3107 last_mv[0][1]= s->block[index].my;
3108 last_mv[1][0]= right->mx;
3109 last_mv[1][1]= right->my;
3110 last_mv[2][0]= bottom->mx;
3111 last_mv[2][1]= bottom->my;
3118 assert(c-> stride == stride);
3119 assert(c->uvstride == uvstride);
3121 c->penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_cmp);
3122 c->sub_penalty_factor= get_penalty_factor(s->lambda, s->lambda2, c->avctx->me_sub_cmp);
3123 c->mb_penalty_factor = get_penalty_factor(s->lambda, s->lambda2, c->avctx->mb_cmp);
3124 c->current_mv_penalty= c->mv_penalty[s->m.f_code=1] + MAX_MV;
3126 c->xmin = - x*block_w - 16+3;
3127 c->ymin = - y*block_w - 16+3;
3128 c->xmax = - (x+1)*block_w + (w<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
3129 c->ymax = - (y+1)*block_w + (h<<(LOG2_MB_SIZE - s->block_max_depth)) + 16-3;
3131 if(P_LEFT[0] > (c->xmax<<shift)) P_LEFT[0] = (c->xmax<<shift);
3132 if(P_LEFT[1] > (c->ymax<<shift)) P_LEFT[1] = (c->ymax<<shift);
3133 if(P_TOP[0] > (c->xmax<<shift)) P_TOP[0] = (c->xmax<<shift);
3134 if(P_TOP[1] > (c->ymax<<shift)) P_TOP[1] = (c->ymax<<shift);
3135 if(P_TOPRIGHT[0] < (c->xmin<<shift)) P_TOPRIGHT[0]= (c->xmin<<shift);
3136 if(P_TOPRIGHT[0] > (c->xmax<<shift)) P_TOPRIGHT[0]= (c->xmax<<shift); //due to pmx no clip
3137 if(P_TOPRIGHT[1] > (c->ymax<<shift)) P_TOPRIGHT[1]= (c->ymax<<shift);
3139 P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
3140 P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
3143 c->pred_x= P_LEFT[0];
3144 c->pred_y= P_LEFT[1];
3146 c->pred_x = P_MEDIAN[0];
3147 c->pred_y = P_MEDIAN[1];
3152 for(ref=0; ref<s->ref_frames; ref++){
3153 init_ref(c, current_data, s->last_picture[ref].data, NULL, block_w*x, block_w*y, 0);
3155 ref_score= ff_epzs_motion_search(&s->m, &ref_mx, &ref_my, P, 0, /*ref_index*/ 0, last_mv,
3156 (1<<16)>>shift, level-LOG2_MB_SIZE+4, block_w);
3158 assert(ref_mx >= c->xmin);
3159 assert(ref_mx <= c->xmax);
3160 assert(ref_my >= c->ymin);
3161 assert(ref_my <= c->ymax);
3163 ref_score= c->sub_motion_search(&s->m, &ref_mx, &ref_my, ref_score, 0, 0, level-LOG2_MB_SIZE+4, block_w);
3164 ref_score= ff_get_mb_score(&s->m, ref_mx, ref_my, 0, 0, level-LOG2_MB_SIZE+4, block_w, 0);
3165 ref_score+= 2*av_log2(2*ref)*c->penalty_factor;
3166 if(s->ref_mvs[ref]){
3167 s->ref_mvs[ref][index][0]= ref_mx;
3168 s->ref_mvs[ref][index][1]= ref_my;
3169 s->ref_scores[ref][index]= ref_score;
3171 if(score > ref_score){
3178 //FIXME if mb_cmp != SSE then intra cannot be compared currently and mb_penalty vs. lambda2
3181 base_bits= get_rac_count(&s->c) - 8*(s->c.bytestream - s->c.bytestream_start);
3183 pc.bytestream_start=
3184 pc.bytestream= p_buffer; //FIXME end/start? and at the other stoo
3185 memcpy(p_state, s->block_state, sizeof(s->block_state));
3187 if(level!=s->block_max_depth)
3188 put_rac(&pc, &p_state[4 + s_context], 1);
3189 put_rac(&pc, &p_state[1 + left->type + top->type], 0);
3190 if(s->ref_frames > 1)
3191 put_symbol(&pc, &p_state[128 + 1024 + 32*ref_context], best_ref, 0);
3192 pred_mv(s, &pmx, &pmy, best_ref, left, top, tr);
3193 put_symbol(&pc, &p_state[128 + 32*(mx_context + 16*!!best_ref)], mx - pmx, 1);
3194 put_symbol(&pc, &p_state[128 + 32*(my_context + 16*!!best_ref)], my - pmy, 1);
3195 p_len= pc.bytestream - pc.bytestream_start;
3196 score += (s->lambda2*(get_rac_count(&pc)-base_bits))>>FF_LAMBDA_SHIFT;
3198 block_s= block_w*block_w;
3199 sum = pix_sum(current_data[0], stride, block_w);
3200 l= (sum + block_s/2)/block_s;
3201 iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
3203 block_s= block_w*block_w>>2;
3204 sum = pix_sum(current_data[1], uvstride, block_w>>1);
3205 cb= (sum + block_s/2)/block_s;
3206 // iscore += pix_norm1(¤t_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;
3207 sum = pix_sum(current_data[2], uvstride, block_w>>1);
3208 cr= (sum + block_s/2)/block_s;
3209 // iscore += pix_norm1(¤t_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
3212 ic.bytestream_start=
3213 ic.bytestream= i_buffer; //FIXME end/start? and at the other stoo
3214 memcpy(i_state, s->block_state, sizeof(s->block_state));
3215 if(level!=s->block_max_depth)
3216 put_rac(&ic, &i_state[4 + s_context], 1);
3217 put_rac(&ic, &i_state[1 + left->type + top->type], 1);
3218 put_symbol(&ic, &i_state[32], l-pl , 1);
3219 put_symbol(&ic, &i_state[64], cb-pcb, 1);
3220 put_symbol(&ic, &i_state[96], cr-pcr, 1);
3221 i_len= ic.bytestream - ic.bytestream_start;
3222 iscore += (s->lambda2*(get_rac_count(&ic)-base_bits))>>FF_LAMBDA_SHIFT;
3224 // assert(score==256*256*256*64-1);
3225 assert(iscore < 255*255*256 + s->lambda2*10);
3226 assert(iscore >= 0);
3227 assert(l>=0 && l<=255);
3228 assert(pl>=0 && pl<=255);
3231 int varc= iscore >> 8;
3232 int vard= score >> 8;
3233 if (vard <= 64 || vard < varc)
3234 c->scene_change_score+= ff_sqrt(vard) - ff_sqrt(varc);
3236 c->scene_change_score+= s->m.qscale;
3239 if(level!=s->block_max_depth){
3240 put_rac(&s->c, &s->block_state[4 + s_context], 0);
3241 score2 = encode_q_branch(s, level+1, 2*x+0, 2*y+0);
3242 score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+0);
3243 score2+= encode_q_branch(s, level+1, 2*x+0, 2*y+1);
3244 score2+= encode_q_branch(s, level+1, 2*x+1, 2*y+1);
3245 score2+= s->lambda2>>FF_LAMBDA_SHIFT; //FIXME exact split overhead
3247 if(score2 < score && score2 < iscore)
3252 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
3253 memcpy(pbbak, i_buffer, i_len);
3255 s->c.bytestream_start= pbbak_start;
3256 s->c.bytestream= pbbak + i_len;
3257 set_blocks(s, level, x, y, l, cb, cr, pmx, pmy, 0, BLOCK_INTRA);
3258 memcpy(s->block_state, i_state, sizeof(s->block_state));
3261 memcpy(pbbak, p_buffer, p_len);
3263 s->c.bytestream_start= pbbak_start;
3264 s->c.bytestream= pbbak + p_len;
3265 set_blocks(s, level, x, y, pl, pcb, pcr, mx, my, best_ref, 0);
3266 memcpy(s->block_state, p_state, sizeof(s->block_state));
3271 static void encode_q_branch2(SnowContext *s, int level, int x, int y){
3272 const int w= s->b_width << s->block_max_depth;
3273 const int rem_depth= s->block_max_depth - level;
3274 const int index= (x + y*w) << rem_depth;
3275 int trx= (x+1)<<rem_depth;
3276 BlockNode *b= &s->block[index];
3277 const BlockNode *left = x ? &s->block[index-1] : &null_block;
3278 const BlockNode *top = y ? &s->block[index-w] : &null_block;
3279 const BlockNode *tl = y && x ? &s->block[index-w-1] : left;
3280 const BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
3281 int pl = left->color[0];
3282 int pcb= left->color[1];
3283 int pcr= left->color[2];
3285 int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
3286 int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 16*!!b->ref;
3287 int my_context= av_log2(2*FFABS(left->my - top->my)) + 16*!!b->ref;
3288 int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
3291 set_blocks(s, level, x, y, pl, pcb, pcr, 0, 0, 0, BLOCK_INTRA);
3295 if(level!=s->block_max_depth){
3296 if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){
3297 put_rac(&s->c, &s->block_state[4 + s_context], 1);
3299 put_rac(&s->c, &s->block_state[4 + s_context], 0);
3300 encode_q_branch2(s, level+1, 2*x+0, 2*y+0);
3301 encode_q_branch2(s, level+1, 2*x+1, 2*y+0);
3302 encode_q_branch2(s, level+1, 2*x+0, 2*y+1);
3303 encode_q_branch2(s, level+1, 2*x+1, 2*y+1);
3307 if(b->type & BLOCK_INTRA){
3308 pred_mv(s, &pmx, &pmy, 0, left, top, tr);
3309 put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);
3310 put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);
3311 put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);
3312 put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);
3313 set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, 0, BLOCK_INTRA);
3315 pred_mv(s, &pmx, &pmy, b->ref, left, top, tr);
3316 put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);
3317 if(s->ref_frames > 1)
3318 put_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], b->ref, 0);
3319 put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);
3320 put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);
3321 set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, b->ref, 0);
3325 static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index){
3327 Plane *p= &s->plane[plane_index];
3328 const int block_size = MB_SIZE >> s->block_max_depth;
3329 const int block_w = plane_index ? block_size/2 : block_size;
3330 const uint8_t *obmc = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
3331 const int obmc_stride= plane_index ? block_size : 2*block_size;
3332 const int ref_stride= s->current_picture.linesize[plane_index];
3333 uint8_t *src= s-> input_picture.data[plane_index];
3334 IDWTELEM *dst= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4; //FIXME change to unsigned
3335 const int b_stride = s->b_width << s->block_max_depth;
3336 const int w= p->width;
3337 const int h= p->height;
3338 int index= mb_x + mb_y*b_stride;
3339 BlockNode *b= &s->block[index];
3340 BlockNode backup= *b;
3344 b->type|= BLOCK_INTRA;
3345 b->color[plane_index]= 0;
3346 memset(dst, 0, obmc_stride*obmc_stride*sizeof(IDWTELEM));
3349 int mb_x2= mb_x + (i &1) - 1;
3350 int mb_y2= mb_y + (i>>1) - 1;
3351 int x= block_w*mb_x2 + block_w/2;
3352 int y= block_w*mb_y2 + block_w/2;
3354 add_yblock(s, 0, NULL, dst + ((i&1)+(i>>1)*obmc_stride)*block_w, NULL, obmc,
3355 x, y, block_w, block_w, w, h, obmc_stride, ref_stride, obmc_stride, mb_x2, mb_y2, 0, 0, plane_index);
3357 for(y2= FFMAX(y, 0); y2<FFMIN(h, y+block_w); y2++){
3358 for(x2= FFMAX(x, 0); x2<FFMIN(w, x+block_w); x2++){
3359 int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_w*mb_y - block_w/2))*obmc_stride;
3360 int obmc_v= obmc[index];
3362 if(y<0) obmc_v += obmc[index + block_w*obmc_stride];
3363 if(x<0) obmc_v += obmc[index + block_w];
3364 if(y+block_w>h) obmc_v += obmc[index - block_w*obmc_stride];
3365 if(x+block_w>w) obmc_v += obmc[index - block_w];
3366 //FIXME precalculate this or simplify it somehow else
3368 d = -dst[index] + (1<<(FRAC_BITS-1));
3370 ab += (src[x2 + y2*ref_stride] - (d>>FRAC_BITS)) * obmc_v;
3371 aa += obmc_v * obmc_v; //FIXME precalculate this
3377 return av_clip(((ab<<LOG2_OBMC_MAX) + aa/2)/aa, 0, 255); //FIXME we should not need clipping
3380 static inline int get_block_bits(SnowContext *s, int x, int y, int w){
3381 const int b_stride = s->b_width << s->block_max_depth;
3382 const int b_height = s->b_height<< s->block_max_depth;
3383 int index= x + y*b_stride;
3384 const BlockNode *b = &s->block[index];
3385 const BlockNode *left = x ? &s->block[index-1] : &null_block;
3386 const BlockNode *top = y ? &s->block[index-b_stride] : &null_block;
3387 const BlockNode *tl = y && x ? &s->block[index-b_stride-1] : left;
3388 const BlockNode *tr = y && x+w<b_stride ? &s->block[index-b_stride+w] : tl;
3390 // int mx_context= av_log2(2*FFABS(left->mx - top->mx));
3391 // int my_context= av_log2(2*FFABS(left->my - top->my));
3393 if(x<0 || x>=b_stride || y>=b_height)
3400 00001XXXX 15-30 8-15
3402 //FIXME try accurate rate
3403 //FIXME intra and inter predictors if surrounding blocks are not the same type
3404 if(b->type & BLOCK_INTRA){
3405 return 3+2*( av_log2(2*FFABS(left->color[0] - b->color[0]))
3406 + av_log2(2*FFABS(left->color[1] - b->color[1]))
3407 + av_log2(2*FFABS(left->color[2] - b->color[2])));
3409 pred_mv(s, &dmx, &dmy, b->ref, left, top, tr);
3412 return 2*(1 + av_log2(2*FFABS(dmx)) //FIXME kill the 2* can be merged in lambda
3413 + av_log2(2*FFABS(dmy))
3414 + av_log2(2*b->ref));
3418 static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index, const uint8_t *obmc_edged){
3419 Plane *p= &s->plane[plane_index];
3420 const int block_size = MB_SIZE >> s->block_max_depth;
3421 const int block_w = plane_index ? block_size/2 : block_size;
3422 const int obmc_stride= plane_index ? block_size : 2*block_size;
3423 const int ref_stride= s->current_picture.linesize[plane_index];
3424 uint8_t *dst= s->current_picture.data[plane_index];
3425 uint8_t *src= s-> input_picture.data[plane_index];
3426 IDWTELEM *pred= (IDWTELEM*)s->m.obmc_scratchpad + plane_index*block_size*block_size*4;
3427 uint8_t *cur = s->scratchbuf;
3428 uint8_t tmp[ref_stride*(2*MB_SIZE+HTAPS_MAX-1)];
3429 const int b_stride = s->b_width << s->block_max_depth;
3430 const int b_height = s->b_height<< s->block_max_depth;
3431 const int w= p->width;
3432 const int h= p->height;
3435 const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
3436 int sx= block_w*mb_x - block_w/2;
3437 int sy= block_w*mb_y - block_w/2;
3438 int x0= FFMAX(0,-sx);
3439 int y0= FFMAX(0,-sy);
3440 int x1= FFMIN(block_w*2, w-sx);
3441 int y1= FFMIN(block_w*2, h-sy);
3444 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);
3446 for(y=y0; y<y1; y++){
3447 const uint8_t *obmc1= obmc_edged + y*obmc_stride;
3448 const IDWTELEM *pred1 = pred + y*obmc_stride;
3449 uint8_t *cur1 = cur + y*ref_stride;
3450 uint8_t *dst1 = dst + sx + (sy+y)*ref_stride;
3451 for(x=x0; x<x1; x++){
3452 #if FRAC_BITS >= LOG2_OBMC_MAX
3453 int v = (cur1[x] * obmc1[x]) << (FRAC_BITS - LOG2_OBMC_MAX);
3455 int v = (cur1[x] * obmc1[x] + (1<<(LOG2_OBMC_MAX - FRAC_BITS-1))) >> (LOG2_OBMC_MAX - FRAC_BITS);
3457 v = (v + pred1[x]) >> FRAC_BITS;
3458 if(v&(~255)) v= ~(v>>31);
3463 /* copy the regions where obmc[] = (uint8_t)256 */
3464 if(LOG2_OBMC_MAX == 8
3465 && (mb_x == 0 || mb_x == b_stride-1)
3466 && (mb_y == 0 || mb_y == b_height-1)){
3475 for(y=y0; y<y1; y++)
3476 memcpy(dst + sx+x0 + (sy+y)*ref_stride, cur + x0 + y*ref_stride, x1-x0);
3480 /* FIXME rearrange dsputil to fit 32x32 cmp functions */
3481 /* FIXME check alignment of the cmp wavelet vs the encoding wavelet */
3482 /* FIXME cmps overlap but do not cover the wavelet's whole support.
3483 * So improving the score of one block is not strictly guaranteed
3484 * to improve the score of the whole frame, thus iterative motion
3485 * estimation does not always converge. */
3486 if(s->avctx->me_cmp == FF_CMP_W97)
3487 distortion = w97_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
3488 else if(s->avctx->me_cmp == FF_CMP_W53)
3489 distortion = w53_32_c(&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, 32);
3493 int off = sx+16*(i&1) + (sy+16*(i>>1))*ref_stride;
3494 distortion += s->dsp.me_cmp[0](&s->m, src + off, dst + off, ref_stride, 16);
3499 distortion = s->dsp.me_cmp[0](&s->m, src + sx + sy*ref_stride, dst + sx + sy*ref_stride, ref_stride, block_w*2);
3508 rate += get_block_bits(s, mb_x + (i&1) - (i>>1), mb_y + (i>>1), 1);
3510 if(mb_x == b_stride-2)
3511 rate += get_block_bits(s, mb_x + 1, mb_y + 1, 1);
3513 return distortion + rate*penalty_factor;
3516 static int get_4block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){
3518 Plane *p= &s->plane[plane_index];
3519 const int block_size = MB_SIZE >> s->block_max_depth;
3520 const int block_w = plane_index ? block_size/2 : block_size;
3521 const uint8_t *obmc = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth];
3522 const int obmc_stride= plane_index ? block_size : 2*block_size;
3523 const int ref_stride= s->current_picture.linesize[plane_index];
3524 uint8_t *dst= s->current_picture.data[plane_index];
3525 uint8_t *src= s-> input_picture.data[plane_index];
3526 //FIXME zero_dst is const but add_yblock changes dst if add is 0 (this is never the case for dst=zero_dst
3527 // const has only been removed from zero_dst to suppress a warning
3528 static IDWTELEM zero_dst[4096]; //FIXME
3529 const int b_stride = s->b_width << s->block_max_depth;
3530 const int w= p->width;
3531 const int h= p->height;
3534 const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
3537 int mb_x2= mb_x + (i%3) - 1;
3538 int mb_y2= mb_y + (i/3) - 1;
3539 int x= block_w*mb_x2 + block_w/2;
3540 int y= block_w*mb_y2 + block_w/2;
3542 add_yblock(s, 0, NULL, zero_dst, dst, obmc,
3543 x, y, block_w, block_w, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, 1, plane_index);
3545 //FIXME find a cleaner/simpler way to skip the outside stuff
3546 for(y2= y; y2<0; y2++)
3547 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
3548 for(y2= h; y2<y+block_w; y2++)
3549 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
3551 for(y2= y; y2<y+block_w; y2++)
3552 memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
3555 for(y2= y; y2<y+block_w; y2++)
3556 memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
3559 assert(block_w== 8 || block_w==16);
3560 distortion += s->dsp.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_w);
3564 BlockNode *b= &s->block[mb_x+mb_y*b_stride];
3565 int merged= same_block(b,b+1) && same_block(b,b+b_stride) && same_block(b,b+b_stride+1);
3573 rate = get_block_bits(s, mb_x, mb_y, 2);
3574 for(i=merged?4:0; i<9; i++){
3575 static const int dxy[9][2] = {{0,0},{1,0},{0,1},{1,1},{2,0},{2,1},{-1,2},{0,2},{1,2}};
3576 rate += get_block_bits(s, mb_x + dxy[i][0], mb_y + dxy[i][1], 1);
3579 return distortion + rate*penalty_factor;
3582 static void ff_spatial_idwt_init(DWTCompose *cs, IDWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count){
3584 for(level=decomposition_count-1; level>=0; level--){
3586 case DWT_97: spatial_compose97i_init(cs+level, buffer, height>>level, stride<<level); break;
3587 case DWT_53: spatial_compose53i_init(cs+level, buffer, height>>level, stride<<level); break;
3592 static void ff_spatial_idwt_slice(DWTCompose *cs, IDWTELEM *buffer, int width, int height, int stride, int type, int decomposition_count, int y){
3593 const int support = type==1 ? 3 : 5;
3597 for(level=decomposition_count-1; level>=0; level--){
3598 while(cs[level].y <= FFMIN((y>>level)+support, height>>level)){
3600 case DWT_97: spatial_compose97i_dy(cs+level, buffer, width>>level, height>>level, stride<<level);