629367ac44534445bcd1d4dbd3008ccf732623db
[ffmpeg.git] / libavcodec / snow.c
1 /*
2  * Copyright (C) 2004 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of Libav.
5  *
6  * Libav is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * Libav is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with Libav; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 #include "libavutil/intmath.h"
22 #include "libavutil/log.h"
23 #include "libavutil/opt.h"
24 #include "avcodec.h"
25 #include "dsputil.h"
26 #include "dwt.h"
27 #include "snow.h"
28 #include "snowdata.h"
29
30 #include "rangecoder.h"
31 #include "mathops.h"
32 #include "h263.h"
33
34 #undef NDEBUG
35 #include <assert.h>
36
37
38 void ff_snow_inner_add_yblock(const uint8_t *obmc, const int obmc_stride, uint8_t * * block, int b_w, int b_h,
39                               int src_x, int src_y, int src_stride, slice_buffer * sb, int add, uint8_t * dst8){
40     int y, x;
41     IDWTELEM * dst;
42     for(y=0; y<b_h; y++){
43         //FIXME ugly misuse of obmc_stride
44         const uint8_t *obmc1= obmc + y*obmc_stride;
45         const uint8_t *obmc2= obmc1+ (obmc_stride>>1);
46         const uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1);
47         const uint8_t *obmc4= obmc3+ (obmc_stride>>1);
48         dst = slice_buffer_get_line(sb, src_y + y);
49         for(x=0; x<b_w; x++){
50             int v=   obmc1[x] * block[3][x + y*src_stride]
51                     +obmc2[x] * block[2][x + y*src_stride]
52                     +obmc3[x] * block[1][x + y*src_stride]
53                     +obmc4[x] * block[0][x + y*src_stride];
54
55             v <<= 8 - LOG2_OBMC_MAX;
56             if(FRAC_BITS != 8){
57                 v >>= 8 - FRAC_BITS;
58             }
59             if(add){
60                 v += dst[x + src_x];
61                 v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS;
62                 if(v&(~255)) v= ~(v>>31);
63                 dst8[x + y*src_stride] = v;
64             }else{
65                 dst[x + src_x] -= v;
66             }
67         }
68     }
69 }
70
71 void ff_snow_reset_contexts(SnowContext *s){ //FIXME better initial contexts
72     int plane_index, level, orientation;
73
74     for(plane_index=0; plane_index<3; plane_index++){
75         for(level=0; level<MAX_DECOMPOSITIONS; level++){
76             for(orientation=level ? 1:0; orientation<4; orientation++){
77                 memset(s->plane[plane_index].band[level][orientation].state, MID_STATE, sizeof(s->plane[plane_index].band[level][orientation].state));
78             }
79         }
80     }
81     memset(s->header_state, MID_STATE, sizeof(s->header_state));
82     memset(s->block_state, MID_STATE, sizeof(s->block_state));
83 }
84
85 int ff_snow_alloc_blocks(SnowContext *s){
86     int w= -((-s->avctx->width )>>LOG2_MB_SIZE);
87     int h= -((-s->avctx->height)>>LOG2_MB_SIZE);
88
89     s->b_width = w;
90     s->b_height= h;
91
92     av_free(s->block);
93     s->block= av_mallocz(w * h * sizeof(BlockNode) << (s->block_max_depth*2));
94     return 0;
95 }
96
97 static void init_qexp(void){
98     int i;
99     double v=128;
100
101     for(i=0; i<QROOT; i++){
102         ff_qexp[i]= lrintf(v);
103         v *= pow(2, 1.0 / QROOT);
104     }
105 }
106 static void mc_block(Plane *p, uint8_t *dst, const uint8_t *src, int stride, int b_w, int b_h, int dx, int dy){
107     static const uint8_t weight[64]={
108     8,7,6,5,4,3,2,1,
109     7,7,0,0,0,0,0,1,
110     6,0,6,0,0,0,2,0,
111     5,0,0,5,0,3,0,0,
112     4,0,0,0,4,0,0,0,
113     3,0,0,5,0,3,0,0,
114     2,0,6,0,0,0,2,0,
115     1,7,0,0,0,0,0,1,
116     };
117
118     static const uint8_t brane[256]={
119     0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
120     0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
121     0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
122     0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
123     0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
124     0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
125     0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
126     0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
127     0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
128     0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
129     0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
130     0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
131     0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
132     0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
133     0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
134     0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
135     };
136
137     static const uint8_t needs[16]={
138     0,1,0,0,
139     2,4,2,0,
140     0,1,0,0,
141     15
142     };
143
144     int x, y, b, r, l;
145     int16_t tmpIt   [64*(32+HTAPS_MAX)];
146     uint8_t tmp2t[3][64*(32+HTAPS_MAX)];
147     int16_t *tmpI= tmpIt;
148     uint8_t *tmp2= tmp2t[0];
149     const uint8_t *hpel[11];
150     assert(dx<16 && dy<16);
151     r= brane[dx + 16*dy]&15;
152     l= brane[dx + 16*dy]>>4;
153
154     b= needs[l] | needs[r];
155     if(p && !p->diag_mc)
156         b= 15;
157
158     if(b&5){
159         for(y=0; y < b_h+HTAPS_MAX-1; y++){
160             for(x=0; x < b_w; x++){
161                 int a_1=src[x + HTAPS_MAX/2-4];
162                 int a0= src[x + HTAPS_MAX/2-3];
163                 int a1= src[x + HTAPS_MAX/2-2];
164                 int a2= src[x + HTAPS_MAX/2-1];
165                 int a3= src[x + HTAPS_MAX/2+0];
166                 int a4= src[x + HTAPS_MAX/2+1];
167                 int a5= src[x + HTAPS_MAX/2+2];
168                 int a6= src[x + HTAPS_MAX/2+3];
169                 int am=0;
170                 if(!p || p->fast_mc){
171                     am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
172                     tmpI[x]= am;
173                     am= (am+16)>>5;
174                 }else{
175                     am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
176                     tmpI[x]= am;
177                     am= (am+32)>>6;
178                 }
179
180                 if(am&(~255)) am= ~(am>>31);
181                 tmp2[x]= am;
182             }
183             tmpI+= 64;
184             tmp2+= 64;
185             src += stride;
186         }
187         src -= stride*y;
188     }
189     src += HTAPS_MAX/2 - 1;
190     tmp2= tmp2t[1];
191
192     if(b&2){
193         for(y=0; y < b_h; y++){
194             for(x=0; x < b_w+1; x++){
195                 int a_1=src[x + (HTAPS_MAX/2-4)*stride];
196                 int a0= src[x + (HTAPS_MAX/2-3)*stride];
197                 int a1= src[x + (HTAPS_MAX/2-2)*stride];
198                 int a2= src[x + (HTAPS_MAX/2-1)*stride];
199                 int a3= src[x + (HTAPS_MAX/2+0)*stride];
200                 int a4= src[x + (HTAPS_MAX/2+1)*stride];
201                 int a5= src[x + (HTAPS_MAX/2+2)*stride];
202                 int a6= src[x + (HTAPS_MAX/2+3)*stride];
203                 int am=0;
204                 if(!p || p->fast_mc)
205                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
206                 else
207                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
208
209                 if(am&(~255)) am= ~(am>>31);
210                 tmp2[x]= am;
211             }
212             src += stride;
213             tmp2+= 64;
214         }
215         src -= stride*y;
216     }
217     src += stride*(HTAPS_MAX/2 - 1);
218     tmp2= tmp2t[2];
219     tmpI= tmpIt;
220     if(b&4){
221         for(y=0; y < b_h; y++){
222             for(x=0; x < b_w; x++){
223                 int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
224                 int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
225                 int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
226                 int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
227                 int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
228                 int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
229                 int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
230                 int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
231                 int am=0;
232                 if(!p || p->fast_mc)
233                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
234                 else
235                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
236                 if(am&(~255)) am= ~(am>>31);
237                 tmp2[x]= am;
238             }
239             tmpI+= 64;
240             tmp2+= 64;
241         }
242     }
243
244     hpel[ 0]= src;
245     hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);
246     hpel[ 2]= src + 1;
247
248     hpel[ 4]= tmp2t[1];
249     hpel[ 5]= tmp2t[2];
250     hpel[ 6]= tmp2t[1] + 1;
251
252     hpel[ 8]= src + stride;
253     hpel[ 9]= hpel[1] + 64;
254     hpel[10]= hpel[8] + 1;
255
256 #define MC_STRIDE(x) (needs[x] ? 64 : stride)
257
258     if(b==15){
259         int dxy = dx / 8 + dy / 8 * 4;
260         const uint8_t *src1 = hpel[dxy    ];
261         const uint8_t *src2 = hpel[dxy + 1];
262         const uint8_t *src3 = hpel[dxy + 4];
263         const uint8_t *src4 = hpel[dxy + 5];
264         int stride1 = MC_STRIDE(dxy);
265         int stride2 = MC_STRIDE(dxy + 1);
266         int stride3 = MC_STRIDE(dxy + 4);
267         int stride4 = MC_STRIDE(dxy + 5);
268         dx&=7;
269         dy&=7;
270         for(y=0; y < b_h; y++){
271             for(x=0; x < b_w; x++){
272                 dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
273                          (8-dx)*   dy *src3[x] + dx*   dy *src4[x]+32)>>6;
274             }
275             src1+=stride1;
276             src2+=stride2;
277             src3+=stride3;
278             src4+=stride4;
279             dst +=stride;
280         }
281     }else{
282         const uint8_t *src1= hpel[l];
283         const uint8_t *src2= hpel[r];
284         int stride1 = MC_STRIDE(l);
285         int stride2 = MC_STRIDE(r);
286         int a= weight[((dx&7) + (8*(dy&7)))];
287         int b= 8-a;
288         for(y=0; y < b_h; y++){
289             for(x=0; x < b_w; x++){
290                 dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
291             }
292             src1+=stride1;
293             src2+=stride2;
294             dst +=stride;
295         }
296     }
297 }
298
299 void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h){
300     if(block->type & BLOCK_INTRA){
301         int x, y;
302         const unsigned color  = block->color[plane_index];
303         const unsigned color4 = color*0x01010101;
304         if(b_w==32){
305             for(y=0; y < b_h; y++){
306                 *(uint32_t*)&dst[0 + y*stride]= color4;
307                 *(uint32_t*)&dst[4 + y*stride]= color4;
308                 *(uint32_t*)&dst[8 + y*stride]= color4;
309                 *(uint32_t*)&dst[12+ y*stride]= color4;
310                 *(uint32_t*)&dst[16+ y*stride]= color4;
311                 *(uint32_t*)&dst[20+ y*stride]= color4;
312                 *(uint32_t*)&dst[24+ y*stride]= color4;
313                 *(uint32_t*)&dst[28+ y*stride]= color4;
314             }
315         }else if(b_w==16){
316             for(y=0; y < b_h; y++){
317                 *(uint32_t*)&dst[0 + y*stride]= color4;
318                 *(uint32_t*)&dst[4 + y*stride]= color4;
319                 *(uint32_t*)&dst[8 + y*stride]= color4;
320                 *(uint32_t*)&dst[12+ y*stride]= color4;
321             }
322         }else if(b_w==8){
323             for(y=0; y < b_h; y++){
324                 *(uint32_t*)&dst[0 + y*stride]= color4;
325                 *(uint32_t*)&dst[4 + y*stride]= color4;
326             }
327         }else if(b_w==4){
328             for(y=0; y < b_h; y++){
329                 *(uint32_t*)&dst[0 + y*stride]= color4;
330             }
331         }else{
332             for(y=0; y < b_h; y++){
333                 for(x=0; x < b_w; x++){
334                     dst[x + y*stride]= color;
335                 }
336             }
337         }
338     }else{
339         uint8_t *src= s->last_picture[block->ref].data[plane_index];
340         const int scale= plane_index ?  s->mv_scale : 2*s->mv_scale;
341         int mx= block->mx*scale;
342         int my= block->my*scale;
343         const int dx= mx&15;
344         const int dy= my&15;
345         const int tab_index= 3 - (b_w>>2) + (b_w>>4);
346         sx += (mx>>4) - (HTAPS_MAX/2-1);
347         sy += (my>>4) - (HTAPS_MAX/2-1);
348         src += sx + sy*stride;
349         if(   (unsigned)sx >= w - b_w - (HTAPS_MAX-2)
350            || (unsigned)sy >= h - b_h - (HTAPS_MAX-2)){
351             s->dsp.emulated_edge_mc(tmp + MB_SIZE, src, stride, b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1, sx, sy, w, h);
352             src= tmp + MB_SIZE;
353         }
354 //        assert(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h);
355 //        assert(!(b_w&(b_w-1)));
356         assert(b_w>1 && b_h>1);
357         assert((tab_index>=0 && tab_index<4) || b_w==32);
358         if((dx&3) || (dy&3) || !(b_w == b_h || 2*b_w == b_h || b_w == 2*b_h) || (b_w&(b_w-1)) || !s->plane[plane_index].fast_mc )
359             mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
360         else if(b_w==32){
361             int y;
362             for(y=0; y<b_h; y+=16){
363                 s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
364                 s->dsp.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
365             }
366         }else if(b_w==b_h)
367             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
368         else if(b_w==2*b_h){
369             s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst    ,src + 3       + 3*stride,stride);
370             s->dsp.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
371         }else{
372             assert(2*b_w==b_h);
373             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst           ,src + 3 + 3*stride           ,stride);
374             s->dsp.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
375         }
376     }
377 }
378
379 #define mca(dx,dy,b_w)\
380 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, int stride, int h){\
381     assert(h==b_w);\
382     mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
383 }
384
385 mca( 0, 0,16)
386 mca( 8, 0,16)
387 mca( 0, 8,16)
388 mca( 8, 8,16)
389 mca( 0, 0,8)
390 mca( 8, 0,8)
391 mca( 0, 8,8)
392 mca( 8, 8,8)
393
394 av_cold int ff_snow_common_init(AVCodecContext *avctx){
395     SnowContext *s = avctx->priv_data;
396     int width, height;
397     int i, j, ret;
398
399     s->avctx= avctx;
400     s->max_ref_frames=1; //just make sure its not an invalid value in case of no initial keyframe
401
402     ff_dsputil_init(&s->dsp, avctx);
403     ff_dwt_init(&s->dwt);
404
405 #define mcf(dx,dy)\
406     s->dsp.put_qpel_pixels_tab       [0][dy+dx/4]=\
407     s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
408         s->dsp.put_h264_qpel_pixels_tab[0][dy+dx/4];\
409     s->dsp.put_qpel_pixels_tab       [1][dy+dx/4]=\
410     s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
411         s->dsp.put_h264_qpel_pixels_tab[1][dy+dx/4];
412
413     mcf( 0, 0)
414     mcf( 4, 0)
415     mcf( 8, 0)
416     mcf(12, 0)
417     mcf( 0, 4)
418     mcf( 4, 4)
419     mcf( 8, 4)
420     mcf(12, 4)
421     mcf( 0, 8)
422     mcf( 4, 8)
423     mcf( 8, 8)
424     mcf(12, 8)
425     mcf( 0,12)
426     mcf( 4,12)
427     mcf( 8,12)
428     mcf(12,12)
429
430 #define mcfh(dx,dy)\
431     s->dsp.put_pixels_tab       [0][dy/4+dx/8]=\
432     s->dsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
433         mc_block_hpel ## dx ## dy ## 16;\
434     s->dsp.put_pixels_tab       [1][dy/4+dx/8]=\
435     s->dsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
436         mc_block_hpel ## dx ## dy ## 8;
437
438     mcfh(0, 0)
439     mcfh(8, 0)
440     mcfh(0, 8)
441     mcfh(8, 8)
442
443     init_qexp();
444
445 //    dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
446
447     width= s->avctx->width;
448     height= s->avctx->height;
449
450     FF_ALLOCZ_OR_GOTO(avctx, s->spatial_idwt_buffer, width * height * sizeof(IDWTELEM), fail);
451     FF_ALLOCZ_OR_GOTO(avctx, s->spatial_dwt_buffer,  width * height * sizeof(DWTELEM),  fail); //FIXME this does not belong here
452     FF_ALLOCZ_OR_GOTO(avctx, s->temp_dwt_buffer,     width * sizeof(DWTELEM),  fail);
453     FF_ALLOCZ_OR_GOTO(avctx, s->temp_idwt_buffer,    width * sizeof(IDWTELEM), fail);
454     FF_ALLOC_OR_GOTO(avctx,  s->run_buffer,          ((width + 1) >> 1) * ((height + 1) >> 1) * sizeof(*s->run_buffer), fail);
455
456     for(i=0; i<MAX_REF_FRAMES; i++)
457         for(j=0; j<MAX_REF_FRAMES; j++)
458             ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1);
459
460     if ((ret = s->avctx->get_buffer(s->avctx, &s->mconly_picture)) < 0) {
461         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
462         return ret;
463     }
464     FF_ALLOC_OR_GOTO(avctx, s->scratchbuf, s->mconly_picture.linesize[0]*7*MB_SIZE, fail);
465
466     return 0;
467 fail:
468     return AVERROR(ENOMEM);
469 }
470
471 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
472     SnowContext *s = avctx->priv_data;
473     int plane_index, level, orientation;
474
475     for(plane_index=0; plane_index<3; plane_index++){
476         int w= s->avctx->width;
477         int h= s->avctx->height;
478
479         if(plane_index){
480             w>>= s->chroma_h_shift;
481             h>>= s->chroma_v_shift;
482         }
483         s->plane[plane_index].width = w;
484         s->plane[plane_index].height= h;
485
486         for(level=s->spatial_decomposition_count-1; level>=0; level--){
487             for(orientation=level ? 1 : 0; orientation<4; orientation++){
488                 SubBand *b= &s->plane[plane_index].band[level][orientation];
489
490                 b->buf= s->spatial_dwt_buffer;
491                 b->level= level;
492                 b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
493                 b->width = (w + !(orientation&1))>>1;
494                 b->height= (h + !(orientation>1))>>1;
495
496                 b->stride_line = 1 << (s->spatial_decomposition_count - level);
497                 b->buf_x_offset = 0;
498                 b->buf_y_offset = 0;
499
500                 if(orientation&1){
501                     b->buf += (w+1)>>1;
502                     b->buf_x_offset = (w+1)>>1;
503                 }
504                 if(orientation>1){
505                     b->buf += b->stride>>1;
506                     b->buf_y_offset = b->stride_line >> 1;
507                 }
508                 b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
509
510                 if(level)
511                     b->parent= &s->plane[plane_index].band[level-1][orientation];
512                 //FIXME avoid this realloc
513                 av_freep(&b->x_coeff);
514                 b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
515             }
516             w= (w+1)>>1;
517             h= (h+1)>>1;
518         }
519     }
520
521     return 0;
522 }
523
524 #define USE_HALFPEL_PLANE 0
525
526 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
527     int p,x,y;
528
529     for(p=0; p<3; p++){
530         int is_chroma= !!p;
531         int w= s->avctx->width  >>is_chroma;
532         int h= s->avctx->height >>is_chroma;
533         int ls= frame->linesize[p];
534         uint8_t *src= frame->data[p];
535
536         halfpel[1][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
537         halfpel[2][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
538         halfpel[3][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
539
540         halfpel[0][p]= src;
541         for(y=0; y<h; y++){
542             for(x=0; x<w; x++){
543                 int i= y*ls + x;
544
545                 halfpel[1][p][i]= (20*(src[i] + src[i+1]) - 5*(src[i-1] + src[i+2]) + (src[i-2] + src[i+3]) + 16 )>>5;
546             }
547         }
548         for(y=0; y<h; y++){
549             for(x=0; x<w; x++){
550                 int i= y*ls + x;
551
552                 halfpel[2][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
553             }
554         }
555         src= halfpel[1][p];
556         for(y=0; y<h; y++){
557             for(x=0; x<w; x++){
558                 int i= y*ls + x;
559
560                 halfpel[3][p][i]= (20*(src[i] + src[i+ls]) - 5*(src[i-ls] + src[i+2*ls]) + (src[i-2*ls] + src[i+3*ls]) + 16 )>>5;
561             }
562         }
563
564 //FIXME border!
565     }
566 }
567
568 void ff_snow_release_buffer(AVCodecContext *avctx)
569 {
570     SnowContext *s = avctx->priv_data;
571     int i;
572
573     if(s->last_picture[s->max_ref_frames-1].data[0]){
574         avctx->release_buffer(avctx, &s->last_picture[s->max_ref_frames-1]);
575         for(i=0; i<9; i++)
576             if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
577                 av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture.linesize[i%3]));
578     }
579 }
580
581 int ff_snow_frame_start(SnowContext *s){
582    AVFrame tmp;
583    int w= s->avctx->width; //FIXME round up to x16 ?
584    int h= s->avctx->height;
585
586     if (s->current_picture.data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)) {
587         s->dsp.draw_edges(s->current_picture.data[0],
588                           s->current_picture.linesize[0], w   , h   ,
589                           EDGE_WIDTH  , EDGE_WIDTH  , EDGE_TOP | EDGE_BOTTOM);
590         s->dsp.draw_edges(s->current_picture.data[1],
591                           s->current_picture.linesize[1], w>>1, h>>1,
592                           EDGE_WIDTH/2, EDGE_WIDTH/2, EDGE_TOP | EDGE_BOTTOM);
593         s->dsp.draw_edges(s->current_picture.data[2],
594                           s->current_picture.linesize[2], w>>1, h>>1,
595                           EDGE_WIDTH/2, EDGE_WIDTH/2, EDGE_TOP | EDGE_BOTTOM);
596     }
597
598     ff_snow_release_buffer(s->avctx);
599
600     tmp= s->last_picture[s->max_ref_frames-1];
601     memmove(s->last_picture+1, s->last_picture, (s->max_ref_frames-1)*sizeof(AVFrame));
602     memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
603     if(USE_HALFPEL_PLANE && s->current_picture.data[0])
604         halfpel_interpol(s, s->halfpel_plane[0], &s->current_picture);
605     s->last_picture[0]= s->current_picture;
606     s->current_picture= tmp;
607
608     if(s->keyframe){
609         s->ref_frames= 0;
610     }else{
611         int i;
612         for(i=0; i<s->max_ref_frames && s->last_picture[i].data[0]; i++)
613             if(i && s->last_picture[i-1].key_frame)
614                 break;
615         s->ref_frames= i;
616         if(s->ref_frames==0){
617             av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
618             return -1;
619         }
620     }
621
622     s->current_picture.reference= 1;
623     if(s->avctx->get_buffer(s->avctx, &s->current_picture) < 0){
624         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
625         return -1;
626     }
627
628     s->current_picture.key_frame= s->keyframe;
629
630     return 0;
631 }
632
633 av_cold void ff_snow_common_end(SnowContext *s)
634 {
635     int plane_index, level, orientation, i;
636
637     av_freep(&s->spatial_dwt_buffer);
638     av_freep(&s->temp_dwt_buffer);
639     av_freep(&s->spatial_idwt_buffer);
640     av_freep(&s->temp_idwt_buffer);
641     av_freep(&s->run_buffer);
642
643     s->m.me.temp= NULL;
644     av_freep(&s->m.me.scratchpad);
645     av_freep(&s->m.me.map);
646     av_freep(&s->m.me.score_map);
647     av_freep(&s->m.obmc_scratchpad);
648
649     av_freep(&s->block);
650     av_freep(&s->scratchbuf);
651
652     for(i=0; i<MAX_REF_FRAMES; i++){
653         av_freep(&s->ref_mvs[i]);
654         av_freep(&s->ref_scores[i]);
655         if(s->last_picture[i].data[0])
656             s->avctx->release_buffer(s->avctx, &s->last_picture[i]);
657     }
658
659     for(plane_index=0; plane_index<3; plane_index++){
660         for(level=s->spatial_decomposition_count-1; level>=0; level--){
661             for(orientation=level ? 1 : 0; orientation<4; orientation++){
662                 SubBand *b= &s->plane[plane_index].band[level][orientation];
663
664                 av_freep(&b->x_coeff);
665             }
666         }
667     }
668     if (s->mconly_picture.data[0])
669         s->avctx->release_buffer(s->avctx, &s->mconly_picture);
670     if (s->current_picture.data[0])
671         s->avctx->release_buffer(s->avctx, &s->current_picture);
672 }