AVSTerminate::~AVSTerminate()
{
WINE_LOADER *cur_loader = first_loader;
int i = 0;
DEBUG_PRINTF("Call terminate!!!\n");
if (cur_loader)
do {
DEBUG_PRINTF("Count %d\n", i++);
if (cur_loader->avs_pipes[PIPE_LOADER_WRITE].hpipe != -1)
{
send_cmd(cur_loader->avs_pipes[PIPE_LOADER_WRITE].hpipe,
UNLOAD_AVS_SCRIPT, NULL, 0);
DEBUG_PRINTF("UNLOAD_AVS_SCRIPT try\n");
}
if (cur_loader->avs_pipes[PIPE_LOADER_WRITE].hpipe != -1)
{
send_cmd(cur_loader->avs_pipes[PIPE_LOADER_WRITE].hpipe,
UNLOAD_AVS_LOADER, NULL, 0);
DEBUG_PRINTF("UNLOAD_AVS_LOADER try\n");
}
deinit_pipes(cur_loader->avs_pipes, CMD_PIPE_NUM);
} while((cur_loader = (WINE_LOADER*)cur_loader->next_wine_loader) != NULL);
}
bool open_pipes(AVS_PIPES *avsp, int num)
{
int i;
for (i = 0; i < num; i++)
{
DEBUG_PRINTF("avsfilter : try to open %s fifo\n", avsp[i].pipename);
if ((avsp[i].hpipe = open(avsp[i].pipename, avsp[i].flags)) == -1)
{
DEBUG_PRINTF_RED("avsfilter : failed open errno %d\n", errno);
deinit_pipe(&avsp[i]);
deinit_pipes(avsp, i);
return false;
}
}
DEBUG_PRINTF("all pipes open ok\n");
return true;
}
bool init_pipes (AVS_PIPES *avsp, int num, FILE *pfile)
{
int i;
for (i = 0; i < num; i++)
{
char sname[MAX_PATH];
if (fscanf(pfile, "%s\n", sname) != 1) DEBUG_PRINTF_RED("fscanf error\n");
else if (!(avsp[i].pipename = strnew(sname))) DEBUG_PRINTF_RED("strnew error\n");
else if (remove(avsp[i].pipename)) DEBUG_PRINTF_RED("error remove file\n");
else if (mkfifo(avsp[i].pipename, 0600))
DEBUG_PRINTF_RED("mkfifo error create fifo file %s, errno %d\n",
avsp[i].pipename, errno);
else continue;
deinit_pipes(avsp, i);
return false;
}
return true;
}
// Main function with event loop
int main(void)
{
int n = -1;
int count = 0;
static bc_buf_ptr_t buf_pa;
int dev_fd;
unsigned long chunkSize;
printf("Initializing egl..\n\n");
if( 0 == initEGL(0)) //No profiling
{
printf("EGL init failed");
goto exitNone;
}
//Also initialise the pipes
n = initPipes(&initAttrib);
if(n) { goto exitPipes; }
//Initialise CMEM allocator - TODO check err status
mem_cmem_init();
//Allocate mem
chunkSize = initAttrib.widthPixels*
initAttrib.heightPixels*
initAttrib.bytesPerPixel*
initAttrib.numBuffers;
if(mem_cmem_alloc( chunkSize, &virtualAddress, &physicalAddress )) {goto exitCMEMInit;}
paArray = (unsigned long*)malloc(initAttrib.numBuffers * sizeof(unsigned long));
freeArray = (unsigned long*)malloc(initAttrib.numBuffers * sizeof(unsigned long));
if(!paArray || !freeArray) {goto exitCMEMAlloc;}
for(count = 0; count < initAttrib.numBuffers; count++)
{
paArray[count] = physicalAddress + count*(chunkSize/initAttrib.numBuffers);
freeArray[count] = 0;
}
//TODO - give the allocated buffers back to requestor via answer
//write_init_buffer_pipe();
init_view();
//Loop reading new data and rendering, till something happens
//TODO - exit cleanly using last msg
while(read_pipe() != -1)
{
render(bcbuf.index);
//TODO - clean up message passing
//if( write_pipe() != sizeof(GstBufferClassBuffer *))
{
printf("Error Writing into Init Queue\n");
//TODO - try again n times ?
break;
}
}
exit:
release_view();
deInitEGL();
exitCMEMAlloc:
mem_cmem_free( virtualAddress);
exitPipes:
if(paArray) free(paArray);
if(freeArray) free(freeArray);
deinit_pipes();
exitCMEMInit:
mem_cmem_deinit();
exitNone:
return 0;
}
bool avs_start(FilterInfo *info, FilterInfo *avisynth_info,
char *fname, AVS_PIPES *avs_pipes)
{
DEBUG_PRINTF("avsfilter : avs_start()\n");
DEBUG_PRINTF("avsfilter : %X %X %s %X\n",
avs_pipes[PIPE_LOADER_WRITE].hpipe,
avs_pipes[PIPE_FILTER_WRITE].hpipe,
fname, info);
DEBUG_PRINTF("avsfilter : avs_start info : frameIncrement %lu totalDuration %llu\n",
info->frameIncrement, info->totalDuration);
ADV_Info aii, aio;
aii.width = info->width;
aii.height = info->height;
aii.nb_frames = info->totalDuration / info->frameIncrement;
aii.encoding = 1;
aii.codec = 0;
aii.fps1000 = ADM_Fps1000FromUs(info->frameIncrement);
aii.orgFrame = 0;
DEBUG_PRINTF("avsfilter : send ADV_Info to avsloader [fps1000 = %d, nb_frames = %d]\n", aii.fps1000, aii.nb_frames);
if (!send_cmd(avs_pipes[PIPE_LOADER_WRITE].hpipe,
LOAD_AVS_SCRIPT, fname,
strlen(fname) + sizeof("\0")) ||
!send_cmd(avs_pipes[PIPE_FILTER_WRITE].hpipe,
SET_CLIP_PARAMETER, &aii,
sizeof(aii)))
{
DEBUG_PRINTF_RED("avsfilter : cannot set script name or set clip parameters\n");
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
// get avisynth frame info
PIPE_MSG_HEADER msg;
if (!receive_cmd(avs_pipes[PIPE_LOADER_READ].hpipe,
&msg) ||
msg.avs_cmd != SET_CLIP_PARAMETER ||
!receive_data(avs_pipes[PIPE_LOADER_READ].hpipe,
&msg, &aio))
{
DEBUG_PRINTF_RED("avsfilter : cannot receive avisynth clip parameters\n");
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
DEBUG_PRINTF("avsfilter : receive ADV_Info from avsloader [fps1000 = %d, nb_frames = %d]\n", aio.fps1000, aio.nb_frames);
avisynth_info->width = aio.width;
avisynth_info->height = aio.height;
avisynth_info->frameIncrement = ADM_UsecFromFps1000(aio.fps1000);
avisynth_info->totalDuration = aio.nb_frames * avisynth_info->frameIncrement;
// correct avisynth_info for span of frames, calculate fps change metrics
/* float k_fps;
k_fps = float(avisynth_info->frameIncrement) / float(info->frameIncrement);
DEBUG_PRINTF("avsfilter : FPS change metrics %f\n", k_fps);
avisynth_info->nb_frames = int (info->nb_frames * k_fps);
avisynth_info->orgFrame = int (info->orgFrame * k_fps);
DEBUG_PRINTF("avsfilter : Calculate new span for avisynth script [%d - %d]\n",
avisynth_info->orgFrame,avisynth_info->orgFrame + avisynth_info->nb_frames);*/
return true;
}
bool wine_start(char *wine_app, char *avsloader, AVS_PIPES *avs_pipes, int pipe_timeout)
{
char sname[MAX_PATH];
struct stat st;
sprintf(sname, "%s %s %d", wine_app, avsloader, pipe_timeout);
FILE *pfile = popen(sname, "r");
if (!pfile)
{
DEBUG_PRINTF_RED("avsfilter : popen failed, errno %d, failed start app is : [%s]\n", errno, sname);
return false;
}
if (fscanf(pfile, "%s\n", sname) != 1 ||
stat(sname, &st) ||
!S_ISDIR(st.st_mode))
{
DEBUG_PRINTF_RED("avsfilter : tmpdirname [%s] failed, errno %d[stat %d isdir %d]\n", sname, errno, stat(sname, &st), S_ISDIR(st.st_mode));
pclose(pfile);
return false;
}
DEBUG_PRINTF("avsfilter : good tmpdirname %s\n", sname);
if (!init_pipes(avs_pipes, CMD_PIPE_NUM, pfile))
{
DEBUG_PRINTF_RED("init_pipes failed\n");
pclose(pfile);
return false;
}
time_t t = time(NULL);
DEBUG_PRINTF("avsfilter : precreate thread time %s\n",
ctime(&t));
pthread_t thread;
TPARSER tp = { avs_pipes, pfile };
open_pipes_ok = false;
if (pthread_create(&thread, NULL, parse_wine_stdout, &tp))
{
DEBUG_PRINTF_RED("Cannot pthread started...Errno %d\n",errno);
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
t = time(NULL);
DEBUG_PRINTF("avsfilter : preopen time %s\n",
ctime(&t));
if (!open_pipes(avs_pipes, CMD_PIPE_NUM) || wine_loader_down)
{
open_pipes_ok = true;
DEBUG_PRINTF_RED("open_pipes failed\n");
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
open_pipes_ok = true;
if (pipe_test_filter (avs_pipes[PIPE_LOADER_READ].hpipe,
avs_pipes[PIPE_FILTER_WRITE].hpipe))
{
DEBUG_PRINTF("avsfilter : test pipe to filter ok\n");
if (pipe_test_filter (avs_pipes[PIPE_LOADER_READ].hpipe,
avs_pipes[PIPE_LOADER_WRITE].hpipe))
{
DEBUG_PRINTF("avsfilter : test pipe to loader ok\n");
}
else
goto error_pipe_test;
}
else
{
error_pipe_test:
DEBUG_PRINTF_RED("Error test read/write pipes\n");
deinit_pipes(avs_pipes, CMD_PIPE_NUM);
return false;
}
DEBUG_PRINTF("wine start is ok\n");
return true;
}
