Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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