/*--------------------------------------------------------------------*/
int mbr_alm_mgd77txt(int verbose, void *mbio_ptr, int *error)
{
char *function_name = "mbr_alm_mgd77txt";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbf_mgd77txt_struct *data;
char *data_ptr;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mbio_ptr: %p\n",(void *)mbio_ptr);
}
/* get pointer to mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* set initial status */
status = MB_SUCCESS;
/* allocate memory for data structure */
mb_io_ptr->structure_size = sizeof(struct mbf_mgd77txt_struct);
mb_io_ptr->data_structure_size = 0;
status = mb_malloc(verbose,mb_io_ptr->structure_size,
&mb_io_ptr->raw_data,error);
status = mb_malloc(verbose,sizeof(struct mbsys_singlebeam_struct),
&mb_io_ptr->store_data,error);
/* get pointer to mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
data = (struct mbf_mgd77txt_struct *) mb_io_ptr->raw_data;
data_ptr = (char *) data;
/* set number of header records read to zero */
mb_io_ptr->save1 = 0;
/* initialize everything to zeros */
mbr_zero_mgd77txt(verbose,data_ptr,error);
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
/*--------------------------------------------------------------------*/
int mbr_alm_sburivax(int verbose, void *mbio_ptr, int *error)
{
char *function_name = "mbr_alm_sburivax";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mbio_ptr: %p\n",(void *)mbio_ptr);
}
/* get pointer to mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* set initial status */
status = MB_SUCCESS;
/* allocate memory for data structure */
mb_io_ptr->structure_size = sizeof(struct mbf_sburicen_struct);
mb_io_ptr->data_structure_size =
sizeof(struct mbf_sburicen_data_struct);
status = mb_malloc(verbose,mb_io_ptr->structure_size,
&mb_io_ptr->raw_data,error);
status = mb_malloc(verbose,sizeof(struct mbsys_sb_struct),
&mb_io_ptr->store_data,error);
/* set record counters to zero */
mb_io_ptr->irecord_count = 0;
mb_io_ptr->orecord_count = 0;
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
/*--------------------------------------------------------------------*/
int mbr_alm_hsldedmb(int verbose, void *mbio_ptr, int *error)
{
char *function_name = "mbr_alm_hsldedmb";
int status;
struct mb_io_struct *mb_io_ptr;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mbio_ptr: %lu\n",(size_t)mbio_ptr);
}
/* get pointer to mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* set initial status */
status = MB_SUCCESS;
/* allocate memory for data structure */
mb_io_ptr->structure_size = sizeof(struct mbf_hsldedmb_struct);
mb_io_ptr->data_structure_size =
sizeof(struct mbf_hsldedmb_data_struct);
status = mb_malloc(verbose,mb_io_ptr->structure_size,
&mb_io_ptr->raw_data,error);
status = mb_malloc(verbose,sizeof(struct mbsys_hsds_struct),
&mb_io_ptr->store_data,error);
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
//----备份clip_link---------------------------------------------------------
//功能: 备份剪切域队列。
//参数: clip_link，被备份的剪切域队列
//返回: 备份的队列，出错则返回NULL
//-----------------------------------------------------------------------------
struct clip_rect * __gk_copy_clip_link(struct clip_rect *clip_link)
{
struct clip_rect *clip1,*clip2,*clip_rsc,*result = NULL;
clip_rsc = clip_link;
if(clip_rsc == NULL)
return NULL;
//创建第一个节点
clip1 = (struct clip_rect*)mb_malloc(pg_clip_rect_pool,0);
if(clip1 == NULL)
return NULL;
clip1->rect = clip_rsc->rect;
result = clip1;
clip1->next = NULL;
clip_rsc = clip_rsc->next;
while(clip_rsc != clip_link)
{
clip2 = (struct clip_rect*)mb_malloc(pg_clip_rect_pool,0);
if(clip2 == NULL)
goto error_exit;
clip2->rect = clip_rsc->rect;
clip_rsc = clip_rsc->next;
clip1->next = clip2;
clip2->previous = clip1;
clip2->next = NULL;
clip1 = clip2;
}
//以下两句使copy_clip链表形成闭环
result->previous = clip1;
clip1->next = result;
return result;
error_exit:
clip1 = result;
do
{
clip2 = clip1->next;
mb_free(pg_clip_rect_pool,clip1);
clip1 = clip2;
}while(clip2 != NULL);
return NULL;
}
/*--------------------------------------------------------------------*/
int mbsys_surf_alloc(int verbose, void *mbio_ptr, void **store_ptr,
int *error)
{
char *function_name = "mbsys_surf_alloc";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbsys_surf_struct *store;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mbio_ptr: %p\n",(void *)mbio_ptr);
}
/* get mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* allocate memory for data structure */
status = mb_malloc(verbose,sizeof(struct mbsys_surf_struct),
store_ptr,error);
if (status == MB_SUCCESS)
{
/* initialize everything */
memset(*store_ptr, 0, sizeof(struct mbsys_surf_struct));
/* get data structure pointer */
store = (struct mbsys_surf_struct *) *store_ptr;
/* MBIO data record kind */
store->kind = MB_DATA_NONE;
}
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 store_ptr: %p\n",(void *)*store_ptr);
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
/*--------------------------------------------------------------------*/
int mbr_alm_gsfgenmb(int verbose, void *mbio_ptr, int *error)
{
char *function_name = "mbr_alm_gsfgenmb";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mbio_ptr: %p\n",(void *)mbio_ptr);
}
/* get pointer to mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* set initial status */
status = MB_SUCCESS;
/* allocate memory for data structure */
mb_io_ptr->structure_size = sizeof(struct mbf_gsfgenmb_struct);
status = mb_malloc(verbose,mb_io_ptr->structure_size,
&mb_io_ptr->raw_data,error);
memset(mb_io_ptr->raw_data, 0, mb_io_ptr->structure_size);
status = mbsys_gsf_alloc(verbose,mbio_ptr,
&mb_io_ptr->store_data,error);
/* set processing parameter output flag */
mb_io_ptr->save1 = MB_NO;
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
/*--------------------------------------------------------------------*/
int mbsys_sb2100_alloc(int verbose, void *mbio_ptr, void **store_ptr,
int *error)
{
char *function_name = "mbsys_sb2100_alloc";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbsys_sb2100_struct *store;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mbio_ptr: %p\n",(void *)mbio_ptr);
}
/* get mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* allocate memory for data structure */
status = mb_malloc(verbose,sizeof(struct mbsys_sb2100_struct),
store_ptr,error);
/* get store structure pointer */
store = (struct mbsys_sb2100_struct *) *store_ptr;
/* set comment pointer */
store->comment = (char *) &(store->roll_bias_port);
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 store_ptr: %p\n",(void *)*store_ptr);
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
/*--------------------------------------------------------------------*/
int mbsys_hs10_alloc(int verbose, void *mbio_ptr, void **store_ptr,
int *error)
{
char *function_name = "mbsys_hs10_alloc";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mbio_ptr: %lu\n",(size_t)mbio_ptr);
}
/* get mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* allocate memory for data structure */
status = mb_malloc(verbose,sizeof(struct mbsys_hs10_struct),
store_ptr,error);
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 store_ptr: %lu\n",(size_t)*store_ptr);
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
/*--------------------------------------------------------------------*/
int mbsys_benthos_alloc(int verbose, void *mbio_ptr, void **store_ptr,
int *error)
{
char *function_name = "mbsys_benthos_alloc";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbsys_benthos_struct *store;
int i;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Revision id: %s\n",rcs_id);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mbio_ptr: %p\n",(void *)mbio_ptr);
}
/* get mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* allocate memory for data structure */
status = mb_malloc(verbose,sizeof(struct mbsys_benthos_struct),
store_ptr,error);
/* get data structure pointer */
store = (struct mbsys_benthos_struct *) *store_ptr;
/* initialize everything */
/* type of data record */
store->kind = MB_DATA_NONE; /* Data kind */
/* type of sonar */
store->sonar = MBSYS_BENTHOS_UNKNOWN; /* Type of Reson sonar */
/* parameter info */
store->MBOffsetX = 0.0;
store->MBOffsetY = 0.0;
store->MBOffsetZ = 0.0;
store->NavLatency = 0.0; /* GPS_time_received - GPS_time_sent (sec) */
store->NavOffsetY = 0.0; /* Nav offset (m) */
store->NavOffsetX = 0.0; /* Nav offset (m) */
store->NavOffsetZ = 0.0; /* Nav z offset (m) */
store->NavOffsetYaw = 0.0; /* Heading offset (m) */
store->MRUOffsetY = 0.0; /* Multibeam MRU y offset (m) */
store->MRUOffsetX = 0.0; /* Multibeam MRU x offset (m) */
store->MRUOffsetZ = 0.0; /* Multibeam MRU z offset (m) */
store->MRUOffsetPitch = 0.0; /* Multibeam MRU pitch offset (degrees) */
store->MRUOffsetRoll = 0.0; /* Multibeam MRU roll offset (degrees) */
/* nav data */
store->nav_time_d = 0.0;
store->nav_longitude = 0.0;
store->nav_latitude = 0.0;
store->nav_heading = 0.0;
/* attitude data */
store->att_timetag = 0.0;
store->att_heading = 0.0;
store->att_heave = 0.0;
store->att_roll = 0.0;
store->att_pitch = 0.0;
/* comment */
store->comment[0] = '\0';
/* sound velocity profile */
/* survey data */
store->png_time_d = 0.0;
store->png_latency = 0.0;
store->png_latitude = 0.0;
store->png_longitude = 0.0;
store->png_roll = 0.0;
store->png_pitch = 0.0;
store->png_heading = 0.0;
store->png_heave = 0.0;
store->Seconds = 0; /* seconds since 00:00:00, 1 January 1970 */
store->Millisecs = 0; /* milliseconds, LSB = 1 ms */
store->ping_number = 0; /* sequential ping number from sonar startup/reset */
store->ssrawtimedelay = 0.0; /* raw sidescan delay (sec) */
store->ssrawtimeduration = 0.0; /* raw sidescan duration (sec) */
store->ssrawbottompick = 0.0; /* bottom pick time (sec) */
store->ssrawportsamples = 0; /* number of port raw sidescan samples */
store->ssrawstbdsamples = 0; /* number of stbd raw sidescan samples */
for (i=0;i<MBSYS_BENTHOS_MAXRAWPIXELS;i++)
{
store->ssrawport[i] = 0; /* raw port sidescan */
store->ssrawstbd[i] = 0; /* raw starboard sidescan */
}
store->beams_bath = 0;
store->pixels_ss = 0;
store->pixel_size = 0.0;
for (i=0;i<MBSYS_BENTHOS_MAXBEAMS;i++)
{
store->beamflag[i] = MB_FLAG_NULL; /* beamflags */
store->bath[i] = 0.0; /* bathymetry (m) */
}
for (i=0;i<MBSYS_BENTHOS_MAXPIXELS;i++)
{
store->ss[i] = 0.0; /* sidescan */
store->ss_alongtrack[i] = 0.0; /* alongtrack distance (m) */
store->ss_acrosstrack[i] = 0.0; /* alongtrack distance (m) */
}
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 store_ptr: %p\n",(void *)*store_ptr);
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
//----提取剪切域队列重叠部分---------------------------------------------------
//功能: 提取src队列中的所有矩形与sub队列中重叠的部分，用ins参数返回；
// src中非重叠的部分也形成新的剪切域队列，从different返回。
//参数: src，被减的队列指针，执行后，本队列将被释放或转移
// sub，减数队列指针
// ins，src与sub相交的部分
// different，src与sub不相交的部分
//返回: 无
//-----------------------------------------------------------------------------
void __gk_cliplink_sub(struct clip_rect *src,struct clip_rect *sub,
struct clip_rect **ins,struct clip_rect **different)
{
struct clip_rect *difftemp = NULL; //不重叠的部分暂存
struct clip_rect *worksrc; //src中矩形被减产生的工作子队列
struct clip_rect *end;
struct clip_rect *workloop; //工作子队列的循环遍历指针
struct clip_rect *subloop; //减数队列的循环遍历指针
struct clip_rect *clip_ints=NULL; //用于收集重叠的区域
struct clip_rect *temp1; //临时变量
struct st_rect ints_rect,src_rect;
bool_t endloop;
ufast_t uftemp;
//减数队列为空
if(sub == NULL)
{ //被减数队列为空
if(src == NULL)
{//src与sub相交、不相交的部分都为空
*ins = NULL;
*different = NULL;
return;
}else
{//src与sub相交部分为空、不相交的部分为src
*ins = NULL;
*different = src;
return;
}
}else //减数队列不为空
{ //被减数队列为空
if(src == NULL)
{//src与sub相交、不相交的部分都为空
*ins = NULL;
*different = NULL;
return;
}
}
//被减数队列、减数队列都不为空
src->previous->next = NULL;
while(src != NULL)
{
worksrc = src;
src = src->next;
worksrc->next = worksrc;
worksrc->previous = worksrc;
subloop = sub;
do{
workloop = worksrc;
end = worksrc->previous;
endloop = false;
//此处用循环是必要的，减sub中第一个矩形时worksrc只有一个矩形，可
//以不用循环来处理，但减第二个矩形时，worksrc可能分裂成一个队列。
do{
if(workloop == end)
endloop = true;
if(__gk_get_rect_ints(&workloop->rect,&subloop->rect,&ints_rect))
{//矩形相交
temp1 = (struct clip_rect *)mb_malloc(pg_clip_rect_pool,0);
temp1->rect = ints_rect;
//把相交区域加入clip_ints
__gk_clip_connect(&clip_ints,temp1);
src_rect = workloop->rect;
uftemp = 0;
//以下提取workloop中与subloop中不相交的部分，直接替代src队列
//中workloop的位置
if(subloop->rect.top > src_rect.top) //上部矩形
{ //首个矩形，覆盖原结点
workloop->rect.bottom = subloop->rect.top;
workloop = workloop->next;
uftemp++;
}
if(subloop->rect.left > src_rect.left) //左部矩形
{ //首个矩形，覆盖原结点
if(uftemp == 0)
{
workloop->rect.right = subloop->rect.left;
if(src_rect.bottom < subloop->rect.bottom)
workloop->rect.bottom = src_rect.bottom;
else
workloop->rect.bottom = subloop->rect.bottom;
workloop = workloop->next;
}else
{
temp1 =
(struct clip_rect *)mb_malloc(pg_clip_rect_pool,0);
temp1->rect.left = src_rect.left;
temp1->rect.top = subloop->rect.top;
temp1->rect.right = subloop->rect.left;
if(src_rect.bottom < subloop->rect.bottom)
temp1->rect.bottom = src_rect.bottom;
else
temp1->rect.bottom = subloop->rect.bottom;
__gk_clip_connect(&workloop,temp1);
}
uftemp++;
}
if(subloop->rect.right < src_rect.right) //右部矩形
{ //首个矩形，覆盖原结点
if(uftemp == 0)
{
workloop->rect.left = subloop->rect.right;
if(src_rect.bottom < subloop->rect.bottom)
workloop->rect.bottom = src_rect.bottom;
else
workloop->rect.bottom = subloop->rect.bottom;
workloop = workloop->next;
}else
{
temp1 =
(struct clip_rect *)mb_malloc(pg_clip_rect_pool,0);
temp1->rect.left = subloop->rect.right;
if(src_rect.top < subloop->rect.top)
temp1->rect.top = subloop->rect.top;
else
temp1->rect.top = src_rect.top;
temp1->rect.right = src_rect.right;
if(src_rect.bottom < subloop->rect.bottom)
temp1->rect.bottom = src_rect.bottom;
else
temp1->rect.bottom = subloop->rect.bottom;
__gk_clip_connect(&workloop,temp1);
}
uftemp++;
}
if(subloop->rect.bottom < src_rect.bottom) //下部矩形
{ //首个矩形，覆盖原结点
if(uftemp == 0)
{
workloop->rect.top = subloop->rect.bottom;
workloop = workloop->next;
}else
{
temp1 =
(struct clip_rect *)mb_malloc(pg_clip_rect_pool,0);
temp1->rect.left = src_rect.left;
temp1->rect.top = subloop->rect.bottom;
temp1->rect.right = src_rect.right;
temp1->rect.bottom = src_rect.bottom;
__gk_clip_connect(&workloop,temp1);
}
uftemp++;
}
if(uftemp == 0) //源矩形被完全覆盖,
{
if(worksrc->next == worksrc) //源队列只有一个矩形
{
mb_free(pg_clip_rect_pool,worksrc);
worksrc = NULL;
workloop = NULL;
}else
{
temp1 = workloop;
workloop = workloop->next;
temp1->previous->next = workloop;
workloop->previous = temp1->previous;
if(worksrc == temp1)
worksrc = workloop;
mb_free(pg_clip_rect_pool,temp1);
}
}
}
else //矩形不相交
workloop = workloop->next;
}while(!endloop);
if(worksrc == NULL)
break;
subloop = subloop->next;
}while(subloop != sub);
__gk_cliplink_connect(&difftemp,worksrc);
}
*different = difftemp;
*ins = clip_ints;
}
//----获取被修改区域-----------------------------------------------------------
//功能: 获取一个窗口的被修改部分的剪切域，形成双向循环链表，链表中的clip以先
// 左->右，再上->下的顺序排列，并清零changed_msk数组。
//参数: gkwin，目标窗口
//返回: 链表指针，NULL表示窗口未被修改
//-----------------------------------------------------------------------------
struct clip_rect *__gk_get_changed_clip(struct gkwin_rsc *gkwin)
{
struct clip_rect *clip=NULL,*clip1,*tempclip,*clip_head = NULL;
u8 *msk;
u32 offset_bit,offset,msk_line_words;
s16 loopx,loopy,loopz,loop=0;
bool_t start;
s32 width,height;
if(gkwin->change_flag == cn_gkwin_change_all) //整个窗口均被修改
{
clip = (struct clip_rect *)mb_malloc(pg_clip_rect_pool,0);
clip->rect.left = gkwin->limit_left + gkwin->absx0;
clip->rect.top = gkwin->limit_top + gkwin->absy0;
clip->rect.right = gkwin->limit_right;
clip->rect.bottom = gkwin->limit_bottom;
clip->next = clip;
clip->previous = clip;
gkwin->change_flag = cn_gkwin_change_none;
return clip; //把整个窗口的可显示区域当作一个剪切域返回
}else if(gkwin->change_flag == cn_gkwin_change_none) //没有修改
{
return NULL;
}else //部分修改，先按x方向取得剪切域，再按y方向合并
{
offset = 0; //首行字偏移量
msk = gkwin->changed_msk.bm_bits;
width = gkwin->wm_bitmap.width;
height = gkwin->wm_bitmap.height;
msk_line_words = gkwin->changed_msk.linebytes;
for(loopy = 0; loopy < height; loopy +=8)
{
start = false; //开始一段连续的被修改区域
offset_bit = 0; //起始块的位偏移
for(loopx = 0; loopx < width; loopx+=8)
{
if(msk[offset+offset_bit/8]&(u8)(1<<(8-(offset_bit%8)-1)))
{ //该块的changed flag为true。
if(start == false) //changed block开始被修改
{
start = true;
clip =(struct clip_rect*)mb_malloc(pg_clip_rect_pool,0);
clip->rect.left = gkwin->absx0 + offset_bit*8;
clip->rect.top = loopy + gkwin->absy0;
clip->rect.right = clip->rect.left + 8;
clip->rect.bottom = clip->rect.top + 8;
}else //changed block持续
{
clip->rect.right += 8;
}
}else //如果本行的最后一块也是被改写的块，则程序不会走到这里
{
if(start == true) //changed block结束
{
__gk_clip_connect(&clip_head,clip);
start = false;
}
}
offset_bit++;
}
//本行最后一块是被改写块，需要在这里把该区域加入被修改区域
if(start == true)
__gk_clip_connect(&clip_head,clip);
for(loopz = 0; loopz < (s16)msk_line_words; loopz++) //changed_msk清零
msk[loopz+loop] = 0;
loop += msk_line_words;
offset += msk_line_words;
}
//至此，x方向条状clip已经生成，现在沿y方向合并
clip = clip_head;
do{
clip1 = clip->next;
while(clip1 != clip)
{
if((clip1->rect.left == clip->rect.left)
&&(clip1->rect.right == clip->rect.right)
&&((clip->rect.bottom)== clip1->rect.top))//可合并
{
clip->rect.bottom += 8;
clip1->previous->next = clip1->next;
clip1->next->previous = clip1->previous;
tempclip = clip1;
clip1 = clip1->next;
mb_free(pg_clip_rect_pool,tempclip);
}else
clip1 = clip1->next;
}
clip = clip->next;
}while(clip != clip_head);
gkwin->change_flag = cn_gkwin_change_none;
}
return clip_head;
}
//----扫描可视域---------------------------------------------------------------
//功能: 1、把visible_clip备份到visible_bak中。
// 2、所有窗口生成新的visible_clip
//参数: display，被扫描的显示器
//返回: false=失败，一般是因为剪切域池容量不够
//-----------------------------------------------------------------------------
bool_t __gk_scan_new_visible_clip(struct display_rsc *display)
{
struct gkwin_rsc *tempwin;
struct st_rect *rect;
struct clip_rect *clip,*clip1,*clip_head = NULL;
s32 num,rect_left,rect_top,rect_right,rect_bottom,loop,temp;
u8 *sort_array_x,*sort_array_y;
sort_array_x = m_malloc((display->width+1)*sizeof(u8)
+ (display->height+1)*sizeof(u8),0);
if(sort_array_x == NULL)
return false;
sort_array_y = sort_array_x + display->width+1;
for(num = 0; num <= display->width; num++)
sort_array_x[num] = 0;
for(num = 0; num <= display->height; num++)
sort_array_y[num] = 0;
tempwin = display->z_topmost;
rect_left = 0;
rect_top = 0;
while(1)
{ //取窗口可视边框，该边框是窗口受祖先窗口限制后的矩形
temp = tempwin->limit_left-tempwin->left + tempwin->absx0;
if(sort_array_x[temp] == 0)
{
sort_array_x[temp] = 1;
rect_left++;
}
temp = tempwin->limit_right-tempwin->left+tempwin->absx0;
if(sort_array_x[temp] == 0)
{
sort_array_x[temp] = 1;
rect_left++;
}
temp = tempwin->limit_top-tempwin->top + tempwin->absy0;
if(sort_array_y[temp] == 0)
{
sort_array_y[temp] = 1;
rect_top++;
}
temp = tempwin->limit_bottom-tempwin->top+tempwin->absy0;
if(sort_array_y[temp] == 0)
{
sort_array_y[temp] = 1;
rect_top++;
}
//执行__gk_get_redraw_clip_all函数注释中的step1
//保存窗口原来的可视域
tempwin->visible_bak = tempwin->visible_clip;
tempwin->visible_clip = NULL;
if(tempwin != display->desktop)
tempwin = tempwin->z_back;
else
break;
}
//处理桌面下的窗口，这些窗口肯定没有可视域
while(1)
{
tempwin = tempwin->z_back;
if(tempwin == display->z_topmost)
break;
tempwin->visible_bak = tempwin->visible_clip;
tempwin->visible_clip = NULL;
}
if(mb_query_free(pg_clip_rect_pool) < (u32)((rect_left-1)*(rect_top-1)))
{
m_free(sort_array_x);
return false; //内存池不足，无法生成可视域队列
}
//按从左到右，从上到下的顺序(顺序不能改变)把所有垂直线、水平线围成的小clip
//串成双向链表，由clip_head做链表头
rect_top = 0;
temp = 0;
for(rect_bottom =1;rect_bottom <= display->height; rect_bottom++)
{
if(sort_array_y[rect_bottom] == 0)
continue;
rect_left = 0;
for(rect_right =1;rect_right <= display->width; rect_right++)
{
if(sort_array_x[rect_right] == 0)
continue;
clip = (struct clip_rect*)mb_malloc(pg_clip_rect_pool,0);
clip->rect.left = rect_left;
clip->rect.right = rect_right;
clip->rect.top = rect_top;
clip->rect.bottom = rect_bottom;
rect_left = rect_right;
__gk_clip_connect(&clip_head,clip); //把小clip加入到链接起来
temp++;
}
rect_top = rect_bottom;
}
m_free(sort_array_x);
//下面判断小clip的归属，并把他们加入到所属win的new_clip队列中
tempwin = display->z_topmost;
while(1)
{
clip = clip_head;
for(loop = temp; loop >0; loop--)
{
rect = &(clip->rect);
if((rect->left>=tempwin->limit_left-tempwin->left+tempwin->absx0)
&&(rect->top>=tempwin->limit_top-tempwin->top+tempwin->absy0)
&&(rect->right<=tempwin->limit_right-tempwin->left+tempwin->absx0)
&&(rect->bottom<=tempwin->limit_bottom-tempwin->top+tempwin->absy0))
{ //矩形在tempwin的可显示范围内,若不在则无需处理
//允许alpha或透明，区域将加入窗口可视域，但不从临时链表中删除。
if(tempwin->dest_blend)
{
clip1 = (struct clip_rect*)mb_malloc(pg_clip_rect_pool,0);
*clip1 = *clip;
}else //不允许透明和alpha，区域加入窗口可视域，从临时链表删除
{
if(clip == clip_head)
clip_head = clip_head->next;
clip1 = clip;
clip->previous->next = clip->next;
clip->next->previous = clip->previous;
temp--;
}
clip = clip->next;
//把小clip加入到visible_clip队列中
__gk_clip_connect(&tempwin->visible_clip,clip1);
}else //矩形不在tpwin的可显示范围内，无需处理。
{
clip = clip->next;
}
}
__gk_combine_clip_s(tempwin->visible_clip);//合并clip,按先x后y的顺序合并
if(tempwin != display->desktop)
tempwin = tempwin->z_back;
else
break;
}
return true;
}
static int
multiboot_exec(struct preloaded_file *fp)
{
struct preloaded_file *mfp;
vm_offset_t entry;
struct file_metadata *md;
struct multiboot_info *mb_info = NULL;
struct multiboot_mod_list *mb_mod = NULL;
multiboot_memory_map_t *mmap;
struct bios_smap *smap;
struct devdesc *rootdev;
char *cmdline = NULL;
size_t len;
int error, num, i;
int rootfs = 0; /* flag for rootfs */
int xen = 0; /* flag for xen */
int kernel = 0; /* flag for kernel */
/* Set up base for mb_malloc. */
for (mfp = fp; mfp->f_next != NULL; mfp = mfp->f_next);
/* Start info block from new page. */
last_addr = roundup(mfp->f_addr + mfp->f_size, MULTIBOOT_MOD_ALIGN);
/* Allocate the multiboot struct and fill the basic details. */
mb_info = (struct multiboot_info *)PTOV(mb_malloc(sizeof (*mb_info)));
bzero(mb_info, sizeof(struct multiboot_info));
mb_info->flags = MULTIBOOT_INFO_MEMORY|MULTIBOOT_INFO_BOOT_LOADER_NAME;
mb_info->mem_lower = bios_basemem / 1024;
mb_info->mem_upper = bios_extmem / 1024;
mb_info->boot_loader_name = mb_malloc(strlen(bootprog_info) + 1);
i386_copyin(bootprog_info, mb_info->boot_loader_name,
strlen(bootprog_info) + 1);
i386_getdev((void **)(&rootdev), NULL, NULL);
if (rootdev == NULL) {
printf("can't determine root device\n");
error = EINVAL;
goto error;
}
/*
* Boot image command line. If args were not provided, we need to set
* args here, and that depends on image type...
* Fortunately we only have following options:
* 64 or 32 bit unix or xen. So we just check if f_name has unix.
*/
/* Do we boot xen? */
if (strstr(fp->f_name, "unix") == NULL)
xen = 1;
entry = fp->f_addr;
num = 0;
for (mfp = fp->f_next; mfp != NULL; mfp = mfp->f_next) {
num++;
if (mfp->f_type != NULL && strcmp(mfp->f_type, "rootfs") == 0)
rootfs++;
if (mfp->f_type != NULL && strcmp(mfp->f_type, "kernel") == 0)
kernel++;
}
if (num == 0 || rootfs == 0) {
/* We need at least one module - rootfs. */
printf("No rootfs module provided, aborting\n");
error = EINVAL;
goto error;
}
if (xen == 1 && kernel == 0) {
printf("No kernel module provided for xen, aborting\n");
error = EINVAL;
goto error;
}
mb_mod = (struct multiboot_mod_list *) PTOV(last_addr);
last_addr += roundup(sizeof(*mb_mod) * num, MULTIBOOT_INFO_ALIGN);
bzero(mb_mod, sizeof(*mb_mod) * num);
num = 0;
for (mfp = fp->f_next; mfp != NULL; mfp = mfp->f_next) {
mb_mod[num].mod_start = mfp->f_addr;
mb_mod[num].mod_end = mfp->f_addr + mfp->f_size;
if (strcmp(mfp->f_type, "kernel") == 0) {
cmdline = NULL;
error = mb_kernel_cmdline(mfp, rootdev, &cmdline);
if (error != 0)
goto error;
} else {
len = strlen(mfp->f_name) + 1;
len += strlen(mfp->f_type) + 5 + 1;
if (mfp->f_args != NULL) {
len += strlen(mfp->f_args) + 1;
}
cmdline = malloc(len);
if (cmdline == NULL) {
error = ENOMEM;
goto error;
}
if (mfp->f_args != NULL)
snprintf(cmdline, len, "%s type=%s %s",
mfp->f_name, mfp->f_type, mfp->f_args);
else
snprintf(cmdline, len, "%s type=%s",
mfp->f_name, mfp->f_type);
}
mb_mod[num].cmdline = mb_malloc(strlen(cmdline)+1);
i386_copyin(cmdline, mb_mod[num].cmdline, strlen(cmdline)+1);
free(cmdline);
num++;
}
mb_info->mods_count = num;
mb_info->mods_addr = VTOP(mb_mod);
mb_info->flags |= MULTIBOOT_INFO_MODS;
md = file_findmetadata(fp, MODINFOMD_SMAP);
if (md == NULL) {
printf("no memory smap\n");
error = EINVAL;
goto error;
}
num = md->md_size / sizeof(struct bios_smap); /* number of entries */
mmap = (multiboot_memory_map_t *)PTOV(mb_malloc(sizeof(*mmap) * num));
mb_info->mmap_length = num * sizeof(*mmap);
smap = (struct bios_smap *)md->md_data;
for (i = 0; i < num; i++) {
mmap[i].size = sizeof(*smap);
mmap[i].addr = smap[i].base;
mmap[i].len = smap[i].length;
mmap[i].type = smap[i].type;
}
mb_info->mmap_addr = VTOP(mmap);
mb_info->flags |= MULTIBOOT_INFO_MEM_MAP;
if (strstr(getenv("loaddev"), "net") != NULL &&
bootp_response != NULL) {
mb_info->drives_length = bootp_response_size;
mb_info->drives_addr = mb_malloc(bootp_response_size);
i386_copyin(bootp_response, mb_info->drives_addr,
bootp_response_size);
mb_info->flags &= ~MULTIBOOT_INFO_DRIVE_INFO;
}
/*
* Set the image command line. Need to do this as last thing,
* as illumos kernel dboot_startkern will check cmdline
* address as last check to find first free address.
*/
if (fp->f_args == NULL) {
if (xen)
cmdline = getenv("xen_cmdline");
else
cmdline = getenv("boot-args");
if (cmdline != NULL) {
fp->f_args = strdup(cmdline);
if (fp->f_args == NULL) {
error = ENOMEM;
goto error;
}
}
}
/*
* If the image is xen, we just use f_name + f_args for commandline
* for unix, we need to add zfs-bootfs.
*/
if (xen) {
len = strlen(fp->f_name) + 1;
if (fp->f_args != NULL)
len += strlen(fp->f_args) + 1;
if (fp->f_args != NULL) {
if((cmdline = malloc(len)) == NULL) {
error = ENOMEM;
goto error;
}
snprintf(cmdline, len, "%s %s", fp->f_name, fp->f_args);
} else {
cmdline = strdup(fp->f_name);
if (cmdline == NULL) {
error = ENOMEM;
goto error;
}
}
} else {
cmdline = NULL;
if ((error = mb_kernel_cmdline(fp, rootdev, &cmdline)) != 0)
goto error;
}
mb_info->cmdline = mb_malloc(strlen(cmdline)+1);
i386_copyin(cmdline, mb_info->cmdline, strlen(cmdline)+1);
mb_info->flags |= MULTIBOOT_INFO_CMDLINE;
free(cmdline);
cmdline = NULL;
dev_cleanup();
__exec((void *)VTOP(multiboot_tramp), MULTIBOOT_BOOTLOADER_MAGIC,
(void *)entry, (void *)VTOP(mb_info));
panic("exec returned");
error:
free(cmdline);
return (error);
}
