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