/*
 * Copyright (c) 2002-2007, Jerome Duval (jerome.duval@free.fr)
 * Copyright (c) 2007, François Revol (revol@free.fr)
 * Distributed under the terms of the MIT License.
 */

#include "OpenSoundDevice.h"
#include "OpenSoundDeviceEngine.h"
#include "OpenSoundDeviceMixer.h"
#include "debug.h"
#include "driver_io.h"
#include <MediaDefs.h>
#include <Debug.h>
#include <errno.h>
#include <string.h>

const int gSupportedFormats[] = {
	AFMT_SUPPORTED_PCM,
#ifdef ENABLE_NON_RAW_SUPPORT
	AFMT_MU_LAW,
	AFMT_A_LAW,
	AFMT_IMA_ADPCM,
	AFMT_MPEG,
	AFMT_AC3,
	AFMT_VORBIS,
	AFMT_SPDIF_RAW,
	AFMT_S24_PACKED,
#endif /*ENABLE_NON_RAW_SUPPORT*/
	0
};

const char* gSupportedFormatsNames[] = {
	"raw", //AFMT_SUPPORTED_PCM,
	"µ-law", //AFMT_MU_LAW,
	"a-law", //AFMT_A_LAW,
	"IMA4 ADPCM", //AFMT_IMA_ADPCM,
	"MPEG layer 2", //AFMT_MPEG,
	"AC3", //AFMT_AC3,
	"Vorbis", //AFMT_VORBIS,
	"Raw S/PDIF", //AFMT_SPDIF_RAW,
	"Packed 24bit", //AFMT_S24_PACKED,*/
	0
};




float OpenSoundDevice::convert_oss_rate_to_media_rate(int rate)
{
	return (float)rate;
}


int OpenSoundDevice::convert_media_rate_to_oss_rate(float rate)
{
	return (int)rate;
}


uint32 OpenSoundDevice::convert_oss_format_to_media_format(int fmt)
{
	if (fmt & AFMT_FLOAT)
		return media_raw_audio_format::B_AUDIO_FLOAT;
	if (fmt & AFMT_S32_LE ||
		fmt & AFMT_S24_LE ||
		fmt & AFMT_S32_BE ||
		fmt & AFMT_S24_BE)
		return media_raw_audio_format::B_AUDIO_INT;
	if (fmt & AFMT_S16_LE ||
		fmt & AFMT_S16_BE) /* U16 unsupported */
		return media_raw_audio_format::B_AUDIO_SHORT;
	if (fmt & AFMT_S8)
		return media_raw_audio_format::B_AUDIO_CHAR;
	if (fmt & AFMT_U8)
		return media_raw_audio_format::B_AUDIO_UCHAR;
	return 0;
}


int OpenSoundDevice::convert_oss_format_to_endian(int fmt)
{
	if (fmt & AFMT_FLOAT)
		return B_MEDIA_HOST_ENDIAN;
	if (fmt & AFMT_S32_LE ||
		fmt & AFMT_S24_LE ||
		fmt & AFMT_S16_LE ||
		fmt & AFMT_U16_LE ||
		fmt & AFMT_S24_PACKED)
		return B_MEDIA_LITTLE_ENDIAN;
	if (fmt & AFMT_S32_BE ||
		fmt & AFMT_S24_BE ||
		fmt & AFMT_S16_BE ||
		fmt & AFMT_U16_BE)
		return B_MEDIA_BIG_ENDIAN;
	if (fmt & AFMT_S8 ||
		fmt & AFMT_U8)
		return B_MEDIA_HOST_ENDIAN;
	return B_MEDIA_HOST_ENDIAN;
}

int16 OpenSoundDevice::convert_oss_format_to_valid_bits(int fmt)
{
	if (fmt & AFMT_S32_NE)
		return 32;
	if (fmt & AFMT_S24_NE)
		return 24;
	if (fmt & AFMT_S32_OE)
		return 32;
	if (fmt & AFMT_S24_OE)
		return 24;
	if (fmt & AFMT_S24_PACKED)
		return 24;
	if (fmt & AFMT_SPDIF_RAW)
		return 32;
	return 0;
}


int OpenSoundDevice::convert_media_format_to_oss_format(uint32 fmt)
{
	switch (fmt) {
		case media_raw_audio_format::B_AUDIO_FLOAT:
			return AFMT_FLOAT;
		case media_raw_audio_format::B_AUDIO_INT:
			return AFMT_S32_NE;
		case media_raw_audio_format::B_AUDIO_SHORT:
			return AFMT_S16_NE;
		case media_raw_audio_format::B_AUDIO_CHAR:
			return AFMT_S8;
		case media_raw_audio_format::B_AUDIO_UCHAR:
			return AFMT_U8;
		default:
			return 0;
	}
}


int OpenSoundDevice::select_oss_rate(const oss_audioinfo *info, int rate)
{
	if (info->caps & PCM_CAP_FREERATE) {
		// if not wildcard and matches, return the hint
		if (rate && rate >= info->min_rate && rate <= info->max_rate)
			return rate;
		// else use max available
		return info->max_rate;
	}
	uint32 max_rate = 0;
	for (uint32 i = 0; i < info->nrates; i++) {
		if ((int32)info->rates[i] < info->min_rate
			|| (int32)info->rates[i] > info->max_rate)
			continue;
		// if the hint matches
		if (rate && rate == (int32)info->rates[i])
			return rate;
		if (info->rates[i] > max_rate)
			max_rate = info->rates[i];
	}
	// highest rate
	return max_rate;
}


int OpenSoundDevice::select_oss_format(int fmt)
{
	//highest format, Native Endian first
	if (fmt & AFMT_FLOAT) {
		return AFMT_FLOAT;
	} else if (fmt & AFMT_S32_NE) {
		return AFMT_S32_NE;
	} else if (fmt & AFMT_S24_NE) {
		return AFMT_S24_NE;
	} else if (fmt & AFMT_S16_NE) {
		return AFMT_S16_NE;
	} else if (fmt & AFMT_S32_OE) {
		return AFMT_S32_OE;
	} else if (fmt & AFMT_S24_OE) {
		return AFMT_S24_OE;
	} else if (fmt & AFMT_S16_OE) {
		return AFMT_S16_OE;
	} else if (fmt & AFMT_S8) {
		return AFMT_S8;
	} else if (fmt & AFMT_U8) {
		return AFMT_U8;
	} else
		return 0;
}

status_t OpenSoundDevice::get_media_format_description_for(int fmt, media_format_description *desc, int count)
{
	int i;
	for (i = 0; i < count; i++)
		desc[i] = media_format_description();
	if (count < 1)
		return 0;
	if (fmt & AFMT_SUPPORTED_PCM) {
		desc[0].family = B_BEOS_FORMAT_FAMILY;
		desc[0].u.beos.format = 1;
		return 1;
	}
	switch (fmt) {
	case AFMT_MU_LAW:
		desc[0].family = B_MISC_FORMAT_FAMILY;
		desc[0].u.misc.file_format = '.snd';
		desc[0].u.misc.codec = 'ulaw';
		if (count < 2)
			return 1;
		desc[1].family = B_WAV_FORMAT_FAMILY;
		desc[1].u.wav.codec = 0x07;
		return 2;
		if (count < 3)
			return 2;
		desc[1].family = B_QUICKTIME_FORMAT_FAMILY;
		desc[1].u.quicktime.codec = 'ulaw';
		desc[1].u.quicktime.vendor = 0;
		return 3;
	case AFMT_A_LAW:
		desc[0].family = B_MISC_FORMAT_FAMILY;
		desc[0].u.misc.file_format = '.snd';
		desc[0].u.misc.codec = 'alaw';
		return 1;
		// wav/qt ?
	case AFMT_IMA_ADPCM:
		desc[0].family = B_BEOS_FORMAT_FAMILY;
		desc[0].u.beos.format = 'ima4';
		return 1;
	case AFMT_MPEG: /* layer 2 */
		desc[0].family = B_MPEG_FORMAT_FAMILY;
		desc[0].u.mpeg.id = 0x102;
		if (count < 2)
			return 1;
		desc[1].family = B_WAV_FORMAT_FAMILY;
		desc[1].u.wav.codec = 0x50;
		if (count < 3)
			return 2;
		desc[1].family = B_AVI_FORMAT_FAMILY;
		desc[1].u.avi.codec = 0x65610050;
		return 3;
	case AFMT_AC3:
		desc[0].family = B_WAV_FORMAT_FAMILY;
		desc[0].u.wav.codec = 0x2000;
		if (count < 2)
			return 1;
		desc[1].family = B_AVI_FORMAT_FAMILY;
		desc[1].u.avi.codec = 0x65612000;
		return 2;
	case AFMT_VORBIS:
		// nothing official
		desc[0].family = B_MISC_FORMAT_FAMILY;
		desc[0].u.misc.file_format = 'OSS4';
		desc[0].u.misc.codec = 'VORB';
		return 1;
	case AFMT_SPDIF_RAW:
		// nothing official
		desc[0].family = B_MISC_FORMAT_FAMILY;
		desc[0].u.misc.file_format = 'OSS4';
		desc[0].u.misc.codec = 'PDIF';
		return 1;
	case AFMT_S24_PACKED:
		// nothing official
		desc[0].family = B_MISC_FORMAT_FAMILY;
		desc[0].u.misc.file_format = 'OSS4';
		desc[0].u.misc.codec = 'S24P';
		return 1;
	default:
		return EINVAL;
	}
	return 0;
};


status_t OpenSoundDevice::register_media_formats()
{
	status_t err;
	int i, count;
	BMediaFormats formats;
	if (formats.InitCheck() < B_OK)
		return formats.InitCheck();
	media_format format;
	for (i = 0; gSupportedFormats[i]; i++) {
		media_format_description desc[10];
		err = count = get_media_format_description_for(gSupportedFormats[i], desc, 10);
		if (err < 1)
			continue;
		if (gSupportedFormats[i] & AFMT_SUPPORTED_PCM) {
			format.type = B_MEDIA_RAW_AUDIO;
			format.u.raw_audio = media_multi_audio_format::wildcard;
		} else {
			format.type = B_MEDIA_ENCODED_AUDIO;
			format.u.encoded_audio = media_encoded_audio_format::wildcard;
		}
		err = formats.MakeFormatFor(desc, count, &format);
		PRINT(("OpenSoundDevice::register_media_formats: MakeFormatFor: %s\n", strerror(err)));
	}
	return B_OK;
};


status_t OpenSoundDevice::get_media_format_for(int fmt, media_format &format)
{
	status_t err;
	BMediaFormats formats;
	if (formats.InitCheck() < B_OK)
		return formats.InitCheck();
	/* shortcut for raw */
	if (fmt & AFMT_SUPPORTED_PCM) {
		format = media_format();
		format.type = B_MEDIA_RAW_AUDIO;
		format.u.raw_audio = media_raw_audio_format::wildcard;
		return B_OK;
	}
	media_format_description desc;
	err = get_media_format_description_for(fmt, &desc);
	if (err < B_OK)
		return err;
	err = formats.GetFormatFor(desc, &format);
	return err;
};


OpenSoundDevice::~OpenSoundDevice()
{
	CALLED();
	OpenSoundDeviceEngine *engine;
	OpenSoundDeviceMixer *mixer;
	while ((engine = EngineAt(0))) {
		delete engine;
		fEngines.RemoveItems(0, 1);
	}
	while ((mixer = MixerAt(0))) {
		delete mixer;
		fMixers.RemoveItems(0, 1);
	}
}

OpenSoundDevice::OpenSoundDevice(oss_card_info *cardinfo)
	: fLocker("OpenSoundDevice")
{
	CALLED();
	fInitCheckStatus = B_NO_INIT;
	memcpy(&fCardInfo, cardinfo, sizeof(oss_card_info));
	memset(&fFragments, 0, sizeof(fFragments));
#if 0
	strcpy(fDevice_name, name);
	strcpy(fDevice_path, path);

	PRINT(("name : %s, path : %s\n", fDevice_name, fDevice_path));

	if (InitDriver() != B_OK)
		return;

	fInitCheckStatus = B_OK;
#endif
}


status_t OpenSoundDevice::InitCheck(void) const
{
	CALLED();
	return fInitCheckStatus;
}


status_t OpenSoundDevice::InitDriver()
{

	CALLED();
	PRINT(("OpenSoundDevice::InitDriver: %" B_PRId32 " engines, %" B_PRId32
		" mixers\n", CountEngines(), CountMixers()));

	if (CountMixers()) {
		;//...
	}

	fInitCheckStatus = B_OK;

	return B_OK;
}


status_t
OpenSoundDevice::AddEngine(oss_audioinfo *info)
{
	status_t err;
	/* discard shadow/hidden engines (!?) */
	CALLED();
/*
	if (info->caps & PCM_CAP_SHADOW)
		return B_OK;
	if (info->caps & PCM_CAP_HIDDEN)
		return B_OK;
*/
	OpenSoundDeviceEngine *engine =
		new(std::nothrow) OpenSoundDeviceEngine(info);
	if (!engine)
		return ENOMEM;
	err = engine->InitCheck();
	if (err < B_OK) {
		delete engine;
		return err;
	}
	fEngines.AddItem(engine);
	return B_OK;
}


status_t
OpenSoundDevice::AddMixer(oss_mixerinfo *info)
{
	status_t err;
	CALLED();
	OpenSoundDeviceMixer *mixer =
		new(std::nothrow) OpenSoundDeviceMixer(info);
	if (!mixer)
		return ENOMEM;
	err = mixer->InitCheck();
	if (err < B_OK) {
		delete mixer;
		return err;
	}
	fMixers.AddItem(mixer);
	return B_OK;
}


int32
OpenSoundDevice::CountEngines()
{
	return fEngines.CountItems();
}


int32
OpenSoundDevice::CountMixers()
{
	return fMixers.CountItems();
}


OpenSoundDeviceEngine *
OpenSoundDevice::EngineAt(int32 i)
{
	return (OpenSoundDeviceEngine *)(fEngines.ItemAt(i));
}


OpenSoundDeviceMixer *
OpenSoundDevice::MixerAt(int32 i)
{
	return (OpenSoundDeviceMixer *)(fMixers.ItemAt(i));
}

OpenSoundDeviceEngine *
OpenSoundDevice::NextFreeEngineAt(int32 i, bool rec)
{
	// find the first free engine in the rec or play chain
	OpenSoundDeviceEngine *engine = EngineAt(i);
	while (engine && engine->InUse()) {
		engine = rec ? (engine->NextRec()) : (engine->NextPlay());
	}
	return engine;
}