git.sesse.net Git - ffmpeg/blob - libavcodec/snowdec.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 "snow_dwt.h"
  26 #include "internal.h"
  27 #include "snow.h"
  28
  29 #include "rangecoder.h"
  30 #include "mathops.h"
  31
  32 #include "mpegvideo.h"
  33 #include "h263.h"
  34
  35 static av_always_inline void predict_slice_buffered(SnowContext *s, slice_buffer * sb, IDWTELEM * old_buffer, int plane_index, int add, int mb_y){
  36     Plane *p= &s->plane[plane_index];
  37     const int mb_w= s->b_width  << s->block_max_depth;
  38     const int mb_h= s->b_height << s->block_max_depth;
  39     int x, y, mb_x;
  40     int block_size = MB_SIZE >> s->block_max_depth;
  41     int block_w    = plane_index ? block_size>>s->chroma_h_shift : block_size;
  42     int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;
  43     const uint8_t *obmc  = plane_index ? ff_obmc_tab[s->block_max_depth+s->chroma_h_shift] : ff_obmc_tab[s->block_max_depth];
  44     int obmc_stride= plane_index ? (2*block_size)>>s->chroma_h_shift : 2*block_size;
  45     int ref_stride= s->current_picture->linesize[plane_index];
  46     uint8_t *dst8= s->current_picture->data[plane_index];
  47     int w= p->width;
  48     int h= p->height;
  49
  50     if(s->keyframe || (s->avctx->debug&512)){
  51         if(mb_y==mb_h)
  52             return;
  53
  54         if(add){
  55             for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
  56 //                DWTELEM * line = slice_buffer_get_line(sb, y);
  57                 IDWTELEM * line = sb->line[y];
  58                 for(x=0; x<w; x++){
  59 //                    int v= buf[x + y*w] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
  60                     int v= line[x] + (128<<FRAC_BITS) + (1<<(FRAC_BITS-1));
  61                     v >>= FRAC_BITS;
  62                     if(v&(~255)) v= ~(v>>31);
  63                     dst8[x + y*ref_stride]= v;
  64                 }
  65             }
  66         }else{
  67             for(y=block_h*mb_y; y<FFMIN(h,block_h*(mb_y+1)); y++){
  68 //                DWTELEM * line = slice_buffer_get_line(sb, y);
  69                 IDWTELEM * line = sb->line[y];
  70                 for(x=0; x<w; x++){
  71                     line[x] -= 128 << FRAC_BITS;
  72 //                    buf[x + y*w]-= 128<<FRAC_BITS;
  73                 }
  74             }
  75         }
  76
  77         return;
  78     }
  79
  80     for(mb_x=0; mb_x<=mb_w; mb_x++){
  81         add_yblock(s, 1, sb, old_buffer, dst8, obmc,
  82                    block_w*mb_x - block_w/2,
  83                    block_h*mb_y - block_h/2,
  84                    block_w, block_h,
  85                    w, h,
  86                    w, ref_stride, obmc_stride,
  87                    mb_x - 1, mb_y - 1,
  88                    add, 0, plane_index);
  89     }
  90
  91     if(s->avmv && mb_y < mb_h && plane_index == 0)
  92         for(mb_x=0; mb_x<mb_w; mb_x++){
  93             AVMotionVector *avmv = s->avmv + (s->avmv_index++);
  94             const int b_width = s->b_width  << s->block_max_depth;
  95             const int b_stride= b_width;
  96             BlockNode *bn= &s->block[mb_x + mb_y*b_stride];
  97
  98             if (bn->type)
  99                 continue;
 100
 101             avmv->w = block_w;
 102             avmv->h = block_h;
 103             avmv->dst_x = block_w*mb_x - block_w/2;
 104             avmv->dst_y = block_h*mb_y - block_h/2;
 105             avmv->src_x = avmv->dst_x + (bn->mx * s->mv_scale)/8;
 106             avmv->src_y = avmv->dst_y + (bn->my * s->mv_scale)/8;
 107             avmv->source= -1 - bn->ref;
 108             avmv->flags = 0;
 109         }
 110 }
 111
 112 static inline void decode_subband_slice_buffered(SnowContext *s, SubBand *b, slice_buffer * sb, int start_y, int h, int save_state[1]){
 113     const int w= b->width;
 114     int y;
 115     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
 116     int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
 117     int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
 118     int new_index = 0;
 119
 120     if(b->ibuf == s->spatial_idwt_buffer || s->qlog == LOSSLESS_QLOG){
 121         qadd= 0;
 122         qmul= 1<<QEXPSHIFT;
 123     }
 124
 125     /* If we are on the second or later slice, restore our index. */
 126     if (start_y != 0)
 127         new_index = save_state[0];
 128
 129
 130     for(y=start_y; y<h; y++){
 131         int x = 0;
 132         int v;
 133         IDWTELEM * line = slice_buffer_get_line(sb, y * b->stride_line + b->buf_y_offset) + b->buf_x_offset;
 134         memset(line, 0, b->width*sizeof(IDWTELEM));
 135         v = b->x_coeff[new_index].coeff;
 136         x = b->x_coeff[new_index++].x;
 137         while(x < w){
 138             register int t= ( (v>>1)*qmul + qadd)>>QEXPSHIFT;
 139             register int u= -(v&1);
 140             line[x] = (t^u) - u;
 141
 142             v = b->x_coeff[new_index].coeff;
 143             x = b->x_coeff[new_index++].x;
 144         }
 145     }
 146
 147     /* Save our variables for the next slice. */
 148     save_state[0] = new_index;
 149
 150     return;
 151 }
 152
 153 static int decode_q_branch(SnowContext *s, int level, int x, int y){
 154     const int w= s->b_width << s->block_max_depth;
 155     const int rem_depth= s->block_max_depth - level;
 156     const int index= (x + y*w) << rem_depth;
 157     int trx= (x+1)<<rem_depth;
 158     const BlockNode *left  = x ? &s->block[index-1] : &null_block;
 159     const BlockNode *top   = y ? &s->block[index-w] : &null_block;
 160     const BlockNode *tl    = y && x ? &s->block[index-w-1] : left;
 161     const BlockNode *tr    = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
 162     int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
 163     int res;
 164
 165     if(s->keyframe){
 166         set_blocks(s, level, x, y, null_block.color[0], null_block.color[1], null_block.color[2], null_block.mx, null_block.my, null_block.ref, BLOCK_INTRA);
 167         return 0;
 168     }
 169
 170     if(level==s->block_max_depth || get_rac(&s->c, &s->block_state[4 + s_context])){
 171         int type, mx, my;
 172         int l = left->color[0];
 173         int cb= left->color[1];
 174         int cr= left->color[2];
 175         int ref = 0;
 176         int ref_context= av_log2(2*left->ref) + av_log2(2*top->ref);
 177         int mx_context= av_log2(2*FFABS(left->mx - top->mx)) + 0*av_log2(2*FFABS(tr->mx - top->mx));
 178         int my_context= av_log2(2*FFABS(left->my - top->my)) + 0*av_log2(2*FFABS(tr->my - top->my));
 179
 180         type= get_rac(&s->c, &s->block_state[1 + left->type + top->type]) ? BLOCK_INTRA : 0;
 181
 182         if(type){
 183             pred_mv(s, &mx, &my, 0, left, top, tr);
 184             l += get_symbol(&s->c, &s->block_state[32], 1);
 185             if (s->nb_planes > 2) {
 186                 cb+= get_symbol(&s->c, &s->block_state[64], 1);
 187                 cr+= get_symbol(&s->c, &s->block_state[96], 1);
 188             }
 189         }else{
 190             if(s->ref_frames > 1)
 191                 ref= get_symbol(&s->c, &s->block_state[128 + 1024 + 32*ref_context], 0);
 192             if (ref >= s->ref_frames) {
 193                 av_log(s->avctx, AV_LOG_ERROR, "Invalid ref\n");
 194                 return AVERROR_INVALIDDATA;
 195             }
 196             pred_mv(s, &mx, &my, ref, left, top, tr);
 197             mx+= get_symbol(&s->c, &s->block_state[128 + 32*(mx_context + 16*!!ref)], 1);
 198             my+= get_symbol(&s->c, &s->block_state[128 + 32*(my_context + 16*!!ref)], 1);
 199         }
 200         set_blocks(s, level, x, y, l, cb, cr, mx, my, ref, type);
 201     }else{
 202         if ((res = decode_q_branch(s, level+1, 2*x+0, 2*y+0)) < 0 ||
 203             (res = decode_q_branch(s, level+1, 2*x+1, 2*y+0)) < 0 ||
 204             (res = decode_q_branch(s, level+1, 2*x+0, 2*y+1)) < 0 ||
 205             (res = decode_q_branch(s, level+1, 2*x+1, 2*y+1)) < 0)
 206             return res;
 207     }
 208     return 0;
 209 }
 210
 211 static void dequantize_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, IDWTELEM *src, int stride, int start_y, int end_y){
 212     const int w= b->width;
 213     const int qlog= av_clip(s->qlog + b->qlog, 0, QROOT*16);
 214     const int qmul= ff_qexp[qlog&(QROOT-1)]<<(qlog>>QSHIFT);
 215     const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT;
 216     int x,y;
 217
 218     if(s->qlog == LOSSLESS_QLOG) return;
 219
 220     for(y=start_y; y<end_y; y++){
 221 //        DWTELEM * line = slice_buffer_get_line_from_address(sb, src + (y * stride));
 222         IDWTELEM * line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
 223         for(x=0; x<w; x++){
 224             int i= line[x];
 225             if(i<0){
 226                 line[x]= -((-i*qmul + qadd)>>(QEXPSHIFT)); //FIXME try different bias
 227             }else if(i>0){
 228                 line[x]=  (( i*qmul + qadd)>>(QEXPSHIFT));
 229             }
 230         }
 231     }
 232 }
 233
 234 static void correlate_slice_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median, int start_y, int end_y){
 235     const int w= b->width;
 236     int x,y;
 237
 238     IDWTELEM * line=0; // silence silly "could be used without having been initialized" warning
 239     IDWTELEM * prev;
 240
 241     if (start_y != 0)
 242         line = slice_buffer_get_line(sb, ((start_y - 1) * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
 243
 244     for(y=start_y; y<end_y; y++){
 245         prev = line;
 246 //        line = slice_buffer_get_line_from_address(sb, src + (y * stride));
 247         line = slice_buffer_get_line(sb, (y * b->stride_line) + b->buf_y_offset) + b->buf_x_offset;
 248         for(x=0; x<w; x++){
 249             if(x){
 250                 if(use_median){
 251                     if(y && x+1<w) line[x] += mid_pred(line[x - 1], prev[x], prev[x + 1]);
 252                     else  line[x] += line[x - 1];
 253                 }else{
 254                     if(y) line[x] += mid_pred(line[x - 1], prev[x], line[x - 1] + prev[x] - prev[x - 1]);
 255                     else  line[x] += line[x - 1];
 256                 }
 257             }else{
 258                 if(y) line[x] += prev[x];
 259             }
 260         }
 261     }
 262 }
 263
 264 static void decode_qlogs(SnowContext *s){
 265     int plane_index, level, orientation;
 266
 267     for(plane_index=0; plane_index < s->nb_planes; plane_index++){
 268         for(level=0; level<s->spatial_decomposition_count; level++){
 269             for(orientation=level ? 1:0; orientation<4; orientation++){
 270                 int q;
 271                 if     (plane_index==2) q= s->plane[1].band[level][orientation].qlog;
 272                 else if(orientation==2) q= s->plane[plane_index].band[level][1].qlog;
 273                 else                    q= get_symbol(&s->c, s->header_state, 1);
 274                 s->plane[plane_index].band[level][orientation].qlog= q;
 275             }
 276         }
 277     }
 278 }
 279
 280 #define GET_S(dst, check) \
 281     tmp= get_symbol(&s->c, s->header_state, 0);\
 282     if(!(check)){\
 283         av_log(s->avctx, AV_LOG_ERROR, "Error " #dst " is %d\n", tmp);\
 284         return AVERROR_INVALIDDATA;\
 285     }\
 286     dst= tmp;
 287
 288 static int decode_header(SnowContext *s){
 289     int plane_index, tmp;
 290     uint8_t kstate[32];
 291
 292     memset(kstate, MID_STATE, sizeof(kstate));
 293
 294     s->keyframe= get_rac(&s->c, kstate);
 295     if(s->keyframe || s->always_reset){
 296         ff_snow_reset_contexts(s);
 297         s->spatial_decomposition_type=
 298         s->qlog=
 299         s->qbias=
 300         s->mv_scale=
 301         s->block_max_depth= 0;
 302     }
 303     if(s->keyframe){
 304         GET_S(s->version, tmp <= 0U)
 305         s->always_reset= get_rac(&s->c, s->header_state);
 306         s->temporal_decomposition_type= get_symbol(&s->c, s->header_state, 0);
 307         s->temporal_decomposition_count= get_symbol(&s->c, s->header_state, 0);
 308         GET_S(s->spatial_decomposition_count, 0 < tmp && tmp <= MAX_DECOMPOSITIONS)
 309         s->colorspace_type= get_symbol(&s->c, s->header_state, 0);
 310         if (s->colorspace_type == 1) {
 311             s->avctx->pix_fmt= AV_PIX_FMT_GRAY8;
 312             s->nb_planes = 1;
 313         } else if(s->colorspace_type == 0) {
 314             s->chroma_h_shift= get_symbol(&s->c, s->header_state, 0);
 315             s->chroma_v_shift= get_symbol(&s->c, s->header_state, 0);
 316
 317             if(s->chroma_h_shift == 1 && s->chroma_v_shift==1){
 318                 s->avctx->pix_fmt= AV_PIX_FMT_YUV420P;
 319             }else if(s->chroma_h_shift == 0 && s->chroma_v_shift==0){
 320                 s->avctx->pix_fmt= AV_PIX_FMT_YUV444P;
 321             }else if(s->chroma_h_shift == 2 && s->chroma_v_shift==2){
 322                 s->avctx->pix_fmt= AV_PIX_FMT_YUV410P;
 323             } else {
 324                 av_log(s, AV_LOG_ERROR, "unsupported color subsample mode %d %d\n", s->chroma_h_shift, s->chroma_v_shift);
 325                 s->chroma_h_shift = s->chroma_v_shift = 1;
 326                 s->avctx->pix_fmt= AV_PIX_FMT_YUV420P;
 327                 return AVERROR_INVALIDDATA;
 328             }
 329             s->nb_planes = 3;
 330         } else {
 331             av_log(s, AV_LOG_ERROR, "unsupported color space\n");
 332             s->chroma_h_shift = s->chroma_v_shift = 1;
 333             s->avctx->pix_fmt= AV_PIX_FMT_YUV420P;
 334             return AVERROR_INVALIDDATA;
 335         }
 336
 337
 338         s->spatial_scalability= get_rac(&s->c, s->header_state);
 339 //        s->rate_scalability= get_rac(&s->c, s->header_state);
 340         GET_S(s->max_ref_frames, tmp < (unsigned)MAX_REF_FRAMES)
 341         s->max_ref_frames++;
 342
 343         decode_qlogs(s);
 344     }
 345
 346     if(!s->keyframe){
 347         if(get_rac(&s->c, s->header_state)){
 348             for(plane_index=0; plane_index<FFMIN(s->nb_planes, 2); plane_index++){
 349                 int htaps, i, sum=0;
 350                 Plane *p= &s->plane[plane_index];
 351                 p->diag_mc= get_rac(&s->c, s->header_state);
 352                 htaps= get_symbol(&s->c, s->header_state, 0)*2 + 2;
 353                 if((unsigned)htaps > HTAPS_MAX || htaps==0)
 354                     return AVERROR_INVALIDDATA;
 355                 p->htaps= htaps;
 356                 for(i= htaps/2; i; i--){
 357                     p->hcoeff[i]= get_symbol(&s->c, s->header_state, 0) * (1-2*(i&1));
 358                     sum += p->hcoeff[i];
 359                 }
 360                 p->hcoeff[0]= 32-sum;
 361             }
 362             s->plane[2].diag_mc= s->plane[1].diag_mc;
 363             s->plane[2].htaps  = s->plane[1].htaps;
 364             memcpy(s->plane[2].hcoeff, s->plane[1].hcoeff, sizeof(s->plane[1].hcoeff));
 365         }
 366         if(get_rac(&s->c, s->header_state)){
 367             GET_S(s->spatial_decomposition_count, 0 < tmp && tmp <= MAX_DECOMPOSITIONS)
 368             decode_qlogs(s);
 369         }
 370     }
 371
 372     s->spatial_decomposition_type+= get_symbol(&s->c, s->header_state, 1);
 373     if(s->spatial_decomposition_type > 1U){
 374         av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_type %d not supported\n", s->spatial_decomposition_type);
 375         return AVERROR_INVALIDDATA;
 376     }
 377     if(FFMIN(s->avctx-> width>>s->chroma_h_shift,
 378              s->avctx->height>>s->chroma_v_shift) >> (s->spatial_decomposition_count-1) <= 1){
 379         av_log(s->avctx, AV_LOG_ERROR, "spatial_decomposition_count %d too large for size\n", s->spatial_decomposition_count);
 380         return AVERROR_INVALIDDATA;
 381     }
 382
 383
 384     s->qlog           += get_symbol(&s->c, s->header_state, 1);
 385     s->mv_scale       += get_symbol(&s->c, s->header_state, 1);
 386     s->qbias          += get_symbol(&s->c, s->header_state, 1);
 387     s->block_max_depth+= get_symbol(&s->c, s->header_state, 1);
 388     if(s->block_max_depth > 1 || s->block_max_depth < 0){
 389         av_log(s->avctx, AV_LOG_ERROR, "block_max_depth= %d is too large\n", s->block_max_depth);
 390         s->block_max_depth= 0;
 391         return AVERROR_INVALIDDATA;
 392     }
 393
 394     return 0;
 395 }
 396
 397 static av_cold int decode_init(AVCodecContext *avctx)
 398 {
 399     int ret;
 400
 401     if ((ret = ff_snow_common_init(avctx)) < 0) {
 402         ff_snow_common_end(avctx->priv_data);
 403         return ret;
 404     }
 405
 406     return 0;
 407 }
 408
 409 static int decode_blocks(SnowContext *s){
 410     int x, y;
 411     int w= s->b_width;
 412     int h= s->b_height;
 413     int res;
 414
 415     for(y=0; y<h; y++){
 416         for(x=0; x<w; x++){
 417             if ((res = decode_q_branch(s, 0, x, y)) < 0)
 418                 return res;
 419         }
 420     }
 421     return 0;
 422 }
 423
 424 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 425                         AVPacket *avpkt)
 426 {
 427     const uint8_t *buf = avpkt->data;
 428     int buf_size = avpkt->size;
 429     SnowContext *s = avctx->priv_data;
 430     RangeCoder * const c= &s->c;
 431     int bytes_read;
 432     AVFrame *picture = data;
 433     int level, orientation, plane_index;
 434     int res;
 435
 436     ff_init_range_decoder(c, buf, buf_size);
 437     ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 438
 439     s->current_picture->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
 440     if ((res = decode_header(s)) < 0)
 441         return res;
 442     if ((res=ff_snow_common_init_after_header(avctx)) < 0)
 443         return res;
 444
 445     // realloc slice buffer for the case that spatial_decomposition_count changed
 446     ff_slice_buffer_destroy(&s->sb);
 447     if ((res = ff_slice_buffer_init(&s->sb, s->plane[0].height,
 448                                     (MB_SIZE >> s->block_max_depth) +
 449                                     s->spatial_decomposition_count * 11 + 1,
 450                                     s->plane[0].width,
 451                                     s->spatial_idwt_buffer)) < 0)
 452         return res;
 453
 454     for(plane_index=0; plane_index < s->nb_planes; plane_index++){
 455         Plane *p= &s->plane[plane_index];
 456         p->fast_mc= p->diag_mc && p->htaps==6 && p->hcoeff[0]==40
 457                                               && p->hcoeff[1]==-10
 458                                               && p->hcoeff[2]==2;
 459     }
 460
 461     ff_snow_alloc_blocks(s);
 462
 463     if((res = ff_snow_frame_start(s)) < 0)
 464         return res;
 465
 466     s->current_picture->pict_type = s->keyframe ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
 467
 468     //keyframe flag duplication mess FIXME
 469     if(avctx->debug&FF_DEBUG_PICT_INFO)
 470         av_log(avctx, AV_LOG_ERROR,
 471                "keyframe:%d qlog:%d qbias: %d mvscale: %d "
 472                "decomposition_type:%d decomposition_count:%d\n",
 473                s->keyframe, s->qlog, s->qbias, s->mv_scale,
 474                s->spatial_decomposition_type,
 475                s->spatial_decomposition_count
 476               );
 477
 478     av_assert0(!s->avmv);
 479     if (s->avctx->flags2 & CODEC_FLAG2_EXPORT_MVS) {
 480         s->avmv = av_malloc_array(s->b_width * s->b_height, sizeof(AVMotionVector) << (s->block_max_depth*2));
 481     }
 482     s->avmv_index = 0;
 483
 484     if ((res = decode_blocks(s)) < 0)
 485         return res;
 486
 487     for(plane_index=0; plane_index < s->nb_planes; plane_index++){
 488         Plane *p= &s->plane[plane_index];
 489         int w= p->width;
 490         int h= p->height;
 491         int x, y;
 492         int decode_state[MAX_DECOMPOSITIONS][4][1]; /* Stored state info for unpack_coeffs. 1 variable per instance. */
 493
 494         if(s->avctx->debug&2048){
 495             memset(s->spatial_dwt_buffer, 0, sizeof(DWTELEM)*w*h);
 496             predict_plane(s, s->spatial_idwt_buffer, plane_index, 1);
 497
 498             for(y=0; y<h; y++){
 499                 for(x=0; x<w; x++){
 500                     int v= s->current_picture->data[plane_index][y*s->current_picture->linesize[plane_index] + x];
 501                     s->mconly_picture->data[plane_index][y*s->mconly_picture->linesize[plane_index] + x]= v;
 502                 }
 503             }
 504         }
 505
 506         {
 507         for(level=0; level<s->spatial_decomposition_count; level++){
 508             for(orientation=level ? 1 : 0; orientation<4; orientation++){
 509                 SubBand *b= &p->band[level][orientation];
 510                 unpack_coeffs(s, b, b->parent, orientation);
 511             }
 512         }
 513         }
 514
 515         {
 516         const int mb_h= s->b_height << s->block_max_depth;
 517         const int block_size = MB_SIZE >> s->block_max_depth;
 518         const int block_h    = plane_index ? block_size>>s->chroma_v_shift : block_size;
 519         int mb_y;
 520         DWTCompose cs[MAX_DECOMPOSITIONS];
 521         int yd=0, yq=0;
 522         int y;
 523         int end_y;
 524
 525         ff_spatial_idwt_buffered_init(cs, &s->sb, w, h, 1, s->spatial_decomposition_type, s->spatial_decomposition_count);
 526         for(mb_y=0; mb_y<=mb_h; mb_y++){
 527
 528             int slice_starty = block_h*mb_y;
 529             int slice_h = block_h*(mb_y+1);
 530
 531             if (!(s->keyframe || s->avctx->debug&512)){
 532                 slice_starty = FFMAX(0, slice_starty - (block_h >> 1));
 533                 slice_h -= (block_h >> 1);
 534             }
 535
 536             for(level=0; level<s->spatial_decomposition_count; level++){
 537                 for(orientation=level ? 1 : 0; orientation<4; orientation++){
 538                     SubBand *b= &p->band[level][orientation];
 539                     int start_y;
 540                     int end_y;
 541                     int our_mb_start = mb_y;
 542                     int our_mb_end = (mb_y + 1);
 543                     const int extra= 3;
 544                     start_y = (mb_y ? ((block_h * our_mb_start) >> (s->spatial_decomposition_count - level)) + s->spatial_decomposition_count - level + extra: 0);
 545                     end_y = (((block_h * our_mb_end) >> (s->spatial_decomposition_count - level)) + s->spatial_decomposition_count - level + extra);
 546                     if (!(s->keyframe || s->avctx->debug&512)){
 547                         start_y = FFMAX(0, start_y - (block_h >> (1+s->spatial_decomposition_count - level)));
 548                         end_y = FFMAX(0, end_y - (block_h >> (1+s->spatial_decomposition_count - level)));
 549                     }
 550                     start_y = FFMIN(b->height, start_y);
 551                     end_y = FFMIN(b->height, end_y);
 552
 553                     if (start_y != end_y){
 554                         if (orientation == 0){
 555                             SubBand * correlate_band = &p->band[0][0];
 556                             int correlate_end_y = FFMIN(b->height, end_y + 1);
 557                             int correlate_start_y = FFMIN(b->height, (start_y ? start_y + 1 : 0));
 558                             decode_subband_slice_buffered(s, correlate_band, &s->sb, correlate_start_y, correlate_end_y, decode_state[0][0]);
 559                             correlate_slice_buffered(s, &s->sb, correlate_band, correlate_band->ibuf, correlate_band->stride, 1, 0, correlate_start_y, correlate_end_y);
 560                             dequantize_slice_buffered(s, &s->sb, correlate_band, correlate_band->ibuf, correlate_band->stride, start_y, end_y);
 561                         }
 562                         else
 563                             decode_subband_slice_buffered(s, b, &s->sb, start_y, end_y, decode_state[level][orientation]);
 564                     }
 565                 }
 566             }
 567
 568             for(; yd<slice_h; yd+=4){
 569                 ff_spatial_idwt_buffered_slice(&s->dwt, cs, &s->sb, s->temp_idwt_buffer, w, h, 1, s->spatial_decomposition_type, s->spatial_decomposition_count, yd);
 570             }
 571
 572             if(s->qlog == LOSSLESS_QLOG){
 573                 for(; yq<slice_h && yq<h; yq++){
 574                     IDWTELEM * line = slice_buffer_get_line(&s->sb, yq);
 575                     for(x=0; x<w; x++){
 576                         line[x] <<= FRAC_BITS;
 577                     }
 578                 }
 579             }
 580
 581             predict_slice_buffered(s, &s->sb, s->spatial_idwt_buffer, plane_index, 1, mb_y);
 582
 583             y = FFMIN(p->height, slice_starty);
 584             end_y = FFMIN(p->height, slice_h);
 585             while(y < end_y)
 586                 ff_slice_buffer_release(&s->sb, y++);
 587         }
 588
 589         ff_slice_buffer_flush(&s->sb);
 590         }
 591
 592     }
 593
 594     emms_c();
 595
 596     ff_snow_release_buffer(avctx);
 597
 598     if(!(s->avctx->debug&2048))
 599         res = av_frame_ref(picture, s->current_picture);
 600     else
 601         res = av_frame_ref(picture, s->mconly_picture);
 602     if (res >= 0 && s->avmv_index) {
 603         AVFrameSideData *sd;
 604
 605         sd = av_frame_new_side_data(picture, AV_FRAME_DATA_MOTION_VECTORS, s->avmv_index * sizeof(AVMotionVector));
 606         if (!sd)
 607             return AVERROR(ENOMEM);
 608         memcpy(sd->data, s->avmv, s->avmv_index * sizeof(AVMotionVector));
 609     }
 610
 611     av_freep(&s->avmv);
 612
 613     if (res < 0)
 614         return res;
 615
 616     *got_frame = 1;
 617
 618     bytes_read= c->bytestream - c->bytestream_start;
 619     if(bytes_read ==0) av_log(s->avctx, AV_LOG_ERROR, "error at end of frame\n"); //FIXME
 620
 621     return bytes_read;
 622 }
 623
 624 static av_cold int decode_end(AVCodecContext *avctx)
 625 {
 626     SnowContext *s = avctx->priv_data;
 627
 628     ff_slice_buffer_destroy(&s->sb);
 629
 630     ff_snow_common_end(s);
 631
 632     return 0;
 633 }
 634
 635 AVCodec ff_snow_decoder = {
 636     .name           = "snow",
 637     .long_name      = NULL_IF_CONFIG_SMALL("Snow"),
 638     .type           = AVMEDIA_TYPE_VIDEO,
 639     .id             = AV_CODEC_ID_SNOW,
 640     .priv_data_size = sizeof(SnowContext),
 641     .init           = decode_init,
 642     .close          = decode_end,
 643     .decode         = decode_frame,
 644     .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
 645 };