git.sesse.net Git - ffmpeg/blob - 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 "snow_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= FF_CEIL_RSHIFT(s->avctx->width,  LOG2_MB_SIZE);
  85     int h= FF_CEIL_RSHIFT(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 av_cold 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         av_assert2(b_w>1 && b_h>1);
 356         av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
 357         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 )
 358             mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
 359         else if(b_w==32){
 360             int y;
 361             for(y=0; y<b_h; y+=16){
 362                 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
 363                 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
 364             }
 365         }else if(b_w==b_h)
 366             s->h264qpel.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
 367         else if(b_w==2*b_h){
 368             s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst    ,src + 3       + 3*stride,stride);
 369             s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
 370         }else{
 371             av_assert2(2*b_w==b_h);
 372             s->h264qpel.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst           ,src + 3 + 3*stride           ,stride);
 373             s->h264qpel.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
 374         }
 375     }
 376 }
 377
 378 #define mca(dx,dy,b_w)\
 379 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\
 380     av_assert2(h==b_w);\
 381     mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
 382 }
 383
 384 mca( 0, 0,16)
 385 mca( 8, 0,16)
 386 mca( 0, 8,16)
 387 mca( 8, 8,16)
 388 mca( 0, 0,8)
 389 mca( 8, 0,8)
 390 mca( 0, 8,8)
 391 mca( 8, 8,8)
 392
 393 av_cold int ff_snow_common_init(AVCodecContext *avctx){
 394     SnowContext *s = avctx->priv_data;
 395     int width, height;
 396     int i, j;
 397
 398     s->avctx= avctx;
 399     s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
 400
 401     ff_dsputil_init(&s->dsp, avctx);
 402     ff_hpeldsp_init(&s->hdsp, avctx->flags);
 403     ff_videodsp_init(&s->vdsp, 8);
 404     ff_dwt_init(&s->dwt);
 405     ff_h264qpel_init(&s->h264qpel, 8);
 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->h264qpel.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->h264qpel.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->hdsp.put_pixels_tab       [0][dy/4+dx/8]=\
 434     s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
 435         mc_block_hpel ## dx ## dy ## 16;\
 436     s->hdsp.put_pixels_tab       [1][dy/4+dx/8]=\
 437     s->hdsp.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         avcodec_get_frame_defaults(&s->last_picture[i]);
 462     }
 463
 464     avcodec_get_frame_defaults(&s->mconly_picture);
 465     avcodec_get_frame_defaults(&s->current_picture);
 466
 467     return 0;
 468 fail:
 469     return AVERROR(ENOMEM);
 470 }
 471
 472 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
 473     SnowContext *s = avctx->priv_data;
 474     int plane_index, level, orientation;
 475     int ret, emu_buf_size;
 476
 477     if(!s->scratchbuf) {
 478         if ((ret = ff_get_buffer(s->avctx, &s->mconly_picture,
 479                                  AV_GET_BUFFER_FLAG_REF)) < 0)
 480             return ret;
 481         FF_ALLOCZ_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture.linesize[0], 2*avctx->width+256)*7*MB_SIZE, fail);
 482         emu_buf_size = FFMAX(s->mconly_picture.linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);
 483         FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail);
 484     }
 485
 486     if(s->mconly_picture.format != avctx->pix_fmt) {
 487         av_log(avctx, AV_LOG_ERROR, "pixel format changed\n");
 488         return AVERROR_INVALIDDATA;
 489     }
 490
 491     for(plane_index=0; plane_index<3; plane_index++){
 492         int w= s->avctx->width;
 493         int h= s->avctx->height;
 494
 495         if(plane_index){
 496             w>>= s->chroma_h_shift;
 497             h>>= s->chroma_v_shift;
 498         }
 499         s->plane[plane_index].width = w;
 500         s->plane[plane_index].height= h;
 501
 502         for(level=s->spatial_decomposition_count-1; level>=0; level--){
 503             for(orientation=level ? 1 : 0; orientation<4; orientation++){
 504                 SubBand *b= &s->plane[plane_index].band[level][orientation];
 505
 506                 b->buf= s->spatial_dwt_buffer;
 507                 b->level= level;
 508                 b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
 509                 b->width = (w + !(orientation&1))>>1;
 510                 b->height= (h + !(orientation>1))>>1;
 511
 512                 b->stride_line = 1 << (s->spatial_decomposition_count - level);
 513                 b->buf_x_offset = 0;
 514                 b->buf_y_offset = 0;
 515
 516                 if(orientation&1){
 517                     b->buf += (w+1)>>1;
 518                     b->buf_x_offset = (w+1)>>1;
 519                 }
 520                 if(orientation>1){
 521                     b->buf += b->stride>>1;
 522                     b->buf_y_offset = b->stride_line >> 1;
 523                 }
 524                 b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
 525
 526                 if(level)
 527                     b->parent= &s->plane[plane_index].band[level-1][orientation];
 528                 //FIXME avoid this realloc
 529                 av_freep(&b->x_coeff);
 530                 b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
 531             }
 532             w= (w+1)>>1;
 533             h= (h+1)>>1;
 534         }
 535     }
 536
 537     return 0;
 538 fail:
 539     return AVERROR(ENOMEM);
 540 }
 541
 542 #define USE_HALFPEL_PLANE 0
 543
 544 static void halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
 545     int p,x,y;
 546
 547     for(p=0; p<3; p++){
 548         int is_chroma= !!p;
 549         int w= is_chroma ? s->avctx->width >>s->chroma_h_shift : s->avctx->width;
 550         int h= is_chroma ? s->avctx->height>>s->chroma_v_shift : s->avctx->height;
 551         int ls= frame->linesize[p];
 552         uint8_t *src= frame->data[p];
 553
 554         halfpel[1][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
 555         halfpel[2][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
 556         halfpel[3][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
 557
 558         halfpel[0][p]= src;
 559         for(y=0; y<h; y++){
 560             for(x=0; x<w; x++){
 561                 int i= y*ls + x;
 562
 563                 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;
 564             }
 565         }
 566         for(y=0; y<h; y++){
 567             for(x=0; x<w; x++){
 568                 int i= y*ls + x;
 569
 570                 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;
 571             }
 572         }
 573         src= halfpel[1][p];
 574         for(y=0; y<h; y++){
 575             for(x=0; x<w; x++){
 576                 int i= y*ls + x;
 577
 578                 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;
 579             }
 580         }
 581
 582 //FIXME border!
 583     }
 584 }
 585
 586 void ff_snow_release_buffer(AVCodecContext *avctx)
 587 {
 588     SnowContext *s = avctx->priv_data;
 589     int i;
 590
 591     if(s->last_picture[s->max_ref_frames-1].data[0]){
 592         av_frame_unref(&s->last_picture[s->max_ref_frames-1]);
 593         for(i=0; i<9; i++)
 594             if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
 595                 av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture.linesize[i%3]));
 596     }
 597 }
 598
 599 int ff_snow_frame_start(SnowContext *s){
 600    AVFrame tmp;
 601    int i, ret;
 602    int w= s->avctx->width; //FIXME round up to x16 ?
 603    int h= s->avctx->height;
 604
 605     if (s->current_picture.data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)) {
 606         s->dsp.draw_edges(s->current_picture.data[0],
 607                           s->current_picture.linesize[0], w   , h   ,
 608                           EDGE_WIDTH  , EDGE_WIDTH  , EDGE_TOP | EDGE_BOTTOM);
 609         s->dsp.draw_edges(s->current_picture.data[1],
 610                           s->current_picture.linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
 611                           EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
 612         s->dsp.draw_edges(s->current_picture.data[2],
 613                           s->current_picture.linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
 614                           EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
 615     }
 616
 617     ff_snow_release_buffer(s->avctx);
 618
 619     av_frame_move_ref(&tmp, &s->last_picture[s->max_ref_frames-1]);
 620     for(i=s->max_ref_frames-1; i>0; i--)
 621         av_frame_move_ref(&s->last_picture[i], &s->last_picture[i-1]);
 622     memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
 623     if(USE_HALFPEL_PLANE && s->current_picture.data[0])
 624         halfpel_interpol(s, s->halfpel_plane[0], &s->current_picture);
 625     av_frame_move_ref(&s->last_picture[0], &s->current_picture);
 626     av_frame_move_ref(&s->current_picture, &tmp);
 627
 628     if(s->keyframe){
 629         s->ref_frames= 0;
 630     }else{
 631         int i;
 632         for(i=0; i<s->max_ref_frames && s->last_picture[i].data[0]; i++)
 633             if(i && s->last_picture[i-1].key_frame)
 634                 break;
 635         s->ref_frames= i;
 636         if(s->ref_frames==0){
 637             av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
 638             return -1;
 639         }
 640     }
 641
 642     if ((ret = ff_get_buffer(s->avctx, &s->current_picture, AV_GET_BUFFER_FLAG_REF)) < 0)
 643         return ret;
 644
 645     s->current_picture.key_frame= s->keyframe;
 646
 647     return 0;
 648 }
 649
 650 av_cold void ff_snow_common_end(SnowContext *s)
 651 {
 652     int plane_index, level, orientation, i;
 653
 654     av_freep(&s->spatial_dwt_buffer);
 655     av_freep(&s->temp_dwt_buffer);
 656     av_freep(&s->spatial_idwt_buffer);
 657     av_freep(&s->temp_idwt_buffer);
 658     av_freep(&s->run_buffer);
 659
 660     s->m.me.temp= NULL;
 661     av_freep(&s->m.me.scratchpad);
 662     av_freep(&s->m.me.map);
 663     av_freep(&s->m.me.score_map);
 664     av_freep(&s->m.obmc_scratchpad);
 665
 666     av_freep(&s->block);
 667     av_freep(&s->scratchbuf);
 668     av_freep(&s->emu_edge_buffer);
 669
 670     for(i=0; i<MAX_REF_FRAMES; i++){
 671         av_freep(&s->ref_mvs[i]);
 672         av_freep(&s->ref_scores[i]);
 673         if(s->last_picture[i].data[0]) {
 674             av_assert0(s->last_picture[i].data[0] != s->current_picture.data[0]);
 675             av_frame_unref(&s->last_picture[i]);
 676         }
 677     }
 678
 679     for(plane_index=0; plane_index<3; plane_index++){
 680         for(level=s->spatial_decomposition_count-1; level>=0; level--){
 681             for(orientation=level ? 1 : 0; orientation<4; orientation++){
 682                 SubBand *b= &s->plane[plane_index].band[level][orientation];
 683
 684                 av_freep(&b->x_coeff);
 685             }
 686         }
 687     }
 688     av_frame_unref(&s->mconly_picture);
 689     av_frame_unref(&s->current_picture);
 690 }