LCOV - code coverage report
Current view: top level - libavcodec - snowdec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 304 387 78.6 %
Date: 2017-12-11 04:34:20 Functions: 11 11 100.0 %

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

Generated by: LCOV version 1.13