Пример #1
0
static void
sLogRET (
  struct MqS * const context,
  struct MqBufferS * const dyn,
  MQ_CST prefix,
  const MQ_INT level,
  struct MqBufferS * space
)
{
  MQ_INT retNum;

  // set binary or string
  dyn->type = MQ_STRING_TYPE(context->config.isString);

  // read numItems
  SEEK (dyn, 0);
  retNum = (dyn->type==MQ_BINT ? MqBufU2INT(dyn->cur) : str2int(dyn->cur.C,NULL,16));
  SEEK (dyn, RET_NumItems_S);
  dyn->numItems = (dyn->type==MQ_BINT ? MqBufU2INT(dyn->cur) : str2int(dyn->cur.C,NULL,16));
  SEEK (dyn, RET_SIZE);

  // Message
  if (likely (!context->config.isSilent))
      MqLog (stderr, "code<%c> retNum<%i> numItems<" MQ_FORMAT_Z ">\n", 
	  pReadGetReturnCode(context), retNum, dyn->numItems);

  // print item's
  MqBufferPush (space, "   ");
  sLogDynItem (context, dyn, prefix, level, space);
  MqBufferPop (space, "   ");

  return;
}
Пример #2
0
wxString ReplayList::GetScriptFromReplay (const wxString& ReplayPath  , const int version) const
{

	wxString script;
    try
    {
        wxFile replay( ReplayPath, wxFile::read );
        if ( !replay.IsOpened() ) return script;
        SEEK( 20 );
        int headerSize=0 ;
        replay.Read( &headerSize, 4);
        const int seek = 64 + (version < 5 ? 0 : 240);
		SEEK( seek );
		wxFileOffset scriptSize=0;
        replay.Read( &scriptSize, 4);
		scriptSize = LSL::Util::Clamp( wxFileOffset(scriptSize), wxFileOffset(0), replay.Length() );
		SEEK( headerSize );
        std::string script_a(scriptSize,0);
        replay.Read( &script_a[0], scriptSize );
        script = TowxString( script_a ) ;//(script_a,scriptSize);

    }
    catch (...)
    {
    }
	return script;

}
Пример #3
0
/*\ Return in length the length of the file
\*/
int elio_length(Fd_t fd, Off_t *dlength)
{
  off_t length;
  int status;

  /* Add up the lengths of any extents */
  if (fd->next) {
    status = elio_length((Fd_t) fd->next, dlength);
    *dlength += elio_max_file_size(fd);
    return status;
  }
  else {
#ifdef PABLO
    int pablo_code = PABLO_elio_length;
    PABLO_start( pablo_code );
#endif
    
    if ((length = SEEK(fd->fd, (off_t) 0, SEEK_END)) != -1)
      status = ELIO_OK;
    else
      status = SEEKFAIL;
    
#ifdef PABLO
    PABLO_end(pablo_code);
#endif
    
    *dlength = (Off_t) length;
    return status;
  }
}
Пример #4
0
static VC_CONTAINER_STATUS_T avi_finish_data_chunk( VC_CONTAINER_T *p_ctx, uint32_t chunk_size )
{
   VC_CONTAINER_STATUS_T status = VC_CONTAINER_SUCCESS;
 
   if (chunk_size)
   {
      /* Rewrite the chunk size, this won't be efficient if it happens often */
      if (STREAM_SEEKABLE(p_ctx))
      {
         SEEK(p_ctx, STREAM_POSITION(p_ctx) - chunk_size - 4);
         WRITE_U32(p_ctx, chunk_size, "Chunk Size");
         SKIP_BYTES(p_ctx, chunk_size);
      }
      else
      {
         LOG_DEBUG(p_ctx, "warning, can't rewrite chunk size, data will be malformed");
         status = VC_CONTAINER_ERROR_FAILED;
      }
   }
      
   AVI_END_CHUNK(p_ctx);

   if (status != VC_CONTAINER_SUCCESS) status = STREAM_STATUS(p_ctx);

   return status;
}
Пример #5
0
/*\ Truncate the file at the specified length.
\*/
int elio_truncate(Fd_t fd, Off_t dlength)
{
  off_t length = (off_t) dlength;
#ifdef WIN32
#   define ftruncate _chsize 
#endif

#ifdef PABLO
    int pablo_code = PABLO_elio_truncate;
    PABLO_start( pablo_code );
#endif
    if(dlength >= elio_max_file_size(fd)){
      Fd_t next_fd = elio_get_next_extent(fd);
      dlength -= elio_max_file_size(fd);
#       if defined(DEBUG)
      printf(stderr," calling ftruncate with length = %f \n", dlength);
#endif
      return elio_truncate(next_fd, dlength);
    }
    (void) SEEK(fd->fd, 0L, SEEK_SET);
    if (ftruncate(fd->fd, length))
    return TRUNFAIL;
    else {
    return ELIO_OK;
    }
#ifdef PABLO
    PABLO_end(pablo_code);
#endif
}
Пример #6
0
int replayVersion( const wxString& ReplayPath )
{
    wxFile replay( ReplayPath, wxFile::read );
    if ( !replay.IsOpened() ) return 0;
    SEEK( 16 );
    int version = 0;
    replay.Read( &version, 4);
    return version;
}
Пример #7
0
  TraceContainerReader::TraceContainerReader(std::string filename) throw (TraceException)
  {
    ifs = fopen(filename.c_str(), "rb");
    if (!ifs) { throw (TraceException("Unable to open trace for reading")); }

    /* Verify the magic number. */
    uint64_t magic_number_read;
    READ(magic_number_read);
    if (magic_number_read != magic_number) {
      throw (TraceException("Magic number not found in trace"));
    }

    READ(trace_version);
    if (trace_version > highest_supported_version ||
        trace_version < lowest_supported_version) {
      throw (TraceException("Unsupported trace version"));
    }

    uint64_t archt;
    READ(archt);
    arch = (bfd_architecture) archt;

    READ(mach);

    /* Read number of trace frames. */
    READ(num_frames);

    /* Find offset of toc. */
    uint64_t toc_offset;
    READ(toc_offset);

    /* Find the toc. */
    SEEK(ifs, toc_offset);

    /* Read number of frames per toc entry. */
    READ(frames_per_toc_entry);

    /* Read each toc entry. */
    for (int i = 0; i < ((num_frames - 1) / frames_per_toc_entry); i++) {
      uint64_t offset;
      READ(offset);
      toc.push_back(offset);
    }

    /* We should be at the end of the file now. */
    traceoff_t us = TELL(ifs);
    traceoff_t end = SEEKNAME(ifs, 0, SEEK_END);
    if (us != TELL(ifs) || end != 0) {
      throw(TraceException("The table of contents is malformed."));
    }

    /* Seek to the first frame. */
    seek(0);
  }
Пример #8
0
int main(int ac, char ** av)
{
	if(!av[1]){
		fprintf(stderr, "Usage: %s filename\n", av[0]);
		return 1;
	}
	
	FILE * f = fopen(av[1], "r+b");
	struct arch_header ah;
	READ(ah);

	for(int i=1;i<(int)(ah.index_size / sizeof(struct arch_section_header));i++){
		struct arch_section_header ash;
		printf("Section %d...", i);
		fflush(stdout);
		
		SEEK(ah.index_offset + i * sizeof(struct arch_section_header));
		READ(ash);

		unsigned long block_off = ash.first_block;

		for(int j=0;j<(int)ash.n_blocks;j++){
			struct arch_section_block asb;
			
			SEEK(ah.data_offset + block_off);
			READ(asb);
		
			SEEK(ah.data_offset + block_off + 4);
			CRC crc;
			for(int j=0;j<(int)asb.length - 4;j++) crc.add(fgetc(f));
			asb.crc = crc.get_value();
			SEEK(ah.data_offset + block_off);
			WRITE(asb);
			block_off = asb.next_block;
		}
	}

	fclose(f);
}
Пример #9
0
void
pLogHDR (
  struct MqS * const context,
  MQ_CST prefix,
  const MQ_INT level,
  struct MqBufferS * const buf
)
{
  struct MqBufferS * hd = MqBufferDup (buf);
  register MQ_STR t;
  register MQ_STR e;

  if (likely(context->config.isString == MQ_NO)) {
    SEEK (hd, HDR_CtxId_S);
    sprintf (hd->cur.C, MQ_FORMAT_XI (HDR_INT_LEN), MqBufU2INT(hd->cur));
    SEEK (hd, HDR_BdySize_S);
    sprintf (hd->cur.C, MQ_FORMAT_XI (HDR_INT_LEN), MqBufU2INT(hd->cur));
    SEEK (hd, HDR_Token_S);
  }

  SEEK (hd, HDR_Trans_S);
  mq_snprintf (hd->cur.C, 4, "%d", hd->cur.A->I);
  hd->data[HDR_Code_S-1] = BUFFER_CHAR;
  hd->data[HDR_SIZE] = '\0';

  // fix \0
  t = (MQ_STR) hd->data;
  e = (MQ_STR) (hd->data + buf->cursize);
  while (t < e) {
    if (!isprint (*t)) *t = (*t == 0 ? '+' : '?');
    t++;
  }

  MqLogV (context, prefix, level, "HEADER <%s> ...\n", hd->data);

  MqBufferDelete (&hd);
}
Пример #10
0
void ReplayList::GetHeaderInfo(Replay& rep, const wxString& ReplayPath , const int version) const
{
    try
    {
        wxFile replay( ReplayPath, wxFile::read );
        const int seek = 72 + (version < 5 ? 0 : 240);
        SEEK( seek );
        int gametime = 0 ;
        replay.Read( &gametime, 4);
        rep.duration = gametime;
        rep.size = replay.Length();
		//! \todo don't use long long? (pedantic)
		wxLongLong_t unixtime = 0;
		SEEK( 56 );
        replay.Read( &unixtime, 8 );
        wxDateTime dt;
        dt.Set( (time_t) unixtime );
        // todo: add 2 strings one for date other for time?
        wxString date_string = dt.FormatISODate()+_T(" ")+dt.FormatISOTime();
        rep.date = (time_t) unixtime ;
        rep.date_string = date_string;
    }
    catch (...){ }
}
Пример #11
0
  void TraceContainerWriter::finish(void) throw (TraceException) {
    if (is_finished) {
      throw (TraceException("finish called twice"));
    }

    /* Save the offset where we will write the toc. */
    uint64_t toc_offset = TELL(ofs);
    if (toc_offset == -1) {
      throw (TraceException("Unable to determine the current offset in the trace"));
    }

    /* Make sure the toc is the right size. */
    assert ((num_frames == 0) || ((num_frames - 1) / frames_per_toc_entry) == toc.size());

    /* Write frames per toc entry. */
    WRITE(frames_per_toc_entry);

    /* Write each offset to the file. */
    for (std::vector<uint64_t>::size_type i = 0; i < toc.size(); i++) {
      WRITE(toc[i]);
    }

    /* Now we need to write the magic number, number of trace frames
       and the offset of field m at the start of the trace. */

    /* Magic number. */
    SEEK(ofs, magic_number_offset);
    WRITE(magic_number);

    /* Trace version. */
    SEEK(ofs, trace_version_offset);
    WRITE(out_trace_version);

    /* CPU architecture. */
    SEEK(ofs, bfd_arch_offset);
    uint64_t archt = (uint64_t) arch;
    WRITE(archt);

    /* Machine type. */
    SEEK(ofs, bfd_machine_offset);
    WRITE(mach);

    /* Numer of trace frames */
    SEEK(ofs, num_trace_frames_offset);
    WRITE(num_frames);

    /* Offset of toc. */
    SEEK(ofs, toc_offset_offset);
    WRITE(toc_offset);

    /* Finally, close the file and mark us as finished. */
    if (fclose(ofs)) {
      throw (TraceException("Unable to close trace file"));
    }
    is_finished = true;
  }
Пример #12
0
  void TraceContainerReader::seek(uint64_t frame_number) throw (TraceException) {
    /* First, make sure the frame is in range. */
    check_end_of_trace_num(frame_number, "seek() to non-existant frame");

    /* Find the closest toc entry, if any. */
    uint64_t toc_number = frame_number / frames_per_toc_entry;

    if (toc_number == 0) {
      current_frame = 0;
      SEEK(ifs, first_frame_offset);
    } else {
      current_frame = toc_number * frames_per_toc_entry;
      /* Use toc_number - 1 because there is no toc for frames [0,m). */
      SEEK(ifs, toc[toc_number - 1]);
    }

    while (current_frame != frame_number) {
      /* Read frame length and skip that far ahead. */
      uint64_t frame_len;
      READ(frame_len);
      SEEK(ifs, (uint64_t)TELL(ifs) + frame_len);
      current_frame++;
    }
  }
/*
** Read data from a file into a buffer.  Return SQLITE_OK if all
** bytes were read successfully and SQLITE_IOERR if anything goes
** wrong.
*/
int sqlite3OsRead(OsFile *id, void *pBuf, int amt){
  int got;
  assert( id->isOpen );
  SimulateIOError(SQLITE_IOERR);
  TIMER_START;
  got = read(id->h, pBuf, amt);
  TIMER_END;
  TRACE5("READ    %-3d %5d %7d %d\n", id->h, got, last_page, TIMER_ELAPSED);
  SEEK(0);
  /* if( got<0 ) got = 0; */
  if( got==amt ){
    return SQLITE_OK;
  }else{
    return SQLITE_IOERR;
  }
}
Пример #14
0
 TraceContainerWriter::TraceContainerWriter(std::string filename,
                                            bfd_architecture arch,
                                            uint64_t machine,
                                            uint64_t frames_per_toc_entry_in,
                                            bool auto_finish_in) throw (TraceException)
   : num_frames (0),
     frames_per_toc_entry (frames_per_toc_entry_in),
     arch (arch),
     mach (machine),
     auto_finish (auto_finish_in),
     is_finished (false)
 {
   ofs = fopen(filename.c_str(), "wb");
   if (!ofs) { throw (TraceException("Unable to open trace file for writing")); }
   SEEK(ofs, first_frame_offset);
 }
/*
** Write data from a buffer into a file.  Return SQLITE_OK on success
** or some other error code on failure.
*/
int sqlite3OsWrite(OsFile *id, const void *pBuf, int amt){
  int wrote = 0;
  assert( id->isOpen );
  assert( amt>0 );
  SimulateIOError(SQLITE_IOERR);
  SimulateDiskfullError;
  TIMER_START;
  while( amt>0 && (wrote = write(id->h, pBuf, amt))>0 ){
    amt -= wrote;
    pBuf = &((char*)pBuf)[wrote];
  }
  TIMER_END;
  TRACE5("WRITE   %-3d %5d %7d %d\n", id->h, wrote, last_page, TIMER_ELAPSED);
  SEEK(0);
  if( amt>0 ){
    return SQLITE_FULL;
  }
  return SQLITE_OK;
}
Пример #16
0
int elio_set_cb(Fd_t fd, Off_t doffset, int reqn, void *buf, Size_t bytes)
{
#if defined(AIO)
    off_t offset = (off_t) doffset;
#   if defined(CRAY)
       if(offset != SEEK(fd->fd, offset, SEEK_SET))return (SEEKFAIL);
       cb_fout_arr[reqn] = cb_fout+reqn;
       cb_fout[reqn].filedes    = fd->fd;
#   else
       cb_fout[reqn].aio_offset = offset;
       cb_fout_arr[reqn] = cb_fout+reqn;
         cb_fout[reqn].aio_buf    = buf;
         cb_fout[reqn].aio_nbytes = bytes;
#        if defined(AIX)
           cb_fout[reqn].aio_whence = SEEK_SET;
#        else
           cb_fout[reqn].aio_sigevent.sigev_notify = SIGEV_NONE;
           cb_fout[reqn].aio_fildes    = fd->fd;
#        endif
#   endif
#endif
    return ELIO_OK;
}
Пример #17
0
/*\ Blocking Write 
 *    - returns number of bytes written or error code (<0) if failed
\*/
Size_t elio_write(Fd_t fd, Off_t  doffset, const void* buf, Size_t bytes)
{
  off_t offset;
  Size_t stat, bytes_to_write = bytes;
  Size_t nextbytes;

  if (doffset >= ABSURDLY_LARGE) 
    ELIO_ERROR(SEEKFAIL,0);

  /* Follow the linked list of extents down until we hit the file
     that contains the offset */
  if (doffset >= elio_max_file_size(fd)) {
    Fd_t next_fd = elio_get_next_extent(fd);
    if (!next_fd) ELIO_ERROR(OPENFAIL,0);
    doffset -= elio_max_file_size(fd);
    return elio_write(next_fd, doffset, buf, bytes);
  }

  /* Figure out if the write continues onto the next extent */
  offset = (off_t) doffset;
  nextbytes = 0;
  if ((doffset+bytes_to_write) >= elio_max_file_size(fd)) {
    nextbytes = bytes_to_write;
    bytes_to_write = (Size_t) (elio_max_file_size(fd)-doffset);
    nextbytes -= bytes_to_write;
  }
  /*printf("TRYING TO WRITE AT doffset=%f offset=%lu bw=%lu nb=%lu\n", doffset, offset,
    bytes_to_write, nextbytes);*/

  /* Write to this extent */

#ifdef PABLO
  int pablo_code = PABLO_elio_write;
  PABLO_start( pablo_code );
#endif
  
  if(offset != SEEK(fd->fd,offset,SEEK_SET)) ELIO_ERROR(SEEKFAIL,0);
  
  while (bytes_to_write) {
    stat = WRITE(fd->fd, buf, bytes_to_write);
    if ((stat == -1) && ((errno == EINTR) || (errno == EAGAIN))) {
      ; /* interrupted write should be restarted */
    } else if (stat > 0) {
      bytes_to_write -= stat;
      buf = stat + (char*)buf; /*advance pointer by # bytes written*/
    } else {
      ELIO_ERROR(WRITFAIL, stat);
    }
  }

  /* Only get here if all has gone OK */
  
#ifdef PABLO
  PABLO_end(pablo_code);
#endif

  /* Write to next extent(s) ... relies on incrementing of buf */
  if (nextbytes) {
    Fd_t next_fd = elio_get_next_extent(fd);
    if (!next_fd) ELIO_ERROR(OPENFAIL,0);
    stat = elio_write(next_fd, (Off_t) 0, buf, nextbytes);
    if (stat != nextbytes)
      ELIO_ERROR(WRITFAIL, stat);
  }
  
  return bytes;
}
Пример #18
0
BOOL 
ShowBitmapWithTrColorMem(
	HDC hDC, 
	int xPos, 
	int yPos, 
	char* pFile, 
	COLORREF crTrColor
)
{
	FILE_P fd;
	BMPINFOHEADER infoHeader;
	int iBmpWidth, iBmpHeight;
	int iCliWidth,iCliHeight;
	int iWinWidth,iWinHeight;
	int iWidth,iHeight;

	int x,y;
	void* pCurPointer;
	void* pOutPointer;

	void *pData;
	RECT rc;


	if(!(hDC->hWnd))
		return false;
	GetWindowRect(hDC->hWnd,&rc);
	iWinWidth = rc.right - rc.left + 1;
	iWinHeight = rc.bottom - rc.top + 1;


	if(!(hDC->hWnd))
		return false;
	GetWindowRect(hDC->hWnd,&rc);
	iWinWidth = rc.right - rc.left + 1;
	iWinHeight = rc.bottom - rc.top + 1;

	GetClientRect(hDC->hWnd,&rc);
	iCliWidth = rc.right - rc.left + 1;
	iCliHeight = rc.bottom - rc.top + 1;


	if(xPos>=iWinWidth || xPos<0){
		printerror("show bitmap out of range.");
		return false;
	}
	if(yPos>=iWinHeight || yPos<0){
		printerror("show bitmap out of range.");
		return false;
	}
	fd=OPEN(pFile,RDONLY);
	if(fd<0){
		printerror("open file error!");
		return false;
	}

	SEEK(fd,0x12,0);
	READ(fd,&(infoHeader.biWidth),sizeof(infoHeader.biWidth));
	READ(fd,&(infoHeader.biHeight),sizeof(infoHeader.biHeight));

	SEEK(fd,0x1c,0);
	READ(fd,&(infoHeader.biBitCount),sizeof(infoHeader.biBitCount));

	iBmpWidth=infoHeader.biWidth;
	iBmpHeight=infoHeader.biHeight;

	iWidth=min(iBmpWidth,iCliWidth-xPos);
	iHeight=min(iBmpHeight,iCliHeight-yPos);

	pData=malloc(iWidth*iHeight*Gal_iBytesDataType);
	if(!pData){
		printerror("alloc memory error!");
		return false;
	}

	if(!ReadBmpToBuf(fd, iWidth, iHeight, pData)){
		free(pData);
		CLOSE(fd);
		return false;
	}
	for(y=0;y<iHeight;y++){
		for(x=0;x<iWidth;x++){
			pCurPointer=(acoral_u8*)pData + (y*iWidth+x)*Gal_iBytesDataType;
			if(*((PCOLORREF)(pCurPointer))!=crTrColor){
				pOutPointer=(acoral_u8*)hDC->pData + (y + yPos)*iWinWidth*Gal_iBytesDataType + 
					(x + xPos)*Gal_iBytesDataType;
				memcpy(pOutPointer,pCurPointer,Gal_iBytesDataType);
			}
		}
	}

	free(pData);
	CLOSE(fd);
	return true;
}
Пример #19
0
/* ( open -- flag ) */
static void
macparts_open( macparts_info_t *di )
{
	char *str = my_args_copy();
	char *parstr = NULL, *argstr = NULL;
	char *tmpstr;
	int bs, parnum=-1, apple_parnum=-1;
	int parlist[2], parlist_size = 0;
	desc_map_t dmap;
	part_entry_t par;
	int ret = 0, i = 0, j = 0;
	int want_bootcode = 0;
	phandle_t ph;
	ducell offs = 0, size = -1;

	DPRINTF("macparts_open '%s'\n", str );

	/* 
		Arguments that we accept:
		id: [0-7]
		[(id)][,][filespec]
	*/
	
	if ( str && strlen(str) ) {
		/* Detect the arguments */
		if ((*str >= '0' && *str <= '9') || (*str == ',')) {
		    push_str(str);
		    PUSH(',');
		    fword("left-parse-string");
		    parstr = pop_fstr_copy();
		    argstr = pop_fstr_copy();
		} else {
		    argstr = str;
		}

		/* Make sure argstr is not null */
		if (argstr == NULL)
		    argstr = strdup("");	
		
		/* Convert the id to a partition number */
		if (parstr && strlen(parstr))
		    parnum = atol(parstr);

		/* Detect if we are looking for the bootcode */
		if (strcmp(argstr, "%BOOT") == 0) {
		    want_bootcode = 1;
		}
	}

	DPRINTF("parstr: %s  argstr: %s  parnum: %d\n", parstr, argstr, parnum);

	DPRINTF("want_bootcode %d\n", want_bootcode);
	DPRINTF("macparts_open %d\n", parnum);

	di->filesystem_ph = 0;
	di->read_xt = find_parent_method("read");
	di->seek_xt = find_parent_method("seek");

	SEEK( 0 );
	if( READ(&dmap, sizeof(dmap)) != sizeof(dmap) )
		goto out;

	/* partition maps might support multiple block sizes; in this case,
	 * pmPyPartStart is typically given in terms of 512 byte blocks.
	 */
	bs = __be16_to_cpu(dmap.sbBlockSize);
	if( bs != 512 ) {
		SEEK( 512 );
		READ( &par, sizeof(par) );
		if( __be16_to_cpu(par.pmSig) == DESC_PART_SIGNATURE )
			bs = 512;
	}
	SEEK( bs );
	if( READ(&par, sizeof(par)) != sizeof(par) )
		goto out;
        if (__be16_to_cpu(par.pmSig) != DESC_PART_SIGNATURE)
		goto out;

	/*
	 * Implement partition selection as per the PowerPC Microprocessor CHRP bindings
	 */

	if (argstr == NULL || parnum == 0) {
		/* According to the spec, partition 0 as well as no arguments means the whole disk */
		offs = (long long)0;
		size = (long long)__be32_to_cpu(dmap.sbBlkCount) * bs;

		di->blocksize = (unsigned int)bs;

		di->offs_hi = offs >> BITS;
		di->offs_lo = offs & (ucell) -1;
	
		di->size_hi = size >> BITS;
		di->size_lo = size & (ucell) -1;

		ret = -1;
		goto out;

	} else if (parnum == -1) {
Пример #20
0
BOOL 
ShowBitmapMem(
	HDC hDC, 
	int xPos, 
	int yPos, 
	char* pFile
)
{
	FILE_P fd;
	BMPINFOHEADER infoHeader;
	int iBmpWidth, iBmpHeight;
	int iWinWidth,iWinHeight;
	int iCliWidth,iCliHeight;
	int iWidth,iHeight;
	int iLeftMarge,iTopMarge,iBottom;

	int y;
	void* pCurPointer;
	void* pOutPointer;

	void *pData;
	RECT rc;


	if(!(hDC->hWnd))
		return false;
	GetWindowRect(hDC->hWnd,&rc);
	iWinWidth = rc.right - rc.left + 1;
	iWinHeight = rc.bottom - rc.top + 1;

	GetClientRect(hDC->hWnd,&rc);
	iCliWidth = rc.right - rc.left + 1;
	iCliHeight = rc.bottom - rc.top + 1;

	if(xPos>=iWinWidth || xPos<0){
		printerror("show bitmap out of range.");
		return false;
	}
	if(yPos>=iWinHeight || yPos<0){
		printerror("show bitmap out of range.");
		return false;
	}
	fd=OPEN(pFile,RDONLY);
	if(fd<0){
		printerror("open file error!");
		return false;
	}

	SEEK(fd,0x12,0);
	READ(fd,&(infoHeader.biWidth),sizeof(infoHeader.biWidth));
	READ(fd,&(infoHeader.biHeight),sizeof(infoHeader.biHeight));

	SEEK(fd,0x1c,0);
	READ(fd,&(infoHeader.biBitCount),sizeof(infoHeader.biBitCount));

	iBmpWidth=infoHeader.biWidth;
	iBmpHeight=infoHeader.biHeight;

	iWidth=min(iBmpWidth,iCliWidth-xPos);
	iHeight=min(iBmpHeight,iCliHeight-yPos);

	pData=malloc(iWidth*iHeight*Gal_iBytesDataType);
	if(!pData){
		printerror("alloc memory error!");
		return false;
	}
	if(!ReadBmpToBuf(fd, iWidth, iHeight, pData)){
		free(pData);
		CLOSE(fd);
		return false;
	}


	iBottom=yPos+iHeight-1;

	iLeftMarge=xPos*Gal_iBytesDataType;
	iTopMarge=iWinWidth*yPos*Gal_iBytesDataType;
	pCurPointer=pData;
	pOutPointer=(acoral_u8*)hDC->pData+iTopMarge+iLeftMarge;
	for(y=yPos;y<=iBottom;y++){

		memcpy(pOutPointer,pCurPointer,iWidth*Gal_iBytesDataType);
		pOutPointer = (void*)((acoral_u8*)pOutPointer+iWinWidth*Gal_iBytesDataType);
		pCurPointer= (void*)((acoral_u8*) pCurPointer + iWidth*Gal_iBytesDataType);
	}

	free(pData);
	CLOSE(fd);
	return true;

}
/*
** Move the read/write pointer in a file.
*/
int sqlite3OsSeek(OsFile *id, i64 offset){
  assert( id->isOpen );
  SEEK(offset/1024 + 1);
  lseek(id->h, offset, SEEK_SET);
  return SQLITE_OK;
}
Пример #22
0
/* ( open -- flag ) */
static void
pcparts_open( pcparts_info_t *di )
{
	char *str = my_args_copy();
	char *argstr = strdup("");
	char *parstr = strdup("");
	int bs, parnum=-1;
	int found = 0;
	phandle_t ph;
	ducell offs, size;

	/* Layout of PC partition table */
	struct pc_partition {
		unsigned char boot;
		unsigned char head;
		unsigned char sector;
		unsigned char cyl;
		unsigned char type;
		unsigned char e_head;
		unsigned char e_sector;
		unsigned char e_cyl;
		u32 start_sect; /* unaligned little endian */
		u32 nr_sects; /* ditto */
	} *p, *partition;

	unsigned char buf[512];

	DPRINTF("pcparts_open '%s'\n", str );

	/* 
		Arguments that we accept:
		id: [0-7]
		[(id)][,][filespec]
	*/

	if ( strlen(str) ) {
		/* Detect the arguments */
		if ((*str >= '0' && *str <= '7') || (*str == ',')) {
		    push_str(str);
		    PUSH(',');
		    fword("left-parse-string");
		    parstr = pop_fstr_copy();
		    argstr = pop_fstr_copy();
		} else {
		    argstr = str;
		}
			
		/* Convert the id to a partition number */
		if (parstr && strlen(parstr))
		    parnum = atol(parstr);
	}

	/* Make sure argstr is not null */
	if (argstr == NULL)
	    argstr = strdup("");
	
	DPRINTF("parstr: %s  argstr: %s  parnum: %d\n", parstr, argstr, parnum);
        free(parstr);

	if( parnum < 0 )
		parnum = 0;

	di->filesystem_ph = 0;
	di->read_xt = find_parent_method("read");
	di->seek_xt = find_parent_method("seek");

	SEEK( 0 );
	if( READ(buf, 512) != 512 )
		RET(0);

	/* Check Magic */
	if (!has_pc_part_magic(buf)) {
		DPRINTF("pc partition magic not found.\n");
		RET(0);
	}

	/* Actual partition data */
	partition = (struct pc_partition *) (buf + 0x1be);

	/* Make sure we use a copy accessible from an aligned pointer (some archs
	   e.g. SPARC will crash otherwise) */
	p = malloc(sizeof(struct pc_partition));

	bs = 512;

	if (parnum < 4) {
		/* primary partition */
		partition += parnum;
		memcpy(p, partition, sizeof(struct pc_partition));

		if (p->type == 0 || is_pc_extended_part(p->type)) {
			DPRINTF("partition %d does not exist\n", parnum+1 );
			RET( 0 );
		}

		offs = (long long)(__le32_to_cpu(p->start_sect)) * bs;
		di->offs_hi = offs >> BITS;
		di->offs_lo = offs & (ucell) -1;

		size = (long long)(__le32_to_cpu(p->nr_sects)) * bs;
        	di->size_hi = size >> BITS;
        	di->size_lo = size & (ucell) -1;

		DPRINTF("Primary partition at sector %x\n", __le32_to_cpu(p->start_sect));

		/* If PReP boot partition, exit immediately with no filesystem probe */
		if (p->type == 0x41) {
			RET(-1);
		}

		found = 1;
	} else {
Пример #23
0
/*\ Blocking Read 
 *      - returns number of bytes read or error code (<0) if failed
\*/
Size_t elio_read(Fd_t fd, Off_t doffset, void* buf, Size_t bytes)
{
off_t offset;
Size_t stat, bytes_to_read = bytes;
Size_t nextbytes;
int    attempt=0;

 if (doffset >= ABSURDLY_LARGE) 
    ELIO_ERROR(SEEKFAIL,0);

  /* Follow the linked list of extents down until we hit the file
     that contains the offset */
  if (doffset >= elio_max_file_size(fd)) {
    Fd_t next_fd = elio_get_next_extent(fd);
    if (!next_fd) ELIO_ERROR(OPENFAIL,0);
    doffset -= elio_max_file_size(fd);
    return elio_read(next_fd, doffset, buf, bytes);
  }

  /* Figure out if the read continues onto the next extent */
  offset = (off_t) doffset;
  nextbytes = 0;
  if ((doffset+bytes_to_read) >= elio_max_file_size(fd)) {
    nextbytes = bytes_to_read;
    bytes_to_read = (Size_t) (elio_max_file_size(fd)-doffset);
    nextbytes -= bytes_to_read;
  }


  /* Read from this physical file */

#ifdef PABLO
  int pablo_code = PABLO_elio_read;
  PABLO_start( pablo_code );
#endif

  if(offset != SEEK(fd->fd,offset,SEEK_SET)) ELIO_ERROR(SEEKFAIL,0);
  
  while (bytes_to_read) {
    stat = READ(fd->fd, buf, bytes_to_read);
    if(stat==0){
      ELIO_ERROR(EOFFAIL, stat);
    } else if ((stat == -1) && ((errno == EINTR) || (errno == EAGAIN))) {
      ; /* interrupted read should be restarted */
    } else if (stat > 0) {
      bytes_to_read -= stat;
      buf = stat + (char*)buf; /*advance pointer by # bytes read*/
    } else {
      ELIO_ERROR(READFAIL, stat);
    }
    attempt++;
  }
  
  /* Only get here if all went OK */
  
#ifdef PABLO
  PABLO_end(pablo_code);
#endif
  
  /* Read from next extent(s) ... relies on incrementing of buf */
  if (nextbytes) {
    Fd_t next_fd = elio_get_next_extent(fd);
    if (!next_fd) ELIO_ERROR(OPENFAIL,0);
    stat = elio_read(next_fd, (Off_t) 0, buf, nextbytes);
    if (stat != nextbytes)
      ELIO_ERROR(READFAIL, stat);
  }


  return bytes;
}
Пример #24
0
void ZFXModel::ReadFile()
{
	ZFXCOLOR cA, cD, cE, cS;
	UINT     i, nNumFaces, nNumTris = 0;
	float    fPower = 0;
	char     Line[80];
	char     Texture[80];
	TRI     *pTris = NULL;


	// READ SKINS
	SEEK(Line, "BEGIN_SKINS");
	NEXT(Line);
	sscanf(Line, "%d;", &m_nSkinNum);
	m_pSkin = new UINT[m_nSkinNum];
	for (i = 0; i < m_nSkinNum; i++) 
	{
		NEXT(Line);  NEXT(Line);// skip opening brag
		sscanf(Line, "%f, %f, %f, %f;", &cA.fR, &cA.fG, &cA.fB, &cA.fA);           NEXT(Line);
		sscanf(Line, "%f,%f,%f,%f;", &cD.fR, &cD.fG, &cD.fB, &cD.fA);              NEXT(Line);
		sscanf(Line, "%f,%f,%f,%f;", &cE.fR, &cE.fG, &cE.fB, &cE.fA);              NEXT(Line);
		sscanf(Line, "%f,%f,%f,%f,%f;", &cS.fR, &cS.fG, &cS.fB, &cS.fA, &fPower);  NEXT(Line);
		sscanf(Line, "%s", &Texture);

		// add skin to skin-manager
		m_pRenderDevice->GetSkinManager()->AddSkin(&cA, &cD, &cE, &cS, fPower, &m_pSkin[i]);
		m_pRenderDevice->GetSkinManager()->AddTexture(m_pSkin[i], Texture, false, 0, NULL, 0);
		NEXT(Line); // skip closing brag
	}


	// READ VERTICES
	rewind(m_pFile);
	SEEK(Line, "BEGIN_VERTICES");
	NEXT(Line);
	sscanf(Line, "%d;", &m_nVertexNum);
	m_pVertex = new VERTEX[m_nVertexNum];
	m_pVertex3T = new VERTEX3T[m_nVertexNum];
	for (i = 0; i < m_nVertexNum; i++) 
	{
		NEXT(Line);
		sscanf(Line, "%f,%f,%f,%f,%f;", &m_pVertex[i].x,
			&m_pVertex[i].y, &m_pVertex[i].z,
			&m_pVertex[i].tu, &m_pVertex[i].tv);

		memset(&m_pVertex3T[i], 0, sizeof(VERTEX3T));
		m_pVertex3T[i].x = m_pVertex[i].x;
		m_pVertex3T[i].y = m_pVertex[i].y;
		m_pVertex3T[i].z = m_pVertex[i].z;
		m_pVertex3T[i].tu0 = m_pVertex[i].tu;
		m_pVertex3T[i].tv0 = m_pVertex[i].tv;
	}


	// READ FACES (n-sided polys) TO COUNT TRIS NEEDED
	rewind(m_pFile);
	SEEK(Line, "BEGIN_FACES");
	NEXT(Line);
	sscanf(Line, "%d;", &nNumFaces);
	pTris = new TRI[nNumFaces];
	for (i = 0; i < nNumFaces; i++) 
	{
		NEXT(Line);
		sscanf(Line, "%d,%d,%d;%d", &pTris[nNumTris].i0,
			&pTris[nNumTris].i1, &pTris[nNumTris].i2,
			&pTris[nNumTris].nMat);
		nNumTris++;
	}

	// sort tris by material
	qsort((void*)pTris, nNumTris, sizeof(TRI), (CMPFUNC)SortTris);



	// COUNT INDICES FOR EACH MATERIAL
	UINT nOldMat = pTris[0].nMat;
	m_pCount = new UINT[m_nSkinNum];
	m_pBufferID = new UINT[m_nSkinNum];
	m_pBufferID3T = new UINT[m_nSkinNum];
	memset(m_pCount, 0, sizeof(UINT)*m_nSkinNum);
	memset(m_pBufferID, 0, sizeof(UINT)*m_nSkinNum);
	memset(m_pBufferID3T, 0, sizeof(UINT)*m_nSkinNum);
	m_pIndex = new WORD[nNumTris * 3];
	m_nIndexNum = nNumFaces * 3;
	for (i = 0; i < nNumTris; i++) 
	{
		// copy indices in indexlist
		m_pIndex[i * 3] = pTris[i].i0;
		m_pIndex[i * 3 + 1] = pTris[i].i1;
		m_pIndex[i * 3 + 2] = pTris[i].i2;

		// count indices per material
		if (pTris[i].nMat != nOldMat)
			nOldMat = pTris[i].nMat;
		else
			m_pCount[pTris[i].nMat] += 3;
	}


	WORD *pIndices = m_pIndex;
	for (i = 0; i < m_nSkinNum; pIndices += m_pCount[i], i++)
	{
		if (FAILED(m_pRenderDevice->GetVertexManager()->CreateStaticBuffer(
			VID_UU,
			m_pSkin[i],
			m_nVertexNum,
			m_pCount[i],
			m_pVertex,
			m_pIndex,
			&m_pBufferID[i])))
			Log("CREATE STATIC FAILED\n");

		if (FAILED(m_pRenderDevice->GetVertexManager()->CreateStaticBuffer(
			VID_3T,
			m_pSkin[i],
			m_nVertexNum,
			m_pCount[i],
			m_pVertex3T,
			m_pIndex,
			&m_pBufferID3T[i])))
			Log("CREATE STATIC 3T FAILED\n");

	}
	delete[] pTris;
}
Пример #25
0
BOOL 
ShowBitmapWithTrColorWin(
	HDC hDC, 
	int xPos, 
	int yPos, 
	char* pFile, 
	COLORREF crTrColor
)
{
	PClipRect pClipRect;
	FILE_P fd;
	BMPINFOHEADER infoHeader;

	void* pData;
	RECT rcSource,rcDest;
	int iWinWidth, iWinHeight;
	int iBmpWidth, iBmpHeight;
	int iWidth,iHeight;

	GetWindowRect(hDC->hWnd,&rcSource);
	WindowToScreen(hDC->hWnd,&xPos,&yPos);

	if(xPos>rcSource.right || xPos<rcSource.left)
		return false;
	if(yPos>rcSource.bottom || yPos<rcSource.top)
		return false;

	iWinWidth	=rcSource.right-xPos+1;
	iWinHeight	=rcSource.bottom-yPos+1;

	fd=OPEN(pFile,RDONLY);
	if(fd<0)
		return false;
	SEEK(fd,0x12,0);
	READ(fd,&(infoHeader.biWidth),sizeof(infoHeader.biWidth));
	READ(fd,&(infoHeader.biHeight),sizeof(infoHeader.biHeight));

	SEEK(fd,0x1c,0);
	READ(fd,&(infoHeader.biBitCount),sizeof(infoHeader.biBitCount));

	iBmpWidth	=infoHeader.biWidth;
	iBmpHeight	=infoHeader.biHeight;

	iWidth=min(iBmpWidth,iWinWidth);
	iHeight=min(iBmpHeight,iWinHeight);

	pData=malloc(iWidth*iHeight*Gal_iBytesDataType);
	if(!pData){
		CLOSE(fd);
		return false;
	}
	SetRect(&rcSource,xPos,yPos,xPos+iWidth-1,yPos+iHeight-1);

	if(!ReadBmpToBuf(fd, iWidth, iHeight, pData)){
		free(pData);
		CLOSE(fd);
		return false;
	}

	pClipRect=((PWindowsTree)(hDC->hWnd))->pClipRgn->pHead;
	while(pClipRect){
		if(IntersectRect(&rcDest,&rcSource,&(pClipRect->rect)))
			Gal_PutRectWithTrCor(&rcDest,&rcSource,pData,crTrColor);
		pClipRect=pClipRect->pNext;
	}

	free(pData);
	CLOSE(fd);
	return true;
}
kal_int32 _gif_sw_draw_internal(
            kal_int32 ox,
            kal_int32 oy,
            kal_bool is_resized,
            kal_int32 resized_width,
            kal_int32 resized_height,
            kal_uint8 *src,
            kal_uint32 size,
            kal_uint32 cache_id,
            kal_uint16 frame_number,
            kal_bool use_disposal_method,
            kal_bool transparent_enable,
            GIF_COLOR_FORMAT_ENUM gif_color_format,
            GIF_COLOR_FORMAT_ENUM palette_format)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_int8 gif_done;
    kal_int32 frame_counter = 0;
    kal_uint16 transparent_index = 256;
    kal_uint16 temp_width, temp_height;
    kal_int32 n;
    kal_int16 lcd_idx;
    kal_int8 gif_is_hit_cache = 0;
    gif_sw_image_struct *cache;
    //kal_uint32 start, end;
    //kal_uint32 start_after_decode, end_after_decode;
    //start = drv_get_current_time();

    //SW_GIF_TRACE(MOD_MMI, "[gif] - _gif_sw_draw_internal(): Enter.\n");

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    INIT_SRC(src, size);

    // try to hit the cache and initialize the cache item
    {
       kal_int32 offset;

       /* If the frame_counter<frame_number, gif will decode from frame_counter to frame_number. */
       if (gif_sw_gif_hit_cache(cache_id, ox,oy, KAL_FALSE, frame_number, &lcd_idx, &frame_counter, &offset, KAL_TRUE))
       {
          gif_is_hit_cache = 1;
          SEEK(offset);
       }
       cache = &g_gif_sw_cache[lcd_idx];
       //pcurrent_match_gif_sw_cache = cache;
    }

    g_gif_sw_palette_size = 0;

    // /////////////////////////////////////////////////////////
    // read the GIF file signature
    if (frame_counter == 0)
    {
       kal_uint32 header;
       kal_uint32 bg_color_idx = 0;

       header = _get_data(FSAL_ACCESS_U24, pfsal_handle); //GET_U24(header);

       if (header != 0x464947) /* 'GIF' */
       {
          return GIF_SW_RET_FAILED;
       }

       ///////////////////////////////////////////////////////////
       // read the GIF dimension
       FLUSH(3);
       temp_width = _get_data(FSAL_ACCESS_U16, pfsal_handle); //GET_U16(temp_width);
       temp_height = _get_data(FSAL_ACCESS_U16, pfsal_handle); //GET_U16(temp_height);

       cache->image_width = temp_width;
       cache->image_height = temp_height;

       /*
        * Check the validity of clipping
        */
       if (ox > g_gif_sw_dest_clipx2 || oy > g_gif_sw_dest_clipy2 ||
           ox + temp_width - 1 < g_gif_sw_dest_clipx1 || oy + temp_height - 1 < g_gif_sw_dest_clipy1)
       {
          return GIF_SW_RET_SUCCEED;
       }

       /* ///////////////////////////////////////////////////////// */
       /*
        * Read the global color palette
        */
       n = _get_data(FSAL_ACCESS_U8, pfsal_handle); //GET_U8(n);

       bg_color_idx = _get_data(FSAL_ACCESS_U8, pfsal_handle);
       FLUSH(1);

       cache->has_gct = ((n & 0x80) > 0) ? 1 : 0;

       if (cache->has_gct)
       {
          kal_int32 i;
          gif_sw_color_from_rgb_func palette_color_from_rgb;

          n = 1 << ((n & 0x7) + 1);

          if (gif_color_format == GIF_SW_COLOR_FORMAT_8)
          {
#if defined(GIF_SUPPORT_SET_PALETTE_FORMAT)
             palette_color_from_rgb = gif_sw_color_from_rgb_array[palette_format];
#else
             palette_color_from_rgb = GIF_SW_PALETTE_COLOR_FROM_RGB;
#endif
          }
          else
          {
             palette_color_from_rgb = g_gif_sw_act_color_from_rgb;
          }

          /* Read the global color palette */
          if (n)
          {
             g_gif_sw_palette_size = n;
          }

          for (i = 0; i < n; i++)
          {
             kal_uint8 R, G, B;

             R = _get_data(FSAL_ACCESS_U8, pfsal_handle);
             G = _get_data(FSAL_ACCESS_U8, pfsal_handle);
             B = _get_data(FSAL_ACCESS_U8, pfsal_handle);
             cache->palette[i] = palette_color_from_rgb(0xFF, R, G, B);
             if ((g_gif_sw_dest_source_key_enable && cache->palette[i] == g_gif_sw_dest_source_key)
             ||  (g_gif_sw_decoder_is_bypass_color && cache->palette[i] == g_gif_sw_decoder_bypass_color))
             {
                cache->palette[i] ^= 1;
             }
          }

          /* current layer is index color layer */
          if (gif_color_format == GIF_SW_COLOR_FORMAT_8)
          {
             for (i = 0; i < (kal_int32) n; i++)
             {
                if(g_gif_sw_layer_set_palette)
                   (*g_gif_sw_layer_set_palette)((kal_uint8) i, cache->palette[i]);
                {
                   cache->palette[i] = i;
                }
             }
          }
       }
       //_gif_sw_set_background_color((gif_sw_color) cache->palette[bg_color_idx]);
       //MAUI_03107299
       g_gif_sw_cache[lcd_idx].original_background = g_gif_sw_background_color;
    }

    /* If resized width > original width or resized height > original height, do not resize */
    if (!is_resized
        || resized_width > cache->image_width
        || resized_height > cache->image_height)
    {
       resized_width = cache->image_width;
       resized_height = cache->image_height;
    }
    /* don't process resized_width/resized_height == 0*/
    if (resized_width == 0 || resized_height == 0)
    {
        return (GIF_SW_RET_SUCCEED);
    }

    /* first draw , we should keep 1 pixels background color for later used. */
    if (!gif_is_hit_cache)
    {
       ////MAUI_03107299
       //g_gif_sw_cache[lcd_idx].original_background = g_gif_sw_background_color;

       {
          kal_int32 x1;
          kal_int32 y1;
          x1 = ox;
          y1 = oy;

          if (x1 < g_gif_sw_dest_clipx1)
          {
             x1 = g_gif_sw_dest_clipx1;
          }
           if (y1 < g_gif_sw_dest_clipy1)
          {
             y1 = g_gif_sw_dest_clipy1;
          }

          /* If using disposal, alloc a memory to save the origianl background. */
          /* If memory is not enougn, use the 1 pixel background color to redraw the background. */
          /* Currently, only support "restore to background", not support "restore to previous". */
          if (g_gif_sw_using_disposal)
          {
             g_gif_sw_cache[lcd_idx].disposal_bg_buf_size = (resized_width * resized_height * DRV_MAINLCD_BIT_PER_PIXEL) >> 3;
             g_gif_sw_cache[lcd_idx].disposal_bg_buf = (kal_uint8 *)g_gif_malloc(g_gif_sw_cache[lcd_idx].disposal_bg_buf_size);

             //SW_GIF_TRACE(MOD_MMI, "[gif_hal_dbg] - _gif_sw_draw_internal() g_gif_sw_using_disposal=KAL_TRUE \n");
             if (g_gif_sw_cache[lcd_idx].disposal_bg_buf)
             {
                gif_sw_rect_struct dest_clip;

                dest_clip.x1 = 0;
                dest_clip.y1 = 0;
                dest_clip.x2 = resized_width - 1;
                dest_clip.y2 = resized_height - 1;

                /* copy the content of original background */
                if(g_gif_sw_bitblt)
                {
                   (*g_gif_sw_bitblt)(
                       g_gif_sw_dest_buf_ptr,  //dst
                       g_gif_sw_dest_buf_width,
                       x1,
                       y1,
                       resized_width,
                       resized_height,
                       cache->disposal_bg_buf, //src
                       resized_width,
                       0,
                       0,
                       dest_clip,
                       DRV_MAINLCD_BIT_PER_PIXEL);
                   //SW_GIF_TRACE(MOD_MMI, "[gif_hal_dbg] - _gif_sw_draw_internal() g_gif_sw_bitblt=KAL_TRUE \n");
                }
             }
          }
       }
Пример #27
0
OFFT CPPF::FileSize(FILE* f)
{
  SEEK(f,0,SEEK_END);
  return(FTELL(f));
}