source: mainline/uspace/srv/audio/hound/audio_data.c@ eca79ff

/*
 * Copyright (c) 2013 Jan Vesely
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup audio
 * @brief HelenOS sound server
 * @{
 */
/** @file
 */

#include <macros.h>
#include <malloc.h>

#include "audio_data.h"
#include "log.h"

audio_data_t *audio_data_create(const void *data, size_t size,
    pcm_format_t format)
{
        audio_data_t *adata = malloc(sizeof(audio_data_t));
        if (adata) {
                unsigned overflow = size % pcm_format_frame_size(&format);
                if (overflow)
                        log_warning("Data not a multiple of frame size, "
                            "clipping.");

                adata->data = data;
                adata->size = size - overflow;
                adata->format = format;
                atomic_set(&adata->refcount, 1);
        }
        return adata;
}

void audio_data_addref(audio_data_t *adata)
{
        assert(adata);
        assert(atomic_get(&adata->refcount) > 0);
        atomic_inc(&adata->refcount);
}

void audio_data_unref(audio_data_t *adata)
{
        assert(adata);
        assert(atomic_get(&adata->refcount) > 0);
        atomic_count_t refc = atomic_predec(&adata->refcount);
        if (refc == 0) {
                free(adata->data);
                free(adata);
        }
}

/* Data link helpers */

typedef struct {
        link_t link;
        audio_data_t *adata;
        size_t position;
} audio_data_link_t;

static inline audio_data_link_t * audio_data_link_list_instance(link_t *l)
{
        return l ? list_get_instance(l, audio_data_link_t, link) : NULL;
}

static audio_data_link_t *audio_data_link_create(audio_data_t *adata)
{
        assert(adata);
        audio_data_link_t *link = malloc(sizeof(audio_data_link_t));
        if (link) {
                audio_data_addref(adata);
                link->adata = adata;
                link->position = 0;
        }
        return link;
}

static void audio_data_link_destroy(audio_data_link_t *link)
{
        assert(link);
        assert(!link_in_use(&link->link));
        audio_data_unref(link->adata);
        free(link);
}

static inline const void * audio_data_link_start(audio_data_link_t *alink)
{
        assert(alink);
        assert(alink->adata);
        return alink->adata->data + alink->position;
}

static inline size_t audio_data_link_remain_size(audio_data_link_t *alink)
{
        assert(alink);
        assert(alink->adata);
        assert(alink->position <= alink->adata->size);
        return alink->adata->size - alink->position;
}


static inline size_t audio_data_link_available_frames(audio_data_link_t *alink)
{
        assert(alink);
        assert(alink->adata);
        return pcm_format_size_to_frames(audio_data_link_remain_size(alink),
            &alink->adata->format);
}

/* Audio Pipe */


void audio_pipe_init(audio_pipe_t *pipe)
{
        assert(pipe);
        list_initialize(&pipe->list);
        fibril_mutex_initialize(&pipe->guard);
        pipe->frames = 0;
        pipe->bytes = 0;
}



void audio_pipe_fini(audio_pipe_t *pipe)
{
        assert(pipe);
        while (!list_empty(&pipe->list)) {
                audio_data_t *adata = audio_pipe_pop(pipe);
                audio_data_unref(adata);
        }
}

int audio_pipe_push(audio_pipe_t *pipe, audio_data_t *data)
{
        assert(pipe);
        assert(data);
        audio_data_link_t *alink = audio_data_link_create(data);
        if (!alink)
                return ENOMEM;

        fibril_mutex_lock(&pipe->guard);
        list_append(&alink->link, &pipe->list);
        pipe->bytes += audio_data_link_remain_size(alink);
        pipe->frames += audio_data_link_available_frames(alink);
        fibril_mutex_unlock(&pipe->guard);
        return EOK;
}

audio_data_t *audio_pipe_pop(audio_pipe_t *pipe)
{
        assert(pipe);
        fibril_mutex_lock(&pipe->guard);
        audio_data_t *adata = NULL;
        link_t *l = list_first(&pipe->list);
        if (l) {
                audio_data_link_t *alink = audio_data_link_list_instance(l);
                list_remove(&alink->link);
                pipe->bytes -= audio_data_link_remain_size(alink);
                pipe->frames -= audio_data_link_available_frames(alink);
                adata = alink->adata;
                audio_data_addref(adata);
                audio_data_link_destroy(alink);
        }
        fibril_mutex_unlock(&pipe->guard);
        return adata;
}

ssize_t audio_pipe_mix_data(audio_pipe_t *pipe, void *data,
    size_t size, const pcm_format_t *f)
{
        assert(pipe);
        const size_t dst_frame_size = pcm_format_frame_size(f);
        size_t needed_frames = size / dst_frame_size;
        size_t copied_size = 0;
        fibril_mutex_lock(&pipe->guard);
        while (needed_frames > 0 && !list_empty(&pipe->list)) {
                /* Get first audio chunk */
                link_t *l = list_first(&pipe->list);
                audio_data_link_t *alink = audio_data_link_list_instance(l);

                /* Get audio chunk metadata */
                const size_t src_frame_size =
                    pcm_format_frame_size(&alink->adata->format);
                const size_t available_frames =
                    audio_data_link_available_frames(alink);
                const size_t copy_frames = min(available_frames, needed_frames);
                const size_t copy_size = copy_frames * dst_frame_size;

                /* Copy audio data */
                pcm_format_convert_and_mix(data, copy_size,
                    audio_data_link_start(alink),
                    audio_data_link_remain_size(alink),
                    &alink->adata->format, f);

                /* Update values */
                copied_size += copy_size;
                needed_frames -= copy_frames;
                data += copy_size;
                alink->position += (copy_frames * src_frame_size);
                pipe->bytes -= (copy_frames * src_frame_size);
                pipe->frames -= copy_frames;
                if (audio_data_link_remain_size(alink) == 0) {
                        list_remove(&alink->link);
                        audio_data_link_destroy(alink);
                } else {
                        assert(needed_frames == 0);
                }
        }
        fibril_mutex_unlock(&pipe->guard);
        return copied_size;
}

/**
 * @}
 */