audio_buffer.cpp

/*
 * If not stated otherwise in this file or this component's Licenses.txt file the
 * following copyright and licenses apply:
 *
 * Copyright 2016 RDK Management
 *
 * 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 <audio_buffer.h>
#include <string.h>
#include <stdlib.h>
#include "basic_types.h"
#include <pthread.h>
#include "safec_lib.h"
 
audio_buffer::audio_buffer(const unsigned char *in_ptr, unsigned int in_size, unsigned int clip_length, unsigned int refcount) : m_size(in_size), m_clip_length(clip_length), m_refcount(refcount)
{
        DEBUG("Creating new buffer.\n");
        errno_t rc = -1;
        m_start_ptr = (unsigned char *)malloc(in_size);
        rc = memcpy_s(m_start_ptr, in_size, in_ptr, m_size);
        if(rc != EOK)
        {
                ERR_CHK(rc);
        }
}
 
audio_buffer::~audio_buffer()
{
        DEBUG("Deleting buffer.\n");
        free(m_start_ptr);
}
 
 
audio_buffer * create_new_audio_buffer(const unsigned char *in_ptr, unsigned int in_size, unsigned int clip_length, unsigned int refcount)
{
        return new audio_buffer(in_ptr, in_size, clip_length, refcount);
}
 
static pthread_mutex_t g_audio_buffer_mutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
void unref_audio_buffer(audio_buffer *ptr)
{
        /* Current implementation will go for a simple plan, which is to check the refcount of the buffer while protected by a mutex. This means
         * every unref operation involving any buffer at all will be serialized. If this turns out to be a performance bottleneck, plan B is to launch
         * a garbage-cleaning thread of sorts that will actually check the refcount and free the buffers. In that implementation, this funciton
         * will simply post a message (the address of the buffer to be unreffed) to the GC thread and be done with it.*/
        REPORT_IF_UNEQUAL(0, pthread_mutex_lock(&g_audio_buffer_mutex));
        if(1 == ptr->m_refcount)
        {
                delete ptr;
        }
        else
        {
                ptr->m_refcount--;
        }
        REPORT_IF_UNEQUAL(0, pthread_mutex_unlock(&g_audio_buffer_mutex));
}
 
void free_audio_buffer(audio_buffer *ptr)
{
        delete ptr;
}
void audio_buffer_get_global_lock()
{
        REPORT_IF_UNEQUAL(0, pthread_mutex_lock(&g_audio_buffer_mutex));
}
void audio_buffer_release_global_lock()
{
        REPORT_IF_UNEQUAL(0, pthread_mutex_unlock(&g_audio_buffer_mutex));
}