Esempio n. 1
0
// **************************************************************************
// **************************************************************************
// vma <a>
int P4_vmaccess(int argc, char* argv[])
{
	unsigned short int adr, rpt, upt;

	printf("\nValidate arguments...");	// ?? validate arguments
	adr = INTEGER(argv[1]);

	printf(" = %04x", getMemAdr(adr, 1)-&MEMWORD(0));
	for (rpt = 0; rpt < 64; rpt+=2)
	{
		if (MEMWORD(rpt+TASK_RPT) || MEMWORD(rpt+TASK_RPT+1))
		{
			outPTE("  RPT  =", rpt+TASK_RPT);
			for(upt = 0; upt < 64; upt+=2)
			{
				if (DEFINED(MEMWORD(rpt+TASK_RPT)) &&
						(DEFINED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt))
								|| PAGED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt+1))))
				{
					outPTE("    UPT=", (FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt);
				}
			}
		}
	}
	printf("\nPages = %d", nextPage);
	return 0;
} // end P4_vmaccess
Esempio n. 2
0
void swapOutFrame(int entry1Index)
{
    // clear the definition bit in entry 1 probably just set entry 1 to 0
    int entry1, entry2;

    entry1 = memory[entry1Index];
    entry2 = memory[entry1Index + 1];

    // if dirty bit is not set and swap exists we are done
    if (DIRTY(entry1) && PAGED(entry2)) {
        DEBUG_STATEMENT(DEBUG_MMU,"\nDirty copy of swap write to old page");
        // if swap exits swap access page with old write
        accessPage(SWAPPAGE(entry2), FRAME(entry1), PAGE_OLD_WRITE);
    } else if (!PAGED(entry2)) {
        DEBUG_STATEMENT(DEBUG_MMU,"\nNo copy in swap write to new swap");
        // if swap doesn't exist then we need to write out to an new write
        memory[entry1Index + 1] = entry2 = SET_PAGED(nextPage);
        accessPage(nextPage, FRAME(entry1), PAGE_NEW_WRITE);
    }

    if (DEBUG_MMU) { outPTE("\nSwapped Entry - (Pre-clear) ", entry1Index); }
    memory[entry1Index] = 0;
    if (DEBUG_MMU) { outPTE("Swapped Entry - ", entry1Index); }

    return;
}
Esempio n. 3
0
unsigned short int *getMemAdr(int va, int rwFlg)
{
	unsigned short int pa;
	int rpta, rpte1, rpte2;
	int upta, upte1, upte2;
	int rptFrame, uptFrame;

	// turn off virtual addressing for system RAM
	if (va < 0x3000) return &memory[va];
#if MMU_ENABLE
	rpta = tcb[curTask].RPT + RPTI(va);		// root page table address
	rpte1 = memory[rpta];					// FDRP__ffffffffff
	rpte2 = memory[rpta+1];					// S___pppppppppppp
	if (DEFINED(rpte1))	{ }					// rpte defined
		else			{ }					// rpte undefined
	memory[rpta] = SET_REF(rpte1);			// set rpt frame access bit

	upta = (FRAME(rpte1)<<6) + UPTI(va);	// user page table address
	upte1 = memory[upta]; 					// FDRP__ffffffffff
	upte2 = memory[upta+1]; 				// S___pppppppppppp
	if (DEFINED(upte1))	{ }					// upte defined
		else			{ }					// upte undefined
	memory[upta] = SET_REF(upte1); 			// set upt frame access bit
	return &memory[(FRAME(upte1)<<6) + FRAMEOFFSET(va)];
#else
	return &memory[va];
#endif
} // end getMemAdr
Esempio n. 4
0
// **************************************************************************
// **************************************************************************
// vma <a>
int P4_vmaccess(int argc, char* argv[])
{
	unsigned short int adr, rpt, upt;

	adr = INTEGER(argv[1]);
	printf(" = %04x", getMemAdr(adr, 1)-&MEMWORD(0));
	printf("\nRPTI:%d(0x%x) UPTI:%d(0x%x) OFFSET:%d(0x%x)", RPTI(adr)/2, RPTI(adr), UPTI(adr)/2, UPTI(adr), FRAMEOFFSET(adr), FRAMEOFFSET(adr));

	for (rpt = 0; rpt < 64; rpt+=2)
	{
		if (MEMWORD(rpt+TASK_RPT) || MEMWORD(rpt+TASK_RPT+1))
		{
			outPTE("  RPT  =", rpt+TASK_RPT);
			for(upt = 0; upt < 64; upt+=2)
			{
				if (DEFINED(MEMWORD(rpt+TASK_RPT)) &&
					(DEFINED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt))
					|| PAGED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt+1))))
				{
					outPTE("    UPT=", (FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt);
				}
			}
		}
	}
	printf("\nPages = %d", nextPage);
	return 0;
} // end P4_vmaccess
Esempio n. 5
0
//##ModelId=48DC5D4603C0
void TiLib_OSD_Driver::Test()
{
    UWORD displaySurfWidth = SCREEN_WIDTH;
    UWORD displaySurfHeight = 100;
    UWORD displaySurf_X = 0;
    UWORD displaySurf_Y = SCREEN_HEIGHT - displaySurfHeight;
    
    FRAME(displaySurf_X, displaySurf_Y, displaySurfWidth-1, displaySurf_Y+displaySurfHeight-1, 10, 0xFF0000FF);    
    FRAME(displaySurf_X+10, displaySurf_Y+10, displaySurfWidth-1-10, displaySurf_Y+displaySurfHeight-1-10, 10, 0xFF00FF00);    
    FRAME(displaySurf_X+20, displaySurf_Y+20, displaySurfWidth-1-20, displaySurf_Y+displaySurfHeight-1-20, 10, 0xFFFF0000);    
    FRAME(displaySurf_X+30, displaySurf_Y+30, displaySurfWidth-1-30, displaySurf_Y+displaySurfHeight-1-30, 10, 0xFFFF00FF);    
    FRAME(displaySurf_X+40, displaySurf_Y+40, displaySurfWidth-1-40, displaySurf_Y+displaySurfHeight-1-40, 10, 0xFFFFFF00);    
}
Esempio n. 6
0
/* This will limit the size of the core file by reducing or removing the
 * largest memory segments first, effectively prioritizing the smaller memory
 * segments. This behavior is preferred when the process has a large heap and
 * you would like to preserve the relatively small stack.
 */
int WriteCoreDumpLimitedByPriority(const char *file_name, size_t max_length) {
  FRAME(frame);
  struct CoreDumpParameters params;
  ClearCoreDumpParameters(&params);
  SetCoreDumpLimitedByPriority(&params, max_length);
  return WriteCoreDumpFunction(&frame, &params, file_name);
}
Esempio n. 7
0
void FORTE_TrkEclipse::executeEvent(int pa_nEIID){
  QO() = QI();
  switch (pa_nEIID){
    case scm_nEventREQID:
      if(true == QI()){
        //TODO: test with and without type casts
        track_update(); // get new image data
        COUNT() = static_cast<TForteInt16>(track_count(CH()));

        if(COUNT() > I_BLOB()){ // there is at least I_BLOBs on CH()
          SIZE() = static_cast<TForteInt16>(track_size(CH(), I_BLOB())); //
          FRAME() = static_cast<TForteInt16>(track_get_frame()); //
          CONFIDENCE() = static_cast<TForteInt16>(track_confidence(CH(), I_BLOB()));
          X() = static_cast<TForteInt16>(track_x(CH(), I_BLOB())); // get image  data
          Y() = static_cast<TForteInt16>(track_y(CH(), I_BLOB())); //    and data
          MAJOR() = static_cast<TForteInt16>(track_major_axis(CH(), I_BLOB())); // get image  data
          MINOR() = static_cast<TForteInt16>(track_minor_axis(CH(), I_BLOB())); //    and data

          if(true == INFO()){
            if(COUNT() > I_BLOB()){ // there is a blob
              printf("On Channel=%d  Eclipse Blob#%d is at (X,Y,MAJOR,MINOR)=(%d,%d,%d,%d)\n", (int) CH(), (int) I_BLOB(), (int) X(), (int) Y(), (int) MAJOR(), (int) MINOR());
              printf("\t Confidence=%d; Size=%d;Frame=%d\n", (int) CONFIDENCE(), (int) SIZE(), (int) FRAME());
            }
            else{
              printf("No Blob#%i in sight on Color Channel %i\n", (int) I_BLOB(), (int) CH());
            }
          }

        }

      }
      sendOutputEvent(scm_nEventCNFID);
      break;
  }
}
Esempio n. 8
0
// **************************************************************************
// **************************************************************************
// output page table entry
void outPTE(char* s, int pte)
{
	int pte1, pte2;
	char flags[10];

	// read pt
	pte1 = memory[pte];
	pte2 = memory[pte+1];

	// look at appropriate flags
	strcpy(flags, "-----");
	if (DEFINED(pte1)) flags[0] = 'F';
	if (DIRTY(pte1)) flags[1] = 'D';
	if (REFERENCED(pte1)) flags[2] = 'R';
	if (PINNED(pte1)) flags[3] = 'P';
	if (PAGED(pte2)) flags[4] = 'S';

	// output pte line
	if(DEFINED(pte1) || DEFINED(pte2))
		printf("\n%s x%04x = %04x %04x  %s", s, pte, pte1, pte2, flags);
	if (DEFINED(pte1) || DEFINED(pte2)) printf(" Frame=%d", FRAME(pte1));
	if (DEFINED(pte2)) printf(" Page=%d", SWAPPAGE(pte2));

	return;
} // end outPTE
Esempio n. 9
0
// **************************************************************************
// **************************************************************************
// display contents of UPT
void displayUPT(int rptNum, int uptNum)
{
	unsigned short int rpte, upt, upte1, upte2, uptba;
	rptNum &= BITS_3_0_MASK;
	uptNum &= BITS_4_0_MASK;

	// index to process <rptNum>'s rpt + <uptNum> index
	rpte = MEMWORD(((LC3_RPT + (rptNum<<6)) + uptNum*2));
	// calculate upt's base address
	uptba = uptNum<<11;
	if (!DEFINED(rpte))
		return;
	printf("\nUser Page Table %d", FRAME(rpte));
	upt = FRAME(rpte)<<6;
	displayPT(upt, uptba, 1<<6);
	return;
} // end displayUPT
Esempio n. 10
0
 void Sprite::AddFrame(const iRect &frameRect)
 {
     if (!_texture) return;
     const iSize& texSize = _texture->GetSize();
     fRect frame((float)frameRect.x/texSize.width, (float)frameRect.y/texSize.height,
                 (float)frameRect.width/texSize.width, (float)frameRect.height/texSize.height);
     _frames.push_back(FRAME(frame));
 }
Esempio n. 11
0
/* Attempts to compress the core file on the fly, if a suitable compressor
 * could be located. Sets "selected_compressor" to the compressor that
 * was picked.
 */
int GetCompressedCoreDump(const struct CoredumperCompressor compressors[],
                          struct CoredumperCompressor **selected_compressor) {
  FRAME(frame);
  struct CoreDumpParameters params;
  ClearCoreDumpParameters(&params);
  SetCoreDumpCompressed(&params, compressors, selected_compressor);
  return GetCoreDumpFunction(&frame, &params);
}
Esempio n. 12
0
BOOL CPubThread::FtpImage(LPCTSTR pServer, CFtp *pFtp, LPBYTE buf, DWORD size, LPCTSTR pPath)
{
	// Sanity checks
	if ( pServer == NULL || pFtp == NULL || buf == NULL || size == 0 || pPath == NULL )
		return FALSE;

	// Is the FTP already working?
	if ( pFtp->IsConnecting() || pFtp->IsConnected() )
		return FALSE;

	// Reset the FTP object
	pFtp->Destroy();
	
	// Ensure we have server information
	HGROUP hGroup = FTPSERVERS().FindGroup( pServer );
	if ( hGroup == NULL )
	{	_Log( MB_ICONERROR, pServer, "FTP server information not found" );
		return FALSE;
	} // end if

	char user[ CWF_STRSIZE ];
	char password[ CWF_STRSIZE ];
	char addr[ CWF_STRSIZE ];
	char folder[ CWF_STRSIZE ];
	DWORD port = 21;
	DWORD passive = 1;

	strcpy( addr, FTPSERVERS().GetSz( hGroup, "Address" ) );
	strcpy( folder, FTPSERVERS().GetSz( hGroup, "Folder" ) );
	strcpy( user, FTPSERVERS().GetSz( hGroup, "Username" ) );
	strcpy( password, FTPSERVERS().GetSz( hGroup, "Password" ) );
	port = FTPSERVERS().GetDword( hGroup, "Port", 21 );
	passive = FTPSERVERS().GetDword( hGroup, "Passive", 1 );

	// Set passive FTP mode
	pFtp->SetPassiveMode( passive != 0 );

	// Connect to server
	pFtp->SetUsernamePassword( user, password );
	if ( !pFtp->Connect( addr, port ) ) return FALSE;

	// Build full path to remote file
	CWinFile::WebBuildPath( folder, folder, pPath );

	// Upload file
	pFtp->AutoClose( TRUE );
	if ( !pFtp->Upload( buf, size, folder ) )
	{	_Log( MB_ICONERROR, addr, "Upload error" );
		return FALSE;
	} // end if

	// Inform user
	char msg[ CWF_STRSIZE ];
	wsprintf( msg, "Uploading %s to %s", folder, addr );
	FRAME()->SetStatus( msg );

	return TRUE;
}
Esempio n. 13
0
int GetCoreDumpWith(const struct CoreDumpParameters *params) {
  FRAME(frame);
  if ((params->flags & COREDUMPER_FLAG_LIMITED) ||
      (params->flags & COREDUMPER_FLAG_LIMITED_BY_PRIORITY)) {
    errno = EINVAL;
    return -1;
  }
  return GetCoreDumpFunction(&frame, params);
}
Esempio n. 14
0
BOOL CPubThread::Email(LPPUBINFO ppi)
{
	if ( ppi == NULL || ppi->pemi == NULL ) return FALSE;

	// Inform user
	char msg[ CWF_STRSIZE ];
	wsprintf( msg, "Emailing %s to %s", ppi->pub_fname, ppi->pemi->to );
	FRAME()->SetStatus( msg );

	// Get FTP object
	CEmailThread *pEmail = ppi->pemail;
	if ( pEmail == NULL )
	{	_Log( MB_ICONERROR, ppi->str, "Invalid object." );
		return FALSE;
	} // end if

	HGROUP hGroup = EMAILSERVERS().FindGroup( ppi->str );
	if ( hGroup == NULL ) 
	{	_Log( MB_ICONERROR, ppi->str, "Email Server information not found." );
		return FALSE;
	} // end if

	CString server = (LPCTSTR)EMAILSERVERS().GetValuePtr( hGroup, "Address" );
	CString username = (LPCTSTR)EMAILSERVERS().GetValuePtr( hGroup, "Username" );
	CString password = (LPCTSTR)EMAILSERVERS().GetValuePtr( hGroup, "Password" );

	DWORD login = 0;
	EMAILSERVERS().GetValue( hGroup, "Login", &login );

	DWORD authdetect = 1;
	EMAILSERVERS().GetValue( hGroup, "AuthDetect", &authdetect );

	DWORD authtype = 0;
	EMAILSERVERS().GetValue( hGroup, "AuthType", &authtype );

	// Is it an avi file
	if ( *ppi->avicachefile != 0 )

		// E-mail the AVI
		return pEmail->Email(	NULL, ppi->avicachefile,
								ppi->pemi->to, ppi->pemi->from,
								ppi->pemi->subject, ppi->pub_fname,
								server, username, password, 
								ppi->pemi->body, login, 
								authdetect, authtype );


	// E-mail image
	return pEmail->Email(	ppi->img, NULL,
							ppi->pemi->to, ppi->pemi->from,
							ppi->pemi->subject, ppi->pub_fname,
							server, username, password, 
							ppi->pemi->body, login, 
							authdetect, authtype );

}
Esempio n. 15
0
/* Attempts to compress the core file on the fly, if a suitable compressor
 * could be located. Sets "selected_compressor" to the compressor that
 * was picked. The filename automatically has a suitable suffix appended
 * to it. Normally this would be ".bz2" for bzip2 compression ".gz" for
 * gzip compression, or ".Z" for compress compression. This behavior can
 * be changed by defining custom CoredumperCompressor descriptions.
 */
int WriteCompressedCoreDump(const char *file_name, size_t max_length,
                            const struct CoredumperCompressor compressors[],
                            struct CoredumperCompressor **selected_compressor){
  FRAME(frame);
  struct CoreDumpParameters params;
  ClearCoreDumpParameters(&params);
  SetCoreDumpCompressed(&params, compressors, selected_compressor);
  SetCoreDumpLimited(&params, max_length);
  return WriteCoreDumpFunction(&frame, &params, file_name);
}
Esempio n. 16
0
void dump_rpt_and_upt()
{
  int rpt, upt;
  for (rpt = 0; rpt < 64; rpt+=2)
  {
    if (MEMWORD(rpt+TASK_RPT) || MEMWORD(rpt+TASK_RPT+1))
    {
      outPTE("  RPT  =", rpt+TASK_RPT);
      for(upt = 0; upt < 64; upt+=2)
      {
        if (DEFINED(MEMWORD(rpt+TASK_RPT)) &&(DEFINED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt))
                          || PAGED(MEMWORD((FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt+1))))
        {
          outPTE("    UPT=", (FRAME(MEMWORD(rpt+TASK_RPT))<<6)+upt);
        }
      }
    }
  }
}
Esempio n. 17
0
// **************************************************************************
// **************************************************************************
// look at virtual memory location va
void lookVM(int va)
{
   unsigned short int rpte1, rpte2, upte1, upte2, pa;

   // get root page table entry
	rpte1 = MEMWORD(LC3_RPT + RPTI(va));
   rpte2 = MEMWORD(LC3_RPT + RPTI(va) + 1);
   if (DEFINED(rpte1))
   {	upte1 = MEMWORD((FRAME(rpte1)<<6) + UPTI(va));
		upte2 = MEMWORD((FRAME(rpte1)<<6) + UPTI(va) + 1);
   }
   else
   {
		// rpte undefined
		printf("\n  RTB[Undefined]");
		return;
	}
  	if (DEFINED(upte1))
	{
		pa = (FRAME(upte1)<<6) + FRAMEOFFSET(va);
	}
   else
   {
		// upte undefined
     	printf("\n  UTB[Undefined]");
		return;
   }
   printf("\n  RPT[0x%04x] = %04x %04x", LC3_RPT + RPTI(va), rpte1, rpte2);
      if (rpte1&BIT_14_MASK) printf(" D");
      if (rpte1&BIT_13_MASK) printf(" R");
      if (rpte1&BIT_12_MASK) printf(" P");
      printf(" Frame=%d", rpte1&0x03ff);
      if (DEFINED(rpte2)) printf(" Page=%d", rpte2&0x0fff);
   printf("\n  UPT[0x%04x] = %04x %04x", (FRAME(rpte1)<<6) + UPTI(va), upte1, upte2);
      if (upte1&BIT_14_MASK) printf(" D");
      if (upte1&BIT_13_MASK) printf(" R");
      if (upte1&BIT_12_MASK) printf(" P");
      printf(" Frame=%d", upte1&0x03ff);
      if (DEFINED(upte2)) printf(" Page=%d", upte2&0x0fff);
   printf("\n  MEM[0x%04x] = %04x", pa, MEMWORD(pa));
	return;
} // end lookVM
Esempio n. 18
0
BOOL CDlgImgView::SaveImg()
{
	CWinImg img, *pimg = &img;

	if ( m_bCapture )
	{
		char title[ CWF_STRSIZE ];
		GetWindowText( title, sizeof( title ) );
		if ( !IMGLIST().GetImage( title, &img ) )
		{	_Log( MB_ICONERROR, "Error loading image", title );
			return FALSE;
		} // end if
		
	} // end if

	else
	{
		pimg = m_img.GetImg();
		if ( pimg == NULL || !pimg->IsValid() )
		{	_Log( MB_ICONERROR, "Save Image", "Image not available" );
			return FALSE;
		} // end if

	} // end else

	// Get the file name
	char filename[ CWF_STRSIZE ] = { 0 };
	if ( !CWinFile::GetSaveFileName(	filename, "Save Image As",
										"All Images (*.bmp;*.jpg;*.jpeg;*.png;*.ico;*.tif;*.tiff;*.tga;*.pcx;*.wmf;*.emf;*.jp2)\x0*.bmp;*.jpg;*.jpeg;*.png;*.ico;*.tif;*.tiff;*.tga;*.pcx;*.wmf;*.emf;*.jp2\x0"
										"Windows Bitmap (*.bmp;*.dib)\x0*.bmp;*.dib\x0"
										"JPEG (*.jpg;*.jpeg)\x0*.jpg;*.jpeg\x0"
										"Portable Network Graphic (*.png)\x0*.png\x0"
										"Icon (*.ico)\x0*.ico\x0"
										"Tagged Image File (*.tif; *.tiff)\x0*.tif;*.tiff\x0"
										"Targa (*.tga)\x0*.tga\x0"
										"PC Paintbrush (*.pcx)\x0*.pcx\x0"
										"Windows Metafile (*.wmf;*.emf)\x0*.wmf;*.emf\x0"
										"JPEG 2000 (*.jp2)\x0*.jp2\x0"
										"All Files (*.*)\x0*.*\x0",
										"jpg",
									 GetSafeHwnd() ) ) return FALSE;

	// Save the image
	FRAME()->SetQuality( pimg );
	if ( !pimg->Save( filename ) )
	{	_Log( MB_ICONERROR, "Error saving image", pimg->GetLastError() );
		return FALSE;
	} // end if

	return TRUE;
}
Esempio n. 19
0
void CPgImageProp::OnChangeName() 
{
	UpdateData( TRUE );

	// Get the current image
	LPPUBIMGINFO ppii = IMGLIST().GetSelImage();
	if ( ppii == NULL ) return;

	// Verify non-NULL non-preexisting name
	if ( !m_sName.IsEmpty() && IMGLIST().FindByName( m_sName ) == NULL )
		strcpy( ppii->name, m_sName );

	FRAME()->SetUpdateTimer();
}
Esempio n. 20
0
void StencilSwap::fire(void){
	LOAD_FRAME(Stencil2DPartition);
	uint64_t timestep = FRAME(timeStep);
	double *src = FRAME(Initial); //matrix pointer initial Matrix[M][N]
	const uint64_t InitialM = FRAME(nRows); // matrix M row
	const uint64_t InitialN = FRAME(nCols); // Matrix N column
	double *dst = FRAME(New);
	timestep --;

	typedef double (*Array2D)[InitialN];
	Array2D DST = (Array2D) dst,
			SRC = (Array2D) src;
	SWAP_PTR(&DST,&SRC);

	if (timestep == 0)
		SIGNAL(signalUP);
	else if (timestep !=0){
	//	INVOKE(Stencil2D,NewMatrix,InitialM,InitialN,InitialMatrix,timestep,&Runtime::finalSignal);

		INVOKE(Stencil2DPartition,src,InitialM,InitialN,dst,timestep,&Runtime::finalSignal);
	}
	EXIT_TP();
}
Esempio n. 21
0
void StencilComputeInner::fire(void){
	LOAD_FRAME(Stencil2DPartition);
	
	double *Initial = FRAME(Initial); //matrix pointer initial Matrix[M][N]
	const uint64_t n_rows = FRAME(nRows); // matrix M row
	const uint64_t n_cols = FRAME(nCols); // Matrix N column
	double *New = FRAME(New);
	uint64_t n_totalsize = (n_rows-2)*(n_cols-2);//the total number of pixel in inner matrix (the whole matrix - left_edge - right_edge - upper_edge - down_edge)
	uint64_t n_rowscut = n_totalsize/TOTAL_TILE_SZ ;	
	uint64_t n_threads = (g_nCU+1)*g_nSU*N_THREADS;//(nCU+1)*nSU is available cores, N_THREADS are number of threads per cores
	/*
	*if the matrix < 84*84 (n_rowscut <1)
	*then final_cut =1, only allocate one core to compute 
	*if the matrix larger one core cache (matrix are very large or suitable for available cores)   
	*then final_cut = n_threads
	*if the matrix is very large (larger than total available core cache size), we will cut them to suitable size within the rowdecomposition TP.
	**/
	uint64_t n_rowscut_final = (n_rowscut<1)?1:n_threads;

	ADD(swapMatrix);
	INVOKE(Stencil2DRowDecomposition,n_rowscut_final,Initial,n_rows,n_cols,New,&FRAME(swapMatrix));
	EXIT_TP();

}
Esempio n. 22
0
void CPgImageProp::OnChangeHeight() 
{
	UpdateData( TRUE );

	// Get the current image
	LPPUBIMGINFO ppii = IMGLIST().GetSelImage();
	if ( ppii == NULL ) return;

	long h = strtoul( m_sHeight, NULL, 10 );
	if ( h <= 8 || h > 2600 ) h = 320;

	ppii->rect.bottom = ppii->rect.top + h;

	EDIT().Size( NULL );

	// Regen everything
	FRAME()->SetUpdateTimer();
}
Esempio n. 23
0
void CPgImageProp::OnChangeWidth() 
{
	UpdateData( TRUE );

	// Get the current image
	LPPUBIMGINFO ppii = IMGLIST().GetSelImage();
	if ( ppii == NULL ) return;

	long w = strtoul( m_sWidth, NULL, 10 );
	if ( w <= 8 || w > 2600 ) w = 320;

	ppii->rect.right = ppii->rect.left + w;

	EDIT().Size( NULL );

	// Regen everything
	FRAME()->SetUpdateTimer();
}
Esempio n. 24
0
int
as_copy(struct addrspace *old, struct addrspace **ret, pid_t pid)
{
	struct addrspace *newas;
	struct page *newpage, *page;
	int i;
	int nindex, oindex;
	paddr_t nf, of;

	newas = as_create();
	if (newas==NULL) {
		return ENOMEM;
	}

	for(i=0;i<array_getnum(old->pages);i++)
	{
		newpage = (struct page *) kmalloc(sizeof(struct page));
		if (newpage==NULL)
			return ENOMEM;
		page = (struct page *) array_getguy(old->pages, i);
		memcpy(newpage, page, sizeof(struct page));
		array_add(newas->pages, newpage);

		oindex = getindex(newpage->vaddr);
		of = FRAME(oindex);

		nindex = addpage(newpage->vaddr,
				pid, 
				newpage->perms & P_R_B,
				newpage->perms & P_W_B,
				newpage->perms & P_X_B,
				PADDR_TO_KVADDR(of));


	}

	*ret = newas;
	return 0;
}
Esempio n. 25
0
void Stencil2DPartitionChunks::fire(void) 
{
	LOAD_FRAME(Stencil2DPartition);
	double *initial = FRAME(initial); //matrix pointer initial Matrix[M][n]
	const uint64_t n_rows = FRAME(nRows); // matrix M row
	const uint64_t n_cols = FRAME(nCols); // Matrix N column
//	double *share = FRAME(shareChunks);
	uint64_t ts=FRAME(timeStep);	
	uint64_t nTpRows = n_rows-2;
	uint64_t nChunks=nTpRows/g_nSU;
	uint64_t	*n_tpSync = FRAME(nTpSync);
	
	for(size_t i=0; i<g_nSU; ++i){
		uint64_t pos = nChunks*i*n_cols;
		uint64_t nTpRowsFinal = ((i==(g_nSU-1))? (nTpRows%g_nSU):0) + nChunks;
		INVOKE(Stencil2DRowDecomposition,initial+pos,nTpRowsFinal+2,n_cols,ts,i,n_tpSync, &FRAME(sync)); 
	}

	EXIT_TP();

}
Esempio n. 26
0
/*---------------------------------------------------------------------------*
 * Routine:  DR_Save
 *---------------------------------------------------------------------------*
 * Description:
 *      Save the currently shown image to the flash drive.
 * Inputs:
 *      const T_choice *aChoice   -- Choice object selected for this action.
 *---------------------------------------------------------------------------*/
static void DR_Save(const T_choice *aChoice)
{
    T_uezError error;
    T_uezError errorUSB, errorSD;
    T_uezFile file;
    INT_32 winX, winY;
    T_pixelColor *raster;
    TUInt32 num;
    TUInt16 x, y;

    // Draw line around choice while saving
    swim_set_fill_transparent(&G_drWin, 1);
    swim_set_pen_color(&G_drWin, YELLOW);
    swim_put_box(
        &G_drWin,
        aChoice->iLeft,
        aChoice->iTop,
        aChoice->iRight,
        aChoice->iBottom);

    // Try to save to the USB drive
    error = errorUSB = UEZFileOpen("0:IMAGE.RAW", FILE_FLAG_WRITE, &file);

    // If an error, try to save to the SD Card
    if (error != UEZ_ERROR_NONE)
        error = errorSD = UEZFileOpen("1:IMAGE.RAW", FILE_FLAG_WRITE, &file);
    else
        errorSD = UEZ_ERROR_UNKNOWN;

    // Any errors?
    if (error == UEZ_ERROR_NONE) {
        raster = (T_pixelColor  *)LOAD_SPACE;
        for (y=0; y<DR_IMAGE_HEIGHT; y++) {
            for (x=0; x<DR_IMAGE_WIDTH; x++) {
                winX = x + DR_IMAGE_LEFT+1;
                winY = y + DR_IMAGE_TOP+1;
                swim_get_physical_xy(&G_drWin, &winX, &winY);
                swim_driver_get_raster(&G_drWin, winX, winY, (COLOR_T *)raster, 1); // get pixel color
                raster++;
            }
        }
        // Save image
        error = UEZFileWrite(
                    file,
                    LOAD_SPACE,
                    DR_IMAGE_WIDTH*DR_IMAGE_HEIGHT*sizeof(T_pixelColor),
                    &num);
        if ((error != UEZ_ERROR_NONE) &&
                (num != DR_IMAGE_WIDTH*DR_IMAGE_HEIGHT*sizeof(T_pixelColor))) {
            BeepError();
        }
        UEZFileClose(file);
    } else {
        // Had an error, report it
        SUICopyFast32(FRAME(1), FRAME(0), FRAME_SIZE);
        BeepError();
        swim_set_fill_transparent(&G_drWin, 0);
        swim_set_fill_color(&G_drWin, BLACK);
        swim_set_pen_color(&G_drWin, YELLOW);
        swim_put_box(
            &G_drWin,
            DR_IMAGE_LEFT,
            DR_IMAGE_TOP,
            DR_IMAGE_RIGHT,
            DR_IMAGE_TOP+16);
        if (errorUSB == UEZ_ERROR_NOT_FOUND) {
            if (errorSD == UEZ_ERROR_NOT_READY) {
                swim_put_text_xy(
                    &G_drWin,
                    "Could not write image to USB Drive",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            } else if (errorSD == UEZ_ERROR_NOT_FOUND) {
                swim_put_text_xy(
                    &G_drWin,
                    "Could not write to USB Drive or SD Card",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            } else {
                swim_put_text_xy(
                    &G_drWin,
                    "Could not write to USB Drive",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            }
        } else if (errorUSB == UEZ_ERROR_NOT_READY) {
            if (errorSD == UEZ_ERROR_NOT_READY) {
                swim_put_text_xy(
                    &G_drWin,
                    "No USB Drive or SDCard found!",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            } else if (errorSD == UEZ_ERROR_NOT_FOUND) {
                swim_put_text_xy(
                    &G_drWin,
                    "Could not write to SD Card!",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            } else {
                swim_put_text_xy(
                    &G_drWin,
                    "Could not write to SD Card!",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            }
        } else {
            swim_put_text_xy(
                &G_drWin,
                "Write error!",
                DR_IMAGE_LEFT+2,
                DR_IMAGE_TOP+2);
        }
        swim_set_fill_transparent(&G_drWin, 1);
        UEZTaskDelay(2000);
        SUICopyFast32(FRAME(0), FRAME(1), FRAME_SIZE);
    }

    swim_set_fill_transparent(&G_drWin, 1);
    swim_set_pen_color(&G_drWin, BLACK);
    swim_put_box(
        &G_drWin,
        aChoice->iLeft,
        aChoice->iTop,
        aChoice->iRight,
        aChoice->iBottom);
}
Esempio n. 27
0
/*---------------------------------------------------------------------------*
 * Routine:  DR_Load
 *---------------------------------------------------------------------------*
 * Description:
 *      Load an image from the flash drive and show.
 * Inputs:
 *      const T_choice *aChoice   -- Choice object selected for this action.
 *---------------------------------------------------------------------------*/
static void DR_Load(const T_choice *aChoice)
{
    T_uezError error;
    T_uezError errorUSB, errorSD;
    T_uezFile file;
    INT_32 winX, winY;
    TUInt32 num;
    TUInt16 x, y;

    // Draw line around choice while loading
    swim_set_fill_transparent(&G_drWin, 1);
    swim_set_pen_color(&G_drWin, YELLOW);
    swim_put_box(
        &G_drWin,
        aChoice->iLeft,
        aChoice->iTop,
        aChoice->iRight,
        aChoice->iBottom);

    // Try to load from the USB drive
    error = errorUSB = UEZFileOpen("0:IMAGE.RAW", FILE_FLAG_READ_ONLY, &file);

    // If an error, try to load from the SD Card
    if (error != UEZ_ERROR_NONE)
        error = errorSD = UEZFileOpen("1:IMAGE.RAW", FILE_FLAG_READ_ONLY, &file);
    else
        errorSD = UEZ_ERROR_UNKNOWN;

    // Continue if no errors
    if (error == UEZ_ERROR_NONE) {
        error = UEZFileRead(
                    file,
                    LOAD_SPACE,
                    DR_IMAGE_WIDTH*DR_IMAGE_HEIGHT*sizeof(T_pixelColor),
                    &num);
        UEZFileClose(file);
        if ((error != UEZ_ERROR_NONE) &&
                (num != DR_IMAGE_WIDTH*DR_IMAGE_HEIGHT*sizeof(T_pixelColor))) {
            BeepError();
        } else {
            T_pixelColor *raster = (T_pixelColor *)LOAD_SPACE;
            for (y=0; y<DR_IMAGE_HEIGHT; y++) {
                for (x=0; x<DR_IMAGE_WIDTH; x++) {
                    winX = x + DR_IMAGE_LEFT+1;
                    winY = y + DR_IMAGE_TOP+1;
                    swim_get_physical_xy(&G_drWin, &winX, &winY);
                    swim_driver_put_pixel(&G_drWin, winX, winY, raster[x]);
                }
                raster += DR_IMAGE_WIDTH;
            }
        }
    }
    if (error) {
        // Had an error, report it
        SUICopyFast32(FRAME(1), FRAME(0), FRAME_SIZE);
        BeepError();
        swim_set_fill_transparent(&G_drWin, 0);
        swim_set_fill_color(&G_drWin, BLACK);
        swim_set_pen_color(&G_drWin, YELLOW);
        swim_put_box(
            &G_drWin,
            DR_IMAGE_LEFT,
            DR_IMAGE_TOP,
            DR_IMAGE_RIGHT,
            DR_IMAGE_TOP+16);
        if (errorUSB == UEZ_ERROR_NOT_FOUND) {
            if (errorSD == UEZ_ERROR_NOT_READY) {
                swim_put_text_xy(
                    &G_drWin,
                    "Image file not found on USB Drive!",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            } else if (errorSD == UEZ_ERROR_NOT_FOUND) {
                swim_put_text_xy(
                    &G_drWin,
#if UEZ_DEFAULT_LCD_RES_QVGA
                    // Shorter string on QVGA screens
                    "Image file not found on USB or SD Card!",
#else
                    "Image file not found on USB Drive or SD Card!",
#endif
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            } else {
                swim_put_text_xy(
                    &G_drWin,
                    "Image file not found on USB Drive!",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            }
        } else if (errorUSB == UEZ_ERROR_NOT_READY) {
            if (errorSD == UEZ_ERROR_NOT_READY) {
                swim_put_text_xy(
                    &G_drWin,
                    "No USB Drive or SD Card found!",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            } else if (errorSD == UEZ_ERROR_NOT_FOUND) {
                swim_put_text_xy(
                    &G_drWin,
                    "Image file not found on SD Card!",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            } else {
                swim_put_text_xy(
                    &G_drWin,
                    "No USB Drive or SD Card found!",
                    DR_IMAGE_LEFT+2,
                    DR_IMAGE_TOP+2);
            }
        } else {
            swim_put_text_xy(
                &G_drWin,
                "Read error!",
                DR_IMAGE_LEFT+2,
                DR_IMAGE_TOP+2);
        }
        swim_set_fill_transparent(&G_drWin, 1);
        UEZTaskDelay(2000);
        SUICopyFast32(FRAME(0), FRAME(1), FRAME_SIZE);
    }

    swim_set_fill_transparent(&G_drWin, 1);
    swim_set_pen_color(&G_drWin, BLACK);
    swim_put_box(
        &G_drWin,
        aChoice->iLeft,
        aChoice->iTop,
        aChoice->iRight,
        aChoice->iBottom);
}
Esempio n. 28
0
BOOL CPubThread::Disk(LPPUBINFO ppi)
{
	if ( ppi == NULL ) return FALSE;

	// Is it an avi file
	if ( *ppi->avicachefile != 0 )
	{
		// Build target filename
		char fname[ CWF_STRSIZE ];
		CWinFile::BuildPath( fname, ppi->path, ppi->pub_fname );

		// Copy the file
		if ( !MoveFile( ppi->avicachefile, fname ) )
			CopyFile( ppi->avicachefile, fname, FALSE );

	} // end if

	else
	{
		CWinImg img;

		// Get the image
		if ( !IMGLIST().GetImage( ppi->img, &img ) )
		{	_Log( MB_ICONERROR, ppi->img, "Invalid image." );
			return FALSE;
		} // end if

		// Inform user
		char msg[ CWF_STRSIZE ];
		wsprintf( msg, "Saving %s to %s", ppi->pub_fname, ppi->path );
		FRAME()->SetStatus( msg );

		char fname[ CWF_STRSIZE ];
		CWinFile::BuildPath( fname, ppi->path, ppi->pub_fname );
		
		// Save the file
		if ( !img.Save( fname ) )
		{	_Log( MB_ICONERROR, ppi->img, img.GetLastError() );
		} // end if

	} // end else

	// Punt if no thumbnail
	if ( ( ppi->f1 & PUBF1_THUMBNAIL ) == 0 ) return TRUE;

	// Is it an avi file
	if ( *ppi->thmavicachefile != 0 )
	{
		// Build target filename
		char fname[ CWF_STRSIZE ];
		CWinFile::BuildPath( fname, ppi->path, ppi->pub_tfname );

		// Copy the file
		if ( !MoveFile( ppi->thmavicachefile, fname ) )
			CopyFile( ppi->thmavicachefile, fname, FALSE );

	} // end if

	else
	{
		CWinImg img;

		// Get thumbnail
		GetThumbnail( ppi, &img, img.GetWidth(), img.GetHeight() );

		// Build thumbnail path
		char fname[ CWF_STRSIZE ];
		CWinFile::BuildPath( fname, ppi->path, ppi->pub_tfname );
		
		// Save thumbnail
		if ( !img.Save( fname ) )
		{	_Log( MB_ICONERROR, ppi->img, img.GetLastError() );
		} // end if

	} // end else

	return TRUE;
}
Esempio n. 29
0
BOOL CPubThread::FtpImage(LPCTSTR pServer, CNetFile *pNf, LPBYTE buf, DWORD size, LPCTSTR pPath)
{
	// Sanity checks
	if ( pServer == NULL || pNf == NULL || buf == NULL || size == 0 || pPath == NULL )
		return FALSE;

	// Is the FTP already working?
	if ( pNf->IsWorking() ) return FALSE;
	pNf->Destroy();
	
	// Ensure we have server information
	HGROUP hGroup = FTPSERVERS().FindGroup( pServer );
	if ( hGroup == NULL ) return FALSE;

	char user[ CWF_STRSIZE ];
	char password[ CWF_STRSIZE ];
	char addr[ CWF_STRSIZE ];
	char folder[ CWF_STRSIZE ];
	DWORD port = 21;
	DWORD passive = 1;

	// Get server information
	strcpy( addr, FTPSERVERS().GetSz( hGroup, "Address" ) );
	strcpy( folder, FTPSERVERS().GetSz( hGroup, "Folder" ) );
	strcpy( user, FTPSERVERS().GetSz( hGroup, "Username" ) );
	strcpy( password, FTPSERVERS().GetSz( hGroup, "Password" ) );
	port = FTPSERVERS().GetDword( hGroup, "Port", 21 );
	passive = FTPSERVERS().GetDword( hGroup, "Passive", 1 );

//	FTPSERVERS().GetValue( hGroup, "Address", addr, sizeof( addr ) );
//	FTPSERVERS().GetValue( hGroup, "Folder", folder, sizeof( folder ) );
//	FTPSERVERS().GetValue( hGroup, "Port", &port );
//	FTPSERVERS().GetValue( hGroup, "Username", user, sizeof( user ) );
//	FTPSERVERS().GetValue( hGroup, "Password", password, sizeof( password ) );
//	FTPSERVERS().GetValue( hGroup, "Passive", &passive );

	char connect[ CWF_STRSIZE * 2 ];
	strcpy( connect, "ftp://" );
	strcat( connect, addr );
	CWinFile::WebBuildPath( connect, connect, folder );
	CWinFile::WebBuildPath( connect, connect, pPath );

	// Connect to server
	pNf->SetUsernamePassword( user, password );

	// Set callback
	pNf->SetCallback( CPubThread::OnNfCallback, (DWORD)this );

	// Upload the data
	if ( !pNf->Upload( connect, buf, size, passive != 0 ) )
	{	_Log( MB_ICONERROR, connect, "Upload error" );
		return FALSE;
	} // end if

	// Inform user
	char msg[ CWF_STRSIZE ];
	wsprintf( msg, "Uploading %s", connect );
	FRAME()->SetStatus( msg );

	return TRUE;
}
Esempio n. 30
0
BOOL CPubThread::DoThread(LPVOID pData)
{
	DWORD enablepublishing = 0;
	CFG().GetValue( "Settings", "EnablePublishing", &enablepublishing );

	// Punt if publishing is disabled
	if ( !enablepublishing )
	{	m_bReset = TRUE;
		Sleep( 1000 ); return TRUE;
	} // end if

	DWORD tickcount = GetTickCount();
	
	SYSTEMTIME	st;
	GetSystemTime( &st );

	// Calculate seconds offset
	DWORD seconds = ( st.wHour * 60 * 60 ) + ( st.wMinute * 60 ) + st.wSecond;

	// Process each job
	LPPUBINFO ppi = NULL;
	while ( ( ppi = (LPPUBINFO)PUBLIST().GetNext( ppi ) ) != NULL )
	{
		try
		{
			// Is publishing on hold?
			if ( ppi->bHold ) continue;

			// Image information
			LPPUBIMGINFO ppii = NULL;

			// Are we doing any avi capturing?
			if ( ( ppi->f1 & ( PUBF1_AVI | PUBF1_THMAVI ) ) != 0 )
			{
				// Update AVI's
				if ( ( ppi->f1 & PUBF1_AVICAPMOTION ) == 0 || IsMotion( ppi ) )
				{
					// Check for avi
					if ( ( ppi->f1 & PUBF1_AVI ) != 0 )
					{
						// Time to capture?
						if (	( ppi->f1 & PUBF1_AVICAPMOTION ) != 0 || 
								ppi->avitimeout < tickcount )
						{
							ppii = IMGLIST().FindByName( ppi->img );
							if ( ppii != NULL )
							{
								// Refresh the image
								IMGLIST().Update( ppii, TRUE );

								// Wait for next frame
								if ( ppi->capframes < 1 ) ppi->capframes = 1;
								if ( ppi->capseconds < 1 ) ppi->capseconds = 1;
								long delay = ( ppi->capseconds * 1000 ) / ppi->capframes;
								ppi->avitimeout = tickcount + delay;

								// Write out a frame of the avi
								WriteAviFrame( ppi, ppi->avi, ppii, ppi->pub_fname );
							
							} // end if

						} // end if

					} // end if

					// Check for thumbnail avi
					if ( ( ppi->f1 & PUBF1_THMAVI ) != 0 )
					{
						// Time to capture?
						if (	( ppi->f1 & PUBF1_AVICAPMOTION ) != 0 || 
								ppi->thmavitimeout < tickcount )
						{
							// Get image if we don't already have it
							if ( ppii == NULL )
							{	ppii = IMGLIST().FindByName( ppi->img );
								IMGLIST().Update( ppii, TRUE );
							} // end if

							if ( ppii != NULL )
							{
								// Wait for next frame
								if ( ppi->capframes < 1 ) ppi->capframes = 1;
								if ( ppi->capseconds < 1 ) ppi->capseconds = 1;
								long delay = ( ppi->capseconds * 1000 ) / ppi->capframes;
								ppi->thmavitimeout = tickcount + delay;

								// Write out a frame of the avi
								WriteAviFrame( ppi, ppi->thmavi, ppii, ppi->pub_tfname );

							} // end if

						} // end if

					} // end if

				} // end if

			} // end if

			// Are we detecting motion?
			if ( ( ppi->f1 & PUBF1_MOTION ) != 0 )
			{
				if ( IsMotion( ppi ) )
				{
					// Save motion time
					if ( ppi->motioninterval == 0 ) ppi->motioninterval = 30;
					ppi->nextmotion = GetTickCount() + ( ppi->motioninterval * 1000 );

					// Get current file name
					GetFileName( ppi );

					// Refresh the image
					if ( ppii == NULL ) IMGLIST().Update( ppi->img, TRUE );

					// Handle avi
					if ( ( ppi->f1 & PUBF1_AVI ) != 0 )
					{
						if ( ppi->avi->IsOpen() )
						{
							// Save avi filename
							strcpy( ppi->avicachefile, ppi->avi->GetFileName() );
							ppi->avi->Close();

							// Save thumbnail avi filename
							strcpy( ppi->thmavicachefile, ppi->thmavi->GetFileName() );
							ppi->thmavi->Close();

						} // end if

					} // end if

					// Handle thumbnail avi
					if ( ( ppi->f1 & PUBF1_THMAVI ) != 0 )
					{
						if ( ppi->thmavi->IsOpen() )
						{
							// Save avi filename
							strcpy( ppi->thmavicachefile, ppi->thmavi->GetFileName() );
							ppi->thmavi->Close();

							// Save thumbnail avi filename
							strcpy( ppi->thmavicachefile, ppi->thmavi->GetFileName() );
							ppi->thmavi->Close();

						} // end if

					} // end if

					BOOL bPublished = FALSE;

					// Check for FTP
					if ( ppi->type == PUBTYPE_FTP ) bPublished = Ftp( ppi );

					// Check for Email
					else if ( ppi->type == PUBTYPE_EMAIL ) bPublished = Email( ppi );

					// Check for Disk
					else if ( ppi->type == PUBTYPE_DISK ) bPublished = Disk( ppi );

					if ( bPublished )
					{
						// Inform FRAME
						if ( ppi->type == PUBTYPE_FTP ) FRAME()->SetEvent( 2 );
						else if ( ppi->type == PUBTYPE_EMAIL ) FRAME()->SetEvent( 3 );
						else if ( ppi->type == PUBTYPE_DISK ) FRAME()->SetEvent( 4 );

						// Play sound if needed
						if ( ( ppi->f1 & PUBF1_PLAYSOUND ) != 0 )
						{	if ( *ppi->snd ) PLAYSOUND( ppi->snd );
							else PLAYSOUND( IDW_CAMERA );
						} // end if

					} // end if

					// Ensure cache files are gone
					if ( *ppi->avicachefile != 0 )
					{	CWinFile::Delete( ppi->avicachefile );
						*ppi->avicachefile = 0;
					} // end if
					if ( *ppi->thmavicachefile != 0 )
					{	CWinFile::Delete( ppi->thmavicachefile );
						*ppi->thmavicachefile = 0;
					} // end if

				} // end if

			} // end if

			// Has an interval been specified?
			else if ( ppi->interval != 0 )
			{
				// Set interval first time
				if ( m_bReset || ppi->timeout == 0 ) 
					ppi->timeout = tickcount + ( ppi->interval * 1000 );

				// Have we timed out?			
				BOOL publish = ppi->timeout < tickcount;

				// Do we want to sync to the system clock?
				if ( !publish && ( ppi->f1 & PUBF1_SYNCTOCLOCK ) != 0 ) 
				{
					// Is it a new second?
					if ( seconds != ppi->lasttime )
					{
						// Record last pub time
						ppi->lasttime = seconds;

						// Is it time to publish?
						if ( !( seconds % ppi->interval ) ) publish = TRUE;

					} // end if

				} // end if

				if ( publish )
				{
					// Record next timeout interval
					ppi->timeout = tickcount + ( ppi->interval * 1000 );

					// Record last pub time
					ppi->lasttime = seconds;
					
					// Get current file name
					GetFileName( ppi );

					// Refresh the image
					if ( ppii == NULL ) IMGLIST().Update( ppi->img, TRUE );

					// Handle avi
					if ( ( ppi->f1 & PUBF1_AVI ) != 0 )
					{
						if ( ppi->avi->IsOpen() )
						{
							// Save avi filename
							strcpy( ppi->avicachefile, ppi->avi->GetFileName() );
							ppi->avi->Close();

							// Save thumbnail avi filename
							strcpy( ppi->thmavicachefile, ppi->thmavi->GetFileName() );
							ppi->thmavi->Close();

						} // end if

						// Punt if no avi
						else return TRUE;

					} // end if

					// Handle thumbnail avi
					if ( ( ppi->f1 & PUBF1_THMAVI ) != 0 )
					{
						if ( ppi->thmavi->IsOpen() )
						{
							// Save avi filename
							strcpy( ppi->thmavicachefile, ppi->thmavi->GetFileName() );
							ppi->thmavi->Close();

							// Save thumbnail avi filename
							strcpy( ppi->thmavicachefile, ppi->thmavi->GetFileName() );
							ppi->thmavi->Close();

						} // end if

					} // end if

					BOOL bPublished = FALSE;

					// Check for FTP
					if ( ppi->type == PUBTYPE_FTP ) bPublished = Ftp( ppi );

					// Check for Email
					else if ( ppi->type == PUBTYPE_EMAIL ) bPublished = Email( ppi );

					// Check for Disk
					else if ( ppi->type == PUBTYPE_DISK ) bPublished = Disk( ppi );

					if ( bPublished )
					{
						// Inform FRAME
						if ( ppi->type == PUBTYPE_FTP ) FRAME()->SetEvent( 2 );
						else if ( ppi->type == PUBTYPE_EMAIL ) FRAME()->SetEvent( 3 );
						else if ( ppi->type == PUBTYPE_DISK ) FRAME()->SetEvent( 4 );

						// Play sound if needed
						if ( ( ppi->f1 & PUBF1_PLAYSOUND ) != 0 )
						{	if ( *ppi->snd ) PLAYSOUND( ppi->snd );
							else PLAYSOUND( IDW_CAMERA );
						} // end if

					} // end if

					// Ensure cache files are gone
					if ( *ppi->avicachefile != 0 )
					{	CWinFile::Delete( ppi->avicachefile );
						*ppi->avicachefile = 0;
					} // end if
					if ( *ppi->thmavicachefile != 0 )
					{	CWinFile::Delete( ppi->thmavicachefile );
						*ppi->thmavicachefile = 0;
					} // end if

				} // end if

			} // end if

		} // end try

		// Try to return to a normal life if we can...
		catch( ... ) 
		{	_Log( MB_ICONERROR, "PublishThread()", "Assert" );	
			ASSERT( 0 ); 
		}
	
	} // end while

	m_bReset = FALSE;

	Sleep( 100 );

	return TRUE;
}