From a0d1931c0e6d1a701e1dce791d1955bbaba74ee8 Mon Sep 17 00:00:00 2001 From: Yartrebo Date: Sun, 3 Apr 2005 15:43:57 +0000 Subject: [PATCH] Snow Slicing patch by (Yartrebo) yartrebo earthlink net Originally committed as revision 4101 to svn://svn.ffmpeg.org/ffmpeg/trunk --- libavcodec/snow.c | 749 ++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 683 insertions(+), 66 deletions(-) diff --git a/libavcodec/snow.c b/libavcodec/snow.c index 901e95d75e..522c01f5c8 100644 --- a/libavcodec/snow.c +++ b/libavcodec/snow.c @@ -371,6 +371,11 @@ typedef struct BlockNode{ #define LOG2_MB_SIZE 4 #define MB_SIZE (1<line[line_num] ? (slice_buf)->line[line_num] : slice_buffer_load_line((slice_buf), (line_num))) +//#define slice_buffer_get_line(slice_buf, line_num) (slice_buffer_load_line((slice_buf), (line_num))) + +static void slice_buffer_init(slice_buffer * buf, int line_count, int max_allocated_lines, int line_width, DWTELEM * base_buffer) +{ + int i; + + buf->base_buffer = base_buffer; + buf->line_count = line_count; + buf->line_width = line_width; + buf->data_count = max_allocated_lines; + buf->line = (DWTELEM * *) av_mallocz (sizeof(DWTELEM *) * line_count); + buf->data_stack = (DWTELEM * *) av_malloc (sizeof(DWTELEM *) * max_allocated_lines); + + for (i = 0; i < max_allocated_lines; i++) + { + buf->data_stack[i] = (DWTELEM *) av_malloc (sizeof(DWTELEM) * line_width); + } + + buf->data_stack_top = max_allocated_lines - 1; +} + +static DWTELEM * slice_buffer_load_line(slice_buffer * buf, int line) +{ + int i; + int offset; + DWTELEM * buffer; + +// av_log(NULL, AV_LOG_DEBUG, "Cache hit: %d\n", line); + + assert(buf->data_stack_top >= 0); +// assert(!buf->line[line]); + if (buf->line[line]) + return buf->line[line]; + + offset = buf->line_width * line; + buffer = buf->data_stack[buf->data_stack_top]; + buf->data_stack_top--; + buf->line[line] = buffer; + +// av_log(NULL, AV_LOG_DEBUG, "slice_buffer_load_line: line: %d remaining: %d\n", line, buf->data_stack_top + 1); + + return buffer; +} + +static void slice_buffer_release(slice_buffer * buf, int line) +{ + int i; + int offset; + DWTELEM * buffer; + + assert(line >= 0 && line < buf->line_count); + assert(buf->line[line]); + + offset = buf->line_width * line; + buffer = buf->line[line]; + buf->data_stack_top++; + buf->data_stack[buf->data_stack_top] = buffer; + buf->line[line] = NULL; + +// av_log(NULL, AV_LOG_DEBUG, "slice_buffer_release: line: %d remaining: %d\n", line, buf->data_stack_top + 1); +} + +static void slice_buffer_flush(slice_buffer * buf) +{ + int i; + for (i = 0; i < buf->line_count; i++) + { + if (buf->line[i]) + { +// av_log(NULL, AV_LOG_DEBUG, "slice_buffer_flush: line: %d \n", i); + slice_buffer_release(buf, i); + } + } +} + +static void slice_buffer_destroy(slice_buffer * buf) +{ + int i; + slice_buffer_flush(buf); + + for (i = buf->data_count - 1; i >= 0; i--) + { + assert(buf->data_stack[i]); + av_free(buf->data_stack[i]); + } + assert(buf->data_stack); + av_free(buf->data_stack); + assert(buf->line); + av_free(buf->line); +} + #ifdef __sgi // Avoid a name clash on SGI IRIX #undef qexp @@ -1174,12 +1285,45 @@ static void vertical_compose53iL0(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int wid } } +static void spatial_compose53i_buffered_init(dwt_compose_t *cs, slice_buffer * sb, int height, int stride_line){ + cs->b0 = slice_buffer_get_line(sb, mirror(-1-1, height-1) * stride_line); + cs->b1 = slice_buffer_get_line(sb, mirror(-1 , height-1) * stride_line); + cs->y = -1; +} + static void spatial_compose53i_init(dwt_compose_t *cs, DWTELEM *buffer, int height, int stride){ cs->b0 = buffer + mirror(-1-1, height-1)*stride; cs->b1 = buffer + mirror(-1 , height-1)*stride; cs->y = -1; } +static void spatial_compose53i_dy_buffered(dwt_compose_t *cs, slice_buffer * sb, int width, int height, int stride_line){ + int y= cs->y; + int mirror0 = mirror(y-1, height-1); + int mirror1 = mirror(y , height-1); + int mirror2 = mirror(y+1, height-1); + int mirror3 = mirror(y+2, height-1); + + DWTELEM *b0= cs->b0; + DWTELEM *b1= cs->b1; + DWTELEM *b2= slice_buffer_get_line(sb, mirror2 * stride_line); + DWTELEM *b3= slice_buffer_get_line(sb, mirror3 * stride_line); + +{START_TIMER + if(mirror1 <= mirror3) vertical_compose53iL0(b1, b2, b3, width); + if(mirror0 <= mirror2) vertical_compose53iH0(b0, b1, b2, width); +STOP_TIMER("vertical_compose53i*")} + +{START_TIMER + if(y-1 >= 0) horizontal_compose53i(b0, width); + if(mirror0 <= mirror2) horizontal_compose53i(b1, width); +STOP_TIMER("horizontal_compose53i")} + + cs->b0 = b2; + cs->b1 = b3; + cs->y += 2; +} + static void spatial_compose53i_dy(dwt_compose_t *cs, DWTELEM *buffer, int width, int height, int stride){ int y= cs->y; DWTELEM *b0= cs->b0; @@ -1259,6 +1403,14 @@ static void vertical_compose97iL1(DWTELEM *b0, DWTELEM *b1, DWTELEM *b2, int wid } } +static void spatial_compose97i_buffered_init(dwt_compose_t *cs, slice_buffer * sb, int height, int stride_line){ + cs->b0 = slice_buffer_get_line(sb, mirror(-3-1, height-1) * stride_line); + cs->b1 = slice_buffer_get_line(sb, mirror(-3 , height-1) * stride_line); + cs->b2 = slice_buffer_get_line(sb, mirror(-3+1, height-1) * stride_line); + cs->b3 = slice_buffer_get_line(sb, mirror(-3+2, height-1) * stride_line); + cs->y = -3; +} + static void spatial_compose97i_init(dwt_compose_t *cs, DWTELEM *buffer, int height, int stride){ cs->b0 = buffer + mirror(-3-1, height-1)*stride; cs->b1 = buffer + mirror(-3 , height-1)*stride; @@ -1267,6 +1419,61 @@ static void spatial_compose97i_init(dwt_compose_t *cs, DWTELEM *buffer, int heig cs->y = -3; } +static void spatial_compose97i_dy_buffered(dwt_compose_t *cs, slice_buffer * sb, int width, int height, int stride_line){ + int y = cs->y; + + int mirror0 = mirror(y - 1, height - 1); + int mirror1 = mirror(y + 0, height - 1); + int mirror2 = mirror(y + 1, height - 1); + int mirror3 = mirror(y + 2, height - 1); + int mirror4 = mirror(y + 3, height - 1); + int mirror5 = mirror(y + 4, height - 1); + DWTELEM *b0= cs->b0; + DWTELEM *b1= cs->b1; + DWTELEM *b2= cs->b2; + DWTELEM *b3= cs->b3; + DWTELEM *b4= slice_buffer_get_line(sb, mirror4 * stride_line); + DWTELEM *b5= slice_buffer_get_line(sb, mirror5 * stride_line); + + if(stride_line == 1 && y+4 < height && 0){ + int x; + for(x=0; x400){ +//STOP_TIMER("vertical_compose97i-NEW")}} +// } +// else +// { +{START_TIMER + if(mirror3 <= mirror5) vertical_compose97iL1(b3, b4, b5, width); + if(mirror2 <= mirror4) vertical_compose97iH1(b2, b3, b4, width); + if(mirror1 <= mirror3) vertical_compose97iL0(b1, b2, b3, width); + if(mirror0 <= mirror2) vertical_compose97iH0(b0, b1, b2, width); +if(width>400){ +STOP_TIMER("vertical_compose97i")}} +// } + +{START_TIMER + if(y-1>= 0) horizontal_compose97i(b0, width); + if(mirror0 <= mirror2) horizontal_compose97i(b1, width); +if(width>400 && mirror0 <= mirror2){ +STOP_TIMER("horizontal_compose97i")}} + + cs->b0=b2; + cs->b1=b3; + cs->b2=b4; + cs->b3=b5; + cs->y += 2; +} + static void spatial_compose97i_dy(dwt_compose_t *cs, DWTELEM *buffer, int width, int height, int stride){ int y = cs->y; DWTELEM *b0= cs->b0; @@ -1312,6 +1519,19 @@ static void spatial_compose97i(DWTELEM *buffer, int width, int height, int strid spatial_compose97i_dy(&cs, buffer, width, height, stride); } +void ff_spatial_idwt_buffered_init(dwt_compose_t *cs, slice_buffer * sb, int width, int height, int stride_line, int type, int decomposition_count){ + int level; + for(level=decomposition_count-1; level>=0; level--){ + switch(type){ + case 0: spatial_compose97i_buffered_init(cs+level, sb, height>>level, stride_line<>level, stride_line<>level, height>>level, stride<=0; level--){ @@ -1342,6 +1562,24 @@ void ff_spatial_idwt_slice(dwt_compose_t *cs, DWTELEM *buffer, int width, int he } } +void ff_spatial_idwt_buffered_slice(dwt_compose_t *cs, slice_buffer * slice_buf, int width, int height, int stride_line, int type, int decomposition_count, int y){ + const int support = type==1 ? 3 : 5; + int level; + if(type==2) return; + + for(level=decomposition_count-1; level>=0; level--){ + while(cs[level].y <= FFMIN((y>>level)+support, height>>level)){ + switch(type){ + case 0: spatial_compose97i_dy_buffered(cs+level, slice_buf, width>>level, height>>level, stride_line<>level, height>>level, stride_line<width; const int h= b->height; int x,y; - const int qlog= clip(s->qlog + b->qlog, 0, 128); - int qmul= qexp[qlog&7]<<(qlog>>3); - int qadd= (s->qbias*qmul)>>QBIAS_SHIFT; - START_TIMER - - if(b->buf == s->spatial_dwt_buffer || s->qlog == LOSSLESS_QLOG){ - qadd= 0; - qmul= 1<height; y++) - memset(&src[y*stride], 0, b->width*sizeof(DWTELEM)); run= get_symbol2(&s->c, b->state[1], 3); for(y=0; yx[prev_index] == 0){ - rt= b->coeff[prev_index]; + if(y && b->x_coeff[prev_index].x == 0){ + rt= b->x_coeff[prev_index].coeff; } for(x=0; xx[prev_index] <= x) + if(b->x_coeff[prev_index].x <= x) prev_index++; - if(b->x[prev_index] == x + 1) - rt= b->coeff[prev_index]; + if(b->x_coeff[prev_index].x == x + 1) + rt= b->x_coeff[prev_index].coeff; else rt=0; } if(parent){ - if(x>>1 > b->parent->x[parent_index]){ + if(x>>1 > parent->x_coeff[parent_index].x){ parent_index++; } - if(x>>1 == b->parent->x[parent_index]){ - p= b->parent->coeff[parent_index]; + if(x>>1 == parent->x_coeff[parent_index].x){ + p= parent->x_coeff[parent_index].coeff; } } if(/*ll|*/l|lt|t|rt|p){ @@ -1547,8 +1772,8 @@ static inline void decode_subband(SnowContext *s, SubBand *b, DWTELEM *src, DWTE if(y && parent){ int max_run; - max_run= FFMIN(run, b->x[prev_index] - x - 2); - max_run= FFMIN(max_run, 2*b->parent->x[parent_index] - x - 1); + max_run= FFMIN(run, b->x_coeff[prev_index].x - x - 2); + max_run= FFMIN(max_run, 2*parent->x_coeff[parent_index].x - x - 1); x+= max_run; run-= max_run; } @@ -1557,40 +1782,79 @@ static inline void decode_subband(SnowContext *s, SubBand *b, DWTELEM *src, DWTE if(v){ int context= av_log2(/*ABS(ll) + */3*ABS(l) + ABS(lt) + 2*ABS(t) + ABS(rt) + ABS(p)); v= get_symbol2(&s->c, b->state[context + 2], context-4) + 1; - if(get_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3b[l&0xFF] + 3*quant3b[t&0xFF]])){ - src[x + y*stride]=-(( v*qmul + qadd)>>(QEXPSHIFT)); - v= -v; - }else{ - src[x + y*stride]= (( v*qmul + qadd)>>(QEXPSHIFT)); - } - b->x[index]=x; //FIXME interleave x/coeff - b->coeff[index++]= v; + if(get_rac(&s->c, &b->state[0][16 + 1 + 3 + quant3b[l&0xFF] + 3*quant3b[t&0xFF]])) + v *= -1; + b->x_coeff[index].x=x; + b->x_coeff[index++].coeff= v; } } - b->x[index++]= w+1; //end marker + b->x_coeff[index++].x= w+1; //end marker prev_index= prev2_index; prev2_index= index; if(parent){ - while(b->parent->x[parent_index] != b->parent->width+1) - parent_index++; - parent_index++; if(y&1){ + while(parent->x_coeff[parent_index].x != parent->width+1) + parent_index++; + parent_index++; prev_parent_index= parent_index; }else{ parent_index= prev_parent_index; } } } - b->x[index++]= w+1; //end marker - if(w > 200 /*level+1 == s->spatial_decomposition_count*/){ - STOP_TIMER("decode_subband") - } - - return; + + b->x_coeff[index++].x= w+1; //end marker } } +static inline void decode_subband_slice_buffered(SnowContext *s, SubBand *b, slice_buffer * sb, int start_y, int h, int save_state[1]){ + const int w= b->width; + int x,y; + const int qlog= clip(s->qlog + b->qlog, 0, 128); + int qmul= qexp[qlog&7]<<(qlog>>3); + int qadd= (s->qbias*qmul)>>QBIAS_SHIFT; + int new_index = 0; + + START_TIMER + + if(b->buf == s->spatial_dwt_buffer || s->qlog == LOSSLESS_QLOG){ + qadd= 0; + qmul= 1<stride_line + b->buf_y_offset) + b->buf_x_offset; + memset(line, 0, b->width*sizeof(DWTELEM)); + v = b->x_coeff[new_index].coeff; + x = b->x_coeff[new_index++].x; + while(x < w) + { + if (v < 0) + line[x] = -(( -v*qmul + qadd)>>(QEXPSHIFT)); + else + line[x] = (( v*qmul + qadd)>>(QEXPSHIFT)); + v = b->x_coeff[new_index].coeff; + x = b->x_coeff[new_index++].x; + } + } + if(w > 200 && start_y != 0/*level+1 == s->spatial_decomposition_count*/){ + STOP_TIMER("decode_subband") + } + + /* Save our variables for the next slice. */ + save_state[0] = new_index; + + return; +} + static void reset_contexts(SnowContext *s){ int plane_index, level, orientation; @@ -2120,6 +2384,160 @@ static always_inline int same_block(BlockNode *a, BlockNode *b){ return !((a->mx - b->mx) | (a->my - b->my) | a->type | b->type); } +//FIXME name clenup (b_w, block_w, b_width stuff) +static always_inline void add_yblock_buffered(SnowContext *s, slice_buffer * sb, DWTELEM *old_dst, uint8_t *dst8, uint8_t *src, uint8_t *obmc, int src_x, int src_y, int b_w, int b_h, int w, int h, int dst_stride, int src_stride, int obmc_stride, int b_x, int b_y, int add, int plane_index){ + DWTELEM * dst = NULL; + const int b_width = s->b_width << s->block_max_depth; + const int b_height= s->b_height << s->block_max_depth; + const int b_stride= b_width; + BlockNode *lt= &s->block[b_x + b_y*b_stride]; + BlockNode *rt= lt+1; + BlockNode *lb= lt+b_stride; + BlockNode *rb= lb+1; + uint8_t *block[4]; + uint8_t tmp[src_stride*(b_h+5)]; //FIXME align + int x,y; + + if(b_x<0){ + lt= rt; + lb= rb; + }else if(b_x + 1 >= b_width){ + rt= lt; + rb= lb; + } + if(b_y<0){ + lt= lb; + rt= rb; + }else if(b_y + 1 >= b_height){ + lb= lt; + rb= rt; + } + + if(src_x<0){ //FIXME merge with prev & always round internal width upto *16 + obmc -= src_x; + b_w += src_x; + src_x=0; + }else if(src_x + b_w > w){ + b_w = w - src_x; + } + if(src_y<0){ + obmc -= src_y*obmc_stride; + b_h += src_y; + src_y=0; + }else if(src_y + b_h> h){ + b_h = h - src_y; + } + + if(b_w<=0 || b_h<=0) return; + +assert(src_stride > 7*MB_SIZE); +// old_dst += src_x + src_y*dst_stride; + dst8+= src_x + src_y*src_stride; +// src += src_x + src_y*src_stride; + + block[0]= tmp+3*MB_SIZE; + pred_block(s, block[0], src, tmp, src_stride, src_x, src_y, b_w, b_h, lt, plane_index, w, h); + + if(same_block(lt, rt)){ + block[1]= block[0]; + }else{ + block[1]= tmp + 4*MB_SIZE; + pred_block(s, block[1], src, tmp, src_stride, src_x, src_y, b_w, b_h, rt, plane_index, w, h); + } + + if(same_block(lt, lb)){ + block[2]= block[0]; + }else if(same_block(rt, lb)){ + block[2]= block[1]; + }else{ + block[2]= tmp+5*MB_SIZE; + pred_block(s, block[2], src, tmp, src_stride, src_x, src_y, b_w, b_h, lb, plane_index, w, h); + } + + if(same_block(lt, rb) ){ + block[3]= block[0]; + }else if(same_block(rt, rb)){ + block[3]= block[1]; + }else if(same_block(lb, rb)){ + block[3]= block[2]; + }else{ + block[3]= tmp+6*MB_SIZE; + pred_block(s, block[3], src, tmp, src_stride, src_x, src_y, b_w, b_h, rb, plane_index, w, h); + } +#if 0 + for(y=0; y>1); + for(x=0; x>1); + for(x=0; x>1); + uint8_t *obmc4= obmc3+ (obmc_stride>>1); + for(x=0; x>1); + uint8_t *obmc3= obmc1+ obmc_stride*(obmc_stride>>1); + uint8_t *obmc4= obmc3+ (obmc_stride>>1); + dst = slice_buffer_get_line(sb, src_y + y); + for(x=0; x>= 8 - FRAC_BITS; + } + if(add){ +// v += old_dst[x + y*dst_stride]; + v += dst[x + src_x]; + v = (v + (1<<(FRAC_BITS-1))) >> FRAC_BITS; + if(v&(~255)) v= ~(v>>31); + dst8[x + y*src_stride] = v; + }else{ +// old_dst[x + y*dst_stride] -= v; + dst[x + src_x] -= v; + } + } + } + STOP_TIMER("Inner add y block") +} +#endif +} + //FIXME name clenup (b_w, block_w, b_width stuff) static always_inline void add_yblock(SnowContext *s, DWTELEM *dst, uint8_t *dst8, uint8_t *src, uint8_t *obmc, int src_x, int src_y, int b_w, int b_h, int w, int h, int dst_stride, int src_stride, int obmc_stride, int b_x, int b_y, int add, int plane_index){ const int b_width = s->b_width << s->block_max_depth; @@ -2263,6 +2681,74 @@ assert(src_stride > 7*MB_SIZE); #endif } +static always_inline void predict_slice_buffered(SnowContext *s, slice_buffer * sb, DWTELEM * old_buffer, int plane_index, int add, int mb_y){ + Plane *p= &s->plane[plane_index]; + const int mb_w= s->b_width << s->block_max_depth; + const int mb_h= s->b_height << s->block_max_depth; + int x, y, mb_x; + int block_size = MB_SIZE >> s->block_max_depth; + int block_w = plane_index ? block_size/2 : block_size; + const uint8_t *obmc = plane_index ? obmc_tab[s->block_max_depth+1] : obmc_tab[s->block_max_depth]; + int obmc_stride= plane_index ? block_size : 2*block_size; + int ref_stride= s->current_picture.linesize[plane_index]; + uint8_t *ref = s->last_picture.data[plane_index]; + uint8_t *dst8= s->current_picture.data[plane_index]; + int w= p->width; + int h= p->height; + START_TIMER + + if(s->keyframe || (s->avctx->debug&512)){ + if(mb_y==mb_h) + return; + + if(add){ + for(y=block_w*mb_y; yline[y]; + for(x=0; x>= FRAC_BITS; + if(v&(~255)) v= ~(v>>31); + dst8[x + y*ref_stride]= v; + } + } + }else{ + for(y=block_w*mb_y; yline[y]; + for(x=0; xplane[plane_index]; const int mb_w= s->b_width << s->block_max_depth; @@ -2391,6 +2877,36 @@ static void quantize(SnowContext *s, SubBand *b, DWTELEM *src, int stride, int b } } +static void dequantize_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, DWTELEM *src, int stride){ + const int w= b->width; + const int h= b->height; + const int qlog= clip(s->qlog + b->qlog, 0, 128); + const int qmul= qexp[qlog&7]<<(qlog>>3); + const int qadd= (s->qbias*qmul)>>QBIAS_SHIFT; + int x,y; + START_TIMER + + if(s->qlog == LOSSLESS_QLOG) return; + + assert(QROOT==8); + + for(y=0; ystride_line) + b->buf_y_offset) + b->buf_x_offset; + for(x=0; x>(QEXPSHIFT)); //FIXME try different bias + }else if(i>0){ + line[x]= (( i*qmul + qadd)>>(QEXPSHIFT)); + } + } + } + if(w > 200 /*level+1 == s->spatial_decomposition_count*/){ + STOP_TIMER("dquant") + } +} + static void dequantize(SnowContext *s, SubBand *b, DWTELEM *src, int stride){ const int w= b->width; const int h= b->height; @@ -2443,6 +2959,38 @@ static void decorrelate(SnowContext *s, SubBand *b, DWTELEM *src, int stride, in } } +static void correlate_buffered(SnowContext *s, slice_buffer * sb, SubBand *b, DWTELEM *src, int stride, int inverse, int use_median){ + const int w= b->width; + const int h= b->height; + int x,y; + +// START_TIMER + + DWTELEM * line; + DWTELEM * prev; + + for(y=0; ystride_line) + b->buf_y_offset) + b->buf_x_offset; + for(x=0; xwidth; const int h= b->height; @@ -2640,13 +3188,22 @@ static int common_init(AVCodecContext *avctx){ b->width = (w + !(orientation&1))>>1; b->height= (h + !(orientation>1))>>1; - if(orientation&1) b->buf += (w+1)>>1; - if(orientation>1) b->buf += b->stride>>1; + b->stride_line = 1 << (s->spatial_decomposition_count - level); + b->buf_x_offset = 0; + b->buf_y_offset = 0; + + if(orientation&1){ + b->buf += (w+1)>>1; + b->buf_x_offset = (w+1)>>1; + } + if(orientation>1){ + b->buf += b->stride>>1; + b->buf_y_offset = b->stride_line >> 1; + } if(level) b->parent= &s->plane[plane_index].band[level-1][orientation]; - b->x = av_mallocz(((b->width+1) * b->height+1)*sizeof(int16_t)); - b->coeff= av_mallocz(((b->width+1) * b->height+1)*sizeof(DWTELEM)); + b->x_coeff=av_mallocz(((b->width+1) * b->height+1)*sizeof(x_and_coeff)); } w= (w+1)>>1; h= (h+1)>>1; @@ -2952,8 +3509,7 @@ static void common_end(SnowContext *s){ for(orientation=level ? 1 : 0; orientation<4; orientation++){ SubBand *b= &s->plane[plane_index].band[level][orientation]; - av_freep(&b->x); - av_freep(&b->coeff); + av_freep(&b->x_coeff); } } } @@ -2970,10 +3526,18 @@ static int encode_end(AVCodecContext *avctx) static int decode_init(AVCodecContext *avctx) { -// SnowContext *s = avctx->priv_data; + SnowContext *s = avctx->priv_data; + int block_size; common_init(avctx); + block_size = MB_SIZE >> s->block_max_depth; + /* FIXME block_size * 2 is determined empirically. block_size * 1.5 is definitely needed, but I (Robert) cannot figure out why more than that is needed. Perhaps there is a bug, or perhaps I overlooked some demands that are placed on the buffer. */ + /* FIXME The formula is WRONG. For height > 480, the buffer will overflow. */ + /* FIXME For now, I will use a full frame of lines. Fortunately, this should not materially effect cache performance because lines are allocated using a stack, so if in fact only 50 out of 496 lines are needed at a time, the other 446 will sit allocated but never accessed. */ +// slice_buffer_init(s->plane[0].sb, s->plane[0].height, (block_size * 2) + (s->spatial_decomposition_count * s->spatial_decomposition_count), s->plane[0].width, s->spatial_dwt_buffer); + slice_buffer_init(&s->sb, s->plane[0].height, s->plane[0].height, s->plane[0].width, s->spatial_dwt_buffer); + return 0; } @@ -3003,6 +3567,8 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8 int w= p->width; int h= p->height; int x, y; + int decode_state[MAX_DECOMPOSITIONS][4][1]; /* Stored state info for unpack_coeffs. 1 variable per instance. */ + SubBand * correlate_band; if(s->avctx->debug&2048){ memset(s->spatial_dwt_buffer, 0, sizeof(DWTELEM)*w*h); @@ -3015,18 +3581,22 @@ if(s->avctx->debug&2048){ } } } - for(level=0; levelspatial_decomposition_count; level++){ - for(orientation=level ? 1 : 0; orientation<4; orientation++){ - SubBand *b= &p->band[level][orientation]; - decode_subband(s, b, b->buf, b->parent ? b->parent->buf : NULL, b->stride, orientation); - if(orientation==0){ - correlate(s, b, b->buf, b->stride, 1, 0); - dequantize(s, b, b->buf, b->stride); - assert(b->buf == s->spatial_dwt_buffer); - } - } +{ START_TIMER + for(level=0; levelspatial_decomposition_count; level++){ + for(orientation=level ? 1 : 0; orientation<4; orientation++){ + SubBand *b= &p->band[level][orientation]; + unpack_coeffs(s, b, b->parent, orientation); } + } + STOP_TIMER("unpack coeffs"); +} + + /* Handle level 0, orientation 0 specially. It is particularly resistant to slicing but fortunately quite small, so process it in one pass. */ + correlate_band = &p->band[0][0]; + decode_subband_slice_buffered(s, correlate_band, &s->sb, 0, correlate_band->height, decode_state[0][0]); + correlate_buffered(s, &s->sb, correlate_band, correlate_band->buf, correlate_band->stride, 1, 0); + dequantize_buffered(s, &s->sb, correlate_band, correlate_band->buf, correlate_band->stride); {START_TIMER const int mb_h= s->b_height << s->block_max_depth; @@ -3035,23 +3605,68 @@ if(s->avctx->debug&2048){ int mb_y; dwt_compose_t cs[MAX_DECOMPOSITIONS]; int yd=0, yq=0; + int y; + int end_y; - ff_spatial_idwt_init(cs, s->spatial_dwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count); + ff_spatial_idwt_buffered_init(cs, &s->sb, w, h, 1, s->spatial_decomposition_type, s->spatial_decomposition_count); for(mb_y=0; mb_y<=mb_h; mb_y++){ + + const int slice_starty = block_w*mb_y; const int slice_h = block_w*(mb_y+1); - for(; ydspatial_dwt_buffer, w, h, w, s->spatial_decomposition_type, s->spatial_decomposition_count, yd); + { + START_TIMER + for(level=0; levelspatial_decomposition_count; level++){ + for(orientation=level ? 1 : 1; orientation<4; orientation++){ + SubBand *b= &p->band[level][orientation]; + int start_y; + int end_y; + int our_mb_start = mb_y; + int our_mb_end = (mb_y + 1); + start_y = FFMIN(b->height, (mb_y ? ((block_w * our_mb_start - 4) >> (s->spatial_decomposition_count - level)) + 5 : 0)); + end_y = FFMIN(b->height, (((block_w * our_mb_end - 4) >> (s->spatial_decomposition_count - level)) + 5)); + + if (start_y != end_y) + decode_subband_slice_buffered(s, b, &s->sb, start_y, end_y, decode_state[level][orientation]); + } + } + STOP_TIMER("decode_subband_slice"); + } + +{ START_TIMER + for(; ydsb, w, h, 1, s->spatial_decomposition_type, s->spatial_decomposition_count, yd); + } + STOP_TIMER("idwt slice");} + + if(s->qlog == LOSSLESS_QLOG){ for(; yqsb, yq); for(x=0; xspatial_dwt_buffer[yq*w + x]<<=FRAC_BITS; + line[x] <<= FRAC_BITS; } } } - predict_slice(s, s->spatial_dwt_buffer, plane_index, 1, mb_y); + predict_slice_buffered(s, &s->sb, s->spatial_dwt_buffer, plane_index, 1, mb_y); + + /* Nasty hack based empirically on how predict_slice_buffered() hits the buffer. */ + /* FIXME If possible, make predict_slice fit into the slice. As of now, it works on some previous lines (up to slice_height / 2) if the condition on the next line is false. */ + if (s->keyframe || (s->avctx->debug&512)){ + y = FFMIN(p->height, slice_starty); + end_y = FFMIN(p->height, slice_h); + } + else{ + y = FFMAX(0, FFMIN(p->height, slice_starty - (block_w >> 1))); + end_y = FFMAX(0, FFMIN(p->height, slice_h - (block_w >> 1))); + } + while(y < end_y) + slice_buffer_release(&s->sb, y++); } + + slice_buffer_flush(&s->sb); + STOP_TIMER("idwt + predict_slices")} } @@ -3077,6 +3692,8 @@ static int decode_end(AVCodecContext *avctx) { SnowContext *s = avctx->priv_data; + slice_buffer_destroy(&s->sb); + common_end(s); return 0;