p71924506
/
aosp12
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
aosp12/external/libhevc/encoder/osal.h

624 lines
26 KiB
C
Raw Blame History

/******************************************************************************
*
* Copyright (C) 2018 The Android Open Source Project
*
* 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.
*
*****************************************************************************
* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
*/
/*****************************************************************************/
/* */
/* File Name : osal.h */
/* */
/* Description : This file contains all the necessary OSAL Constants, */
/* Enums, Structures and API declarations. */
/* */
/* List of Functions : None */
/* */
/* Issues / Problems : None */
/* */
/* Revision History : */
/* */
/* DD MM YYYY Author(s) Changes (Describe the changes made) */
/* 03 03 2006 Ittiam Draft */
/* */
/*****************************************************************************/
#ifndef OSAL_H
#define OSAL_H
/* C linkage specifiers for C++ declarations. */
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/*****************************************************************************/
/* Constants */
/*****************************************************************************/
/* OSAL handle size */
#define OSAL_HANDLE_SIZE 40
/* Number of select entries */
#define OSAL_SELECT_MAX 20
/* OSAL Return Status */
#define OSAL_SUCCESS 0
#define OSAL_ERROR -1
#define OSAL_NOT_SUPPORTED -2
#define OSAL_TIMEOUT -3
/* OSAL thread priority levels. */
/* OSAL_PRIORITY_1 represents MINIMUM, */
/* OSAL_PRIORITY_10 represents MAXIMUM, */
/* OSAL_PRIORITY_DEFAULT represnts DEFAULT SYSTEM PRIROTIY LEVEL */
#define OSAL_PRIORITY_DEFAULT 0
#define OSAL_PRIORITY_1 1
#define OSAL_PRIORITY_2 2
#define OSAL_PRIORITY_3 3
#define OSAL_PRIORITY_4 4
#define OSAL_PRIORITY_5 5
#define OSAL_PRIORITY_6 6
#define OSAL_PRIORITY_7 7
#define OSAL_PRIORITY_8 8
#define OSAL_PRIORITY_9 9
#define OSAL_PRIORITY_10 10
/* OSAL socket option levels */
#define OSAL_SOL_SOCKET 10000
#define OSAL_IPPROTO_IP 10001
/* OSAL socket options */
#define OSAL_BROADCAST 1000
#define OSAL_REUSEADDR 1001
#define OSAL_KEEPALIVE 1002
#define OSAL_LINGER 1003
#define OSAL_OOBINLINE 1004
#define OSAL_SNDBUF 1005
#define OSAL_RCVBUF 1006
#define OSAL_RCVTIMEO 1007
#define OSAL_SNDTIMEO 1008
#define OSAL_ADD_MEMBERSHIP 1009
#define OSAL_DROP_MEMBERSHIP 1010
#define OSAL_TTL 1011
#define OSAL_DSCP 1012
#define OSAL_MULTICAST_TTL 1013
#define OSAL_ADDSRC_MEMBERSHIP 1014
#define OSAL_DROPSRC_MEMBERSHIP 1015
/*****************************************************************************/
/* Enums */
/*****************************************************************************/
/* Protocols supported. */
typedef enum
{
OSAL_TCP, /* Address family = AF_INET, Type = SOCK_STREAM, Protocol = 0 */
OSAL_UDP /* Address family = AF_INET, Type = SOCK_DGRAM, Protocol = 0 */
} OSAL_PROTOCOL_T;
/* File Descriptor types. Used to specify the type of activity to check on */
/* a socket. */
typedef enum
{
OSAL_READ_FD,
OSAL_WRITE_FD,
OSAL_EXCEPT_FD
} OSAL_FD_TYPE_T;
/* Scheduling policies supported */
typedef enum
{
OSAL_SCHED_RR,
OSAL_SCHED_FIFO,
OSAL_SCHED_OTHER
} OSAL_SCHED_POLICY_TYPE_T;
/*****************************************************************************/
/* Structures */
/*****************************************************************************/
/* Structure to initialize OSAL */
typedef struct
{
/* Handle of memory manager being used. NULL is a valid argument.*/
void *mmr_handle;
/* Call back API to be called during allocation */
void *(*osal_alloc)(void *mmr_handle, UWORD32 size);
/* Call back API for freeing */
void (*osal_free)(void *mmr_handle, void *mem);
} osal_cb_funcs_t;
/* The structure (osal_mbox_attr_t) contains the attributes of the thread */
/* which are passed to osal_mbox_create() API. The created Mail box has */
/* attributes specified using the structure variable. */
typedef struct
{
void *thread_handle; /* Thread to be associated with mail box. */
STRWORD8 *name; /* NULL terminated string name for mail box */
UWORD32 msg_size; /* Length of each message. */
UWORD32 mbx_len; /* Maximum number of messages. */
} osal_mbox_attr_t;
/* The structure (osal_sem_attr_t) contains the attributes of the semaphore */
/* which are passed to osal_sem_create() API. The Semaphore attributes like */
/* initial value of semaphore. */
typedef struct
{
WORD32 value;
} osal_sem_attr_t;
/* The Structure (osal_thread_attr_t) contains the attributes of the thread */
/* which are passed to osal_thread_create() API. The created thread has */
/* attributes specified using the structure variable. */
typedef struct
{
/* Function from where thread execution starts */
void *thread_func;
/* Parameters for thread function. */
void *thread_param;
/* Stack size in bytes. For default value, set to '0' */
UWORD32 stack_size;
/* This attribute specifies a pre-allocated block of size 'stack_size' */
/* to be used for the task's private stack. For default value, set to */
/* 'NULL'. */
void *stack_addr;
/* NULL terminated string name for thread. For default value, set to */
/* 'NULL'. */
WORD8 *name;
/* Flag determining whether to use OSAL Thread priority mapping or not. */
/* Value set to 1 - use OSAL thread priority mapping. */
/* Value set to 0 - Direct value set as thread priority */
WORD32 priority_map_flag;
/* Priority range shall be considered + ve values for increasing */
/* priority and negative values for decreasing priority. The range shall */
/* be mapped to specific OS range internally through OSAL. For default */
/* value, set to '0'. */
WORD32 priority;
/* Exit return value on which thread shall exit */
WORD32 exit_code;
/* Scheduling policy of the thread */
OSAL_SCHED_POLICY_TYPE_T sched_policy;
/* Mask to specify on which cores the thread can run */
ULWORD64 core_affinity_mask;
/* Specifies on which group of processors the thread can run */
WORD16 group_num;
} osal_thread_attr_t;
/* The structure (osal_socket_attr_t) contains the attributes of the socket */
/* which are to be specified during socket creation. */
typedef struct
{
OSAL_PROTOCOL_T protocol;
} osal_socket_attr_t;
/* The structure (osal_sockaddr_t) is used to uniquely determine a socket in */
/* the network. The socket can be addressed using IP address and port number.*/
typedef struct
{
WORD8 ip_addr[16];
UWORD16 port;
} osal_sockaddr_t;
/* The structure contains the select engine thread parameters like thread */
/* name thread priority etc. */
typedef struct
{
/* Flag determining whether to use OSAL Thread priority mapping or not. */
/* Value set to 1 - use OSAL thread priority mapping. */
/* Value set to 0 - Direct value set as thread priority */
WORD32 priority_map_flag;
/* Priority range shall be considered + ve values for increasing */
/* priority and negative values for decreasing priority. The range shall */
/* be mapped to specific OS range internally through OSAL. For default */
/* value, set to '0'. */
WORD32 priority;
/* NULL terminated string name for thread. For default value, set to */
/* 'NULL'. */
WORD8 *name;
/* Timeout for thread sleep in micro seconds */
UWORD32 select_timeout;
/* Timeout for SELECT system called by osal library in micro seconds */
UWORD32 select_poll_interval;
} osal_select_engine_attr_t;
/* The structure used to register sockets to select engine. This structure */
/* has to be updated for each socket handle and select register has to be */
/* done. Currently registration is supported one at a time. */
/* Note: Function 'init' is assumed to return the socket handle. */
typedef struct osal_select_entry_t
{
/* Socket handle to be registered. */
void *socket_handle;
/* Activity to select for. */
OSAL_FD_TYPE_T type;
/* Call back called before doing select. The function init is assumed to */
/* return the socket handle. In case of NULL being returning by this */
/* function, The socket will be unregistered */
void *(*init)(void *);
/* Argument to init function */
void *init_param;
/* Call back function on select success */
WORD32 (*call_back)(void *socket_handle, void *call_back_param);
/* Call back function parameters */
void *call_back_param;
/* Call back called when the socket is unregistered. If set to NULL, */
/* this will not be called. The socket that has been registered is the */
/* first argument, the second argument will be terminate_param */
void (*terminate)(void *, void *);
/* Argument to terminate callback */
void *terminate_param;
/* Exit code of the call back function. */
WORD32 exit_code;
/* Identifier. Do not initialize this. */
WORD32 id;
} osal_select_entry_t;
/* File descriptor structure. Used in osal_socket_select() API call. */
/* Currently maximum number of sockets that can be set is fixed to */
/* SELECT_MAX */
/* Note : To initialize osal_fd_set structure variable, call API */
/* osal_socket_fd_zero() for Initialization. If initialization is not */
/* done, behaviour of osal_socket_select() and fd_set API's is */
/* undefined. */
typedef struct
{
void *array[OSAL_SELECT_MAX]; /* Array for holding the socket descriptors*/
WORD32 count; /* Number of socket descriptors in array */
} osal_fd_set_t;
/* Timeout value for osal_socket_select() API. */
typedef struct
{
WORD32 tv_sec; /* Time in seconds. */
WORD32 tv_usec; /* Time in micro seconds. */
} osal_timeval_t;
/* Attributes for setting Linger option for socket */
typedef struct
{
UWORD16 l_onoff;
UWORD16 l_linger;
} osal_sockopt_linger_t;
/* Attributes for Joining or dropping from a multicast group */
typedef struct
{
WORD8 imr_multiaddr[16];
WORD8 imr_interface[16];
WORD8 imr_srcaddr[16];
} osal_ip_mreq_t;
/*****************************************************************************/
/* Extern OSAL Initialization Function Declarations */
/*****************************************************************************/
/* Allocates memory for the OSAL instance handle. It also allocates memory */
/* for storing debug information. */
extern WORD32 osal_init(IN void *osal_handle);
/* Releases all the resources held by the OSAL handle */
extern WORD32 osal_close(IN void *osal_handle);
/* This function registers MMR call backs for OSAL */
extern WORD32 osal_register_callbacks(IN void *osal_handle, IN osal_cb_funcs_t *cb_funcs);
/*****************************************************************************/
/* Extern Mail Box Function Declarations */
/*****************************************************************************/
/* Allocates memory for mail box handle. Creates a mail box which is */
/* associated with the thread and updates the mail box, which returned for */
/* further actions to be performed on the mail box. */
extern void *osal_mbox_create(IN void *osal_handle, IN osal_mbox_attr_t *attr);
/* Closes the mail box and frees the memory allocated for mail box handle. */
extern WORD32 osal_mbox_destroy(IN void *mbox_handle);
/* Posts a message to the mail box */
extern WORD32 osal_mbox_post(IN void *mbox_handle, IN void *buf, IN UWORD32 len);
/* Gets the message form the specified mail box. If there are not messages */
/* in mail box, it waits infinitely till a message arrives. */
extern WORD32 osal_mbox_get(IN void *mbox_handle, OUT void *buf, IN UWORD32 len);
/* Gets the message from the specified mail box within the timeout period. */
/* If no messages are present in specified time, error code is returned. The */
/* error can be got from osal_get_last_error() API */
extern WORD32
osal_mbox_get_timed(IN void *mbox_handle, OUT void *buf, IN UWORD32 len, IN UWORD32 timeout);
/*****************************************************************************/
/* Extern Custom Mail Box Function Declarations */
/*****************************************************************************/
/* Allocates memory for mail box handle. Creates a mail box which is */
/* associated with the thread and updates the mail box, which returned for */
/* further actions to be performed on the mail box. */
extern void *osal_custom_mbox_create(IN void *osal_handle, IN osal_mbox_attr_t *attr);
/* Closes the mail box and frees the memory allocated for mail box handle. */
extern WORD32 osal_custom_mbox_destroy(IN void *mbox_handle);
/* Posts a message to the mail box */
extern WORD32 osal_custom_mbox_post(IN void *cust_mbox_handle, IN void *buf, IN UWORD32 len);
/* Gets the message form the specified mail box. If there are not messages */
/* in mail box, it waits infinitely till a message arrives. */
extern WORD32 osal_custom_mbox_get(IN void *cust_mbox_handle, OUT void *buf, IN UWORD32 len);
/* Gets the message from the specified mail box within the timeout period. */
/* If no messages are present in specified time, error code is returned. The */
/* error can be got from osal_get_last_error() API */
extern WORD32 osal_custom_mbox_get_timed(
IN void *cust_mbox_handle, OUT void *buf, IN UWORD32 len, IN UWORD32 timeout);
/*****************************************************************************/
/* Extern Mutex Function Declarations */
/*****************************************************************************/
/* Creates a mutex and returns the to mutex */
extern void *osal_mutex_create(IN void *osal_handle);
/* Closes the mutex. */
extern WORD32 osal_mutex_destroy(IN void *mutex_handle);
/* Waits infinitely till mutex lock is got. */
extern WORD32 osal_mutex_lock(IN void *mutex_handle);
/* Releases the lock held on the mutex. */
extern WORD32 osal_mutex_unlock(IN void *mutex_handle);
/*****************************************************************************/
/* Extern Semaphore Function Declarations */
/*****************************************************************************/
/* Creates a semaphore and returns the handle to semaphore. */
extern void *osal_sem_create(IN void *osal_handle, IN osal_sem_attr_t *attr);
/* Closes the semaphore. */
extern WORD32 osal_sem_destroy(IN void *sem_handle);
/* Waits infinitely till semaphore is zero. */
extern WORD32 osal_sem_wait(IN void *sem_handle);
/* Increments the value of semaphore by one. */
extern WORD32 osal_sem_post(IN void *sem_handle);
/* Returns the current value of semaphore. */
extern WORD32 osal_sem_count(IN void *sem_handle, OUT WORD32 *count);
/*****************************************************************************/
/* Extern Conditional Variable Function Declarations */
/*****************************************************************************/
/* Creates a conditional variable and returns the handle to it. */
extern void *osal_cond_var_create(IN void *osal_handle);
/* Destroys the conditional variable. */
extern WORD32 osal_cond_var_destroy(IN void *cond_var_handle);
/* Waits infinitely till conditional variable receives signal. */
extern WORD32 osal_cond_var_wait(IN void *cond_var_handle, IN void *mutex_handle);
/* Signals on conditional variable. */
extern WORD32 osal_cond_var_signal(IN void *cond_var_handle);
/*****************************************************************************/
/* Extern Thread Function Declarations */
/*****************************************************************************/
/* Creates a thread with specified parameters */
extern void *osal_thread_create(IN void *osal_handle, IN osal_thread_attr_t *attr);
/* Closes or halts the execution of thread specified by the handle. */
extern WORD32 osal_thread_destroy(IN void *thread_handle);
/* Makes the thread sleep for specified number of milliseconds */
extern WORD32 osal_thread_sleep(IN UWORD32 milli_seconds);
/* Yields the execution of thread. */
extern WORD32 osal_thread_yield(void);
/* Suspends the execution of thread until osal_thread_resume API is called. */
extern WORD32 osal_thread_suspend(IN void *thread_handle);
/* Resumes the execution of thread which was suspended by */
/* osal_thread_suspend API call. */
extern WORD32 osal_thread_resume(IN void *thread_handle);
/* Waits infinitely till the thread, whose handle is passed, completes */
/* execution. */
extern WORD32 osal_thread_wait(IN void *thread_handle);
/* Returns current thread handle */
extern void *osal_get_thread_handle(IN void *osal_handle);
/*****************************************************************************/
/* Extern Network Socket Function Declarations */
/*****************************************************************************/
/* Initializes network resources */
extern WORD32 osal_network_init(void);
/* Un-initializes all the network resources */
extern WORD32 osal_network_close(void);
/* Creates the socket and returns the socket descriptor. */
extern void *osal_socket_create(IN void *osal_handle, IN osal_socket_attr_t *attr);
/* Closes the open socket. */
extern WORD32 osal_socket_destroy(IN void *socket_handle);
/* Binds to the specified port number on the local machine. Socket_create */
/* API has to be called before calling socket_bind. */
extern WORD32 osal_socket_bind(IN void *socket_handle, IN osal_sockaddr_t *addr);
/* Starts listening at the specified port for any incoming connections. */
/* Socket descriptor should be bound before calling socket_listen */
extern WORD32 osal_socket_listen(IN void *socket_handle, IN WORD32 backlog);
/* Accepts incoming connection. If listen queue is empty it blocks till a */
/* successful connection is made. */
extern void *osal_socket_accept(IN void *socket_handle, OUT osal_sockaddr_t *addr);
/* Makes a connection request to the remote address specified. */
extern WORD32 osal_socket_connect(IN void *socket_handle, IN osal_sockaddr_t *addr);
/* Sends the specified number of bytes of data */
extern WORD32 osal_socket_send(
IN void *socket_handle, IN const WORD8 *buf, IN WORD32 len, IN WORD32 flags);
/* Receives data over TCP connection. */
extern WORD32
osal_socket_recv(IN void *socket_handle, OUT WORD8 *buf, IN WORD32 len, IN WORD32 flags);
/* Sends data over a datagram protocol */
extern WORD32 osal_socket_sendto(
IN void *socket_handle,
IN const WORD8 *buf,
IN WORD32 len,
IN WORD32 flags,
IN osal_sockaddr_t *to);
/* Receives packet over a UDP connection */
extern WORD32 osal_socket_recvfrom(
IN void *socket_handle,
OUT WORD8 *buf,
IN WORD32 len,
IN WORD32 flags,
OUT osal_sockaddr_t *from);
/* Polls the specified sockets for specified activity */
extern WORD32 osal_socket_select(
INOUT osal_fd_set_t *readfds,
INOUT osal_fd_set_t *writefds,
INOUT osal_fd_set_t *exceptfds,
INOUT osal_timeval_t *timeout);
/* Gets the socket options */
extern WORD32 osal_socket_getsockopt(
IN void *socket_handle,
IN WORD32 level,
IN WORD32 optname,
OUT WORD8 *optval,
INOUT WORD32 *optlen);
/* Sets the socket options to specified values */
extern WORD32 osal_socket_setsockopt(
IN void *socket_handle,
IN WORD32 level,
IN WORD32 optname,
IN const WORD8 *optval,
IN WORD32 optlen);
/* Adds the specified socket handle to the file descriptor set */
extern WORD32 osal_socket_fd_set(IN void *socket_handle, OUT osal_fd_set_t *set);
/* Checks the file descriptor set for the presence of socket handle. */
extern WORD32 osal_socket_fd_isset(IN void *socket_handle, IN osal_fd_set_t *set);
/* Resets the file descriptor set */
extern void osal_socket_fd_zero(INOUT osal_fd_set_t *set);
/* Removes the specified socket handle from the file descriptor set */
extern WORD32 osal_socket_fd_clr(IN void *socket_handle, OUT osal_fd_set_t *set);
/* To convert short integer from host byte order to network byte order */
extern UWORD16 osal_htons(IN UWORD16 hostshort);
/* To convert long integer from host to network byte order */
extern UWORD32 osal_htonl(IN UWORD32 hostlong);
/* To convert short integer from network to host byte order */
extern UWORD16 osal_ntohs(IN UWORD16 netshort);
/* To convert long integer from network to host byte order */
extern UWORD32 osal_ntohl(IN UWORD32 netlong);
/*****************************************************************************/
/* Extern Select Engine Function Declarations */
/*****************************************************************************/
/* Initializes the select engine. */
extern void *
osal_select_engine_init(IN void *osal_handle, IN osal_select_engine_attr_t *se_attr);
/* Closes the select engine. */
extern WORD32 osal_select_engine_close(IN void *select_engine);
/* Registers the socket handle specified in the entry. */
extern WORD32
osal_select_engine_register(IN void *select_engine, IN osal_select_entry_t *entry);
/* Un-registers the specified socket handle. */
extern WORD32 osal_select_engine_unregister(
IN void *select_engine, IN void *socket_handle, IN OSAL_FD_TYPE_T fd_type);
/*****************************************************************************/
/* Extern Other Function Declarations */
/*****************************************************************************/
/* Returns time in milliseconds */
extern UWORD32 osal_get_time(void);
/* For time in micro-second resolution */
extern WORD32 osal_get_time_usec(UWORD32 *sec, UWORD32 *usec);
/* Returns the last error code. 0 is no error */
extern UWORD32 osal_get_last_error(void);
/* Prints the last error code. 0 is no error */
extern void osal_print_last_error(IN const STRWORD8 *string);
/* Gets the version of library in NULL terminated string form. */
extern WORD8 *osal_get_version(void);
/* Gets the tid of the thread in whose context this call was made */
extern WORD32 osal_get_current_tid(void);
/* C linkage specifiers for C++ declarations. */
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* OSAL_H */
Reference in New Issue View Git Blame Copy Permalink