[Ffmpeg-cvslog] CVS: ffmpeg/libavcodec snow.c, 1.68, 1.69 avcodec.h, 1.436, 1.437
Michael Niedermayer CVS
michael
Wed Dec 28 16:43:56 CET 2005
Update of /cvsroot/ffmpeg/ffmpeg/libavcodec
In directory mail:/var2/tmp/cvs-serv16368/libavcodec
Modified Files:
snow.c avcodec.h
Log Message:
iterative overlapped block based motion estimation for snow
Index: snow.c
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/libavcodec/snow.c,v
retrieving revision 1.68
retrieving revision 1.69
diff -u -d -r1.68 -r1.69
--- snow.c 22 Dec 2005 01:10:08 -0000 1.68
+++ snow.c 28 Dec 2005 15:43:53 -0000 1.69
@@ -383,10 +383,19 @@
uint8_t type;
//#define TYPE_SPLIT 1
#define BLOCK_INTRA 1
+#define BLOCK_OPT 2
//#define TYPE_NOCOLOR 4
uint8_t level; //FIXME merge into type?
}BlockNode;
+static const BlockNode null_block= { //FIXME add border maybe
+ .color= {128,128,128},
+ .mx= 0,
+ .my= 0,
+ .type= 0,
+ .level= 0,
+};
+
#define LOG2_MB_SIZE 4
#define MB_SIZE (1<<LOG2_MB_SIZE)
@@ -433,7 +442,8 @@
AVCodecContext *avctx;
RangeCoder c;
DSPContext dsp;
- AVFrame input_picture;
+ AVFrame new_picture;
+ AVFrame input_picture; ///< new_picture with the internal linesizes
AVFrame current_picture;
AVFrame last_picture;
AVFrame mconly_picture;
@@ -463,6 +473,9 @@
int block_max_depth;
Plane plane[MAX_PLANES];
BlockNode *block;
+#define ME_CACHE_SIZE 1024
+ int me_cache[ME_CACHE_SIZE];
+ int me_cache_generation;
slice_buffer sb;
MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to make the motion estimation eventually independant of MpegEncContext, so this will be removed then (FIXME/XXX)
@@ -479,6 +492,8 @@
#define slice_buffer_get_line(slice_buf, line_num) ((slice_buf)->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 iterative_me(SnowContext *s);
+
static void slice_buffer_init(slice_buffer * buf, int line_count, int max_allocated_lines, int line_width, DWTELEM * base_buffer)
{
int i;
@@ -2051,13 +2066,6 @@
const int rem_depth= s->block_max_depth - level;
const int index= (x + y*w) << rem_depth;
const int block_w= 1<<(LOG2_MB_SIZE - level);
- static BlockNode null_block= { //FIXME add border maybe
- .color= {128,128,128},
- .mx= 0,
- .my= 0,
- .type= 0,
- .level= 0,
- };
int trx= (x+1)<<rem_depth;
int try= (y+1)<<rem_depth;
BlockNode *left = x ? &s->block[index-1] : &null_block;
@@ -2072,16 +2080,12 @@
int pmx= mid_pred(left->mx, top->mx, tr->mx);
int pmy= mid_pred(left->my, top->my, tr->my);
int mx=0, my=0;
- int l,cr,cb, i;
+ int l,cr,cb;
const int stride= s->current_picture.linesize[0];
const int uvstride= s->current_picture.linesize[1];
- const int instride= s->input_picture.linesize[0];
- const int uvinstride= s->input_picture.linesize[1];
- uint8_t *new_l = s->input_picture.data[0] + (x + y* instride)*block_w;
- uint8_t *new_cb= s->input_picture.data[1] + (x + y*uvinstride)*block_w/2;
- uint8_t *new_cr= s->input_picture.data[2] + (x + y*uvinstride)*block_w/2;
- uint8_t current_mb[3][stride*block_w];
- uint8_t *current_data[3]= {¤t_mb[0][0], ¤t_mb[1][0], ¤t_mb[2][0]};
+ uint8_t *current_data[3]= { s->input_picture.data[0] + (x + y* stride)*block_w,
+ s->input_picture.data[1] + (x + y*uvstride)*block_w/2,
+ s->input_picture.data[2] + (x + y*uvstride)*block_w/2};
int P[10][2];
int16_t last_mv[3][2];
int qpel= !!(s->avctx->flags & CODEC_FLAG_QPEL); //unused
@@ -2097,14 +2101,6 @@
return 0;
}
- //FIXME optimize
- for(i=0; i<block_w; i++)
- memcpy(¤t_mb[0][0] + stride*i, new_l + instride*i, block_w);
- for(i=0; i<block_w>>1; i++)
- memcpy(¤t_mb[1][0] + uvstride*i, new_cb + uvinstride*i, block_w>>1);
- for(i=0; i<block_w>>1; i++)
- memcpy(¤t_mb[2][0] + uvstride*i, new_cr + uvinstride*i, block_w>>1);
-
// clip predictors / edge ?
P_LEFT[0]= left->mx;
@@ -2190,15 +2186,15 @@
))>>FF_LAMBDA_SHIFT;
block_s= block_w*block_w;
- sum = pix_sum(¤t_mb[0][0], stride, block_w);
+ sum = pix_sum(current_data[0], stride, block_w);
l= (sum + block_s/2)/block_s;
- iscore = pix_norm1(¤t_mb[0][0], stride, block_w) - 2*l*sum + l*l*block_s;
+ iscore = pix_norm1(current_data[0], stride, block_w) - 2*l*sum + l*l*block_s;
block_s= block_w*block_w>>2;
- sum = pix_sum(¤t_mb[1][0], uvstride, block_w>>1);
+ sum = pix_sum(current_data[1], uvstride, block_w>>1);
cb= (sum + block_s/2)/block_s;
// iscore += pix_norm1(¤t_mb[1][0], uvstride, block_w>>1) - 2*cb*sum + cb*cb*block_s;
- sum = pix_sum(¤t_mb[2][0], uvstride, block_w>>1);
+ sum = pix_sum(current_data[2], uvstride, block_w>>1);
cr= (sum + block_s/2)/block_s;
// iscore += pix_norm1(¤t_mb[2][0], uvstride, block_w>>1) - 2*cr*sum + cr*cr*block_s;
@@ -2264,17 +2260,68 @@
}
}
+static always_inline int same_block(BlockNode *a, BlockNode *b){
+ if((a->type&BLOCK_INTRA) && (b->type&BLOCK_INTRA)){
+ return !((a->color[0] - b->color[0]) | (a->color[1] - b->color[1]) | (a->color[2] - b->color[2]));
+ }else{
+ return !((a->mx - b->mx) | (a->my - b->my) | ((a->type ^ b->type)&BLOCK_INTRA));
+ }
+}
+
+static void encode_q_branch2(SnowContext *s, int level, int x, int y){
+ const int w= s->b_width << s->block_max_depth;
+ const int rem_depth= s->block_max_depth - level;
+ const int index= (x + y*w) << rem_depth;
+ int trx= (x+1)<<rem_depth;
+ BlockNode *b= &s->block[index];
+ BlockNode *left = x ? &s->block[index-1] : &null_block;
+ BlockNode *top = y ? &s->block[index-w] : &null_block;
+ BlockNode *tl = y && x ? &s->block[index-w-1] : left;
+ BlockNode *tr = y && trx<w && ((x&1)==0 || level==0) ? &s->block[index-w+(1<<rem_depth)] : tl; //FIXME use lt
+ int pl = left->color[0];
+ int pcb= left->color[1];
+ int pcr= left->color[2];
+ int pmx= mid_pred(left->mx, top->mx, tr->mx);
+ int pmy= mid_pred(left->my, top->my, tr->my);
+ int mx_context= av_log2(2*ABS(left->mx - top->mx));
+ int my_context= av_log2(2*ABS(left->my - top->my));
+ int s_context= 2*left->level + 2*top->level + tl->level + tr->level;
+
+ if(s->keyframe){
+ set_blocks(s, level, x, y, pl, pcb, pcr, pmx, pmy, BLOCK_INTRA);
+ return;
+ }
+
+ if(level!=s->block_max_depth){
+ if(same_block(b,b+1) && same_block(b,b+w) && same_block(b,b+w+1)){
+ put_rac(&s->c, &s->block_state[4 + s_context], 0);
+ encode_q_branch2(s, level+1, 2*x+0, 2*y+0);
+ encode_q_branch2(s, level+1, 2*x+1, 2*y+0);
+ encode_q_branch2(s, level+1, 2*x+0, 2*y+1);
+ encode_q_branch2(s, level+1, 2*x+1, 2*y+1);
+ return;
+ }else{
+ put_rac(&s->c, &s->block_state[4 + s_context], 1);
+ }
+ }
+ if(b->type & BLOCK_INTRA){
+ put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 1);
+ put_symbol(&s->c, &s->block_state[32], b->color[0]-pl , 1);
+ put_symbol(&s->c, &s->block_state[64], b->color[1]-pcb, 1);
+ put_symbol(&s->c, &s->block_state[96], b->color[2]-pcr, 1);
+ set_blocks(s, level, x, y, b->color[0], b->color[1], b->color[2], pmx, pmy, BLOCK_INTRA);
+ }else{
+ put_rac(&s->c, &s->block_state[1 + (left->type&1) + (top->type&1)], 0);
+ put_symbol(&s->c, &s->block_state[128 + 32*mx_context], b->mx - pmx, 1);
+ put_symbol(&s->c, &s->block_state[128 + 32*my_context], b->my - pmy, 1);
+ set_blocks(s, level, x, y, pl, pcb, pcr, b->mx, b->my, 0);
+ }
+}
+
static void decode_q_branch(SnowContext *s, int level, int x, int y){
const int w= s->b_width << s->block_max_depth;
const int rem_depth= s->block_max_depth - level;
const int index= (x + y*w) << rem_depth;
- static BlockNode null_block= { //FIXME add border maybe
- .color= {128,128,128},
- .mx= 0,
- .my= 0,
- .type= 0,
- .level= 0,
- };
int trx= (x+1)<<rem_depth;
BlockNode *left = x ? &s->block[index-1] : &null_block;
BlockNode *top = y ? &s->block[index-w] : &null_block;
@@ -2321,13 +2368,19 @@
int w= s->b_width;
int h= s->b_height;
+ if(s->avctx->me_method == ME_ITER && !s->keyframe)
+ iterative_me(s);
+
for(y=0; y<h; y++){
if(s->c.bytestream_end - s->c.bytestream < w*MB_SIZE*MB_SIZE*3){ //FIXME nicer limit
av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
return;
}
for(x=0; x<w; x++){
- encode_q_branch(s, 0, x, y);
+ if(s->avctx->me_method == ME_ITER)
+ encode_q_branch2(s, 0, x, y);
+ else
+ encode_q_branch (s, 0, x, y);
}
}
}
@@ -2430,7 +2483,7 @@
mca( 8, 8,8)
static void pred_block(SnowContext *s, uint8_t *dst, uint8_t *src, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h){
- if(block->type){
+ if(block->type & BLOCK_INTRA){
int x, y;
const int color= block->color[plane_index];
for(y=0; y < b_h; y++){
@@ -2459,10 +2512,6 @@
}
}
-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;
@@ -2847,7 +2896,7 @@
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;
+ const 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];
@@ -2904,6 +2953,278 @@
predict_slice(s, buf, plane_index, add, mb_y);
}
+static int get_dc(SnowContext *s, int mb_x, int mb_y, int plane_index){
+ int i, x2, y2;
+ Plane *p= &s->plane[plane_index];
+ const int block_size = MB_SIZE >> s->block_max_depth;
+ const 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];
+ const int obmc_stride= plane_index ? block_size : 2*block_size;
+ const int ref_stride= s->current_picture.linesize[plane_index];
+ uint8_t *ref= s-> last_picture.data[plane_index];
+ uint8_t *dst= s->current_picture.data[plane_index];
+ uint8_t *src= s-> input_picture.data[plane_index];
+ const static DWTELEM zero_dst[4096]; //FIXME
+ const int b_stride = s->b_width << s->block_max_depth;
+ const int w= p->width;
+ const int h= p->height;
+ int index= mb_x + mb_y*b_stride;
+ BlockNode *b= &s->block[index];
+ BlockNode backup= *b;
+ int ab=0;
+ int aa=0;
+
+ b->type|= BLOCK_INTRA;
+ b->color[plane_index]= 0;
+
+ for(i=0; i<4; i++){
+ int mb_x2= mb_x + (i &1) - 1;
+ int mb_y2= mb_y + (i>>1) - 1;
+ int x= block_w*mb_x2 + block_w/2;
+ int y= block_w*mb_y2 + block_w/2;
+
+ add_yblock(s, zero_dst, dst, ref, obmc,
+ x, y, block_w, block_w, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, plane_index);
+
+ for(y2= FFMAX(y, 0); y2<FFMIN(h, y+block_w); y2++){
+ for(x2= FFMAX(x, 0); x2<FFMIN(w, x+block_w); x2++){
+ int index= x2-(block_w*mb_x - block_w/2) + (y2-(block_w*mb_y - block_w/2))*obmc_stride;
+ int obmc_v= obmc[index];
+ if(y<0) obmc_v += obmc[index + block_w*obmc_stride];
+ if(x<0) obmc_v += obmc[index + block_w];
+ if(y+block_w>h) obmc_v += obmc[index - block_w*obmc_stride];
+ if(x+block_w>w) obmc_v += obmc[index - block_w];
+ //FIXME precalc this or simplify it somehow else
+
+ ab += (src[x2 + y2*ref_stride] - dst[x2 + y2*ref_stride]) * obmc_v;
+ aa += obmc_v * obmc_v; //FIXME precalclate this
+ }
+ }
+ }
+ *b= backup;
+
+ return clip(((ab<<6) + aa/2)/aa, 0, 255); //FIXME we shouldnt need cliping
+}
+
+static int get_block_rd(SnowContext *s, int mb_x, int mb_y, int plane_index){
+ int i, y2;
+ Plane *p= &s->plane[plane_index];
+ const int block_size = MB_SIZE >> s->block_max_depth;
+ const 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];
+ const int obmc_stride= plane_index ? block_size : 2*block_size;
+ const int ref_stride= s->current_picture.linesize[plane_index];
+ uint8_t *ref= s-> last_picture.data[plane_index];
+ uint8_t *dst= s->current_picture.data[plane_index];
+ uint8_t *src= s-> input_picture.data[plane_index];
+ const static DWTELEM zero_dst[4096]; //FIXME
+ const int b_stride = s->b_width << s->block_max_depth;
+ const int b_height = s->b_height<< s->block_max_depth;
+ const int w= p->width;
+ const int h= p->height;
+ int distortion= 0;
+ int rate= 0;
+ const int penalty_factor= get_penalty_factor(s->lambda, s->lambda2, s->avctx->me_cmp);
+
+ for(i=0; i<4; i++){
+ int mb_x2= mb_x + (i &1) - 1;
+ int mb_y2= mb_y + (i>>1) - 1;
+ int x= block_w*mb_x2 + block_w/2;
+ int y= block_w*mb_y2 + block_w/2;
+
+ add_yblock(s, zero_dst, dst, ref, obmc,
+ x, y, block_w, block_w, w, h, /*dst_stride*/0, ref_stride, obmc_stride, mb_x2, mb_y2, 1, plane_index);
+
+ //FIXME find a cleaner/simpler way to skip the outside stuff
+ for(y2= y; y2<0; y2++)
+ memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
+ for(y2= h; y2<y+block_w; y2++)
+ memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, block_w);
+ if(x<0){
+ for(y2= y; y2<y+block_w; y2++)
+ memcpy(dst + x + y2*ref_stride, src + x + y2*ref_stride, -x);
+ }
+ if(x+block_w > w){
+ for(y2= y; y2<y+block_w; y2++)
+ memcpy(dst + w + y2*ref_stride, src + w + y2*ref_stride, x+block_w - w);
+ }
+
+ assert(block_w== 8 || block_w==16);
+ distortion += s->dsp.me_cmp[block_w==8](&s->m, src + x + y*ref_stride, dst + x + y*ref_stride, ref_stride, block_w);
+ }
+
+ if(plane_index==0){
+ for(i=0; i<4; i++){
+/* ..RRr
+ * .RXx.
+ * rxx..
+ */
+ int x= mb_x + (i&1) - (i>>1);
+ int y= mb_y + (i>>1);
+ int index= x + y*b_stride;
+ BlockNode *b = &s->block[index];
+ BlockNode *left = x ? &s->block[index-1] : &null_block;
+ BlockNode *top = y ? &s->block[index-b_stride] : &null_block;
+ BlockNode *tl = y && x ? &s->block[index-b_stride-1] : left;
+ BlockNode *tr = y && x+1<b_stride ? &s->block[index-b_stride+1] : tl;
+ int dmx= b->mx - mid_pred(left->mx, top->mx, tr->mx);
+ int dmy= b->my - mid_pred(left->my, top->my, tr->my);
+// int mx_context= av_log2(2*ABS(left->mx - top->mx));
+// int my_context= av_log2(2*ABS(left->my - top->my));
+
+ if(x<0 || x>=b_stride || y>=b_height)
+ continue;
+/*
+1 0 0
+01X 1-2 1
+001XX 3-6 2-3
+0001XXX 7-14 4-7
+00001XXXX 15-30 8-15
+*/
+//FIXME try accurate rate
+//FIXME intra and inter predictors if surrounding blocks arent the same type
+ if(b->type & BLOCK_INTRA){
+ rate += 3+2*( av_log2(2*ABS(left->color[0] - b->color[0]))
+ + av_log2(2*ABS(left->color[1] - b->color[1]))
+ + av_log2(2*ABS(left->color[2] - b->color[2])));
+ }else
+ rate += 2*(1 + av_log2(2*ABS(dmx))
+ + av_log2(2*ABS(dmy))); //FIXME kill the 2* can be merged in lambda
+ }
+ }
+
+ return distortion + rate*penalty_factor;
+}
+
+static always_inline int check_block(SnowContext *s, int mb_x, int mb_y, int p[3], int intra, int *best_rd){
+ const int b_stride= s->b_width << s->block_max_depth;
+ BlockNode *block= &s->block[mb_x + mb_y * b_stride];
+ BlockNode backup= *block;
+ int rd, index, value;
+
+ assert(mb_x>=0 && mb_y>=0);
+ assert(mb_y<b_stride);
+
+ if(intra){
+ block->color[0] = p[0];
+ block->color[1] = p[1];
+ block->color[2] = p[2];
+ block->type |= BLOCK_INTRA;
+ }else{
+ index= (p[0] + 31*p[1]) & (ME_CACHE_SIZE-1);
+ value= s->me_cache_generation + (p[0]>>10) + (p[1]<<6);
+ if(s->me_cache[index] == value)
+ return 0;
+ s->me_cache[index]= value;
+
+ block->mx= p[0];
+ block->my= p[1];
+ block->type &= ~BLOCK_INTRA;
+ }
+
+ rd= get_block_rd(s, mb_x, mb_y, 0);
+
+//FIXME chroma
+ if(rd < *best_rd){
+ *best_rd= rd;
+ return 1;
+ }else{
+ *block= backup;
+ return 0;
+ }
+}
+
+static void iterative_me(SnowContext *s){
+ int pass, mb_x, mb_y;
+ 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;
+ int color[3];
+
+ for(pass=0; pass<50; pass++){
+ int change= 0;
+
+ for(mb_y= 0; mb_y<b_height; mb_y++){
+ for(mb_x= 0; mb_x<b_width; mb_x++){
+ int dia_change, i, j;
+ int best_rd= INT_MAX;
+ BlockNode backup;
+ const int index= mb_x + mb_y * b_stride;
+ BlockNode *block= &s->block[index];
+ BlockNode *tb = mb_y ? &s->block[index-b_stride ] : &null_block;
+ BlockNode *lb = mb_x ? &s->block[index -1] : &null_block;
+ BlockNode *rb = mb_x<b_width ? &s->block[index +1] : &null_block;
+ BlockNode *bb = mb_y<b_height ? &s->block[index+b_stride ] : &null_block;
+ BlockNode *tlb= mb_x && mb_y ? &s->block[index-b_stride-1] : &null_block;
+ BlockNode *trb= mb_x<b_width && mb_y ? &s->block[index-b_stride+1] : &null_block;
+ BlockNode *blb= mb_x && mb_y<b_height ? &s->block[index+b_stride-1] : &null_block;
+ BlockNode *brb= mb_x<b_width && mb_y<b_height ? &s->block[index+b_stride+1] : &null_block;
+
+ if(pass && (block->type & BLOCK_OPT))
+ continue;
+ block->type |= BLOCK_OPT;
+
+ backup= *block;
+
+ if(!s->me_cache_generation)
+ memset(s->me_cache, 0, sizeof(s->me_cache));
+ s->me_cache_generation += 1<<22;
+
+ // get previous score (cant be cached due to OBMC)
+ check_block(s, mb_x, mb_y, (int[2]){block->mx, block->my}, 0, &best_rd);
+ check_block(s, mb_x, mb_y, (int[2]){0, 0}, 0, &best_rd);
+ check_block(s, mb_x, mb_y, (int[2]){tb->mx, tb->my}, 0, &best_rd);
+ check_block(s, mb_x, mb_y, (int[2]){lb->mx, lb->my}, 0, &best_rd);
+ check_block(s, mb_x, mb_y, (int[2]){rb->mx, rb->my}, 0, &best_rd);
+ check_block(s, mb_x, mb_y, (int[2]){bb->mx, bb->my}, 0, &best_rd);
+
+ /* fullpel ME */
+ //FIXME avoid subpel interpol / round to nearest integer
+ do{
+ dia_change=0;
+ for(i=0; i<FFMAX(s->avctx->dia_size, 1); i++){
+ for(j=0; j<i; j++){
+ dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx+4*(i-j), block->my+(4*j)}, 0, &best_rd);
+ dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx-4*(i-j), block->my-(4*j)}, 0, &best_rd);
+ dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx+4*(i-j), block->my-(4*j)}, 0, &best_rd);
+ dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx-4*(i-j), block->my+(4*j)}, 0, &best_rd);
+ }
+ }
+ }while(dia_change);
+ /* subpel ME */
+ do{
+ static const int square[8][2]= {{+1, 0},{-1, 0},{ 0,+1},{ 0,-1},{+1,+1},{-1,-1},{+1,-1},{-1,+1},};
+ dia_change=0;
+ for(i=0; i<8; i++)
+ dia_change |= check_block(s, mb_x, mb_y, (int[2]){block->mx+square[i][0], block->my+square[i][1]}, 0, &best_rd);
+ }while(dia_change);
+ //FIXME or try the standard 2 pass qpel or similar
+
+ for(i=0; i<3; i++){
+ color[i]= get_dc(s, mb_x, mb_y, i);
+ }
+ check_block(s, mb_x, mb_y, color, 1, &best_rd);
+ //FIXME RD style color selection
+
+ if(!same_block(block, &backup)){
+ if(tb != &null_block) tb ->type &= ~BLOCK_OPT;
+ if(lb != &null_block) lb ->type &= ~BLOCK_OPT;
+ if(rb != &null_block) rb ->type &= ~BLOCK_OPT;
+ if(bb != &null_block) bb ->type &= ~BLOCK_OPT;
+ if(tlb!= &null_block) tlb->type &= ~BLOCK_OPT;
+ if(trb!= &null_block) trb->type &= ~BLOCK_OPT;
+ if(blb!= &null_block) blb->type &= ~BLOCK_OPT;
+ if(brb!= &null_block) brb->type &= ~BLOCK_OPT;
+ change ++;
+ }
+ }
+ }
+ av_log(NULL, AV_LOG_ERROR, "pass:%d changed:%d\n", pass, change);
+ if(!change)
+ break;
+ }
+}
+
static void quantize(SnowContext *s, SubBand *b, DWTELEM *src, int stride, int bias){
const int level= b->level;
const int w= b->width;
@@ -3412,6 +3733,12 @@
// avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
s->chroma_h_shift= 1;
s->chroma_v_shift= 1;
+
+ ff_set_cmp(&s->dsp, s->dsp.me_cmp, s->avctx->me_cmp);
+ ff_set_cmp(&s->dsp, s->dsp.me_sub_cmp, s->avctx->me_sub_cmp);
+
+ s->avctx->get_buffer(s->avctx, &s->input_picture);
+
return 0;
}
@@ -3445,12 +3772,19 @@
AVFrame *pict = data;
const int width= s->avctx->width;
const int height= s->avctx->height;
- int level, orientation, plane_index;
+ int level, orientation, plane_index, i, y;
ff_init_range_encoder(c, buf, buf_size);
ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
- s->input_picture = *pict;
+ for(i=0; i<3; i++){
+ int shift= !!i;
+ for(y=0; y<(height>>shift); y++)
+ memcpy(&s->input_picture.data[i][y * s->input_picture.linesize[i]],
+ &pict->data[i][y * pict->linesize[i]],
+ width>>shift);
+ }
+ s->new_picture = *pict;
if(avctx->flags&CODEC_FLAG_PASS2){
s->m.pict_type =
@@ -3514,6 +3848,7 @@
s->m.dsp= s->dsp; //move
ff_init_me(&s->m);
+ s->dsp= s->m.dsp;
}
redo_frame:
Index: avcodec.h
===================================================================
RCS file: /cvsroot/ffmpeg/ffmpeg/libavcodec/avcodec.h,v
retrieving revision 1.436
retrieving revision 1.437
diff -u -d -r1.436 -r1.437
--- avcodec.h 25 Dec 2005 18:34:02 -0000 1.436
+++ avcodec.h 28 Dec 2005 15:43:53 -0000 1.437
@@ -289,7 +289,10 @@
ME_LOG,
ME_PHODS,
ME_EPZS,
- ME_X1
+ ME_X1,
+ ME_HEX,
+ ME_UMH,
+ ME_ITER,
};
enum AVDiscard{
More information about the ffmpeg-cvslog
mailing list