/*
 * Copyright 2008, Axel Dörfler, axeld@pinc-software.de.
 * Copyright (c) 2002-2007, Jerome Duval (jerome.duval@free.fr)
 *
 * Distributed under the terms of the MIT License.
 */


#include "MultiAudioUtility.h"

#include <errno.h>

#include <MediaDefs.h>


const float kSampleRates[] = {
        8000.0, 11025.0, 12000.0, 16000.0, 22050.0, 24000.0, 32000.0, 44100.0,
        48000.0, 64000.0, 88200.0, 96000.0, 176400.0, 192000.0, 384000.0, 1536000.0
};
const uint32 kSampleRateCount = sizeof(kSampleRates) / sizeof(kSampleRates[0]);


template<typename T> static status_t
call_driver(int device, int32 op, T* data)
{
        if (ioctl(device, op, data, sizeof(T)) != 0)
                return errno;

        return B_OK;
}


namespace MultiAudio {


float
convert_to_sample_rate(uint32 rate)
{
        for (uint32 i = 0; i < kSampleRateCount; i++) {
                if (rate & 1)
                        return kSampleRates[i];

                rate >>= 1;
        }

        return 0.0;
}


uint32
convert_from_sample_rate(float rate)
{
        for (uint32 i = 0; i < kSampleRateCount; i++) {
                if (rate <= kSampleRates[i])
                        return 1 << i;
        }

        return 0;
}


uint32
convert_to_media_format(uint32 format)
{
        switch (format) {
                case B_FMT_FLOAT:
                        return media_raw_audio_format::B_AUDIO_FLOAT;
                case B_FMT_18BIT:
                case B_FMT_20BIT:
                case B_FMT_24BIT:
                case B_FMT_32BIT:
                        return media_raw_audio_format::B_AUDIO_INT;
                case B_FMT_16BIT:
                        return media_raw_audio_format::B_AUDIO_SHORT;
                case B_FMT_8BIT_S:
                        return media_raw_audio_format::B_AUDIO_CHAR;
                case B_FMT_8BIT_U:
                        return media_raw_audio_format::B_AUDIO_UCHAR;

                default:
                        return 0;
        }
}


int16
convert_to_valid_bits(uint32 format)
{
        switch (format) {
                case B_FMT_18BIT:
                        return 18;
                case B_FMT_20BIT:
                        return 20;
                case B_FMT_24BIT:
                        return 24;
                case B_FMT_32BIT:
                        return 32;

                default:
                        return 0;
        }
}


uint32
convert_from_media_format(uint32 format)
{
        switch (format) {
                case media_raw_audio_format::B_AUDIO_FLOAT:
                        return B_FMT_FLOAT;
                case media_raw_audio_format::B_AUDIO_INT:
                        return B_FMT_32BIT;
                case media_raw_audio_format::B_AUDIO_SHORT:
                        return B_FMT_16BIT;
                case media_raw_audio_format::B_AUDIO_CHAR:
                        return B_FMT_8BIT_S;
                case media_raw_audio_format::B_AUDIO_UCHAR:
                        return B_FMT_8BIT_U;

                default:
                        return 0;
        }
}


uint32
select_sample_rate(uint32 rate)
{
        // highest rate
        uint32 crate = B_SR_1536000;
        while (crate != 0) {
                if (rate & crate)
                        return crate;
                crate >>= 1;
        }
        return 0;
}


uint32
select_format(uint32 format)
{
        // best format
        // TODO ensure we support this format
        /*if (format & B_FMT_FLOAT)
                return B_FMT_FLOAT;*/
        if (format & B_FMT_32BIT)
                return B_FMT_32BIT;
        if (format & B_FMT_24BIT)
                return B_FMT_24BIT;
        if (format & B_FMT_20BIT)
                return B_FMT_20BIT;
        if (format & B_FMT_18BIT)
                return B_FMT_18BIT;
        if (format & B_FMT_16BIT)
                return B_FMT_16BIT;
        if (format & B_FMT_8BIT_S)
                return B_FMT_8BIT_S;
        if (format & B_FMT_8BIT_U)
                return B_FMT_8BIT_U;

        return 0;
}


status_t
get_description(int device, multi_description* description)
{
        return call_driver(device, B_MULTI_GET_DESCRIPTION, description);
}


status_t
get_enabled_channels(int device, multi_channel_enable* enable)
{
        return call_driver(device, B_MULTI_GET_ENABLED_CHANNELS, enable);
}


status_t
set_enabled_channels(int device, multi_channel_enable* enable)
{
        return call_driver(device, B_MULTI_SET_ENABLED_CHANNELS, enable);
}


status_t
get_global_format(int device, multi_format_info* info)
{
        return call_driver(device, B_MULTI_GET_GLOBAL_FORMAT, info);
}


status_t
set_global_format(int device, multi_format_info* info)
{
        return call_driver(device, B_MULTI_SET_GLOBAL_FORMAT, info);
}


status_t
get_buffers(int device, multi_buffer_list* list)
{
        return call_driver(device, B_MULTI_GET_BUFFERS, list);
}


status_t
buffer_exchange(int device, multi_buffer_info* info)
{
        return call_driver(device, B_MULTI_BUFFER_EXCHANGE, info);
}


status_t
list_mix_controls(int device, multi_mix_control_info* info)
{
        return call_driver(device, B_MULTI_LIST_MIX_CONTROLS, info);
}


status_t
get_mix(int device, multi_mix_value_info* info)
{
        return call_driver(device, B_MULTI_GET_MIX, info);
}


status_t
set_mix(int device, multi_mix_value_info* info)
{
        return call_driver(device, B_MULTI_SET_MIX, info);
}


}       // namespace MultiAudio