threadobject.cpp

C++封装的视频采集代码

/*

	thread object wrapper

*/

#include "ThreadObject.h"
#include <sys/time.h>
#include <time.h>
#include <stdlib.h>

ThreadObject::ThreadObject()
{
	retVal_ = NULL;
	mutexInit_ = false;
	running_ = false;
}

ThreadObject::~ThreadObject()
{
	Kill();
}

int ThreadObject::Start()
{
	int status;

	if (!mutexInit_)
	{
		if (!runningMutex_.IsInitialized())
		{
			if (runningMutex_.Init() < 0)
				return ERR_THREAD_OBJECT_CANTINITMUTEX;
		}
		if (!continueMutex_.IsInitialized())
		{
			if (continueMutex_.Init() < 0)
				return ERR_THREAD_OBJECT_CANTINITMUTEX;
		}
		if (!continueMutex2_.IsInitialized())
		{
			if (continueMutex2_.Init() < 0)
				return ERR_THREAD_OBJECT_CANTINITMUTEX;
		}
		mutexInit_ = true;
	}
	
	runningMutex_.Lock();
	if (running_)
	{
		runningMutex_.Unlock();
		return ERR_THREAD_OBJECT_ALREADYRUNNING;
	}
	runningMutex_.Unlock();
	
	pthread_attr_t attr;
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
	
	continueMutex_.Lock();
	status = pthread_create(&threadId_,&attr,TheThread,this);	
	pthread_attr_destroy(&attr);
	if (status != 0)
	{
		continueMutex_.Unlock();
		return ERR_THREAD_OBJECT_CANTSTARTTHREAD;
	}
	
	/* Wait until 'running' is set */
	
	runningMutex_.Lock();			
	while (!running_)
	{
		runningMutex_.Unlock();
		
		struct timespec req,rem;

		req.tv_sec = 0;
		req.tv_nsec = 1000000;
		nanosleep(&req,&rem);

		runningMutex_.Lock();
	}
	runningMutex_.Unlock();
	
	continueMutex_.Unlock();
	
	continueMutex2_.Lock();
	continueMutex2_.Unlock();
	return 0;
}

int ThreadObject::Kill()
{
	runningMutex_.Lock();			
	if (!running_)
	{
		runningMutex_.Unlock();
		return ERR_THREAD_OBJECT_NOTRUNNING;
	}
	pthread_cancel(threadId_);
	running_ = false;
	runningMutex_.Unlock();
	return 0;
}

bool ThreadObject::IsRunning()
{
	bool r;
	
	runningMutex_.Lock();			
	r = running_;
	runningMutex_.Unlock();
	return r;
}

void *ThreadObject::GetReturnValue()
{
	void *val;
	
	runningMutex_.Lock();
	if (running_)
		val = NULL;
	else
		val = retVal_;
	runningMutex_.Unlock();
	return val;
}

void * ThreadObject::TheThread(void *param)
{
	ThreadObject * threadObject;
	void *ret;
	
	threadObject = (ThreadObject *)param;
	
	threadObject->continueMutex2_.Lock();
	threadObject->runningMutex_.Lock();
	threadObject->running_ = true;
	threadObject->runningMutex_.Unlock();
	
	threadObject->continueMutex_.Lock();
	threadObject->continueMutex_.Unlock();
	
	ret = threadObject->ThreadMain();

	threadObject->runningMutex_.Lock();
	threadObject->running_ = false;
	threadObject->retVal_ = ret;
	threadObject->runningMutex_.Unlock();

	return NULL;
}

void ThreadObject::ThreadStarted()
{
	continueMutex2_.Unlock();
}