/src/libhevc/encoder/osal_mutex.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_mutex.c                                         */
/*                                                                           */
/*  Description       : This file contains all the necessary function        */
/*                      definitions required to operate on mutex             */
/*                                                                           */
/*  List of Functions : osal_get_mutex_handle_size                           */
/*                      osal_mutex_create                                    */
/*                      osal_mutex_destroy                                   */
/*                      osal_mutex_lock                                      */
/*                      osal_mutex_lock_timed                                */
/*                      osal_mutex_unlock                                    */
/*                                                                           */
/*  Issues / Problems : None                                                 */
/*                                                                           */
/*  Revision History  :                                                      */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         20 03 2006   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

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

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

#include <errno.h>
#include <semaphore.h>
#include <pthread.h>
#include <time.h>

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

/*****************************************************************************/
/*                                                                           */
/*  Function Name : osal_mutex_create                                        */
/*                                                                           */
/*  Description   : This function creates the mutex and returns the handle   */
/*                  to the user.                                             */
/*                                                                           */
/*  Inputs        : OSAL handle                                              */
/*                  Pointer to Memory manager handle                         */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : Allocates memory for Mutex handle and calls OS specific  */
/*                  mutex create API call.                                   */
/*                                                                           */
/*  Outputs       : Mutex handle                                             */
/*                                                                           */
/*  Returns       : On SUCCESS - Mutex handle                                */
/*                  On FAILURE - NULL                                        */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         20 03 2006   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

void *osal_mutex_create(IN void *osal_handle)
{
    void *mmr_handle = 0;

    /* Currenlty naming semaphores is not supported */
    {
        osal_t *handle = osal_handle;
        mutex_handle_t *mutex_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 */
        mutex_handle = handle->alloc(mmr_handle, sizeof(mutex_handle_t));

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

        mutex_handle->mmr_handle = mmr_handle;
        mutex_handle->hdl = handle;

        /* Create semaphore */
        if(0 != pthread_mutex_init(&(mutex_handle->mutex_handle), NULL))
        {
            handle->free(mmr_handle, mutex_handle);
            return 0;
        }

        return mutex_handle;
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : osal_mutex_destroy                                       */
/*                                                                           */
/*  Description   : This function destroys the mutex.                        */
/*                                                                           */
/*  Inputs        : Mutex Handle                                             */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : This function destroys the mutex refernced by the handle */
/*                  and frees the memory held by the handle.                 */
/*                                                                           */
/*  Outputs       : Status of mutex destroy                                  */
/*                                                                           */
/*  Returns       : On SUCCESS - 0                                           */
/*                  On FAILURE - -1                                          */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         22 03 2006   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

WORD32 osal_mutex_destroy(IN void *mutex_handle)
{
    if(0 == mutex_handle)
        return OSAL_ERROR;

    {
        mutex_handle_t *handle = (mutex_handle_t *)mutex_handle;
        WORD32 status = 0;

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

        /* Destroy the mutex */
        status = pthread_mutex_destroy(&(handle->mutex_handle));

        if(0 != status)
            return OSAL_ERROR;

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

/*****************************************************************************/
/*                                                                           */
/*  Function Name : osal_mutex_lock                                          */
/*                                                                           */
/*  Description   : This function locks the mutex.                           */
/*                                                                           */
/*  Inputs        : Mutex handle                                             */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : Calls OS specific mutex lock API.                        */
/*                                                                           */
/*  Outputs       : Status of mutex lock                                     */
/*                                                                           */
/*  Returns       : On SUCCESS - 0                                           */
/*                  On FAILURE - -1                                          */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         22 03 2006   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

WORD32 osal_mutex_lock(IN void *mutex_handle)
{
    if(0 == mutex_handle)
        return OSAL_ERROR;

    {
        mutex_handle_t *handle = (mutex_handle_t *)mutex_handle;

        /* Wait on mutex lock */
        return pthread_mutex_lock(&(handle->mutex_handle));
    }
}

/*****************************************************************************/
/*                                                                           */
/*  Function Name : osal_mutex_unlock                                        */
/*                                                                           */
/*  Description   : This function unlocks the mutex                          */
/*                                                                           */
/*  Inputs        : Mutex handle                                             */
/*                                                                           */
/*  Globals       : None                                                     */
/*                                                                           */
/*  Processing    : Calls OS specific unlock mutex API.                      */
/*                                                                           */
/*  Outputs       : Status of mutex unlock                                   */
/*                                                                           */
/*  Returns       : On SUCCESS - 0                                           */
/*                  On FAILURE - -1                                          */
/*                                                                           */
/*  Issues        : None                                                     */
/*                                                                           */
/*  Revision History:                                                        */
/*                                                                           */
/*         DD MM YYYY   Author(s)       Changes (Describe the changes made)  */
/*         22 03 2006   Ittiam          Draft                                */
/*                                                                           */
/*****************************************************************************/

WORD32 osal_mutex_unlock(IN void *mutex_handle)
{
    if(0 == mutex_handle)
        return OSAL_ERROR;

    {
        mutex_handle_t *handle = (mutex_handle_t *)mutex_handle;

        /* Release the lock */
        if(0 == pthread_mutex_unlock(&(handle->mutex_handle)))
            return OSAL_SUCCESS;

        return OSAL_ERROR;
    }
}

Coverage Report

Created: 2024-07-27 06:20

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_mutex.c */
24		/* */
25		/* Description : This file contains all the necessary function */
26		/* definitions required to operate on mutex */
27		/* */
28		/* List of Functions : osal_get_mutex_handle_size */
29		/* osal_mutex_create */
30		/* osal_mutex_destroy */
31		/* osal_mutex_lock */
32		/* osal_mutex_lock_timed */
33		/* osal_mutex_unlock */
34		/* */
35		/* Issues / Problems : None */
36		/* */
37		/* Revision History : */
38		/* */
39		/* DD MM YYYY Author(s) Changes (Describe the changes made) */
40		/* 20 03 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 <semaphore.h>
53		#include <pthread.h>
54		#include <time.h>
55
56		/* User include files */
57		#include "cast_types.h"
58		#include "osal.h"
59		#include "osal_handle.h"
60		#include "osal_mutex.h"
61
62		/*****************************************************************************/
63		/* */
64		/* Function Name : osal_mutex_create */
65		/* */
66		/* Description : This function creates the mutex and returns the handle */
67		/* to the user. */
68		/* */
69		/* Inputs : OSAL handle */
70		/* Pointer to Memory manager handle */
71		/* */
72		/* Globals : None */
73		/* */
74		/* Processing : Allocates memory for Mutex handle and calls OS specific */
75		/* mutex create API call. */
76		/* */
77		/* Outputs : Mutex handle */
78		/* */
79		/* Returns : On SUCCESS - Mutex handle */
80		/* On FAILURE - NULL */
81		/* */
82		/* Issues : None */
83		/* */
84		/* Revision History: */
85		/* */
86		/* DD MM YYYY Author(s) Changes (Describe the changes made) */
87		/* 20 03 2006 Ittiam Draft */
88		/* */
89		/*****************************************************************************/
90
91		void osal_mutex_create(IN void osal_handle)
92	177k	{
93	177k	void *mmr_handle = 0;
94
95		/* Currenlty naming semaphores is not supported */
96	177k	{
97	177k	osal_t *handle = osal_handle;
98	177k	mutex_handle_t *mutex_handle = 0;
99
100	177k	if(0 == handle \|\| 0 == handle->alloc \|\| 0 == handle->free)
101	0	return 0;
102
103		/* Initialize MMR handle */
104	177k	mmr_handle = handle->mmr_handle;
105
106		/* Allocate memory for the Handle */
107	177k	mutex_handle = handle->alloc(mmr_handle, sizeof(mutex_handle_t));
108
109		/* Error in memory allocation */
110	177k	if(0 == mutex_handle)
111	0	return 0;
112
113	177k	mutex_handle->mmr_handle = mmr_handle;
114	177k	mutex_handle->hdl = handle;
115
116		/* Create semaphore */
117	177k	if(0 != pthread_mutex_init(&(mutex_handle->mutex_handle), NULL))
118	0	{
119	0	handle->free(mmr_handle, mutex_handle);
120	0	return 0;
121	0	}
122
123	177k	return mutex_handle;
124	177k	}
125	177k	}
126
127		/*****************************************************************************/
128		/* */
129		/* Function Name : osal_mutex_destroy */
130		/* */
131		/* Description : This function destroys the mutex. */
132		/* */
133		/* Inputs : Mutex Handle */
134		/* */
135		/* Globals : None */
136		/* */
137		/* Processing : This function destroys the mutex refernced by the handle */
138		/* and frees the memory held by the handle. */
139		/* */
140		/* Outputs : Status of mutex destroy */
141		/* */
142		/* Returns : On SUCCESS - 0 */
143		/* On FAILURE - -1 */
144		/* */
145		/* Issues : None */
146		/* */
147		/* Revision History: */
148		/* */
149		/* DD MM YYYY Author(s) Changes (Describe the changes made) */
150		/* 22 03 2006 Ittiam Draft */
151		/* */
152		/*****************************************************************************/
153
154		WORD32 osal_mutex_destroy(IN void *mutex_handle)
155	177k	{
156	177k	if(0 == mutex_handle)
157	0	return OSAL_ERROR;
158
159	177k	{
160	177k	mutex_handle_t handle = (mutex_handle_t )mutex_handle;
161	177k	WORD32 status = 0;
162
163	177k	if(0 == handle->hdl \|\| 0 == handle->hdl->free)
164	0	return OSAL_ERROR;
165
166		/* Destroy the mutex */
167	177k	status = pthread_mutex_destroy(&(handle->mutex_handle));
168
169	177k	if(0 != status)
170	0	return OSAL_ERROR;
171
172		/* Free the handle */
173	177k	handle->hdl->free(handle->mmr_handle, handle);
174	177k	return OSAL_SUCCESS;
175	177k	}
176	177k	}
177
178		/*****************************************************************************/
179		/* */
180		/* Function Name : osal_mutex_lock */
181		/* */
182		/* Description : This function locks the mutex. */
183		/* */
184		/* Inputs : Mutex handle */
185		/* */
186		/* Globals : None */
187		/* */
188		/* Processing : Calls OS specific mutex lock API. */
189		/* */
190		/* Outputs : Status of mutex lock */
191		/* */
192		/* Returns : On SUCCESS - 0 */
193		/* On FAILURE - -1 */
194		/* */
195		/* Issues : None */
196		/* */
197		/* Revision History: */
198		/* */
199		/* DD MM YYYY Author(s) Changes (Describe the changes made) */
200		/* 22 03 2006 Ittiam Draft */
201		/* */
202		/*****************************************************************************/
203
204		WORD32 osal_mutex_lock(IN void *mutex_handle)
205	13.5M	{
206	13.5M	if(0 == mutex_handle)
207	8.85k	return OSAL_ERROR;
208
209	13.5M	{
210	13.5M	mutex_handle_t handle = (mutex_handle_t )mutex_handle;
211
212		/* Wait on mutex lock */
213	13.5M	return pthread_mutex_lock(&(handle->mutex_handle));
214	13.5M	}
215	13.5M	}
216
217		/*****************************************************************************/
218		/* */
219		/* Function Name : osal_mutex_unlock */
220		/* */
221		/* Description : This function unlocks the mutex */
222		/* */
223		/* Inputs : Mutex handle */
224		/* */
225		/* Globals : None */
226		/* */
227		/* Processing : Calls OS specific unlock mutex API. */
228		/* */
229		/* Outputs : Status of mutex unlock */
230		/* */
231		/* Returns : On SUCCESS - 0 */
232		/* On FAILURE - -1 */
233		/* */
234		/* Issues : None */
235		/* */
236		/* Revision History: */
237		/* */
238		/* DD MM YYYY Author(s) Changes (Describe the changes made) */
239		/* 22 03 2006 Ittiam Draft */
240		/* */
241		/*****************************************************************************/
242
243		WORD32 osal_mutex_unlock(IN void *mutex_handle)
244	13.5M	{
245	13.5M	if(0 == mutex_handle)
246	8.85k	return OSAL_ERROR;
247
248	13.5M	{
249	13.5M	mutex_handle_t handle = (mutex_handle_t )mutex_handle;
250
251		/* Release the lock */
252	13.5M	if(0 == pthread_mutex_unlock(&(handle->mutex_handle)))
253	13.5M	return OSAL_SUCCESS;
254
255	18.4E	return OSAL_ERROR;
256	13.5M	}
257	13.5M	}