[osal]: add rk_log, rk_list, rk_thread to osal directory

linux test ok
window can not compile, need more check

git-svn-id: https://10.10.10.66:8443/svn/MediaProcessPlatform/trunk/mpp@3 6e48237b-75ef-9749-8fc9-41990f28c85a

CMakeLists.txt

@@ -0,0 +1,211 @@
+# ----------------------------------------------------------------------------
+#  Root CMake file for Rockchip Media Process Platform (MPP)
+#
+#   - 10:34 2015/7/27: Initial version <herman.chen@rock-chips.com>
+#
+# ----------------------------------------------------------------------------
+
+# vim: syntax=cmake
+if(NOT CMAKE_BUILD_TYPE)
+    # default to Release build for GCC builds
+    set(CMAKE_BUILD_TYPE Debug CACHE STRING
+        "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel."
+        FORCE)
+endif()
+message(STATUS "cmake version ${CMAKE_VERSION}")
+if(NOT CMAKE_VERSION VERSION_LESS "2.8.12.20131121")
+    cmake_policy(SET CMP0025 OLD) # report Apple's Clang as just Clang
+    cmake_policy(SET CMP0042 OLD) # do not require MACOSX_RPATH
+endif()
+
+project (rk_mpp)
+
+cmake_minimum_required (VERSION 2.8.8) # OBJECT libraries require 2.8.8
+include(CheckIncludeFiles)
+include(CheckFunctionExists)
+include(CheckSymbolExists)
+include(CheckCXXCompilerFlag)
+
+# ----------------------------------------------------------------------------
+# add debug define in project
+# ----------------------------------------------------------------------------
+if(NOT $(CMAKE_BUILD_TYPE) MATCHES “Release”)
+	option(RK_DEBUG "Enable run-time debug mode(debugging)" ON)
+	if(RK_DEBUG)
+		add_definitions(-DRK_DEBUG)
+		message(STATUS "rk_mpp debug mode is enabled")
+	endif()
+endif()
+
+# ----------------------------------------------------------------------------
+# System architecture detection
+# ----------------------------------------------------------------------------
+string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" SYSPROC)
+set(X86_ALIASES x86 i386 i686 x86_64 amd64)
+list(FIND X86_ALIASES "${SYSPROC}" X86MATCH)
+if("${SYSPROC}" STREQUAL "" OR X86MATCH GREATER "-1")
+    message(STATUS "Detected x86 system processor")
+    set(X86 1)
+    add_definitions(-DARCH_X86=1)
+    if("${CMAKE_SIZEOF_VOID_P}" MATCHES 8)
+        set(X64 1)
+        add_definitions(-DARCH_X64=1)
+        message(STATUS "Define X86_64 to 1")
+    endif()
+elseif(${SYSPROC} STREQUAL "armv6l")
+    message(STATUS "Detected ARM system processor")
+    set(ARM 1)
+    add_definitions(-DARCH_ARM=1 -DDHAVE_ARMV6=1)
+else()
+    message(STATUS "CMAKE_SYSTEM_PROCESSOR value `${CMAKE_SYSTEM_PROCESSOR}` is unknown")
+    message(STATUS "Please add this value near ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE}")
+endif()
+
+if(UNIX)
+    SET(PLATFORM_LIBS pthread)
+    if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+        SET(PLATFORM_LIBS ${PLATFORM_LIBS} rt)
+    endif()
+endif(UNIX)
+
+# ----------------------------------------------------------------------------
+# Compiler detection
+# ----------------------------------------------------------------------------
+if(CMAKE_GENERATOR STREQUAL "Xcode")
+  set(XCODE 1)
+endif()
+
+if (APPLE)
+  add_definitions(-DMACOS)
+endif()
+
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+    set(CLANG 1)
+endif()
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+    set(INTEL_CXX 1)
+endif()
+if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+    set(GCC 1)
+endif()
+
+if(INTEL_CXX AND WIN32)
+    # treat icl roughly like MSVC
+    set(MSVC 1)
+endif()
+if(MSVC)
+    option(STATIC_LINK_CRT "Statically link C runtime for release builds" OFF)
+    if (STATIC_LINK_CRT)
+        set(CompilerFlags CMAKE_CXX_FLAGS_RELEASE CMAKE_C_FLAGS_RELEASE)
+        foreach(CompilerFlag ${CompilerFlags})
+            string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
+        endforeach()
+    endif (STATIC_LINK_CRT)
+    add_definitions(/W3)  # Full warnings
+    add_definitions(/Ob2) # always inline
+    add_definitions(/MP)  # multithreaded build
+    # disable Microsofts suggestions for proprietary secure APIs
+    add_definitions(/D_CRT_SECURE_NO_WARNINGS)
+endif(MSVC)
+
+if(INTEL_CXX AND UNIX)
+    # treat icpc roughly like gcc
+    set(GCC 1)
+    add_definitions(-Wall -Wextra -Wshadow)
+elseif(CLANG)
+    # treat clang roughly like gcc
+    set(GCC 1)
+    add_definitions(-Wall -Wextra -Wshadow -ffast-math)
+elseif(CMAKE_COMPILER_IS_GNUCXX)
+    add_definitions(-Wall -Wextra -Wshadow -ffast-math)
+    check_cxx_compiler_flag(-Wno-narrowing GCC_HAS_NO_NARROWING)
+    check_cxx_compiler_flag(-mstackrealign GCC_HAS_STACK_REALIGN)
+    if (GCC_HAS_STACK_REALIGN)
+        add_definitions(-mstackrealign)
+    endif()
+    execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+endif()
+
+if(GCC)
+    if(X64 AND NOT WIN32)
+        add_definitions(-fPIC)
+    endif(X64 AND NOT WIN32)
+    if(X86 AND NOT X64)
+        add_definitions(-march=i686)
+    endif()
+    if(ARM)
+        add_definitions(-march=armv6 -mfloat-abi=hard -mfpu=vfp)
+    endif()
+endif(GCC)
+
+# ----------------------------------------------------------------------------
+# Build options
+# ----------------------------------------------------------------------------
+set(HDR_INSTALL_DIR "./out/inc" CACHE STRING "Install location of headers")
+set(LIB_INSTALL_DIR "./out/lib" CACHE STRING "Install location of libraries")
+set(BIN_INSTALL_DIR "./out/bin" CACHE STRING "Install location of executables")
+
+# ----------------------------------------------------------------------------
+# Set Warning as Error
+# ----------------------------------------------------------------------------
+option(WARNINGS_AS_ERRORS "Stop compiles on first warning" OFF)
+if(WARNINGS_AS_ERRORS)
+    if(GCC)
+        add_definitions(-Werror)
+    elseif(MSVC)
+        add_definitions(/WX)
+    endif()
+endif(WARNINGS_AS_ERRORS)
+
+# ----------------------------------------------------------------------------
+# Visual leak detector
+# ----------------------------------------------------------------------------
+if (WIN32)
+    find_package(VLD QUIET)
+    if(VLD_FOUND)
+        add_definitions(-DHAVE_VLD)
+        include_directories(${VLD_INCLUDE_DIRS})
+        set(PLATFORM_LIBS ${PLATFORM_LIBS} ${VLD_LIBRARIES})
+        link_directories(${VLD_LIBRARY_DIRS})
+    endif()
+    option(WINXP_SUPPORT "Make binaries compatible with Windows XP" OFF)
+    if(WINXP_SUPPORT)
+        # force use of workarounds for CONDITION_VARIABLE and atomic
+        # intrinsics introduced after XP
+        add_definitions(-D_WIN32_WINNT=_WIN32_WINNT_WINXP)
+    endif()
+endif()
+
+# ----------------------------------------------------------------------------
+# look for stdint.h
+# ----------------------------------------------------------------------------
+if(MSVC)
+	check_include_files(stdint.h HAVE_STDINT_H)
+    if(NOT HAVE_STDINT_H)
+        include_directories(osal/window)
+    endif(NOT HAVE_STDINT_H)
+endif(MSVC)
+
+# ----------------------------------------------------------------------------
+# Share library option
+# ----------------------------------------------------------------------------
+option(ENABLE_STATIC "Build shared library" ON)
+option(ENABLE_SHARED "Build shared library" OFF)
+
+
+# ----------------------------------------------------------------------------
+#  Start module definition
+# ----------------------------------------------------------------------------
+# project overall include file
+include_directories(inc)
+
+# ----------------------------------------------------------------------------
+#  osal library
+# ----------------------------------------------------------------------------
+# Operation System Abstract Layer (OSAL) include
+include_directories(osal/inc)
+# OSAL is needed on all platform, do not need option
+add_subdirectory(osal)
+
+
+

build/linux/make-Makefiles.bash

@@ -0,0 +1,4 @@
+#!/bin/bash
+# Run this from within a bash shell
+cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=debug ../../  && ccmake  ../../
+

build/vc12-x86_64/build-all.bat

@@ -0,0 +1,14 @@
+@echo off
+if "%VS120COMNTOOLS%" == "" (
+  msg "%username%" "Visual Studio 12 not detected"
+  exit 1
+)
+if not exist rk_mpp.sln (
+  call make-solutions.bat
+)
+if exist rk_mpp.sln (
+  call "%VS100COMNTOOLS%\..\..\VC\vcvarsall.bat"
+  rem MSBuild /property:Configuration="Release" rk_mpp.sln
+  MSBuild /property:Configuration="Debug" rk_mpp.sln
+  rem MSBuild /property:Configuration="RelWithDebInfo" rk_mpp.sln
+)

build/vc12-x86_64/make-solutions.bat

@@ -0,0 +1,8 @@
+@echo off
+::
+:: run this batch file to create a Visual Studio solution file for this project.
+:: See the cmake documentation for other generator targets
+::
+cmake -G "Visual Studio 12 Win64" ../../ && cmake-gui ../../
+
+::pause on

inc/rk_type.h

@@ -1,5 +1,4 @@
 /*
- *
  * Copyright 2010 Rockchip Electronics S.LSI Co. LTD
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,8 +21,8 @@
  * Date         : 2010-11-23 21:48:40
  */
  
-#ifndef _RK_TYPE_H_
+#ifndef __RK_TYPE_H__
-#define _RK_TYPE_H_
+#define __RK_TYPE_H__
 
 #if defined(_WIN32) && !defined(__MINGW32CE__)
 
@@ -56,4 +55,4 @@ typedef void                    VOID;
 
 #endif
 
-#endif /*_RK_TYPE_H_*/
+#endif /*__RK_TYPE_H__*/

osal/CMakeLists.txt

@@ -0,0 +1,38 @@
+# vim: syntax=cmake
+set(OSAL_HDR
+    inc/rk_list.h
+    inc/rk_thread.h
+	inc/rk_log.h
+    )
+
+set(OSAL_SRC
+    rk_list.cpp
+	rk_log.cpp
+	)
+
+add_library(osal STATIC
+    ${OSAL_SRC}
+    )
+
+# ----------------------------------------------------------------------------
+# On window import win32 pthread library
+# ----------------------------------------------------------------------------
+if(MSVC)
+    set(WIN32_PTHREAD_INCLUDE_DIRS window/pthread/inc)
+    include_directories(${WIN32_PTHREAD_INCLUDE_DIRS})
+    add_library(pthread STATIC IMPORTED)
+    message(STATUS "platform X86 ${X86} X64 ${X64}")
+    if(X64)
+    set_target_properties(pthread PROPERTIES
+                          IMPORTED_LOCATION "window/pthread/lib/x64/pthreadVC2.lib")
+	else()
+    set_target_properties(pthread PROPERTIES
+                          IMPORTED_LOCATION "window/pthread/lib/x86/pthreadVC2.lib")
+    endif()
+endif()
+target_link_libraries(osal pthread)
+install(TARGETS osal
+    LIBRARY DESTINATION ${LIB_INSTALL_DIR}
+    ARCHIVE DESTINATION ${LIB_INSTALL_DIR})
+
+add_subdirectory(test)

osal/inc/rk_list.h

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2010 Rockchip Electronics S.LSI Co. LTD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __RK_LIST_H__
+#define __RK_LIST_H__
+
+#include "rk_type.h"
+
+/*
+ * two list structures are defined, one for C++, the other for C
+ */
+
+#ifdef __cplusplus
+
+#include "rk_thread.h"
+
+// desctructor of list node
+typedef void *(*node_destructor)(void *);
+
+struct rk_list_node;
+class rk_list {
+public:
+    rk_list(node_destructor func);
+    ~rk_list();
+
+    // for FIFO or FILO implement
+    // adding functions support simple structure like C struct or C++ class pointer,
+    // do not support C++ object
+    RK_S32 add_at_head(void *data, RK_S32 size);
+    RK_S32 add_at_tail(void *data, RK_S32 size);
+    // deleting function will copy the stored data to input pointer with size as size
+    // if NULL is passed to deleting functions, the node will be delete directly
+    RK_S32 del_at_head(void *data, RK_S32 size);
+    RK_S32 del_at_tail(void *data, RK_S32 size);
+
+    // for status check
+    RK_S32 list_is_empty();
+    RK_S32 list_size();
+
+    // for vector implement - not implemented yet
+    // adding function will return a key
+    RK_S32 add_by_key(void *data, RK_S32 size, RK_U32 *key);
+    RK_S32 del_by_key(void *data, RK_S32 size, RK_U32 key);
+    RK_S32 show_by_key(void *data, RK_U32 key);
+
+    RK_S32 flush();
+
+private:
+    pthread_mutex_t         mutex;
+    node_destructor         destroy;
+    struct rk_list_node    *head;
+    RK_S32                  count;
+    static RK_U32           keys;
+    static RK_U32           get_key();
+
+    rk_list();
+    rk_list(const rk_list &);
+    rk_list &operator=(const rk_list &);
+};
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct list_head
+{
+    struct list_head *next, *prev;
+};
+
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
+
+#define LIST_HEAD(name) \
+    struct list_head name = LIST_HEAD_INIT(name)
+
+#define INIT_LIST_HEAD(ptr) do { \
+        (ptr)->next = (ptr); (ptr)->prev = (ptr); \
+    } while (0)
+
+#define list_for_each_safe(pos, n, head) \
+    for (pos = (head)->next, n = pos->next; pos != (head); \
+            pos = n, n = pos->next)
+
+#define list_entry(ptr, type, member) \
+    ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
+
+#define list_for_each_entry(pos, head, member)              \
+    for (pos = list_entry((head)->next, typeof(*pos), member);  \
+         &pos->member != (head);    \
+         pos = list_entry(pos->member.next, typeof(*pos), member))
+#define list_for_each_entry_safe(pos, n, head, member)          \
+    for (pos = list_entry((head)->next, typeof(*pos), member),  \
+        n = list_entry(pos->member.next, typeof(*pos), member); \
+         &pos->member != (head);                    \
+         pos = n, n = list_entry(n->member.next, typeof(*n), member))
+
+static inline void __list_add(struct list_head * _new,
+                                  struct list_head * prev,
+                                  struct list_head * next)
+{
+    next->prev = _new;
+    _new->next = next;
+    _new->prev = prev;
+    prev->next = _new;
+}
+
+static inline void list_add(struct list_head *_new, struct list_head *head)
+{
+    __list_add(_new, head, head->next);
+}
+
+static inline void list_add_tail(struct list_head *_new, struct list_head *head)
+{
+    __list_add(_new, head->prev, head);
+}
+
+static inline void __list_del(struct list_head * prev, struct list_head * next)
+{
+    next->prev = prev;
+    prev->next = next;
+}
+
+static inline void list_del_init(struct list_head *entry)
+{
+    __list_del(entry->prev, entry->next);
+
+    INIT_LIST_HEAD(entry);
+}
+
+static inline int list_is_last(const struct list_head *list, const struct list_head *head)
+{
+    return list->next == head;
+}
+
+static inline int list_empty(struct list_head *head)
+{
+    return head->next == head;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /*__RK_LIST_H__*/

osal/inc/rk_log.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2010 Rockchip Electronics S.LSI Co. LTD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __RK_LOG_H__
+#define __RK_LOG_H__
+
+#include "rk_type.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * STATIC_LOG_LEVE is for
+ */
+#define STATIC_LOG_LEVE             (0xffffffff)
+
+#ifdef  STATIC_LOG_LEVE
+#define rk_debug                    STATIC_LOG_LEVE
+#else
+extern  RK_U32 rk_debug;
+#endif
+
+void rk_set_log_flag(RK_U32 flag);
+RK_U32 rk_get_log_flag();
+
+/*
+ * Send the specified message to the log
+ * rk_log : general log function
+ * rk_err : log function for error information
+ */
+void rk_log(const char *fmt, ...);
+void rk_err(const char *fmt, ...);
+
+/*
+ * debug flag usage:
+ * +------+-------------------+
+ * | 8bit |      24bit        |
+ * +------+-------------------+
+ *  0~15 bit: software debug print
+ * 16~23 bit: hardware debug print
+ * 24~31 bit: information print format
+ */
+/*
+ *  0~ 3 bit:
+ */
+#define rk_dbg(flag, debug, fmt, ...) \
+    do { \
+        if (debug & flag) { \
+            rk_log(fmt, ## __VA_ARGS__); \
+        } \
+    } while(0)
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /*__RK_LOG_H__*/

osal/inc/rk_thread.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010 Rockchip Electronics S.LSI Co. LTD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * File         : rk_thread.h
+ * Description  : thread library for different OS
+ * Author       : herman.chen@rock-chips.com
+ * Date         : 9:47 2015/7/27
+ */
+ 
+#ifndef __RK_THREAD_H__
+#define __RK_THREAD_H__
+
+#if defined(_WIN32) && !defined(__MINGW32CE__)
+/*
+ * NOTE: POSIX Threads for Win32
+ * Downloaded from http://www.sourceware.org/pthreads-win32/ 
+ */
+#include "window\pthread\inc\pthread.h"
+#else
+#include <pthread.h>
+#endif
+
+#endif /*__RK_THREAD_H__*/

osal/rk_list.cpp

@@ -0,0 +1,465 @@
+/*
+ * Copyright 2010 Rockchip Electronics S.LSI Co. LTD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define ALOG_TAG "RK_LIST"
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <errno.h>
+
+#include "rk_log.h"
+#include "rk_list.h"
+
+
+#define LIST_DEBUG(fmt, ...) rk_log(fmt, ## __VA_ARGS__)
+#define LIST_ERROR(fmt, ...) rk_err(fmt, ## __VA_ARGS__)
+
+RK_U32 rk_list::keys = 0;
+
+typedef struct rk_list_node {
+    rk_list_node*   prev;
+    rk_list_node*   next;
+    RK_U32          key;
+    RK_S32          size;
+} rk_list_node;
+
+static inline void list_node_init(rk_list_node *node)
+{
+    node->prev = node->next = node;
+}
+
+static inline void list_node_init_with_key_and_size(rk_list_node *node, RK_U32 key, RK_S32 size)
+{
+    list_node_init(node);
+    node->key   = key;
+    node->size  = size;
+}
+
+static rk_list_node* create_list(void *data, RK_S32 size, RK_U32 key)
+{
+    rk_list_node *node = (rk_list_node*)malloc(sizeof(rk_list_node)+size);
+    if (node) {
+        void *dst = (void*)(node + 1);
+        list_node_init_with_key_and_size(node, key, size);
+        memcpy(dst, data, size);
+    } else {
+        LIST_ERROR("failed to allocate list node");
+    }
+    return node;
+}
+
+static inline void _rk_list_add(rk_list_node * _new, rk_list_node * prev, rk_list_node * next)
+{
+    next->prev = _new;
+    _new->next = next;
+    _new->prev = prev;
+    prev->next = _new;
+}
+
+static inline void rk_list_add(rk_list_node *_new, rk_list_node *head)
+{
+    _rk_list_add(_new, head, head->next);
+}
+
+static inline void rk_list_add_tail(rk_list_node *_new, rk_list_node *head)
+{
+    _rk_list_add(_new, head->prev, head);
+}
+
+RK_S32 rk_list::add_at_head(void *data, RK_S32 size)
+{
+    RK_S32 ret = -EINVAL;
+    pthread_mutex_lock(&mutex);
+    if (head) {
+        rk_list_node *node = create_list(data, size, 0);
+        if (node) {
+            rk_list_add(node, head);
+            count++;
+            ret = 0;
+        } else {
+            ret = -ENOMEM;
+        }
+    }
+    pthread_mutex_unlock(&mutex);
+    return ret;
+}
+
+RK_S32 rk_list::add_at_tail(void *data, RK_S32 size)
+{
+    RK_S32 ret = -EINVAL;
+    pthread_mutex_lock(&mutex);
+    if (head) {
+        rk_list_node *node = create_list(data, size, 0);
+        if (node) {
+            rk_list_add_tail(node, head);
+            count++;
+            ret = 0;
+        } else {
+            ret = -ENOMEM;
+        }
+    }
+    pthread_mutex_unlock(&mutex);
+    return ret;
+}
+
+static void release_list(rk_list_node*node, void *data, RK_S32 size)
+{
+    void *src = (void*)(node + 1);
+    if (node->size == size) {
+        memcpy(data, src, size);
+    } else {
+        LIST_ERROR("node size check failed when release_list");
+        size = (size < node->size) ? (size) : (node->size);
+        memcpy(data, src, size);
+    }
+    free(node);
+}
+
+static inline void _rk_list_del(rk_list_node *prev, rk_list_node *next)
+{
+    next->prev = prev;
+    prev->next = next;
+}
+
+static inline void rk_list_del_init(rk_list_node *node)
+{
+    _rk_list_del(node->prev, node->next);
+    list_node_init(node);
+}
+
+static inline int list_is_last(const rk_list_node *list, const rk_list_node *head)
+{
+    return list->next == head;
+}
+
+static inline void _list_del_node_no_lock(rk_list_node *node, void *data, RK_S32 size)
+{
+    rk_list_del_init(node);
+    release_list(node, data, size);
+}
+
+RK_S32 rk_list::del_at_head(void *data, RK_S32 size)
+{
+    RK_S32 ret = -EINVAL;
+    pthread_mutex_lock(&mutex);
+    if (head && count) {
+        _list_del_node_no_lock(head->next, data, size);
+        count--;
+        ret = 0;
+    }
+    pthread_mutex_unlock(&mutex);
+    return ret;
+}
+
+RK_S32 rk_list::del_at_tail(void *data, RK_S32 size)
+{
+    RK_S32 ret = -EINVAL;
+    pthread_mutex_lock(&mutex);
+    if (head && count) {
+        _list_del_node_no_lock(head->prev, data, size);
+        count--;
+        pthread_mutex_unlock(&mutex);
+        ret = 0;
+    }
+    pthread_mutex_unlock(&mutex);
+    return ret;
+}
+
+RK_S32 rk_list::list_is_empty()
+{
+    pthread_mutex_lock(&mutex);
+    RK_S32 ret = (count == 0);
+    pthread_mutex_unlock(&mutex);
+    return ret;
+}
+
+RK_S32 rk_list::list_size()
+{
+    pthread_mutex_lock(&mutex);
+    RK_S32 ret = count;
+    pthread_mutex_unlock(&mutex);
+    return ret;
+}
+
+RK_S32 rk_list::add_by_key(void *data, RK_S32 size, RK_U32 *key)
+{
+    RK_S32 ret = 0;
+    pthread_mutex_lock(&mutex);
+    if (head) {
+        RK_U32 list_key = get_key();
+        *key = list_key;
+        rk_list_node *node = create_list(data, size, list_key);
+        if (node) {
+            rk_list_add_tail(node, head);
+            count++;
+            ret = 0;
+        } else {
+            ret = -ENOMEM;
+        }
+    }
+    pthread_mutex_unlock(&mutex);
+    return ret;
+}
+
+RK_S32 rk_list::del_by_key(void *data, RK_S32 size, RK_U32 key)
+{
+    RK_S32 ret = 0;
+    pthread_mutex_lock(&mutex);
+    if (head && count) {
+        struct rk_list_node *tmp = head->next;
+        ret = -EINVAL;
+        while (tmp->next != head) {
+            if (tmp->key == key) {
+                _list_del_node_no_lock(tmp, data, size);
+                count--;
+                break;
+            }
+        }
+    }
+    pthread_mutex_unlock(&mutex);
+    return ret;
+}
+
+
+RK_S32 rk_list::show_by_key(void *data, RK_U32 key)
+{
+    RK_S32 ret = -EINVAL;
+    (void)data;
+    (void)key;
+    return ret;
+}
+
+RK_S32 rk_list::flush()
+{
+    pthread_mutex_lock(&mutex);
+    if (head) {
+        while (count) {
+            rk_list_node* node = head->next;
+            rk_list_del_init(node);
+            if (destroy) {
+                destroy((void*)(node + 1));
+            }
+            free(node);
+            count--;
+        }
+    }
+    pthread_mutex_unlock(&mutex);
+    return 0;
+}
+
+RK_U32 rk_list::get_key()
+{
+    return keys++;
+}
+
+rk_list::rk_list(node_destructor func)
+    : destroy(NULL),
+      head(NULL),
+      count(0)
+{
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    pthread_mutex_init(&mutex, &attr);
+    pthread_mutexattr_destroy(&attr);
+    destroy = func;
+    head = (rk_list_node*)malloc(sizeof(rk_list_node));
+    if (NULL == head) {
+        LIST_ERROR("failed to allocate list header");
+    } else {
+        list_node_init_with_key_and_size(head, 0, 0);
+    }
+}
+
+rk_list::~rk_list()
+{
+    flush();
+    if (head) free(head);
+    head = NULL;
+    destroy = NULL;
+    pthread_mutex_destroy(&mutex);
+}
+
+#if BUILD_RK_LIST_TEST
+#include "vpu_mem.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define LOOP_RK_LIST    600
+
+#define COUNT_ADD       100
+#define COUNT_DEL       99
+
+volatile int err = 0;
+
+static int rk_list_fifo_test(rk_list *list_0)
+{
+    int count;
+    VPUMemLinear_t m;
+    for (count = 0; count < COUNT_ADD; count++) {
+        err |= VPUMallocLinear(&m, 100);
+        if (err) {
+            printf("VPUMallocLinear in rk_list_fifo_test\n");
+            break;
+        }
+        err |= list_0->add_at_head(&m, sizeof(m));
+        if (err) {
+            printf("add_at_head in rk_list_fifo_test\n");
+            break;
+        }
+    }
+
+    if (!err) {
+        for (count = 0; count < COUNT_DEL; count++) {
+            err |= list_0->del_at_tail(&m, sizeof(m));
+            if (err) {
+                printf("del_at_tail in rk_list_fifo_test\n");
+                break;
+            }
+            err |= VPUFreeLinear(&m);
+            if (err) {
+                printf("VPUFreeLinear in rk_list_fifo_test\n");
+                break;
+            }
+        }
+    }
+    return err;
+}
+
+static int rk_list_filo_test(rk_list *list_0)
+{
+    int count;
+    VPUMemLinear_t m;
+    for (count = 0; count < COUNT_ADD + COUNT_DEL; count++) {
+        if (count & 1) {
+            err |= list_0->del_at_head(&m, sizeof(m));
+            if (err) {
+                printf("del_at_head in rk_list_filo_test\n");
+                break;
+            }
+            err |= VPUFreeLinear(&m);
+            if (err) {
+                printf("VPUFreeLinear in rk_list_fifo_test\n");
+                break;
+            }
+        } else {
+            err |= VPUMallocLinear(&m, 100);
+            if (err) {
+                printf("VPUMallocLinear in rk_list_filo_test\n");
+                break;
+            }
+            err |= list_0->add_at_head(&m, sizeof(m));
+            if (err) {
+                printf("add_at_head in rk_list_fifo_test\n");
+                break;
+            }
+        }
+    }
+
+    return err;
+}
+
+
+void *rk_list_test_loop_0(void *pdata)
+{
+    int i;
+    rk_list *list_0 = (rk_list *)pdata;
+
+    printf("rk_list test 0 loop start\n");
+    for (i = 0; i < LOOP_RK_LIST; i++) {
+        err |= rk_list_filo_test(list_0);
+        if (err) break;
+    }
+
+    if (err) {
+        printf("thread: found vpu mem operation err %d\n", err);
+    } else {
+        printf("thread: test done and found no err\n");
+    }
+    return NULL;
+}
+
+int rk_list_test_0()
+{
+    int i, err = 0;
+    printf("rk_list test 0 FIFO start\n");
+
+    rk_list *list_0 = new rk_list((node_destructor)VPUFreeLinear);
+
+    pthread_t mThread;
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+
+    pthread_create(&mThread, &attr, rk_list_test_loop_0, (void*)list_0);
+    pthread_attr_destroy(&attr);
+
+    for (i = 0; i < LOOP_RK_LIST; i++) {
+        err |= rk_list_fifo_test(list_0);
+        if (err) break;
+    }
+    if (err) {
+        printf("main  : found rk_list operation err %d\n", err);
+    } else {
+        printf("main  : test done and found no err\n");
+    }
+
+    void *dummy;
+    pthread_join(mThread, &dummy);
+
+    printf("rk_list test 0 end size %d\n", list_0->list_size());
+    delete list_0;
+    return err;
+}
+
+#define TOTAL_RK_LIST_TEST_COUNT    1
+
+typedef int (*RK_LIST_TEST_FUNC)(void);
+RK_LIST_TEST_FUNC test_func[TOTAL_RK_LIST_TEST_COUNT] = {
+    rk_list_test_0,
+};
+
+int main(int argc, char *argv[])
+{
+    int i, start = 0, end = 0;
+    if (argc < 2) {
+        end = TOTAL_RK_LIST_TEST_COUNT;
+    } else if (argc == 2) {
+        start = atoi(argv[1]);
+        end   = start + 1;
+    } else if (argc == 3) {
+        start = atoi(argv[1]);
+        end   = atoi(argv[2]);
+    } else {
+        printf("too many argc %d\n", argc);
+        return -1;
+    }
+    if (start < 0 || start > TOTAL_RK_LIST_TEST_COUNT || end < 0 || end > TOTAL_RK_LIST_TEST_COUNT) {
+        printf("invalid input: start %d end %d\n", start, end);
+        return -1;
+    }
+    for (i = start; i < end; i++) {
+        int err = test_func[i]();
+        if (err) {
+            printf("test case %d return err %d\n", i, err);
+            break;
+        }
+    }
+    return 0;
+}
+#endif
+

osal/rk_log.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2010 Rockchip Electronics S.LSI Co. LTD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include "rk_log.h"
+
+#ifdef ANDROID
+#include <utils/Log.h>
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static RK_U32 mpp_log_flag = 0;
+
+void rk_log(const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+#ifdef ANDROID
+    ALOGI(fmt, args);
+#else
+    vfprintf(stdout, fmt, args);
+#endif
+    va_end(args);
+    return ;
+}
+
+void rk_err(const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+#ifdef ANDROID
+    ALOGE(fmt, args);
+#else
+    vfprintf(stderr, fmt, args);
+#endif
+    va_end(args);
+    return ;
+}
+
+void rk_set_log_flag(RK_U32 flag)
+{
+    mpp_log_flag = flag;
+    return ;
+}
+
+RK_U32 rk_get_log_flag()
+{
+    return mpp_log_flag;
+}
+
+
+#ifdef __cplusplus
+}
+#endif

osal/test/CMakeLists.txt

@@ -0,0 +1,18 @@
+# vim: syntax=cmake
+# ----------------------------------------------------------------------------
+# OSAL built-in unit test case
+# ----------------------------------------------------------------------------
+# log system unit test
+option(OSAL_LOG_TEST "Build osal rk_log unit test" ON)
+if(OSAL_THREAD_TEST)
+	add_executable(rk_log_test rk_log_test.c)
+	target_link_libraries(rk_log_test osal)
+endif()
+
+# thread implement unit test
+option(OSAL_THREAD_TEST "Build osal rk_thread unit test" ON)
+if(OSAL_THREAD_TEST)
+	add_executable(rk_thread_test rk_thread_test.c)
+	target_link_libraries(rk_thread_test pthread osal)
+endif()
+

osal/test/rk_log_test.c

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010 Rockchip Electronics S.LSI Co. LTD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rk_log.h"
+
+
+int main()
+{
+    RK_U32 flag = 0xffff;
+
+    rk_err("mpp error log test start\n");
+
+    rk_log("mpp log flag: %08x\n", rk_get_log_flag());
+
+    rk_log("set flag to %08x\n", flag);
+
+    rk_set_log_flag(flag);
+
+    rk_log("mpp log flag: %08x\n", rk_get_log_flag());
+
+    rk_err("mpp error log test done\n");
+
+    return 0;
+}

osal/test/rk_thread_test.c

@@ -0,0 +1,78 @@
+/*
+ *
+ * Copyright 2010 Rockchip Electronics S.LSI Co. LTD
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <unistd.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <sys/poll.h>
+#include <signal.h>
+
+#include "rk_type.h"
+#include "rk_log.h"
+#include "rk_thread.h"
+
+#define MAX_THREAD_NUM      10
+void *thread_test(void *pdata)
+{
+    (void)pdata;
+    for (;;) {
+        int fd = open("/dev/vpu_service", O_RDWR);
+        if (fd < 0) {
+            rk_log("failed to open /dev/vpu_service ret %d\n", fd);
+            return NULL;
+        }
+        close(fd);
+    }
+    return NULL;
+}
+
+int main()
+{
+    int i;
+
+    rk_log("vpu test start\n");
+    pthread_t threads[MAX_THREAD_NUM];
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
+
+    for (i = 0; i < MAX_THREAD_NUM; i++) {
+        pthread_create(&threads[i], &attr, thread_test, NULL);
+    }
+    pthread_attr_destroy(&attr);
+    for (i = 0; i < 2; i++)
+        sleep(1);
+
+    void *dummy;
+
+    for (i = 0; i < MAX_THREAD_NUM; i++) {
+        pthread_join(threads[i], &dummy);
+    }
+
+    rk_log("vpu test end\n");
+    return 0;
+}
+

osal/window/pthread/inc/sched.h

@@ -0,0 +1,183 @@
+/*
+ * Module: sched.h
+ *
+ * Purpose:
+ *      Provides an implementation of POSIX realtime extensions
+ *      as defined in 
+ *
+ *              POSIX 1003.1b-1993      (POSIX.1b)
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads-win32 - POSIX Threads Library for Win32
+ *      Copyright(C) 1998 John E. Bossom
+ *      Copyright(C) 1999,2005 Pthreads-win32 contributors
+ * 
+ *      Contact Email: rpj@callisto.canberra.edu.au
+ * 
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *      http://sources.redhat.com/pthreads-win32/contributors.html
+ * 
+ *      This library is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU Lesser General Public
+ *      License as published by the Free Software Foundation; either
+ *      version 2 of the License, or (at your option) any later version.
+ * 
+ *      This library is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *      Lesser General Public License for more details.
+ * 
+ *      You should have received a copy of the GNU Lesser General Public
+ *      License along with this library in the file COPYING.LIB;
+ *      if not, write to the Free Software Foundation, Inc.,
+ *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+#if !defined(_SCHED_H)
+#define _SCHED_H
+
+#undef PTW32_SCHED_LEVEL
+
+#if defined(_POSIX_SOURCE)
+#define PTW32_SCHED_LEVEL 0
+/* Early POSIX */
+#endif
+
+#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
+#undef PTW32_SCHED_LEVEL
+#define PTW32_SCHED_LEVEL 1
+/* Include 1b, 1c and 1d */
+#endif
+
+#if defined(INCLUDE_NP)
+#undef PTW32_SCHED_LEVEL
+#define PTW32_SCHED_LEVEL 2
+/* Include Non-Portable extensions */
+#endif
+
+#define PTW32_SCHED_LEVEL_MAX 3
+
+#if ( defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112 )  || !defined(PTW32_SCHED_LEVEL)
+#define PTW32_SCHED_LEVEL PTW32_SCHED_LEVEL_MAX
+/* Include everything */
+#endif
+
+
+#if defined(__GNUC__) && !defined(__declspec)
+# error Please upgrade your GNU compiler to one that supports __declspec.
+#endif
+
+/*
+ * When building the library, you should define PTW32_BUILD so that
+ * the variables/functions are exported correctly. When using the library,
+ * do NOT define PTW32_BUILD, and then the variables/functions will
+ * be imported correctly.
+ */
+#if !defined(PTW32_STATIC_LIB)
+#  if defined(PTW32_BUILD)
+#    define PTW32_DLLPORT __declspec (dllexport)
+#  else
+#    define PTW32_DLLPORT __declspec (dllimport)
+#  endif
+#else
+#  define PTW32_DLLPORT
+#endif
+
+/*
+ * This is a duplicate of what is in the autoconf config.h,
+ * which is only used when building the pthread-win32 libraries.
+ */
+
+#if !defined(PTW32_CONFIG_H)
+#  if defined(WINCE)
+#    define NEED_ERRNO
+#    define NEED_SEM
+#  endif
+#  if defined(__MINGW64__)
+#    define HAVE_STRUCT_TIMESPEC
+#    define HAVE_MODE_T
+#  elif defined(_UWIN) || defined(__MINGW32__)
+#    define HAVE_MODE_T
+#  endif
+#endif
+
+/*
+ *
+ */
+
+#if PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX
+#if defined(NEED_ERRNO)
+#include "need_errno.h"
+#else
+#include <errno.h>
+#endif
+#endif /* PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX */
+
+#if (defined(__MINGW64__) || defined(__MINGW32__)) || defined(_UWIN)
+# if PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX
+/* For pid_t */
+#  include <sys/types.h>
+/* Required by Unix 98 */
+#  include <time.h>
+# else
+   typedef int pid_t;
+# endif
+#else
+ typedef int pid_t;
+#endif
+
+/* Thread scheduling policies */
+
+enum {
+  SCHED_OTHER = 0,
+  SCHED_FIFO,
+  SCHED_RR,
+  SCHED_MIN   = SCHED_OTHER,
+  SCHED_MAX   = SCHED_RR
+};
+
+struct sched_param {
+  int sched_priority;
+};
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+PTW32_DLLPORT int __cdecl sched_yield (void);
+
+PTW32_DLLPORT int __cdecl sched_get_priority_min (int policy);
+
+PTW32_DLLPORT int __cdecl sched_get_priority_max (int policy);
+
+PTW32_DLLPORT int __cdecl sched_setscheduler (pid_t pid, int policy);
+
+PTW32_DLLPORT int __cdecl sched_getscheduler (pid_t pid);
+
+/*
+ * Note that this macro returns ENOTSUP rather than
+ * ENOSYS as might be expected. However, returning ENOSYS
+ * should mean that sched_get_priority_{min,max} are
+ * not implemented as well as sched_rr_get_interval.
+ * This is not the case, since we just don't support
+ * round-robin scheduling. Therefore I have chosen to
+ * return the same value as sched_setscheduler when
+ * SCHED_RR is passed to it.
+ */
+#define sched_rr_get_interval(_pid, _interval) \
+  ( errno = ENOTSUP, (int) -1 )
+
+
+#if defined(__cplusplus)
+}                               /* End of extern "C" */
+#endif                          /* __cplusplus */
+
+#undef PTW32_SCHED_LEVEL
+#undef PTW32_SCHED_LEVEL_MAX
+
+#endif                          /* !_SCHED_H */
+

osal/window/pthread/inc/semaphore.h

@@ -0,0 +1,169 @@
+/*
+ * Module: semaphore.h
+ *
+ * Purpose:
+ *	Semaphores aren't actually part of the PThreads standard.
+ *	They are defined by the POSIX Standard:
+ *
+ *		POSIX 1003.1b-1993	(POSIX.1b)
+ *
+ * --------------------------------------------------------------------------
+ *
+ *      Pthreads-win32 - POSIX Threads Library for Win32
+ *      Copyright(C) 1998 John E. Bossom
+ *      Copyright(C) 1999,2005 Pthreads-win32 contributors
+ * 
+ *      Contact Email: rpj@callisto.canberra.edu.au
+ * 
+ *      The current list of contributors is contained
+ *      in the file CONTRIBUTORS included with the source
+ *      code distribution. The list can also be seen at the
+ *      following World Wide Web location:
+ *      http://sources.redhat.com/pthreads-win32/contributors.html
+ * 
+ *      This library is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU Lesser General Public
+ *      License as published by the Free Software Foundation; either
+ *      version 2 of the License, or (at your option) any later version.
+ * 
+ *      This library is distributed in the hope that it will be useful,
+ *      but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *      Lesser General Public License for more details.
+ * 
+ *      You should have received a copy of the GNU Lesser General Public
+ *      License along with this library in the file COPYING.LIB;
+ *      if not, write to the Free Software Foundation, Inc.,
+ *      59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+#if !defined( SEMAPHORE_H )
+#define SEMAPHORE_H
+
+#undef PTW32_SEMAPHORE_LEVEL
+
+#if defined(_POSIX_SOURCE)
+#define PTW32_SEMAPHORE_LEVEL 0
+/* Early POSIX */
+#endif
+
+#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
+#undef PTW32_SEMAPHORE_LEVEL
+#define PTW32_SEMAPHORE_LEVEL 1
+/* Include 1b, 1c and 1d */
+#endif
+
+#if defined(INCLUDE_NP)
+#undef PTW32_SEMAPHORE_LEVEL
+#define PTW32_SEMAPHORE_LEVEL 2
+/* Include Non-Portable extensions */
+#endif
+
+#define PTW32_SEMAPHORE_LEVEL_MAX 3
+
+#if !defined(PTW32_SEMAPHORE_LEVEL)
+#define PTW32_SEMAPHORE_LEVEL PTW32_SEMAPHORE_LEVEL_MAX
+/* Include everything */
+#endif
+
+#if defined(__GNUC__) && ! defined (__declspec)
+# error Please upgrade your GNU compiler to one that supports __declspec.
+#endif
+
+/*
+ * When building the library, you should define PTW32_BUILD so that
+ * the variables/functions are exported correctly. When using the library,
+ * do NOT define PTW32_BUILD, and then the variables/functions will
+ * be imported correctly.
+ */
+#if !defined(PTW32_STATIC_LIB)
+#  if defined(PTW32_BUILD)
+#    define PTW32_DLLPORT __declspec (dllexport)
+#  else
+#    define PTW32_DLLPORT __declspec (dllimport)
+#  endif
+#else
+#  define PTW32_DLLPORT
+#endif
+
+/*
+ * This is a duplicate of what is in the autoconf config.h,
+ * which is only used when building the pthread-win32 libraries.
+ */
+
+#if !defined(PTW32_CONFIG_H)
+#  if defined(WINCE)
+#    define NEED_ERRNO
+#    define NEED_SEM
+#  endif
+#  if defined(__MINGW64__)
+#    define HAVE_STRUCT_TIMESPEC
+#    define HAVE_MODE_T
+#  elif defined(_UWIN) || defined(__MINGW32__)
+#    define HAVE_MODE_T
+#  endif
+#endif
+
+/*
+ *
+ */
+
+#if PTW32_SEMAPHORE_LEVEL >= PTW32_SEMAPHORE_LEVEL_MAX
+#if defined(NEED_ERRNO)
+#include "need_errno.h"
+#else
+#include <errno.h>
+#endif
+#endif /* PTW32_SEMAPHORE_LEVEL >= PTW32_SEMAPHORE_LEVEL_MAX */
+
+#define _POSIX_SEMAPHORES
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif				/* __cplusplus */
+
+#if !defined(HAVE_MODE_T)
+typedef unsigned int mode_t;
+#endif
+
+
+typedef struct sem_t_ * sem_t;
+
+PTW32_DLLPORT int __cdecl sem_init (sem_t * sem,
+			    int pshared,
+			    unsigned int value);
+
+PTW32_DLLPORT int __cdecl sem_destroy (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_trywait (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_wait (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_timedwait (sem_t * sem,
+				 const struct timespec * abstime);
+
+PTW32_DLLPORT int __cdecl sem_post (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_post_multiple (sem_t * sem,
+				     int count);
+
+PTW32_DLLPORT int __cdecl sem_open (const char * name,
+			    int oflag,
+			    mode_t mode,
+			    unsigned int value);
+
+PTW32_DLLPORT int __cdecl sem_close (sem_t * sem);
+
+PTW32_DLLPORT int __cdecl sem_unlink (const char * name);
+
+PTW32_DLLPORT int __cdecl sem_getvalue (sem_t * sem,
+				int * sval);
+
+#if defined(__cplusplus)
+}				/* End of extern "C" */
+#endif				/* __cplusplus */
+
+#undef PTW32_SEMAPHORE_LEVEL
+#undef PTW32_SEMAPHORE_LEVEL_MAX
+
+#endif				/* !SEMAPHORE_H */

osal/window/stdint.h

@@ -0,0 +1,13 @@
+#pragma once
+
+/* a minimal set of C99 types for use with MSVC */
+
+typedef signed char int8_t;
+typedef short int int16_t;
+typedef int int32_t;
+typedef __int64 int64_t;
+
+typedef unsigned char uint8_t;
+typedef unsigned short int uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned __int64 uint64_t;