--- /dev/null
+/*\r
+ * GPAC - Multimedia Framework C SDK\r
+ *\r
+ * Copyright (c) Jean Le Feuvre 2000-2005 \r
+ * All rights reserved\r
+ *\r
+ * This file is part of GPAC / common tools sub-project\r
+ *\r
+ * GPAC is free software; you can redistribute it and/or modify\r
+ * it under the terms of the GNU Lesser General Public License as published by\r
+ * the Free Software Foundation; either version 2, or (at your option)\r
+ * any later version.\r
+ * \r
+ * GPAC is distributed in the hope that it will be useful,\r
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ * GNU Lesser General Public License for more details.\r
+ * \r
+ * You should have received a copy of the GNU Lesser General Public\r
+ * License along with this library; see the file COPYING. If not, write to\r
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. \r
+ *\r
+ */\r
+\r
+#ifndef _GF_THREAD_H_\r
+#define _GF_THREAD_H_\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+/*!\r
+ * \file <gpac/thread.h>\r
+ * \brief threading functions.\r
+ */\r
+\r
+ /*!\r
+ * \addtogroup thr_grp threading\r
+ * \ingroup utils_grp\r
+ * \brief Threading and Mutual Exclusion Functions\r
+ *\r
+ *This section documents the threading of the GPAC framework. These provide an easy way to implement\r
+ *safe multithreaded tools.\r
+ * @{\r
+ */\r
+\r
+#include <gpac/tools.h>\r
+\r
+/*!\r
+ *\brief Thread states\r
+ *\r
+ *Inidcates the execution status of a thread\r
+ */\r
+enum\r
+{\r
+ /*! the thread has been initialized but is not started yet*/\r
+ GF_THREAD_STATUS_STOP = 0,\r
+ /*! the thread is running*/\r
+ GF_THREAD_STATUS_RUN = 1,\r
+ /*! the thread has exited its body function*/\r
+ GF_THREAD_STATUS_DEAD = 2\r
+};\r
+\r
+/*!\r
+ *\brief abstracted thread object\r
+ *\r
+ *The abstracted thread object allows you to execute some code independently of the main process of your application.\r
+*/\r
+typedef struct __tag_thread GF_Thread;\r
+\r
+/*!\r
+ *\brief thread constructor\r
+ *\r
+ *Constructs a new thread object\r
+ *\param log name of the thread if any\r
+ */\r
+GF_Thread *gf_th_new(const char *name);\r
+/*!\r
+ *\brief thread destructor\r
+ *\r
+ * Kills the thread if running and destroys the object\r
+ *\param th the thread object\r
+ */\r
+void gf_th_del(GF_Thread *th);\r
+\r
+/*!\r
+ * \brief thread run function callback\r
+ *\r
+ *The gf_thread_run type is the type for the callback of the \ref gf_thread_run function\r
+ *\param par opaque user data\r
+ *\return exit code of the thread, usually 1 for error and 0 if normal execution\r
+ *\r
+ */\r
+typedef u32 (*gf_thread_run)(void *par);\r
+\r
+/*!\r
+ *\brief thread execution\r
+ *\r
+ *Executes the thread with the given function\r
+ *\param th the thread object\r
+ *\param run the function this thread will call\r
+ *\param par the argument to the function the thread will call\r
+ *\note A thread may be run several times but cannot be run twice in the same time.\r
+ */\r
+GF_Err gf_th_run(GF_Thread *th, gf_thread_run run, void *par);\r
+/*!\r
+ *\brief thread stoping\r
+ *\r
+ *Waits for the thread exit until return\r
+ *\param th the thread object\r
+ */\r
+void gf_th_stop(GF_Thread *th);\r
+/*!\r
+ *\brief thread status query\r
+ *\r
+ *Gets the thread status\r
+ *\param th the thread object\r
+ */\r
+u32 gf_th_status(GF_Thread *th);\r
+\r
+/*!\r
+ * thread priorities\r
+ */\r
+enum\r
+{\r
+ /*!Idle Priority*/\r
+ GF_THREAD_PRIORITY_IDLE=0,\r
+ /*!Less Idle Priority*/\r
+ GF_THREAD_PRIORITY_LESS_IDLE,\r
+ /*!Lowest Priority*/\r
+ GF_THREAD_PRIORITY_LOWEST,\r
+ /*!Low Priority*/\r
+ GF_THREAD_PRIORITY_LOW,\r
+ /*!Normal Priority (the default one)*/\r
+ GF_THREAD_PRIORITY_NORMAL,\r
+ /*!High Priority*/\r
+ GF_THREAD_PRIORITY_HIGH,\r
+ /*!Highest Priority*/\r
+ GF_THREAD_PRIORITY_HIGHEST,\r
+ /*!First real-time priority*/\r
+ GF_THREAD_PRIORITY_REALTIME,\r
+ /*!Last real-time priority*/\r
+ GF_THREAD_PRIORITY_REALTIME_END=255\r
+};\r
+\r
+/*!\r
+ *\brief thread priority\r
+ *\r
+ *Sets the thread execution priority level.\r
+ *\param th the thread object\r
+ *\param priority the desired priority\r
+ *\note this should be used with caution, especially use of real-time priorities.\r
+ */\r
+void gf_th_set_priority(GF_Thread *th, s32 priority);\r
+/*!\r
+ *\brief current thread ID \r
+ *\r
+ *Gets the ID of the current thread the caller is in.\r
+*/\r
+u32 gf_th_id();\r
+\r
+\r
+\r
+/*!\r
+ *\brief abstracted mutex object\r
+ *\r
+ *The abstracted mutex object allows you to make sure that portions of the code (typically access to variables) cannot be executed\r
+ *by two threads (or a thread and the main process) at the same time.\r
+*/\r
+typedef struct __tag_mutex GF_Mutex;\r
+/*\r
+ *\brief mutex constructor\r
+ *\r
+ *Contructs a new mutex object\r
+ *\param log name of the thread if any\r
+*/\r
+GF_Mutex *gf_mx_new(const char *name);\r
+/*\r
+ *\brief mutex denstructor\r
+ *\r
+ *Destroys a mutex object. This will wait for the mutex to be released if needed.\r
+ *\param mx the mutex object\r
+*/\r
+void gf_mx_del(GF_Mutex *mx);\r
+/*\r
+ *\brief mutex locking\r
+ *\r
+ *Locks the mutex object, making sure that another thread locking this mutex cannot exectute until the mutex is unlocked.\r
+ *\param mx the mutex object\r
+ *\return 1 if success, 0 if error locking the mutex (which should never happen)\r
+*/\r
+u32 gf_mx_p(GF_Mutex *mx);\r
+/*\r
+ *\brief mutex unlocking\r
+ *\r
+ *Unlocks the mutex object, allowing other threads waiting on this mutex to continue their execution\r
+ *\param mx the mutex object\r
+*/\r
+void gf_mx_v(GF_Mutex *mx);\r
+/*\r
+ *\brief mutex non-blocking lock\r
+ *\r
+ *Attemps to lock the mutex object without blocking until the object is released.\r
+ *\param mx the mutex object\r
+ *\return 1 if the mutex has been successfully locked, in which case it shall then be unlocked, or 0 if the mutex is locked by another thread.\r
+*/\r
+Bool gf_mx_try_lock(GF_Mutex *mx);\r
+\r
+\r
+/*********************************************************************\r
+ Semaphore Object\r
+**********************************************************************/\r
+/*!\r
+ *\brief abstracted semaphore object\r
+ *\r
+ *The abstracted semaphore object allows you to control how portions of the code (typically access to variables) are executed\r
+ *by two threads (or a thread and the main process) at the same time. The best image for a semaphore is a limited set \r
+ *of money coins (always easy to understand hmm?). If no money is in the set, nobody can buy anything until a coin is \r
+ *put back in the set. When the set is full, the money is wasted (call it "the bank"...).\r
+*/\r
+typedef struct __tag_semaphore GF_Semaphore;\r
+/*\r
+ *\brief semaphore constructor\r
+ *\r
+ *Constructs a new semaphore object\r
+ *\param MaxCount the maximum notification count of this semaphore\r
+ *\param InitCount the initial notification count of this semaphore upon construction\r
+ *\return the semaphore object\r
+ */\r
+GF_Semaphore *gf_sema_new(u32 MaxCount, u32 InitCount);\r
+/*\r
+ *\brief semaphore destructor\r
+ *\r
+ *Destructs the semaphore object. This will wait for the semaphore to be released if needed.\r
+ */\r
+void gf_sema_del(GF_Semaphore *sm);\r
+/*\r
+ *\brief semaphore notifivation\r
+ *\r
+ *Notifies the semaphore of a certain amount of releases.\r
+ *\param sm the semaphore object\r
+ *\param nb_rel sm the number of release to notify\r
+ *\return the number of previous notification count in the semaphore \r
+*/\r
+u32 gf_sema_notify(GF_Semaphore *sm, u32 nb_rel);\r
+/*\r
+ *\brief semaphore wait\r
+ *\r
+ *Waits for the semaphore to be accessible (eg, may wait an infinite time).\r
+ *\param sm the semaphore object\r
+*/\r
+void gf_sema_wait(GF_Semaphore *sm);\r
+/*\r
+ *\brief semaphore time wait\r
+ *\r
+ *Waits for a certain for the semaphore to be accessible, and returns when semaphore is accessible or wait time has passed.\r
+ *\param sm the semaphore object\r
+ *\param time_out the amount of time to wait for the release in milliseconds\r
+ *\return returns 1 if the semaphore was released before the timeout, 0 if the semaphore is still not released after the timeout.\r
+*/\r
+Bool gf_sema_wait_for(GF_Semaphore *sm, u32 time_out);\r
+\r
+/*! @} */\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+\r
+#endif /*_GF_THREAD_H_*/\r
+\r
OSDN Git Service
