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     if (!s->block)
  93         return AVERROR(ENOMEM);
  94
  95     return 0;
  96 }
  97
  98 static av_cold void init_qexp(void){
  99     int i;
 100     double v=128;
 101
 102     for(i=0; i<QROOT; i++){
 103         ff_qexp[i]= lrintf(v);
 104         v *= pow(2, 1.0 / QROOT);
 105     }
 106 }
 107 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){
 108     static const uint8_t weight[64]={
 109     8,7,6,5,4,3,2,1,
 110     7,7,0,0,0,0,0,1,
 111     6,0,6,0,0,0,2,0,
 112     5,0,0,5,0,3,0,0,
 113     4,0,0,0,4,0,0,0,
 114     3,0,0,5,0,3,0,0,
 115     2,0,6,0,0,0,2,0,
 116     1,7,0,0,0,0,0,1,
 117     };
 118
 119     static const uint8_t brane[256]={
 120     0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x11,0x12,0x12,0x12,0x12,0x12,0x12,0x12,
 121     0x04,0x05,0xcc,0xcc,0xcc,0xcc,0xcc,0x41,0x15,0x16,0xcc,0xcc,0xcc,0xcc,0xcc,0x52,
 122     0x04,0xcc,0x05,0xcc,0xcc,0xcc,0x41,0xcc,0x15,0xcc,0x16,0xcc,0xcc,0xcc,0x52,0xcc,
 123     0x04,0xcc,0xcc,0x05,0xcc,0x41,0xcc,0xcc,0x15,0xcc,0xcc,0x16,0xcc,0x52,0xcc,0xcc,
 124     0x04,0xcc,0xcc,0xcc,0x41,0xcc,0xcc,0xcc,0x15,0xcc,0xcc,0xcc,0x16,0xcc,0xcc,0xcc,
 125     0x04,0xcc,0xcc,0x41,0xcc,0x05,0xcc,0xcc,0x15,0xcc,0xcc,0x52,0xcc,0x16,0xcc,0xcc,
 126     0x04,0xcc,0x41,0xcc,0xcc,0xcc,0x05,0xcc,0x15,0xcc,0x52,0xcc,0xcc,0xcc,0x16,0xcc,
 127     0x04,0x41,0xcc,0xcc,0xcc,0xcc,0xcc,0x05,0x15,0x52,0xcc,0xcc,0xcc,0xcc,0xcc,0x16,
 128     0x44,0x45,0x45,0x45,0x45,0x45,0x45,0x45,0x55,0x56,0x56,0x56,0x56,0x56,0x56,0x56,
 129     0x48,0x49,0xcc,0xcc,0xcc,0xcc,0xcc,0x85,0x59,0x5A,0xcc,0xcc,0xcc,0xcc,0xcc,0x96,
 130     0x48,0xcc,0x49,0xcc,0xcc,0xcc,0x85,0xcc,0x59,0xcc,0x5A,0xcc,0xcc,0xcc,0x96,0xcc,
 131     0x48,0xcc,0xcc,0x49,0xcc,0x85,0xcc,0xcc,0x59,0xcc,0xcc,0x5A,0xcc,0x96,0xcc,0xcc,
 132     0x48,0xcc,0xcc,0xcc,0x49,0xcc,0xcc,0xcc,0x59,0xcc,0xcc,0xcc,0x96,0xcc,0xcc,0xcc,
 133     0x48,0xcc,0xcc,0x85,0xcc,0x49,0xcc,0xcc,0x59,0xcc,0xcc,0x96,0xcc,0x5A,0xcc,0xcc,
 134     0x48,0xcc,0x85,0xcc,0xcc,0xcc,0x49,0xcc,0x59,0xcc,0x96,0xcc,0xcc,0xcc,0x5A,0xcc,
 135     0x48,0x85,0xcc,0xcc,0xcc,0xcc,0xcc,0x49,0x59,0x96,0xcc,0xcc,0xcc,0xcc,0xcc,0x5A,
 136     };
 137
 138     static const uint8_t needs[16]={
 139     0,1,0,0,
 140     2,4,2,0,
 141     0,1,0,0,
 142     15
 143     };
 144
 145     int x, y, b, r, l;
 146     int16_t tmpIt   [64*(32+HTAPS_MAX)];
 147     uint8_t tmp2t[3][64*(32+HTAPS_MAX)];
 148     int16_t *tmpI= tmpIt;
 149     uint8_t *tmp2= tmp2t[0];
 150     const uint8_t *hpel[11];
 151     av_assert2(dx<16 && dy<16);
 152     r= brane[dx + 16*dy]&15;
 153     l= brane[dx + 16*dy]>>4;
 154
 155     b= needs[l] | needs[r];
 156     if(p && !p->diag_mc)
 157         b= 15;
 158
 159     if(b&5){
 160         for(y=0; y < b_h+HTAPS_MAX-1; y++){
 161             for(x=0; x < b_w; x++){
 162                 int a_1=src[x + HTAPS_MAX/2-4];
 163                 int a0= src[x + HTAPS_MAX/2-3];
 164                 int a1= src[x + HTAPS_MAX/2-2];
 165                 int a2= src[x + HTAPS_MAX/2-1];
 166                 int a3= src[x + HTAPS_MAX/2+0];
 167                 int a4= src[x + HTAPS_MAX/2+1];
 168                 int a5= src[x + HTAPS_MAX/2+2];
 169                 int a6= src[x + HTAPS_MAX/2+3];
 170                 int am=0;
 171                 if(!p || p->fast_mc){
 172                     am= 20*(a2+a3) - 5*(a1+a4) + (a0+a5);
 173                     tmpI[x]= am;
 174                     am= (am+16)>>5;
 175                 }else{
 176                     am= p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6);
 177                     tmpI[x]= am;
 178                     am= (am+32)>>6;
 179                 }
 180
 181                 if(am&(~255)) am= ~(am>>31);
 182                 tmp2[x]= am;
 183             }
 184             tmpI+= 64;
 185             tmp2+= 64;
 186             src += stride;
 187         }
 188         src -= stride*y;
 189     }
 190     src += HTAPS_MAX/2 - 1;
 191     tmp2= tmp2t[1];
 192
 193     if(b&2){
 194         for(y=0; y < b_h; y++){
 195             for(x=0; x < b_w+1; x++){
 196                 int a_1=src[x + (HTAPS_MAX/2-4)*stride];
 197                 int a0= src[x + (HTAPS_MAX/2-3)*stride];
 198                 int a1= src[x + (HTAPS_MAX/2-2)*stride];
 199                 int a2= src[x + (HTAPS_MAX/2-1)*stride];
 200                 int a3= src[x + (HTAPS_MAX/2+0)*stride];
 201                 int a4= src[x + (HTAPS_MAX/2+1)*stride];
 202                 int a5= src[x + (HTAPS_MAX/2+2)*stride];
 203                 int a6= src[x + (HTAPS_MAX/2+3)*stride];
 204                 int am=0;
 205                 if(!p || p->fast_mc)
 206                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 16)>>5;
 207                 else
 208                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 32)>>6;
 209
 210                 if(am&(~255)) am= ~(am>>31);
 211                 tmp2[x]= am;
 212             }
 213             src += stride;
 214             tmp2+= 64;
 215         }
 216         src -= stride*y;
 217     }
 218     src += stride*(HTAPS_MAX/2 - 1);
 219     tmp2= tmp2t[2];
 220     tmpI= tmpIt;
 221     if(b&4){
 222         for(y=0; y < b_h; y++){
 223             for(x=0; x < b_w; x++){
 224                 int a_1=tmpI[x + (HTAPS_MAX/2-4)*64];
 225                 int a0= tmpI[x + (HTAPS_MAX/2-3)*64];
 226                 int a1= tmpI[x + (HTAPS_MAX/2-2)*64];
 227                 int a2= tmpI[x + (HTAPS_MAX/2-1)*64];
 228                 int a3= tmpI[x + (HTAPS_MAX/2+0)*64];
 229                 int a4= tmpI[x + (HTAPS_MAX/2+1)*64];
 230                 int a5= tmpI[x + (HTAPS_MAX/2+2)*64];
 231                 int a6= tmpI[x + (HTAPS_MAX/2+3)*64];
 232                 int am=0;
 233                 if(!p || p->fast_mc)
 234                     am= (20*(a2+a3) - 5*(a1+a4) + (a0+a5) + 512)>>10;
 235                 else
 236                     am= (p->hcoeff[0]*(a2+a3) + p->hcoeff[1]*(a1+a4) + p->hcoeff[2]*(a0+a5) + p->hcoeff[3]*(a_1+a6) + 2048)>>12;
 237                 if(am&(~255)) am= ~(am>>31);
 238                 tmp2[x]= am;
 239             }
 240             tmpI+= 64;
 241             tmp2+= 64;
 242         }
 243     }
 244
 245     hpel[ 0]= src;
 246     hpel[ 1]= tmp2t[0] + 64*(HTAPS_MAX/2-1);
 247     hpel[ 2]= src + 1;
 248
 249     hpel[ 4]= tmp2t[1];
 250     hpel[ 5]= tmp2t[2];
 251     hpel[ 6]= tmp2t[1] + 1;
 252
 253     hpel[ 8]= src + stride;
 254     hpel[ 9]= hpel[1] + 64;
 255     hpel[10]= hpel[8] + 1;
 256
 257 #define MC_STRIDE(x) (needs[x] ? 64 : stride)
 258
 259     if(b==15){
 260         int dxy = dx / 8 + dy / 8 * 4;
 261         const uint8_t *src1 = hpel[dxy    ];
 262         const uint8_t *src2 = hpel[dxy + 1];
 263         const uint8_t *src3 = hpel[dxy + 4];
 264         const uint8_t *src4 = hpel[dxy + 5];
 265         int stride1 = MC_STRIDE(dxy);
 266         int stride2 = MC_STRIDE(dxy + 1);
 267         int stride3 = MC_STRIDE(dxy + 4);
 268         int stride4 = MC_STRIDE(dxy + 5);
 269         dx&=7;
 270         dy&=7;
 271         for(y=0; y < b_h; y++){
 272             for(x=0; x < b_w; x++){
 273                 dst[x]= ((8-dx)*(8-dy)*src1[x] + dx*(8-dy)*src2[x]+
 274                          (8-dx)*   dy *src3[x] + dx*   dy *src4[x]+32)>>6;
 275             }
 276             src1+=stride1;
 277             src2+=stride2;
 278             src3+=stride3;
 279             src4+=stride4;
 280             dst +=stride;
 281         }
 282     }else{
 283         const uint8_t *src1= hpel[l];
 284         const uint8_t *src2= hpel[r];
 285         int stride1 = MC_STRIDE(l);
 286         int stride2 = MC_STRIDE(r);
 287         int a= weight[((dx&7) + (8*(dy&7)))];
 288         int b= 8-a;
 289         for(y=0; y < b_h; y++){
 290             for(x=0; x < b_w; x++){
 291                 dst[x]= (a*src1[x] + b*src2[x] + 4)>>3;
 292             }
 293             src1+=stride1;
 294             src2+=stride2;
 295             dst +=stride;
 296         }
 297     }
 298 }
 299
 300 void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, ptrdiff_t stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h){
 301     if(block->type & BLOCK_INTRA){
 302         int x, y;
 303         const unsigned color  = block->color[plane_index];
 304         const unsigned color4 = color*0x01010101;
 305         if(b_w==32){
 306             for(y=0; y < b_h; y++){
 307                 *(uint32_t*)&dst[0 + y*stride]= color4;
 308                 *(uint32_t*)&dst[4 + y*stride]= color4;
 309                 *(uint32_t*)&dst[8 + y*stride]= color4;
 310                 *(uint32_t*)&dst[12+ y*stride]= color4;
 311                 *(uint32_t*)&dst[16+ y*stride]= color4;
 312                 *(uint32_t*)&dst[20+ y*stride]= color4;
 313                 *(uint32_t*)&dst[24+ y*stride]= color4;
 314                 *(uint32_t*)&dst[28+ y*stride]= color4;
 315             }
 316         }else if(b_w==16){
 317             for(y=0; y < b_h; y++){
 318                 *(uint32_t*)&dst[0 + y*stride]= color4;
 319                 *(uint32_t*)&dst[4 + y*stride]= color4;
 320                 *(uint32_t*)&dst[8 + y*stride]= color4;
 321                 *(uint32_t*)&dst[12+ y*stride]= color4;
 322             }
 323         }else if(b_w==8){
 324             for(y=0; y < b_h; y++){
 325                 *(uint32_t*)&dst[0 + y*stride]= color4;
 326                 *(uint32_t*)&dst[4 + y*stride]= color4;
 327             }
 328         }else if(b_w==4){
 329             for(y=0; y < b_h; y++){
 330                 *(uint32_t*)&dst[0 + y*stride]= color4;
 331             }
 332         }else{
 333             for(y=0; y < b_h; y++){
 334                 for(x=0; x < b_w; x++){
 335                     dst[x + y*stride]= color;
 336                 }
 337             }
 338         }
 339     }else{
 340         uint8_t *src= s->last_picture[block->ref]->data[plane_index];
 341         const int scale= plane_index ?  (2*s->mv_scale)>>s->chroma_h_shift : 2*s->mv_scale;
 342         int mx= block->mx*scale;
 343         int my= block->my*scale;
 344         const int dx= mx&15;
 345         const int dy= my&15;
 346         const int tab_index= 3 - (b_w>>2) + (b_w>>4);
 347         sx += (mx>>4) - (HTAPS_MAX/2-1);
 348         sy += (my>>4) - (HTAPS_MAX/2-1);
 349         src += sx + sy*stride;
 350         if(   (unsigned)sx >= FFMAX(w - b_w - (HTAPS_MAX-2), 0)
 351            || (unsigned)sy >= FFMAX(h - b_h - (HTAPS_MAX-2), 0)){
 352             s->vdsp.emulated_edge_mc(tmp + MB_SIZE, stride, src, stride,
 353                                      b_w+HTAPS_MAX-1, b_h+HTAPS_MAX-1,
 354                                      sx, sy, w, h);
 355             src= tmp + MB_SIZE;
 356         }
 357
 358         av_assert2(s->chroma_h_shift == s->chroma_v_shift); // only one mv_scale
 359
 360         av_assert2(b_w>1 && b_h>1);
 361         av_assert2((tab_index>=0 && tab_index<4) || b_w==32);
 362         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 )
 363             mc_block(&s->plane[plane_index], dst, src, stride, b_w, b_h, dx, dy);
 364         else if(b_w==32){
 365             int y;
 366             for(y=0; y<b_h; y+=16){
 367                 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + y*stride, src + 3 + (y+3)*stride,stride);
 368                 s->h264qpel.put_h264_qpel_pixels_tab[0][dy+(dx>>2)](dst + 16 + y*stride, src + 19 + (y+3)*stride,stride);
 369             }
 370         }else if(b_w==b_h)
 371             s->h264qpel.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst,src + 3 + 3*stride,stride);
 372         else if(b_w==2*b_h){
 373             s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst    ,src + 3       + 3*stride,stride);
 374             s->h264qpel.put_h264_qpel_pixels_tab[tab_index+1][dy+(dx>>2)](dst+b_h,src + 3 + b_h + 3*stride,stride);
 375         }else{
 376             av_assert2(2*b_w==b_h);
 377             s->h264qpel.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst           ,src + 3 + 3*stride           ,stride);
 378             s->h264qpel.put_h264_qpel_pixels_tab[tab_index  ][dy+(dx>>2)](dst+b_w*stride,src + 3 + 3*stride+b_w*stride,stride);
 379         }
 380     }
 381 }
 382
 383 #define mca(dx,dy,b_w)\
 384 static void mc_block_hpel ## dx ## dy ## b_w(uint8_t *dst, const uint8_t *src, ptrdiff_t stride, int h){\
 385     av_assert2(h==b_w);\
 386     mc_block(NULL, dst, src-(HTAPS_MAX/2-1)-(HTAPS_MAX/2-1)*stride, stride, b_w, b_w, dx, dy);\
 387 }
 388
 389 mca( 0, 0,16)
 390 mca( 8, 0,16)
 391 mca( 0, 8,16)
 392 mca( 8, 8,16)
 393 mca( 0, 0,8)
 394 mca( 8, 0,8)
 395 mca( 0, 8,8)
 396 mca( 8, 8,8)
 397
 398 av_cold int ff_snow_common_init(AVCodecContext *avctx){
 399     SnowContext *s = avctx->priv_data;
 400     int width, height;
 401     int i, j;
 402
 403     s->avctx= avctx;
 404     s->max_ref_frames=1; //just make sure it's not an invalid value in case of no initial keyframe
 405
 406     ff_dsputil_init(&s->dsp, avctx);
 407     ff_hpeldsp_init(&s->hdsp, avctx->flags);
 408     ff_videodsp_init(&s->vdsp, 8);
 409     ff_dwt_init(&s->dwt);
 410     ff_h264qpel_init(&s->h264qpel, 8);
 411
 412 #define mcf(dx,dy)\
 413     s->dsp.put_qpel_pixels_tab       [0][dy+dx/4]=\
 414     s->dsp.put_no_rnd_qpel_pixels_tab[0][dy+dx/4]=\
 415         s->h264qpel.put_h264_qpel_pixels_tab[0][dy+dx/4];\
 416     s->dsp.put_qpel_pixels_tab       [1][dy+dx/4]=\
 417     s->dsp.put_no_rnd_qpel_pixels_tab[1][dy+dx/4]=\
 418         s->h264qpel.put_h264_qpel_pixels_tab[1][dy+dx/4];
 419
 420     mcf( 0, 0)
 421     mcf( 4, 0)
 422     mcf( 8, 0)
 423     mcf(12, 0)
 424     mcf( 0, 4)
 425     mcf( 4, 4)
 426     mcf( 8, 4)
 427     mcf(12, 4)
 428     mcf( 0, 8)
 429     mcf( 4, 8)
 430     mcf( 8, 8)
 431     mcf(12, 8)
 432     mcf( 0,12)
 433     mcf( 4,12)
 434     mcf( 8,12)
 435     mcf(12,12)
 436
 437 #define mcfh(dx,dy)\
 438     s->hdsp.put_pixels_tab       [0][dy/4+dx/8]=\
 439     s->hdsp.put_no_rnd_pixels_tab[0][dy/4+dx/8]=\
 440         mc_block_hpel ## dx ## dy ## 16;\
 441     s->hdsp.put_pixels_tab       [1][dy/4+dx/8]=\
 442     s->hdsp.put_no_rnd_pixels_tab[1][dy/4+dx/8]=\
 443         mc_block_hpel ## dx ## dy ## 8;
 444
 445     mcfh(0, 0)
 446     mcfh(8, 0)
 447     mcfh(0, 8)
 448     mcfh(8, 8)
 449
 450     init_qexp();
 451
 452 //    dec += FFMAX(s->chroma_h_shift, s->chroma_v_shift);
 453
 454     width= s->avctx->width;
 455     height= s->avctx->height;
 456
 457     FF_ALLOCZ_OR_GOTO(avctx, s->spatial_idwt_buffer, width * height * sizeof(IDWTELEM), fail);
 458     FF_ALLOCZ_OR_GOTO(avctx, s->spatial_dwt_buffer,  width * height * sizeof(DWTELEM),  fail); //FIXME this does not belong here
 459     FF_ALLOCZ_OR_GOTO(avctx, s->temp_dwt_buffer,     width * sizeof(DWTELEM),  fail);
 460     FF_ALLOCZ_OR_GOTO(avctx, s->temp_idwt_buffer,    width * sizeof(IDWTELEM), fail);
 461     FF_ALLOC_OR_GOTO(avctx,  s->run_buffer,          ((width + 1) >> 1) * ((height + 1) >> 1) * sizeof(*s->run_buffer), fail);
 462
 463     for(i=0; i<MAX_REF_FRAMES; i++) {
 464         for(j=0; j<MAX_REF_FRAMES; j++)
 465             ff_scale_mv_ref[i][j] = 256*(i+1)/(j+1);
 466         s->last_picture[i] = av_frame_alloc();
 467         if (!s->last_picture[i])
 468             goto fail;
 469     }
 470
 471     s->mconly_picture = av_frame_alloc();
 472     s->current_picture = av_frame_alloc();
 473     if (!s->mconly_picture || !s->current_picture)
 474         goto fail;
 475
 476     return 0;
 477 fail:
 478     return AVERROR(ENOMEM);
 479 }
 480
 481 int ff_snow_common_init_after_header(AVCodecContext *avctx) {
 482     SnowContext *s = avctx->priv_data;
 483     int plane_index, level, orientation;
 484     int ret, emu_buf_size;
 485
 486     if(!s->scratchbuf) {
 487         if ((ret = ff_get_buffer(s->avctx, s->mconly_picture,
 488                                  AV_GET_BUFFER_FLAG_REF)) < 0)
 489             return ret;
 490         FF_ALLOCZ_OR_GOTO(avctx, s->scratchbuf, FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256)*7*MB_SIZE, fail);
 491         emu_buf_size = FFMAX(s->mconly_picture->linesize[0], 2*avctx->width+256) * (2 * MB_SIZE + HTAPS_MAX - 1);
 492         FF_ALLOC_OR_GOTO(avctx, s->emu_edge_buffer, emu_buf_size, fail);
 493     }
 494
 495     if(s->mconly_picture->format != avctx->pix_fmt) {
 496         av_log(avctx, AV_LOG_ERROR, "pixel format changed\n");
 497         return AVERROR_INVALIDDATA;
 498     }
 499
 500     for(plane_index=0; plane_index < s->nb_planes; plane_index++){
 501         int w= s->avctx->width;
 502         int h= s->avctx->height;
 503
 504         if(plane_index){
 505             w>>= s->chroma_h_shift;
 506             h>>= s->chroma_v_shift;
 507         }
 508         s->plane[plane_index].width = w;
 509         s->plane[plane_index].height= h;
 510
 511         for(level=s->spatial_decomposition_count-1; level>=0; level--){
 512             for(orientation=level ? 1 : 0; orientation<4; orientation++){
 513                 SubBand *b= &s->plane[plane_index].band[level][orientation];
 514
 515                 b->buf= s->spatial_dwt_buffer;
 516                 b->level= level;
 517                 b->stride= s->plane[plane_index].width << (s->spatial_decomposition_count - level);
 518                 b->width = (w + !(orientation&1))>>1;
 519                 b->height= (h + !(orientation>1))>>1;
 520
 521                 b->stride_line = 1 << (s->spatial_decomposition_count - level);
 522                 b->buf_x_offset = 0;
 523                 b->buf_y_offset = 0;
 524
 525                 if(orientation&1){
 526                     b->buf += (w+1)>>1;
 527                     b->buf_x_offset = (w+1)>>1;
 528                 }
 529                 if(orientation>1){
 530                     b->buf += b->stride>>1;
 531                     b->buf_y_offset = b->stride_line >> 1;
 532                 }
 533                 b->ibuf= s->spatial_idwt_buffer + (b->buf - s->spatial_dwt_buffer);
 534
 535                 if(level)
 536                     b->parent= &s->plane[plane_index].band[level-1][orientation];
 537                 //FIXME avoid this realloc
 538                 av_freep(&b->x_coeff);
 539                 b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff));
 540                 if (!b->x_coeff)
 541                     goto fail;
 542             }
 543             w= (w+1)>>1;
 544             h= (h+1)>>1;
 545         }
 546     }
 547
 548     return 0;
 549 fail:
 550     return AVERROR(ENOMEM);
 551 }
 552
 553 #define USE_HALFPEL_PLANE 0
 554
 555 static int halfpel_interpol(SnowContext *s, uint8_t *halfpel[4][4], AVFrame *frame){
 556     int p,x,y;
 557
 558     for(p=0; p < s->nb_planes; p++){
 559         int is_chroma= !!p;
 560         int w= is_chroma ? s->avctx->width >>s->chroma_h_shift : s->avctx->width;
 561         int h= is_chroma ? s->avctx->height>>s->chroma_v_shift : s->avctx->height;
 562         int ls= frame->linesize[p];
 563         uint8_t *src= frame->data[p];
 564
 565         halfpel[1][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
 566         halfpel[2][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
 567         halfpel[3][p] = (uint8_t*) av_malloc(ls * (h + 2 * EDGE_WIDTH)) + EDGE_WIDTH * (1 + ls);
 568         if (!halfpel[1][p] || !halfpel[2][p] || !halfpel[3][p])
 569             return AVERROR(ENOMEM);
 570
 571         halfpel[0][p]= src;
 572         for(y=0; y<h; y++){
 573             for(x=0; x<w; x++){
 574                 int i= y*ls + x;
 575
 576                 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;
 577             }
 578         }
 579         for(y=0; y<h; y++){
 580             for(x=0; x<w; x++){
 581                 int i= y*ls + x;
 582
 583                 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;
 584             }
 585         }
 586         src= halfpel[1][p];
 587         for(y=0; y<h; y++){
 588             for(x=0; x<w; x++){
 589                 int i= y*ls + x;
 590
 591                 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;
 592             }
 593         }
 594
 595 //FIXME border!
 596     }
 597     return 0;
 598 }
 599
 600 void ff_snow_release_buffer(AVCodecContext *avctx)
 601 {
 602     SnowContext *s = avctx->priv_data;
 603     int i;
 604
 605     if(s->last_picture[s->max_ref_frames-1]->data[0]){
 606         av_frame_unref(s->last_picture[s->max_ref_frames-1]);
 607         for(i=0; i<9; i++)
 608             if(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3])
 609                 av_free(s->halfpel_plane[s->max_ref_frames-1][1+i/3][i%3] - EDGE_WIDTH*(1+s->current_picture->linesize[i%3]));
 610     }
 611 }
 612
 613 int ff_snow_frame_start(SnowContext *s){
 614    AVFrame *tmp;
 615    int i, ret;
 616    int w= s->avctx->width; //FIXME round up to x16 ?
 617    int h= s->avctx->height;
 618
 619     if (s->current_picture->data[0] && !(s->avctx->flags&CODEC_FLAG_EMU_EDGE)) {
 620         s->dsp.draw_edges(s->current_picture->data[0],
 621                           s->current_picture->linesize[0], w   , h   ,
 622                           EDGE_WIDTH  , EDGE_WIDTH  , EDGE_TOP | EDGE_BOTTOM);
 623         if (s->current_picture->data[2]) {
 624             s->dsp.draw_edges(s->current_picture->data[1],
 625                             s->current_picture->linesize[1], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
 626                             EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
 627             s->dsp.draw_edges(s->current_picture->data[2],
 628                             s->current_picture->linesize[2], w>>s->chroma_h_shift, h>>s->chroma_v_shift,
 629                             EDGE_WIDTH>>s->chroma_h_shift, EDGE_WIDTH>>s->chroma_v_shift, EDGE_TOP | EDGE_BOTTOM);
 630         }
 631     }
 632
 633     ff_snow_release_buffer(s->avctx);
 634
 635     tmp= s->last_picture[s->max_ref_frames-1];
 636     for(i=s->max_ref_frames-1; i>0; i--)
 637         s->last_picture[i] = s->last_picture[i-1];
 638     memmove(s->halfpel_plane+1, s->halfpel_plane, (s->max_ref_frames-1)*sizeof(void*)*4*4);
 639     if(USE_HALFPEL_PLANE && s->current_picture->data[0]) {
 640         if((ret = halfpel_interpol(s, s->halfpel_plane[0], s->current_picture)) < 0)
 641             return ret;
 642     }
 643     s->last_picture[0] = s->current_picture;
 644     s->current_picture = tmp;
 645
 646     if(s->keyframe){
 647         s->ref_frames= 0;
 648     }else{
 649         int i;
 650         for(i=0; i<s->max_ref_frames && s->last_picture[i]->data[0]; i++)
 651             if(i && s->last_picture[i-1]->key_frame)
 652                 break;
 653         s->ref_frames= i;
 654         if(s->ref_frames==0){
 655             av_log(s->avctx,AV_LOG_ERROR, "No reference frames\n");
 656             return -1;
 657         }
 658     }
 659
 660     if ((ret = ff_get_buffer(s->avctx, s->current_picture, AV_GET_BUFFER_FLAG_REF)) < 0)
 661         return ret;
 662
 663     s->current_picture->key_frame= s->keyframe;
 664
 665     return 0;
 666 }
 667
 668 av_cold void ff_snow_common_end(SnowContext *s)
 669 {
 670     int plane_index, level, orientation, i;
 671
 672     av_freep(&s->spatial_dwt_buffer);
 673     av_freep(&s->temp_dwt_buffer);
 674     av_freep(&s->spatial_idwt_buffer);
 675     av_freep(&s->temp_idwt_buffer);
 676     av_freep(&s->run_buffer);
 677
 678     s->m.me.temp= NULL;
 679     av_freep(&s->m.me.scratchpad);
 680     av_freep(&s->m.me.map);
 681     av_freep(&s->m.me.score_map);
 682     av_freep(&s->m.obmc_scratchpad);
 683
 684     av_freep(&s->block);
 685     av_freep(&s->scratchbuf);
 686     av_freep(&s->emu_edge_buffer);
 687
 688     for(i=0; i<MAX_REF_FRAMES; i++){
 689         av_freep(&s->ref_mvs[i]);
 690         av_freep(&s->ref_scores[i]);
 691         if(s->last_picture[i]->data[0]) {
 692             av_assert0(s->last_picture[i]->data[0] != s->current_picture->data[0]);
 693         }
 694         av_frame_free(&s->last_picture[i]);
 695     }
 696
 697     for(plane_index=0; plane_index < s->nb_planes; plane_index++){
 698         for(level=s->spatial_decomposition_count-1; level>=0; level--){
 699             for(orientation=level ? 1 : 0; orientation<4; orientation++){
 700                 SubBand *b= &s->plane[plane_index].band[level][orientation];
 701
 702                 av_freep(&b->x_coeff);
 703             }
 704         }
 705     }
 706     av_frame_free(&s->mconly_picture);
 707     av_frame_free(&s->current_picture);
 708 }