lf_startplay.cxx

很不错的播放代玛

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <malloc.h>
#ifdef _WIN32
#include <WinSock2.h>
#include <direct.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <unistd.h> 
#endif
#include <fltk/run.h>
#include <fltk/events.h>
#include <fltk/Widget.h>
#include <fltk/Window.h>


extern WV_Thread hLFPlayer;
//extern WV_Thread hPackageThread;
extern WV_PEVENT hCloseEvent;
//extern WV_PEVENT hEventProcExit;
extern WV_PEVENT hEndPlayer;
//extern WV_PEVENT hPackageProcExit;

///////////////////////////////////////////////////////////////////////////////////////////////////
#if HAVE_PTHREAD_H
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_LockInitial(WV_LOCK* lock)
{
	pthread_mutex_init(lock,NULL);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_LockFree(WV_LOCK* lock)
{
	pthread_mutex_destroy(lock);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_Lock(WV_LOCK* lock)
{
	pthread_mutex_lock(lock);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_UnLock(WV_LOCK* lock)
{
	pthread_mutex_unlock(lock);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
WV_PEVENT WV_CreateEvent(void)
{
	WV_PEVENT  pEvent =  (WV_PEVENT)malloc(sizeof(WV_EVENT));

	pEvent->ref = 0;
	if (pthread_mutex_init (&(pEvent->mutex),NULL) == -1)
    return NULL;
  if (pthread_cond_init (&(pEvent->cond), NULL) == -1)
		return NULL;    
		
	return pEvent;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
int WV_SetEvent(WV_PEVENT pEvent)
{
	int ret = 0;

	pthread_mutex_lock (&(pEvent->mutex));

	ret = pthread_cond_broadcast(&(pEvent->cond));
	
	if(ret != 0)
	{
		pthread_mutex_unlock(&(pEvent->mutex));
		return -1;
	}
	 
	(pEvent->ref)++;
	pthread_mutex_unlock (&(pEvent->mutex));
  
	return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_ResetEvent(WV_PEVENT pEvent)
{

}
void WV_CloseEvent(WV_PEVENT pEvent)
{

	pthread_mutex_destroy (&(pEvent->mutex));
    
	while (pthread_cond_destroy(&(pEvent->cond) )== EBUSY) 
	{
		pthread_cond_broadcast(&(pEvent->cond));
		sched_yield();
	}

	 free(pEvent);
	 pEvent = NULL;
} 
///////////////////////////////////////////////////////////////////////////////////////////////////
W_DWORD WaitForMultipleObjects(W_DWORD nCount, WV_PEVENT* hEvent, int fWaitAll, W_DWORD timeout_value)
{
	W_DWORD i;
	W_DWORD dwMilliSeconds;
	struct timeval now;
	struct timespec timeout;
	int retcode;


	retcode = WV_WAIT_FAILED;
	if(timeout_value != WV_INFINITE)
	{
		dwMilliSeconds = timeout_value / nCount + timeout_value % nCount;
		gettimeofday(&now, NULL);
		timeout.tv_sec = now.tv_sec;
		timeout.tv_nsec = now.tv_usec * 1000;
	}	
	i = 0;
	while(i < nCount)
	{
		pthread_mutex_lock(&(hEvent[i]->mutex));
		if(hEvent[i]->ref > 0)  // There is a event before wait
		{
			hEvent[i]->ref = 0;
			pthread_mutex_unlock(&(hEvent[i]->mutex)); 
			retcode = i; 	// 
			break;
		}
		else if(hEvent[i]->ref == 0)
		{
			if(timeout_value == WV_INFINITE)
				retcode = pthread_cond_wait(&(hEvent[i]->cond), &(hEvent[i]->mutex));
			else if(timeout_value == 0)
			{
			}
			else
			{
		  		timeout.tv_sec += dwMilliSeconds /1000;
		  		timeout.tv_nsec += (dwMilliSeconds % 1000) * 1000000;
		  		retcode = pthread_cond_timedwait(&(hEvent[i]->cond), &(hEvent[i]->mutex), &timeout);
			}
			if(retcode == -1)  // wait failed . exit waitting imediatly
			{
				pthread_mutex_unlock(&(hEvent[i]->mutex)); 
				break;
			}
			else if(retcode != ETIMEDOUT)  // Capture a 
			{
				hEvent[i]->ref = 0;
				pthread_mutex_unlock(&(hEvent[i]->mutex)); 				
				retcode = i;
				break;
			}
			else
				pthread_mutex_unlock(&(hEvent[i]->mutex)); 
		}
		i++;
	}
	return retcode; 
}
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#elif defined(WIN32)
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_LockInitial(WV_LOCK* lock)
{
	InitializeCriticalSection(lock);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_LockFree(WV_LOCK* lock)
{
	DeleteCriticalSection(lock);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_Lock(WV_LOCK* lock)
{
	EnterCriticalSection(lock);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_UnLock(WV_LOCK* lock)
{
	LeaveCriticalSection(lock);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
WV_PEVENT WV_CreateEvent(void)
{
	return CreateEvent(NULL, TRUE, FALSE,NULL);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
int WV_SetEvent(WV_PEVENT pEvent)
{
	return SetEvent(pEvent);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_CloseEvent(WV_PEVENT pEvent) 
{
	CloseHandle(pEvent);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_ResetEvent(WV_PEVENT pEvent)
{
	ResetEvent(pEvent);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
#endif  // End of HAVE_PTHREAD_H
///////////////////////////////////////////////////////////////////////////////////////////////////
W_DWORD WV_WaitForProcEvent(W_DWORD nCount, WV_PEVENT *hEvent,int fWaitAll, W_DWORD timeout_value)
{
	W_DWORD wait_index;
	W_DWORD exit_proc;

	exit_proc = 0;
	wait_index = WaitForMultipleObjects(nCount,hEvent,fWaitAll,timeout_value);
	switch(wait_index)
	{
		case WV_WAIT_0:
			exit_proc = 1;
			break;
		case WV_WAIT_FAILED:
			break;
		case WV_WAIT_TIMEOUT:
			break;
		default:
			break;
	}
	return exit_proc;

}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_ThreadInit(void)
{
	WV_LockInitial(&wview_lock);

//	memset(&wv_threadevent,0,sizeof(ThreadEvent));
	hCloseEvent = (WV_PEVENT)WV_CreateEvent();
	hEndPlayer = (WV_PEVENT)WV_CreateEvent();
	WV_ResetEvent(hCloseEvent);
	WV_ResetEvent(hEndPlayer);
	WV_ResetEvent(hPackageProcExit);
	/////////////////////////////
	fl_create_thread(hLFPlayer, LF_Player, pWSM); // No of any parameter 
//	fl_create_thread(hPackageThread, WV_PackageProc,pWSM);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
LF_VOID LF_StartPlay(LF_VOID)
{
	lock();
	LF_CreatePlay();
}
LF_DWORD LF_ENDPlay(LF_VOID)
{
	WV_PEVENT hEvent[2];
	W_DWORD state;

//	hEvent[0] = hEventProcExit;
//	hEvent[1] = hPackageProcExit;
	hEvent[0] = hEndPlayer;

	WV_SetEvent(hCloseEvent);

	state = WaitForMultipleObjects(1,hEvent,W_TRUE,2000);
	if(state != WV_WAIT_TIMEOUT && state != WV_WAIT_FAILED)
	{

	}
	//printf("thread exit success\r\n");

	return 0;
}

#if 0
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_SendThreadEvent(DefWindow* pDefW,int event)
{
	if(wv_threadevent.event != THREAD_POPUP_WINDOW && wv_threadevent.event != THREAD_SWI_WINDOW)
	{
		memset(&wv_threadevent,0,sizeof(ThreadEvent));
		wv_threadevent.event = event;
		if(pDefW) wv_threadevent.DefW = *pDefW;
	}
	thread_set_callback(WV_ThreadEventCallback);
	awake((void*)&wv_threadevent);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
void WV_ThreadEventCallback(void)
{
	WV_WorkSpace* pWS = (WV_WorkSpace*)pWSM;
	WV_HMIW* pHMI;

	WV_WindowBank* pbank;
	ThreadEvent* pEvent;
	DefWindow defw;
	W_DWORD parent_id;
	W_DWORD access_window;
	W_DWORD fast_window;
	int x ,y,w,h;

	if(pWS == NULL) return;

	pEvent = (ThreadEvent*)thread_message();

	if(pEvent != NULL)
	{
		defw = pEvent->DefW;
		if(!defw.parent_id || !defw.child_id)
			return;

		if(pEvent->event == THREAD_POPUP_WINDOW)
		{
			pWS->WV_DefWindow(&defw);
		//	printf("pop window \r\n");
		}
		else if(pEvent->event == THREAD_SWI_WINDOW)
		{// switch main window . 
			WV_Lock(&wview_lock);
		//	pbank = pWS->WV_GetBank(defw.parent_id);
		//	if(pbank->WV_HaveAccessory())
			pWS->WV_DestroyHMI(defw.parent_id);

			parent_id = defw.parent_id;
			defw.parent_id = -1;

			pWS->WV_DefWindow(&defw);
			pWS->WV_ConstructAccessoryPage(defw.child_id);
			pHMI = pWS->WV_GetHMI(defw.child_id);
			if(pHMI != NULL) 
			{
					pHMI->show();
#ifndef WIN32
					fast_window = pWS->WV_FastID();
					pHMI = pWS->WV_GetHMI(fast_window);
					if(pHMI&& pWS->WV_IsFastHide()) pHMI->show();
					Window* pwin = pWS->WV_FastCtrlWindow();
					pwin->show();	
#endif					
			}
				
			pWS->WV_CurrentWindow(defw.child_id);
			pWS->WV_PreviousWindow(parent_id);
			WV_UnLock(&wview_lock);

		}
		else if(pEvent->event == THREAD_SWI_ACCESSORY)
		{
			access_window = pWS->WV_AccessoryID();
			pWS->WV_DestroyHMI(access_window);
			pWS->WV_DefWindow(&defw);
			pWS->WV_AccessoryID(defw.child_id);
		}
/*
		else if(pEvent->event == THREAD_CHANGE_FAST)
		{
			fast_window = pWS->WV_FastID();
			pWS->WV_DesoryHMI(fast_window);
			pWS->WV_DefWindow(&defw);
		}
*/
		else if(pEvent->event == THREAD_REDRAW_WIDGET)
		{
     
		}
		else if(pEvent->event == THREAD_DESTROY_WINDOW)
		{
			pWS->WV_DestroyHMI(defw.child_id);
		}
		wv_threadevent.event = 0; // clear event;
	
	}
}
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
//W_DWORD WV_WaitForThreadExit(void)
///////////////////////////////////////////////////////////////////////////////////////////////////
//void* WV_EventProc(void* p)
LF_VOID* LF_Player(LF_VOID* p)
{
	LF_PEVENT hEvent[2];

	LF_Sleep(5);
	hEvent[0] = hCloseEvent;

	while(1)
	{
		LF_Sleep(20);

// Ok, Play your movie here , good lucky !
// Add your playing code below. 
		//...
// End of playing. 

		if(WV_WaitForProcEvent(1,hEvent,W_FALSE,1)==1)
		{
//			printf("exit event proc ... \r\n");
			WV_SetEvent(hEndPlayer);
			break;
		}
	}

#if 0
	WV_WorkSpace* pWS = (WV_WorkSpace*)p;
	WV_PEVENT hEvent[2];
	W_DWORD timer0;
	W_DWORD timer1;
	W_DWORD timer0_count; // for 1ms count
	W_DWORD timer1_count; // for 100ms count
	W_DWORD wait_index;
	W_DWORD i;
	W_DWORD maincount;

/////////////////////////////////////

	if(pWS != pWSM) return 0;

	WV_Sleep(5);
	hEvent[0] = hCloseEvent;
/////////////////////////////////////
	timer0 = 0;
	timer1 = 0;
	timer0_count = 0;
	timer1_count = 0;
////////////////////////////////////
	timer0 = WV_TimerGetTickCount();
	maincount = 0;
	while(1)
	{		
	//	printf("event thread = %d \r\n", maincount++);
		WV_Sleep(20);	

		timer1 = WV_TimerGetTickCount();
		timer0_count = timer1 - timer0;

		for(i = 0; i < timer0_count; i++){
			WV_Lock(&wview_lock);
			WV_Timer1MSHandle(pWS);
	//		printf("event 0 process .. \r\n");
			WV_EQHandler(pWS);
			WV_UnLock(&wview_lock);
		}

		timer1_count += timer0_count;
		while(timer1_count>100)
		{
			
			timer1_count -= 100;
			WV_Lock(&wview_lock);
			WV_Timer100MSHandle(pWS);
//			printf("event 1 process .. \r\n");
			WV_EQHandler(pWS);
			WV_UnLock(&wview_lock);
		}
		timer0 = timer1;
		if(WV_WaitForProcEvent(1,hEvent,W_FALSE,1)==1)
		{
//			printf("exit event proc ... \r\n");
			WV_SetEvent(hEventProcExit);
			break;
		}
	}
#endif
	return 0;
}