Subversion Repositories Kolibri OS

Rev

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