/src/libhevc/encoder/osal_cond_var.c

Source (jump to first uncovered line)
/******************************************************************************
 *
 * 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_cond_var.c                                      */
/*                                                                           */
/*  Description       : This file contains all the necessary function        */
/*                      definitions required to operate on Conditional       */
/*                      Variable.                                            */
/*                                                                           */
/*  List of Functions : osal_cond_var_create                                 */
/*                      osal_cond_var_destroy                                */
/*                      osal_cond_var_wait                                   */
/*                      osal_cond_var_wait_timed                             */
/*                      osal_cond_var_signal                                 */
/*                                                                           */
/*  Issues / Problems : None                                                 */
/*                                                                           */
/*  Revision History  :                                                      */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         05 09 2006   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

/*****************************************************************************/
/* File Includes                                                             */
/*****************************************************************************/

/* System include files */
#include <stdio.h>

#include <errno.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

/* User include files */
#include "cast_types.h"
#include "osal.h"
#include "osal_handle.h"
#include "osal_mutex.h"
#include "osal_cond_var.h"

/*****************************************************************************/
/*                                                                           */
/*  Function Name : osal_cond_var_create                                     */
/*                                                                           */
/*  Description   : This function initializes the conditional variable and   */
/*                  returns the handle to it.                                */
/*                                                                           */
/*  Inputs        : OSAL handle                                              */
/*                  Memory manager handle                                    */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : Calls system specific API and returns handle to the      */
/*                  conditional variable.                                    */
/*                                                                           */
/*  Outputs       : Handle to Condtional Variable                            */
/*                                                                           */
/*  Returns       : On SUCCESS - Handle to Conditional Varaible              */
/*                  On FAILURE - NULL                                        */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         05 09 2006   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

void *osal_cond_var_create(IN void *osal_handle)
{
    if(0 == osal_handle)
        return 0;

    {
        osal_t *handle = osal_handle;
        cond_var_handle_t *cond_var_handle = 0;
        void *mmr_handle = 0;

        if(0 == handle || 0 == handle->alloc || 0 == handle->free)
            return 0;

        /* Initialize MMR handle */
        mmr_handle = handle->mmr_handle;

        /* Allocate memory for the Handle */
        cond_var_handle = handle->alloc(mmr_handle, sizeof(cond_var_handle_t));

        /* Error in memory allocation */
        if(0 == cond_var_handle)
            return 0;

        cond_var_handle->mmr_handle = mmr_handle;
        cond_var_handle->hdl = handle;

        /* Create semaphore */
        if(0 != pthread_cond_init(&(cond_var_handle->cond_var), 0))
        {
            handle->free(mmr_handle, cond_var_handle);
            return 0;
        }

        return cond_var_handle;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : osal_cond_var_destroy                                    */
/*                                                                           */
/*  Description   : This function destroys all the OS resources allocated by */
/*                  'osal_cond_var_create' API.                              */
/*                                                                           */
/*  Inputs        : Conditional Variable handle                              */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : Validates the input and destroys all the OS allocated    */
/*                  resources.                                               */
/*                                                                           */
/*  Outputs       : Status of closure                                        */
/*                                                                           */
/*  Returns       : On SUCCESS - OSAL_SUCCESS                                */
/*                  On FAILURE - OSAL_ERROR                                  */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         10 05 2006   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

WORD32 osal_cond_var_destroy(IN void *cond_var_handle)
{
    if(0 == cond_var_handle)
        return OSAL_ERROR;

    {
        cond_var_handle_t *handle = (cond_var_handle_t *)cond_var_handle;
        WORD32 status = 0;

        if(0 == handle->hdl || 0 == handle->hdl->free)
            return OSAL_ERROR;

        /* Destroy the mutex */
        status = pthread_cond_destroy(&(handle->cond_var));

        if(0 != status)
            return OSAL_ERROR;

        /* Free the handle */
        handle->hdl->free(handle->mmr_handle, handle);
        return OSAL_SUCCESS;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : osal_cond_var_wait                                       */
/*                                                                           */
/*  Description   : This function waits infinitely on conditional varaiable. */
/*                                                                           */
/*  Inputs        : Conditional Variable handle                              */
/*                  Mutex handle for lock                                    */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : This function waits on Conditional variable signal. Till */
/*                  signal is not, lock on mutex is relinquished.            */
/*                                                                           */
/*  Outputs       : Status of wait on conditional variable                   */
/*                                                                           */
/*  Returns       : On SUCCESS - OSAL_SUCCESS                                */
/*                  On FAILURE - OSAL_ERROR                                  */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         10 05 2006   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

WORD32 osal_cond_var_wait(IN void *cond_var_handle, IN void *mutex_handle)
{
    if(0 == cond_var_handle || 0 == mutex_handle)
        return OSAL_ERROR;

    {
        mutex_handle_t *mutex = (mutex_handle_t *)mutex_handle;
        cond_var_handle_t *cond_var = (cond_var_handle_t *)cond_var_handle;

        return pthread_cond_wait(&(cond_var->cond_var), &(mutex->mutex_handle));
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : osal_cond_var_signal                                     */
/*                                                                           */
/*  Description   : This function signals on a conditional variable.         */
/*                                                                           */
/*  Inputs        : Conditional Variable handle                              */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : Calls the underlaying API to signal on a conditional     */
/*                  variable.                                                */
/*                                                                           */
/*  Outputs       : Status of signalling                                     */
/*                                                                           */
/*  Returns       : On SUCCESS - OSAL_SUCCESS                                */
/*                  On FAILURE - OSAL_ERROR                                  */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         10 05 2006   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

WORD32 osal_cond_var_signal(IN void *cond_var_handle)
{
    if(0 == cond_var_handle)
        return OSAL_ERROR;

    {
        cond_var_handle_t *cond_var = (cond_var_handle_t *)cond_var_handle;
        return pthread_cond_signal(&(cond_var->cond_var));
    }
}

Coverage Report

Created: 2025-07-23 06:28

Line	Count	Source (jump to first uncovered line)
1		/******************************************************************************
2		*
3		* Copyright (C) 2018 The Android Open Source Project
4		*
5		* Licensed under the Apache License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at:
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*
17		*****************************************************************************
18		* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19		*/
20
21		/*****************************************************************************/
22		/* */
23		/* File Name : osal_cond_var.c */
24		/* */
25		/* Description : This file contains all the necessary function */
26		/* definitions required to operate on Conditional */
27		/* Variable. */
28		/* */
29		/* List of Functions : osal_cond_var_create */
30		/* osal_cond_var_destroy */
31		/* osal_cond_var_wait */
32		/* osal_cond_var_wait_timed */
33		/* osal_cond_var_signal */
34		/* */
35		/* Issues / Problems : None */
36		/* */
37		/* Revision History : */
38		/* */
39		/* DD MM YYYY Author(s) Changes (Describe the changes made) */
40		/* 05 09 2006 Ittiam Draft */
41		/* */
42		/*****************************************************************************/
43
44		/*****************************************************************************/
45		/* File Includes */
46		/*****************************************************************************/
47
48		/* System include files */
49		#include <stdio.h>
50
51		#include <errno.h>
52		#include <pthread.h>
53		#include <stdlib.h>
54		#include <unistd.h>
55		#include <time.h>
56
57		/* User include files */
58		#include "cast_types.h"
59		#include "osal.h"
60		#include "osal_handle.h"
61		#include "osal_mutex.h"
62		#include "osal_cond_var.h"
63
64		/*****************************************************************************/
65		/* */
66		/* Function Name : osal_cond_var_create */
67		/* */
68		/* Description : This function initializes the conditional variable and */
69		/* returns the handle to it. */
70		/* */
71		/* Inputs : OSAL handle */
72		/* Memory manager handle */
73		/* */
74		/* Globals : None */
75		/* */
76		/* Processing : Calls system specific API and returns handle to the */
77		/* conditional variable. */
78		/* */
79		/* Outputs : Handle to Condtional Variable */
80		/* */
81		/* Returns : On SUCCESS - Handle to Conditional Varaible */
82		/* On FAILURE - NULL */
83		/* */
84		/* Issues : None */
85		/* */
86		/* Revision History: */
87		/* */
88		/* DD MM YYYY Author(s) Changes (Describe the changes made) */
89		/* 05 09 2006 Ittiam Draft */
90		/* */
91		/*****************************************************************************/
92
93		void osal_cond_var_create(IN void osal_handle)
94	8.21k	{
95	8.21k	if(0 == osal_handle)
96	0	return 0;
97
98	8.21k	{
99	8.21k	osal_t *handle = osal_handle;
100	8.21k	cond_var_handle_t *cond_var_handle = 0;
101	8.21k	void *mmr_handle = 0;
102
103	8.21k	if(0 == handle \|\| 0 == handle->alloc \|\| 0 == handle->free)
104	0	return 0;
105
106		/* Initialize MMR handle */
107	8.21k	mmr_handle = handle->mmr_handle;
108
109		/* Allocate memory for the Handle */
110	8.21k	cond_var_handle = handle->alloc(mmr_handle, sizeof(cond_var_handle_t));
111
112		/* Error in memory allocation */
113	8.21k	if(0 == cond_var_handle)
114	0	return 0;
115
116	8.21k	cond_var_handle->mmr_handle = mmr_handle;
117	8.21k	cond_var_handle->hdl = handle;
118
119		/* Create semaphore */
120	8.21k	if(0 != pthread_cond_init(&(cond_var_handle->cond_var), 0))
121	0	{
122	0	handle->free(mmr_handle, cond_var_handle);
123	0	return 0;
124	0	}
125
126	8.21k	return cond_var_handle;
127	8.21k	}
128	8.21k	}
129
130		/*****************************************************************************/
131		/* */
132		/* Function Name : osal_cond_var_destroy */
133		/* */
134		/* Description : This function destroys all the OS resources allocated by */
135		/* 'osal_cond_var_create' API. */
136		/* */
137		/* Inputs : Conditional Variable handle */
138		/* */
139		/* Globals : None */
140		/* */
141		/* Processing : Validates the input and destroys all the OS allocated */
142		/* resources. */
143		/* */
144		/* Outputs : Status of closure */
145		/* */
146		/* Returns : On SUCCESS - OSAL_SUCCESS */
147		/* On FAILURE - OSAL_ERROR */
148		/* */
149		/* Issues : None */
150		/* */
151		/* Revision History: */
152		/* */
153		/* DD MM YYYY Author(s) Changes (Describe the changes made) */
154		/* 10 05 2006 Ittiam Draft */
155		/* */
156		/*****************************************************************************/
157
158		WORD32 osal_cond_var_destroy(IN void *cond_var_handle)
159	8.21k	{
160	8.21k	if(0 == cond_var_handle)
161	0	return OSAL_ERROR;
162
163	8.21k	{
164	8.21k	cond_var_handle_t handle = (cond_var_handle_t )cond_var_handle;
165	8.21k	WORD32 status = 0;
166
167	8.21k	if(0 == handle->hdl \|\| 0 == handle->hdl->free)
168	0	return OSAL_ERROR;
169
170		/* Destroy the mutex */
171	8.21k	status = pthread_cond_destroy(&(handle->cond_var));
172
173	8.21k	if(0 != status)
174	0	return OSAL_ERROR;
175
176		/* Free the handle */
177	8.21k	handle->hdl->free(handle->mmr_handle, handle);
178	8.21k	return OSAL_SUCCESS;
179	8.21k	}
180	8.21k	}
181
182		/*****************************************************************************/
183		/* */
184		/* Function Name : osal_cond_var_wait */
185		/* */
186		/* Description : This function waits infinitely on conditional varaiable. */
187		/* */
188		/* Inputs : Conditional Variable handle */
189		/* Mutex handle for lock */
190		/* */
191		/* Globals : None */
192		/* */
193		/* Processing : This function waits on Conditional variable signal. Till */
194		/* signal is not, lock on mutex is relinquished. */
195		/* */
196		/* Outputs : Status of wait on conditional variable */
197		/* */
198		/* Returns : On SUCCESS - OSAL_SUCCESS */
199		/* On FAILURE - OSAL_ERROR */
200		/* */
201		/* Issues : None */
202		/* */
203		/* Revision History: */
204		/* */
205		/* DD MM YYYY Author(s) Changes (Describe the changes made) */
206		/* 10 05 2006 Ittiam Draft */
207		/* */
208		/*****************************************************************************/
209
210		WORD32 osal_cond_var_wait(IN void cond_var_handle, IN void mutex_handle)
211	145k	{
212	145k	if(0 == cond_var_handle \|\| 0 == mutex_handle)
213	0	return OSAL_ERROR;
214
215	145k	{
216	145k	mutex_handle_t mutex = (mutex_handle_t )mutex_handle;
217	145k	cond_var_handle_t cond_var = (cond_var_handle_t )cond_var_handle;
218
219	145k	return pthread_cond_wait(&(cond_var->cond_var), &(mutex->mutex_handle));
220	145k	}
221	145k	}
222
223		/*****************************************************************************/
224		/* */
225		/* Function Name : osal_cond_var_signal */
226		/* */
227		/* Description : This function signals on a conditional variable. */
228		/* */
229		/* Inputs : Conditional Variable handle */
230		/* */
231		/* Globals : None */
232		/* */
233		/* Processing : Calls the underlaying API to signal on a conditional */
234		/* variable. */
235		/* */
236		/* Outputs : Status of signalling */
237		/* */
238		/* Returns : On SUCCESS - OSAL_SUCCESS */
239		/* On FAILURE - OSAL_ERROR */
240		/* */
241		/* Issues : None */
242		/* */
243		/* Revision History: */
244		/* */
245		/* DD MM YYYY Author(s) Changes (Describe the changes made) */
246		/* 10 05 2006 Ittiam Draft */
247		/* */
248		/*****************************************************************************/
249
250		WORD32 osal_cond_var_signal(IN void *cond_var_handle)
251	166k	{
252	166k	if(0 == cond_var_handle)
253	0	return OSAL_ERROR;
254
255	166k	{
256	166k	cond_var_handle_t cond_var = (cond_var_handle_t )cond_var_handle;
257	166k	return pthread_cond_signal(&(cond_var->cond_var));
258	166k	}
259	166k	}