Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright (c) 2011 KO Myung-Hun <komh@chollian.net>
  3.  *
  4.  * This file is part of FFmpeg.
  5.  *
  6.  * FFmpeg is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU Lesser General Public
  8.  * License as published by the Free Software Foundation; either
  9.  * version 2.1 of the License, or (at your option) any later version.
  10.  *
  11.  * FFmpeg is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  * Lesser General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU Lesser General Public
  17.  * License along with FFmpeg; if not, write to the Free Software
  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19.  */
  20.  
  21. /**
  22.  * @file
  23.  * os2threads to pthreads wrapper
  24.  */
  25.  
  26. #ifndef AVCODEC_OS2PTHREADS_H
  27. #define AVCODEC_OS2PTHREADS_H
  28.  
  29. #define INCL_DOS
  30. #include <os2.h>
  31.  
  32. #undef __STRICT_ANSI__          /* for _beginthread() */
  33. #include <stdlib.h>
  34.  
  35. #include "libavutil/mem.h"
  36.  
  37. typedef TID  pthread_t;
  38. typedef void pthread_attr_t;
  39.  
  40. typedef HMTX pthread_mutex_t;
  41. typedef void pthread_mutexattr_t;
  42.  
  43. typedef struct {
  44.     HEV  event_sem;
  45.     int  wait_count;
  46. } pthread_cond_t;
  47.  
  48. typedef void pthread_condattr_t;
  49.  
  50. struct thread_arg {
  51.     void *(*start_routine)(void *);
  52.     void *arg;
  53. };
  54.  
  55. static void thread_entry(void *arg)
  56. {
  57.     struct thread_arg *thread_arg = arg;
  58.  
  59.     thread_arg->start_routine(thread_arg->arg);
  60.  
  61.     av_free(thread_arg);
  62. }
  63.  
  64. static av_always_inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg)
  65. {
  66.     struct thread_arg *thread_arg;
  67.  
  68.     thread_arg = av_mallocz(sizeof(struct thread_arg));
  69.     if (!thread_arg)
  70.         return ENOMEM;
  71.  
  72.     thread_arg->start_routine = start_routine;
  73.     thread_arg->arg = arg;
  74.  
  75.     *thread = _beginthread(thread_entry, NULL, 256 * 1024, thread_arg);
  76.  
  77.     return 0;
  78. }
  79.  
  80. static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
  81. {
  82.     DosWaitThread((PTID)&thread, DCWW_WAIT);
  83.  
  84.     return 0;
  85. }
  86.  
  87. static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
  88. {
  89.     DosCreateMutexSem(NULL, (PHMTX)mutex, 0, FALSE);
  90.  
  91.     return 0;
  92. }
  93.  
  94. static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
  95. {
  96.     DosCloseMutexSem(*(PHMTX)mutex);
  97.  
  98.     return 0;
  99. }
  100.  
  101. static av_always_inline int pthread_mutex_lock(pthread_mutex_t *mutex)
  102. {
  103.     DosRequestMutexSem(*(PHMTX)mutex, SEM_INDEFINITE_WAIT);
  104.  
  105.     return 0;
  106. }
  107.  
  108. static av_always_inline int pthread_mutex_unlock(pthread_mutex_t *mutex)
  109. {
  110.     DosReleaseMutexSem(*(PHMTX)mutex);
  111.  
  112.     return 0;
  113. }
  114.  
  115. static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
  116. {
  117.     DosCreateEventSem(NULL, &cond->event_sem, DCE_POSTONE, FALSE);
  118.  
  119.     cond->wait_count = 0;
  120.  
  121.     return 0;
  122. }
  123.  
  124. static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
  125. {
  126.     DosCloseEventSem(cond->event_sem);
  127.  
  128.     return 0;
  129. }
  130.  
  131. static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
  132. {
  133.     if (cond->wait_count > 0) {
  134.         DosPostEventSem(cond->event_sem);
  135.  
  136.         cond->wait_count--;
  137.     }
  138.  
  139.     return 0;
  140. }
  141.  
  142. static av_always_inline int pthread_cond_broadcast(pthread_cond_t *cond)
  143. {
  144.     while (cond->wait_count > 0) {
  145.         DosPostEventSem(cond->event_sem);
  146.  
  147.         cond->wait_count--;
  148.     }
  149.  
  150.     return 0;
  151. }
  152.  
  153. static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
  154. {
  155.     cond->wait_count++;
  156.  
  157.     pthread_mutex_unlock(mutex);
  158.  
  159.     DosWaitEventSem(cond->event_sem, SEM_INDEFINITE_WAIT);
  160.  
  161.     pthread_mutex_lock(mutex);
  162.  
  163.     return 0;
  164. }
  165.  
  166. #endif /* AVCODEC_OS2PTHREADS_H */
  167.