- 浏览: 1186837 次
文章分类
最新评论
-
你不懂的温柔:
楼主是好人
H264学习指南 -
18215361994:
谢谢,您能够给我们总结这么多,我们会为了自己的目标加油的, ...
新东方老师谈如何学英语 -
beyondsoros_king:
testerlixieinstein 写道结果就是11,编译不 ...
揪心的JAVA面试题 -
buptwhisper:
其实这个也好弄清楚的,你在每一个可能的地方打上断点,然后deb ...
揪心的JAVA面试题 -
wmswu:
这种类型的面试题 还真不少啊.......
揪心的JAVA面试题
h264快速运动估计算法
#include "stdio.h"
#include "stdlib.h"
#include "malloc.h"
#include "string.h"
#include "sys/timeb.h"
#include "math.h"
#include "inf.h"
#define MIN(a,b) ((a)<(b))?(a):(b);
#define MAX(a,b) ((a)>(b))?(a):(b);
int SAD(const int ox,const int oy,const int dx,const int dy,const int height,const int width,uint32 &best_sad)
{
const int rx=ox+dx,ry=oy+dy;
if( abs(dx)>MAX_MOTION || abs(dy)>MAX_MOTION || flag_search[dx][dy]>0 )
return 0;
if( rx<0 || ry<0 || rx+height>XX || ry+width>YY )
return 0;
uint32 sad=0;
frame_info.frame_pot++;
const uint8 *p1=¤t_frame[ox][oy],*p2=&ref_frame[rx][ry];
for(int i=0;i<height;i++)
{
for(int j=0;j<width;j++)
{
sad+=abs(*(p1++)-*(p2++));
}
p1+=(YY-width);p2+=(YY-width);
}
flag_search[dx][dy]=1+sad;
if(sad>=best_sad)
return 0;
best_sad=sad;
return 1;
}
void rebuilt(const int x,const int y,const int height,const int width)
{
const int dx=frame_info.mv[x][y].dx,dy=frame_info.mv[x][y].dy;
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int rx=ox+dx,ry=oy+dy;
int tmp;
const uint8 *p1=¤t_frame[ox][oy],*p2=&ref_frame[rx][ry];
if( abs(dx)>MAX_MOTION || abs(dy)>MAX_MOTION )
exit(0);
if( rx<0 || ry<0 || rx+height>XX || ry+width>YY )
exit(0);
for(int i=0;i<height;i++)
{
for(int j=0;j<width;j++)
{
tmp=*(p1++)-*(p2++);
frame_info.frame_sse+=tmp*tmp;
}
p1+=(YY-width);p2+=(YY-width);
}
}
void search_FS(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
uint32 sad=0xffffff;
MV mv;
for(int i=-MAX_MOTION;i<=MAX_MOTION;i++)
{
for(int j=-MAX_MOTION;j<=MAX_MOTION;j++)
{
if(SAD(ox,oy,i,j,heigth,width,sad)==1)
{
mv.dx=i;mv.dy=j;
}
}
}
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
#define PATTERN_SEARCH(pattern,num,flag) /
do/
{/
mvx=mv.dx;mvy=mv.dy;/
for(int i=0;i<num;i++)/
{/
if(SAD(ox,oy,mvx+pattern[i][0],mvy+pattern[i][1],heigth,width,sad)==1)/
{/
mv.dx=mvx+pattern[i][0];mv.dy=mvy+pattern[i][1];/
}/
}/
}while ( (mv.dx!=mvx || mv.dy!=mvy) && flag==1 );
void search_4SS(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int L4SS[9][2]={{0,0},{0,2},{-2,2},{-2,0},{-2,-2},{0,-2},{2,-2},{2,0},{2,2}};
const int S4SS[9][2]={{0,0},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1},{1,0},{1,1}};
uint32 sad=0xffffff;
MV mv={0,0};int mvx,mvy;
PATTERN_SEARCH(L4SS,9,1)
PATTERN_SEARCH(S4SS,9,0)
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
void search_BBGDS(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int BBGDS[9][2]={{0,0},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1},{1,0},{1,1}};
uint32 sad=0xffffff;
MV mv={0,0};int mvx,mvy;
PATTERN_SEARCH(BBGDS,9,1)
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
void search_DS(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int LDS[9][2]={{0,0},{0,2},{-1,1},{-2,0},{-1,-1},{0,-2},{1,-1},{2,0},{1,1}};
const int SDS[5][2]={{0,0},{0,1},{-1,0},{0,-1},{1,0}};
uint32 sad=0xffffff;
MV mv={0,0};int mvx,mvy;
PATTERN_SEARCH(LDS,9,1)
PATTERN_SEARCH(SDS,5,0)
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
void search_HS(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int LHS[7][2]={{0,0},{0,2},{-2,1},{-2,-1},{0,-2},{2,-1},{2,1}};
const int SHS[9][2]={{0,0},{0,1},{-1,0},{0,-1},{1,0},{1,1},{1,-1},{-1,1},{-1,-1}};
uint32 sad=0xffffff;
MV mv={0,0};int mvx,mvy;
PATTERN_SEARCH(LHS,7,1)
PATTERN_SEARCH(SHS,9,0)
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
#define CHECK_ONE_PIXEL(i,j) /
if(SAD(ox,oy,i,j,heigth,width,sad)==1)/
{/
mv.dx=i;mv.dy=j;/
}
int x264_median( int a, int b, int c=0 )
{
int min = a, max =a;
if( b < min )
min = b;
else
max = b;
if( c < min )
min = c;
else if( c > max )
max = c;
return a + b + c - min - max;
}
//获取常用的预测运动矢量列表
void Get_MVp(const int x,const int y,MV *pre_mv,int &mvx,int &mvy,uint32 *sad=NULL)
{
uint32 num[10];if(sad==NULL) sad=num;
if(y>0)
{
pre_mv[0]=frame_info.mv[x][y-1];
sad[0]=frame_info.sad[x][y-1];
}
else
{
pre_mv[0].dx=pre_mv[0].dy=0;
sad[0]=0;
}
if(x>0)
{
pre_mv[1]=frame_info.mv[x-1][y];
sad[1]=frame_info.sad[x-1][y];
}
else
{
pre_mv[1].dx=pre_mv[1].dy=0;
sad[1]=0;
}
if(x>0 && y<Y-1)
{
pre_mv[2]=frame_info.mv[x-1][y+1];
sad[2]=frame_info.sad[x-1][y+1];
}
else if(x>0)
{
pre_mv[2]=frame_info.mv[x-1][y-1];
sad[2]=frame_info.sad[x-1][y-1];
}
else
{
pre_mv[2].dx=pre_mv[2].dy=0;
sad[2]=0;
}
if(x>0&&y>0)
{
pre_mv[3]=frame_info.mv[x-1][y-1];
sad[3]=frame_info.sad[x-1][y-1];
}
else
{
pre_mv[3].dx=pre_mv[3].dy=0;
sad[3]=0;
}
pre_mv[4]=frame_info.prev_mv[x][y];
sad[4]=frame_info.prev_sad[x][y];
pre_mv[5].dx=2*frame_info.prev_mv[x][y].dx-frame_info.mv[x][y].dx;
pre_mv[5].dy=2*frame_info.prev_mv[x][y].dy-frame_info.mv[x][y].dy;
if(x==0)
{
mvx=pre_mv[0].dx;
mvy=pre_mv[0].dy;
return;
}
mvx=x264_median(pre_mv[0].dx,pre_mv[1].dx,pre_mv[2].dx);
mvy=x264_median(pre_mv[0].dy,pre_mv[1].dy,pre_mv[2].dy);
}
void search_ARPS(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int SCS[5][2]={{0,0},{0,1},{-1,0},{0,-1},{1,0}};
uint32 sad=0xffffff;
MV mv={0,0},pre_mv[10];int mvx,mvy;
const uint32 T=512;
CHECK_ONE_PIXEL(0,0)
if(sad<T) goto END;
{
Get_MVp(x,y,pre_mv,mvx,mvy);
int Length=abs(pre_mv[0].dx)>abs(pre_mv[0].dy)?abs(pre_mv[0].dx):abs(pre_mv[0].dy);
CHECK_ONE_PIXEL(mvx,mvy)
CHECK_ONE_PIXEL( Length,0)
CHECK_ONE_PIXEL(-Length,0)
CHECK_ONE_PIXEL(0, Length)
CHECK_ONE_PIXEL(0,-Length)
}
PATTERN_SEARCH(SCS,5,1)
END:
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
void search_ARPS3(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int SCS[5][2]={{0,0},{0,1},{-1,0},{0,-1},{1,0}};
uint32 sad=0xffffff;
MV mv={0,0},pre_mv[10];int mvx,mvy;
const uint32 T=512;
CHECK_ONE_PIXEL(0,0)
if(sad<T) goto END;
{
Get_MVp(x,y,pre_mv,mvx,mvy);
int max_x=MAX(pre_mv[0].dx,pre_mv[1].dx);max_x=MAX(max_x,pre_mv[2].dx)max_x=MAX(max_x,pre_mv[3].dx);
int max_y=MAX(pre_mv[0].dy,pre_mv[1].dy);max_y=MAX(max_y,pre_mv[2].dy)max_y=MAX(max_y,pre_mv[3].dy);
int min_x=MIN(pre_mv[0].dx,pre_mv[1].dx);min_x=MIN(min_x,pre_mv[2].dx)min_x=MIN(min_x,pre_mv[3].dx);
int min_y=MIN(pre_mv[0].dy,pre_mv[1].dy);min_y=MIN(min_y,pre_mv[2].dy)min_y=MIN(min_y,pre_mv[3].dy);
CHECK_ONE_PIXEL(mvx,mvy)
CHECK_ONE_PIXEL( max_x,mvy)
CHECK_ONE_PIXEL( min_x,mvy)
CHECK_ONE_PIXEL( mvx,max_y)
CHECK_ONE_PIXEL( mvx,min_y)
}
PATTERN_SEARCH(SCS,5,1)
END:
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
int Get_Mv_Length(int x,int y,MV *pre_mv,int mvx=0,int mvy=0)
{
if(x==0&&y==0)
return 2;
int L=0,num;
num=abs(pre_mv[0].dx-mvx)+abs(pre_mv[0].dy-mvy);
if(L<num)L=num;
num=abs(pre_mv[1].dx-mvx)+abs(pre_mv[1].dy-mvy);
if(L<num)L=num;
num=abs(pre_mv[2].dx-mvx)+abs(pre_mv[2].dy-mvy);
if(L<num)L=num;
return L;
}
void search_MVFAST(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int LDS[9][2]={{0,0},{0,2},{-1,1},{-2,0},{-1,-1},{0,-2},{1,-1},{2,0},{1,1}};
const int SDS[5][2]={{0,0},{0,1},{-1,0},{0,-1},{1,0}};
uint32 sad=0xffffff;
MV mv={0,0},pre_mv[10];int mvx,mvy;
const uint32 T=512,L1=1,L2=2;
CHECK_ONE_PIXEL(0,0)
if(sad<T) goto END;
{
Get_MVp(x,y,pre_mv,mvx,mvy);
int L=Get_Mv_Length(x,y,pre_mv);
if(L<=L1)goto SMALL_SEARCH;
if(L>L2)
{
// CHECK_ONE_PIXEL(mvx,mvy)
CHECK_ONE_PIXEL(pre_mv[0].dx,pre_mv[0].dy)
CHECK_ONE_PIXEL(pre_mv[1].dx,pre_mv[1].dy)
CHECK_ONE_PIXEL(pre_mv[2].dx,pre_mv[2].dy)
goto SMALL_SEARCH;
}
}
PATTERN_SEARCH(LDS,9,1)
SMALL_SEARCH:
PATTERN_SEARCH(SDS,5,1)
END:
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
int equal_mv(MV mv1,MV mv2)
{
if(mv1.dx==mv2.dx && mv1.dy==mv2.dy)
return 1;
else
return 0;
}
void search_PMVFAST(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int LDS[9][2]={{0,0},{0,2},{-1,1},{-2,0},{-1,-1},{0,-2},{1,-1},{2,0},{1,1}};
const int SDS[5][2]={{0,0},{0,1},{-1,0},{0,-1},{1,0}};
uint32 sad=0xffffff;
MV mv={0,0},pre_mv[10];int mvx,mvy;
int thresa=512,thresb=1024,Found=0,PredEq=0;
if(x>0 && y>0)
{
thresa=MIN(frame_info.sad[x-1][y],frame_info.sad[x][y-1]);
thresa=MIN(thresa,frame_info.sad[x-1][y+1]);
thresb=thresa+256;
if(thresa<512) thresa=512;
if(thresa>1024)thresa=1024;
if(thresb>1792)thresb=1792;
}
Get_MVp(x,y,pre_mv,mvx,mvy);
if(x>0 && equal_mv(pre_mv[0],pre_mv[1]) && equal_mv(pre_mv[0],pre_mv[2]) )
PredEq=1;
int Distance=abs(mvx)+abs(mvy);
if( PredEq==1 && mvx==pre_mv[4].dx && mvy==pre_mv[4].dy )
Found=2;
CHECK_ONE_PIXEL(mvx,mvy)
if( equal_mv(mv,pre_mv[4]) && sad<frame_info.prev_sad[x][y] )
goto END;
if(sad<256)
goto END;
CHECK_ONE_PIXEL(0,0)
CHECK_ONE_PIXEL(pre_mv[0].dx,pre_mv[0].dy)
CHECK_ONE_PIXEL(pre_mv[1].dx,pre_mv[1].dy)
CHECK_ONE_PIXEL(pre_mv[2].dx,pre_mv[2].dy)
CHECK_ONE_PIXEL(pre_mv[4].dx,pre_mv[4].dy)
if(sad<thresa)
goto END;
if( equal_mv(mv,pre_mv[4]) && sad<frame_info.prev_sad[x][y] )
goto END;
if( Distance>0 || thresb<1536 || PredEq==1 )
goto SMALL_SEARCH;
PATTERN_SEARCH(LDS,9,Found!=2)
SMALL_SEARCH:
PATTERN_SEARCH(SDS,5,Found!=2)
END:
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
void search_CDHS(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int LCS[9][2]={{0,0},{0,1},{-1,0},{0,-1},{1,0},{0,2},{-2,0},{0,-2},{2,0}};
const int LDS[9][2]={{0,0},{0,2},{-1,1},{-2,0},{-1,-1},{0,-2},{1,-1},{2,0},{1,1}};
const int SDS[5][2]={{0,0},{0,1},{-1,0},{0,-1},{1,0}};
const int HHS[7][2]={{0,0},{0,2},{0,-2},{1,1},{1,-1},{-1,1},{-1,-1}};
const int VHS[7][2]={{0,0},{2,0},{-2,0},{1,1},{1,-1},{-1,1},{-1,-1}};
uint32 sad=0xffffff;
MV mv={0,0},mv_tmp;int mvx,mvy,flag;
PATTERN_SEARCH(SDS,5,0)
if(mv.dx==0&&mv.dy==0)goto END;
PATTERN_SEARCH(SDS,5,0)
if(abs(mv.dx)+abs(mv.dy)==1)goto END;
mv_tmp=mv;mv.dx=mv.dy=0;
PATTERN_SEARCH(LCS,9,0)
if(mv.dx==0&&mv.dy==0) mv=mv_tmp;
if(abs(mv.dx)==1 && abs(mv.dy)==1)
flag=0;
else if(abs(mv.dx)==0 && abs(mv.dy)==2)
flag=1;
else if(abs(mv.dx)==2 && abs(mv.dy)==0)
flag=2;
else
printf("error/n");
do
{
mvx=mv.dx;mvy=mv.dy;
if(flag==0)
{
for(int i=0;i<9;i++)
{
if(SAD(ox,oy,mvx+LDS[i][0],mvy+LDS[i][1],heigth,width,sad)==1)
{
mv.dx=mvx+LDS[i][0];mv.dy=mvy+LDS[i][1];
if (abs(LDS[i][1])==2) flag=1;
else if (abs(LDS[i][0])==2) flag=2;
else flag=0;
}
}
}
else if(flag==1)
{
for(int i=0;i<7;i++)
{
if(SAD(ox,oy,mvx+HHS[i][0],mvy+HHS[i][1],heigth,width,sad)==1)
{
mv.dx=mvx+HHS[i][0];mv.dy=mvy+HHS[i][1];
flag = abs(HHS[i][1])==2 ? 1 : 0;
}
}
}
else
{
for(int i=0;i<7;i++)
{
if(SAD(ox,oy,mvx+VHS[i][0],mvy+VHS[i][1],heigth,width,sad)==1)
{
mv.dx=mvx+VHS[i][0];mv.dy=mvy+VHS[i][1];
flag = abs(VHS[i][0])==2 ? 2 : 0;
}
}
}
}while ( mv.dx!=mvx || mv.dy!=mvy );
PATTERN_SEARCH(SDS,5,0)
END:
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
void search_AVPS(const int x,const int y,const int heigth,const int width)
{
const int ox=x*BLOCK_HEIGTH,oy=y*BLOCK_WIDTH;
const int LDS[9][2]={{0,0},{0,2},{-1,1},{-2,0},{-1,-1},{0,-2},{1,-1},{2,0},{1,1}};
const int SDS[5][2]={{0,0},{0,1},{-1,0},{0,-1},{1,0}};
const int LHS[7][2]={{0,0},{0,2},{-2,1},{-2,-1},{0,-2},{2,-1},{2,1}};
const int SHS[9][2]={{0,0},{0,1},{-1,0},{0,-1},{1,0},{1,1},{1,-1},{-1,1},{-1,-1}};
const int L4SS[9][2]={{0,0},{0,2},{-2,2},{-2,0},{-2,-2},{0,-2},{2,-2},{2,0},{2,2}};
const int S4SS[9][2]={{0,0},{0,1},{-1,1},{-1,0},{-1,-1},{0,-1},{1,-1},{1,0},{1,1}};
uint32 sad=0xffffff;
MV mv={0,0},pre_mv[10];uint32 pre_sad[10];int mvx,mvy;
int thresa=512,thresb=1024,PredEq=0;
Get_MVp(x,y,pre_mv,mvx,mvy,pre_sad);
int sad_max=0xffffff,sad_min=0;
if(x>0 && y>0)
{
if(equal_mv(mv,pre_mv[0]))
sad_min=MAX(sad_min,pre_sad[0])
else
sad_max=MIN(sad_max,pre_sad[0]);
if(equal_mv(mv,pre_mv[1]))
sad_min=MAX(sad_min,pre_sad[1])
else
sad_max=MIN(sad_max,pre_sad[1]);
if(equal_mv(mv,pre_mv[2]))
sad_min=MAX(sad_min,pre_sad[2])
else
sad_max=MIN(sad_max,pre_sad[2]);
// if(equal_mv(mv,pre_mv[3]))
// sad_min=MAX(sad_min,pre_sad[3])
// else
// sad_max=MIN(sad_max,pre_sad[3]);
if(sad_min==0)sad_min=512;
if(sad_max==0xffffff)sad_max=512;
thresa=MAX(sad_max,sad_min);
sad_max=MAX(pre_sad[0],pre_sad[1]);
sad_max=MAX(sad_max,pre_sad[2]);
sad_max=MAX(sad_max,pre_sad[3]);
sad_min=MIN(pre_sad[0],pre_sad[1]);
sad_min=MIN(sad_min,pre_sad[2]);
sad_min=MIN(sad_min,pre_sad[3]);
thresb=MAX(sad_max,thresa+256);
if(thresa<512) thresa=512;
if(thresa>1024)thresa=1024;
if(thresb>1792)thresb=1792;
}
else
{
sad_min=0;
sad_max=2048;
}
if(x>0 && equal_mv(pre_mv[0],pre_mv[1]) && equal_mv(pre_mv[0],pre_mv[2]) )
PredEq=1;
CHECK_ONE_PIXEL(mvx,mvy)
if(sad<256)
goto END;
CHECK_ONE_PIXEL(0,0)
CHECK_ONE_PIXEL(pre_mv[0].dx,pre_mv[0].dy)
CHECK_ONE_PIXEL(pre_mv[1].dx,pre_mv[1].dy)
CHECK_ONE_PIXEL(pre_mv[2].dx,pre_mv[2].dy)
CHECK_ONE_PIXEL(pre_mv[4].dx,pre_mv[4].dy)
if(sad<thresa)
goto END;
if(sad<thresb||sad_max-sad_min<256||(x>0&&y>0&&Get_Mv_Length(x,y,pre_mv,mvx,mvy)<2))
goto SMALL_SEARCH2;
else
{
CHECK_ONE_PIXEL(pre_mv[5].dx,pre_mv[5].dy)
goto LARGE_SEARCH0;
}
// {
// CHECK_ONE_PIXEL(pre_mv[5].dx,pre_mv[5].dy)
// PATTERN_SEARCH(LHS,7,1)
// int sad_sub=0xffffff;mvx=mvy=0;
// for(int i=1;i<7;i++)
// {
// int dx=mv.dx+LHS[i][0],dy=mv.dy+LHS[i][1];
// const int rx=ox+dx,ry=oy+dy;
// if( abs(dx)>MAX_MOTION || abs(dy)>MAX_MOTION)
// continue;
// if( rx<0 || ry<0 || rx+heigth>XX || ry+width>YY )
// continue;
// if( flag_search[dx][dy]<sad_sub )
// {
// sad_sub=flag_search[dx][dy];
// mvx=LHS[i][0];mvy=LHS[i][1];
// }
// }
// int shsxy[3][2];
// if(mvx==0)
// {
// shsxy[0][0]=-1;shsxy[1][0]=0;shsxy[2][0]=1;shsxy[0][1]=shsxy[1][1]=shsxy[2][1]=mvy/2;
// }
// else
// {
// shsxy[0][0]=mvx/2;shsxy[0][1]=mvy;
// shsxy[1][0]=mvx/2;shsxy[1][1]=0;
// shsxy[2][0]= 0;shsxy[2][1]=mvy;
// }
// PATTERN_SEARCH(shsxy,3,0);
// PATTERN_SEARCH(SDS,5,0);
// goto END;
// }
LARGE_SEARCH0:
PATTERN_SEARCH(LDS,9,1)
PATTERN_SEARCH(SDS,5,0)
goto END;
LARGE_SEARCH1:
PATTERN_SEARCH(LHS,7,1)
PATTERN_SEARCH(SHS,9,0)
goto END;
LARGE_SEARCH2:
PATTERN_SEARCH(L4SS,9,1)
PATTERN_SEARCH(S4SS,9,0)
goto END;
SMALL_SEARCH0:
PATTERN_SEARCH(SHS,9,1)
goto END;
SMALL_SEARCH1:
PATTERN_SEARCH(SDS,5,1)
goto END;
SMALL_SEARCH2:
do
{
MV tmp_mv=mv;uint32 tmp_sad=sad;
mvx=mv.dx;mvy=mv.dy;sad=0xffffff;
for(int i=1;i<5;i++)
{
if(SAD(ox,oy,mvx+SDS[i][0],mvy+SDS[i][1],heigth,width,sad)==1)
{
mv.dx=mvx+SDS[i][0];mv.dy=mvy+SDS[i][1];
}
}
if(sad<tmp_sad)
continue;
if(sad/(float)tmp_sad>1.15)
{
mv=tmp_mv;sad=tmp_sad;
break;
}
if(mv.dy!=mvy)
{
CHECK_ONE_PIXEL(mv.dx-1,mv.dy)
CHECK_ONE_PIXEL(mv.dx+1,mv.dy)
}
if(mv.dx!=mvx)
{
CHECK_ONE_PIXEL(mv.dx,mv.dy-1)
CHECK_ONE_PIXEL(mv.dx,mv.dy+1)
}
if(sad>=tmp_sad)
{
mv=tmp_mv;sad=tmp_sad;
break;
}
}while ( 1 );
goto END;
END:
frame_info.mv[x][y]=mv;
frame_info.sad[x][y]=sad;
frame_info.frame_sad+=sad;
}
相关推荐
人工智能-机器学习-H264快速运动估计算法研究与实现.pdf
人工智能-机器学习-H264快速运动估计算法及其在CUDA上的实现.pdf
运动估计是运算量最大的一部分, 对运动估计算法进行优化是提高编码效率 的关键。基于此, 从运动估计的基本原理入手, 对几种典型的快速搜索算法进行了分析比较, 在此基 础上讨论了H. 264标准中运动估计的特点和改进...
基于blackfin 的一篇论文 面向嵌入式的H264AVC快速运动估计算法
最新的 H. 264 视频编码标准的性能比先前的相关 标准有很大的提高。但增加了编码器的复杂度。尤其是使用 穷举搜索算法的时候, 运动估计和模式判定占用相当多的编 码时间, 从而降低了编码器的速度。
H.264/AVC是ITU-T和ISO/IEC联合制定的最新视频...为提高运动估计算法的搜索效率,提出了一种自适应的快速运动估计算法。实验结果表明,该算法可大幅提升编码速度,而PSNR仅略有下降,为工程实现提供了一种可行的选择。
:在UMHexagonS算法的基础上,最新的H.264/AVC视频编码采用一种简单、有效的混合快速运动估计算法。该文介绍一种新的快速搜索算法,初步研究和分析其综合性能的优越性,并提出改进策略,如增加终止搜索的判定、...
UMHexagonS是视频编码标准H.264的一种快速整像素运动估计算法,该算法较之全搜索算法在性能上有很大提高,但仍存在运算量大、复杂度高、耗时等问题。利用提前中止思想,在螺旋搜索和多层次大六边形搜索阶段增加提前...
人工智能-机器学习-H264中的快速运动估计算法研究.pdf
基于H.264/AVC的快速运动估计算法研究,王恒,,运动估计部分是H.264中耗时最多的。全搜索(FS)虽然能得到最佳的匹配,但在计算上却很繁琐,无法达到实时的要求。本文对EPZS和UMHexag
基于人眼视觉系统和视觉域抽取的结构信息高度相关的原理,提出了一种基于结构相似度的快速运动估计算法(FMEBS)。该算法针对H.264率失真优化算法存在的不足,引入基于结构相似度的图像质量衡量标准,对失真度的表示...
h.264中快速的运动估计算法,是由清华大学一个知名的老师提出的,被h.264采纳为标准的,快速算法
H.264视频编码采用UMHexagonS运动估计算法,在此基础上提出了一种新的快速搜索算法。该算法在预测起始点处又增加了一个自适应的阈值判断,来判断是否可以立即停止搜索。对于不同的块类型,采用不同的搜索模板,保证...
综合介绍和分析了各种快速运动估计算法,包括h.263,h.264,mpeg系列协议里的运动估计算法
同时快速运动估计算法一直是视频压缩中的研究热点。本文针对一些快速估计算法过早确定了搜索方向,容易陷入局部点,损失了搜索精度的情况,在原有基础上,运用菱形十字搜索算法(DCS)与阈值估计相结合的方法提高了...
基于H.264/AVC运动估计算法的优化,苏扬,张小丹,简略介绍了H.264/AVC视频编码技术标准,详细分析运动估计的基本原理以及常见的运动估计算法的基础上,提出了一种快速运动估计算法。
基于h264的运动估计器硬件设计与实现 在264帧间编码算法流程来看,帧间编码是整个算法当中运输量最大的部分。帧间编码首先要解决的一个问题是如何快速高效的进行运动估计。本论文提出了最佳运动向量选择算法,并设计...
对编码运动估计理论进行了研究,采用六边形和小菱形相结合的方法,提出了一种新的自适应快速搜索算法来改善搜索效率。自适应快速搜索算法模式由当前块运动强度来决定,当当前块处于剧烈运动时,该算法选择六边形图形...
四篇关于图像通信中的运动估计算法的文章,有H_264中1_4像素运动估计快速算法的比较,H_264中运动估计算法研究与对比,基于块匹配的运动估计搜索算法研究与实现,基于块匹配的运动估计搜索算法研究与实现。