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