/*! \brief Allow other threads to have a go
*
* UNIX/Linux
*
*/
void PMS_RelinquishTimeSlice(void)
{
#ifdef _POSIX_PRIORITY_SCHEDULING
#ifndef LIBuClibc
int nError;
if(sched_yield()!=0)
{
nError = errno;
printf("sched_yield failed %d\n", nError);
}
#else /* LIBuClibc */
PMS_Delay(5);
#endif
#else /* _POSIX_PRIORITY_SCHEDULING */
/* sleep zero does nothing, sleep (1ms) instead */
PMS_Delay(1);
#endif
}
/**
* \brief Wrapper for open input buffer
*
*/
int Input_Buffer_OpenDataStream(void)
{
//ARUN's IF 0
//dataInBuffer = (gps_hostbuf_p *)malloc(26);
/* dataInBuffer = (char *)malloc(26);*/
/*dataInBuffer = "Test Buffer Using New Code";*/
dataInBuffer = NULL;
/*************Call to gpsSinOpen*************************************************/
host_inBuff = GPS_SinOpen(gps_client,job_hostid_in);
if(host_inBuff)
{
printf("GPS_SinOpen : Successful\n");
}
else
{
printf("GPS_SinOpen : Failed\n");
}
PMS_Delay(200);
if(host_inBuff)
{
printf("GPS_SinOpen : host_inBuff Successful\n");
if(host_inBuff->_HostBuf)
dataInBuffer = host_inBuff->_HostBuf->buf;
}
/*************Call to gpsSoutOpen*************************************************/
host_outBuff = GPS_SoutOpen(gps_client,job_hostid_out);
if(host_outBuff)
{
printf("GPS_SoutOpen : Successful\n");
}
else
{
printf("GPS_SoutOpen : Failed\n");
}
if(host_inBuff)
//if(dataInBuffer)
{
return TRUE;
}
//endif //ARUN's ENDIF
return FALSE;
}
/**
* \brief Wrapper for open input buffer
*
*/
int Input_Buffer_OpenDataStream(void)
{
dataInBuffer = NULL;
/*************Call to gpsSinOpen*************************************************/
host_inBuff = GPS_SinOpen(gps_client,job_hostid_in);
if(host_inBuff)
{
printf("GPS_SinOpen : Successful\n");
}
else
{
printf("GPS_SinOpen : Failed\n");
}
PMS_Delay(200);
if(host_inBuff)
{
printf("GPS_SinOpen : host_inBuff Successful\n");
if(host_inBuff->_HostBuf)
dataInBuffer = host_inBuff->_HostBuf->buf;
}
/*************Call to gpsSoutOpen*************************************************/
host_outBuff = GPS_SoutOpen(gps_client,job_hostid_out);
if(host_outBuff)
{
printf("GPS_SoutOpen : Successful\n");
}
else
{
printf("GPS_SoutOpen : Failed\n");
}
if(host_inBuff)
{
return TRUE;
}
return FALSE;
}
/**
* \brief Hot folder search.
*/
int HotFolder_Search()
{
unsigned int filesize, filesize_last;
char szDir[MAX_PATH];
char szExt[6];
void *hFind;
FILE *pFile;
int fd, i;
char *p;
struct stat buf;
int bRescan = 0;
strcpy(szDir, g_pPMSHotFolderPath);
strcat(szDir, "\\*");
do {
hFind = PMS_Initiate_DirectorySearch(szDir);
/* Find the first file in the directory */
if(PMS_Run_DirectorySearch(g_pPMSHotFolderPath, hFind, (char*)&aszHotFolderFiles[0]))
{
/* There is a file, lets wait until its size is stable */
PMS_Stop_DirectorySearch(hFind);
bRescan = 0;
filesize = 0;
bVirtualFile = FALSE;
do {
filesize_last = filesize;
/* wait 1 second to see if the file is complete */
PMS_Delay(1000);
pFile = fopen(aszHotFolderFiles[0], "r");
if(!pFile) { /* probably because of an OS delayed remove or user removed file since the dir scan */
filesize_last = filesize;
bRescan = TRUE;
break;
} else {
fd = fileno(pFile);
fstat(fd, &buf);
filesize = buf.st_size;
fclose(pFile);
}
} while (filesize != filesize_last);
if(bRescan) {
continue; /* restart do loop to rescan directory */
}
/* now save the file info and open the file for input to the rip */
bActiveFile = TRUE;
/* check for a raw image file as we need to send PJL code */
p = (char *)aszHotFolderFiles + strlen(aszHotFolderFiles[0]) ;
i = 0;
while(p--)
{
if(*p == '.'){
strcpy(szExt, p);
break;
}
if(++i >= (sizeof(szExt)-1)){
strcpy(szExt, ".none");
break;
}
}
for(i = 0; i < (int)strlen(szExt);i++)
{
szExt[i] = (char)tolower(szExt[i]);
}
if((strcmp(szExt, ".tiff") == 0) || (strcmp(szExt, ".tif") == 0) ||
(strcmp(szExt, ".jpeg") == 0) || (strcmp(szExt, ".jpg") == 0) ||
(strcmp(szExt, ".jfif") == 0) || (strcmp(szExt, ".jif") == 0))
{
/* set up the PJL wrapper to define the file for ripping */
sprintf(FileBuffer,"%s@PJL SET IMAGEFILE=\"%s\"\n%s", PJLStart, aszHotFolderFiles[0], PJLEnterLanguageImage);
pFileBuffer = FileBuffer;
bVirtualFile = TRUE;
return TRUE;
}
else
{
/* set up file for file input */
pHotFolderFiles[0] = (char*)&aszHotFolderFiles[0];
pHotFolderFiles[1] = (char*)&aszHotFolderFiles[1];
/* Reuse the file input method functions to process the file found */
aszJobNames = (char**)&pHotFolderFiles;
nJobs = 1;
File_InitDataStream();
File_OpenDataStream();
return TRUE;
}
} else {
/* No file to process */
bRescan = FALSE;
}
} while (bRescan);
/* No file to process this time */
return FALSE;
}
/**
* \brief Block until an input module has a connection.
*
* \todo Currently there is no priority override setting on input modules, so in thoery if a job in the hot
* folder might not get a chance to run if there are many pending socket connections available.
*
*/
int PMS_IM_WaitForInput()
{
struct input_modules *pMods;
int bWaitingForJob = 1;
int nResult;
/* If there are no input modules then return */
if(!l_ptModules) {
return FALSE;
}
while(bWaitingForJob) {
if(g_tJob.eTestPage)
return TRUE;
#ifdef PMS_OIL_MERGE_DISABLE_JS
bWaitingForJob = 0; /* Assume all modules are only tried to open once... file on command line etc.
If socket, or hot folder or any other input that waits for a job then it will get set again. */
for(pMods = l_ptModules; pMods; pMods = pMods->pNext) {
/* Get a job */
if(pMods->tInput.pfnOpenDataStream) {
nResult = (*pMods->tInput.pfnOpenDataStream)();
if(nResult > 0) {
l_ptActive = pMods; /* l_ptActive is the connected module until PMS_CloseDataStream */
return TRUE;
} else if(nResult < 0) {
/* Don't try this module again... used for files on command, could be used for a once only folder (sd card or similar) */
pMods->tInput.pfnOpenDataStream = NULL; /* \todo This could be a bit tidier */
} else {
bWaitingForJob = 1; /* Try again in a bit */
}
}
}
PMS_Delay(200); /* /todo Is this delay reasonable? */
#else
if(g_jobAvailable==1)
{
bWaitingForJob = 1; /* Assume all modules are only tried to open once... file on command line etc.
If socket, or hot folder or any other input that waits for a job then it will get set again. */
for(pMods = l_ptModules; pMods; pMods = pMods->pNext) {
/* Get a job */
if(pMods->tInput.pfnOpenDataStream) {
nResult = (*pMods->tInput.pfnOpenDataStream)();
if(nResult > 0) {
l_ptActive = pMods; /* l_ptActive is the connected module until PMS_CloseDataStream */
bWaitingForJob=0;
return TRUE;
} else if(nResult < 0) {
/* Don't try this module again... used for files on command, could be used for a once only folder (sd card or similar) */
pMods->tInput.pfnOpenDataStream = NULL; /* \todo This could be a bit tidier */
} else {
bWaitingForJob = 1; /* Try again in a bit */
}
}
}
}
else
{
bWaitingForJob=1;
}
PMS_Delay(1); /* /todo Is this delay reasonable? */
#endif
}
return FALSE;
}
/**
* \brief Simulates the output
*
* This routine simulates the movement of paper in the engine.
* The first part of the loop determines if a sheet can be lifted from a paper tray,
* the second part determines if the sheet has reached the output tray.
*/
void PMSOutput(void * dummy)
{
PMS_TyPage *ThisPage = NULL; /* pointer the the current page being checked */
PMS_TyPage LastPage; /* pointer the the last sheet that was picked up */
PMS_TyPageList *tmpPageList; /* local pagelist pointer */
unsigned int uCurrentPageGap; /* the gap between sheet pickup */
unsigned int uLastPickUp; /* the time the last sheet was pickup from inout tray */
unsigned int uPagesInMotion; /* the number of sheets travelling in the system */
UNUSED_PARAM(void *, dummy);
uCurrentPageGap = 0;
uLastPickUp = 0;
uPagesInMotion = 0;
g_eJobState = PMS_Waiting_For_Page;
/* loop until the RIP has quit */
while(g_eJobState != PMS_AllJobs_Completed) /* pages in motion OR RIP active */
{
/* keep a local copy of the pagelist for local manipulation */
tmpPageList = g_pstPageList;
if(g_tSystemInfo.uUseEngineSimulator)
{
/* small delay to prevent total processor consumption */
PMS_Delay(PAGECHECK_FREQUENCY);
}
else if(tmpPageList==NULL)
{
/* wait for a page to arrive */
PMS_WaitOnSemaphore_Forever(g_semPageQueue);
}
/* walk through all the pages */
while (tmpPageList!=NULL)
{
ThisPage = tmpPageList->pPage;
if(g_tSystemInfo.uUseEngineSimulator)
PMS_Delay(PAGECHECK_FREQUENCY);
/* is there a page waiting to start travelling */
if (ThisPage->eState==PMS_CHECKEDIN)
{
/* work out the gap between last page and this page */
uCurrentPageGap = EngineGetInterpageGap(ThisPage, &LastPage);
/* has enough time passed since the last sheet pickup */
if(PMS_TimeInMilliSecs() > (uLastPickUp + uCurrentPageGap))
{
/* pick up sheet, mark as printing */
ThisPage->eState = PMS_PRINTING;
ThisPage->ulPickupTime = PMS_TimeInMilliSecs();
ThisPage->ulOutputTime = ThisPage->ulPickupTime + EngineGetTravelTime(g_pstPageList->pPage);
uPagesInMotion++;
/* PMS_SHOW("Pickup Sheet: %d - output: %d\n", ThisPage->ulPickupTime, ThisPage->ulOutputTime); */
/* record some stats about this page incase next page is different a requires a stall in paper path */
LastPage.uTotalPlanes = ThisPage->uTotalPlanes;
/* record pickup time in global */
uLastPickUp = PMS_TimeInMilliSecs();
}
break;
}
/* check sheets that are printing */
if (ThisPage->eState==PMS_PRINTING)
{
/* has a sheet reached output bin */
if(PMS_TimeInMilliSecs() > (ThisPage->ulOutputTime))
{
/* print sheet */
PrintPage(ThisPage);
ThisPage->eState = PMS_COMPLETE;
/* PMS_SHOW("Output Sheet: %d\n", PMS_TimeInMilliSecs()); */
/* send page done at this point*/
OIL_PageDone(ThisPage);
/* remove sheet from system, RemovePage is protected against other threads */
RemovePage(ThisPage);
uPagesInMotion--;
/* page list modified so break out and start again */
break;
}
}
/* move onto the next page */
tmpPageList = tmpPageList->pNext;
}
if(uPagesInMotion == 0)
{
/* set the job state to indicate pms is waiting for next page. */
g_eJobState = PMS_Waiting_For_Page;
}
else
{
/* set the job state to indicate pms has received a page and is processing it. */
g_eJobState = PMS_Page_In_Progress;
}
/* if RIP has finished ripping and page list is empty means all jobs are printed */
if((g_eRipState == PMS_Rip_Finished) && (g_pstPageList == NULL))
{
g_eJobState = PMS_AllJobs_Completed;
}
}
return;
}
