/* 
** Copyright 2004, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
** Distributed under the terms of the MIT License.
*/


#include <MediaFormats.h>

#include <stdio.h>
#include <string.h>


static const char *
get_family_string(media_format_family family)
{
	switch (family) {
		case B_BEOS_FORMAT_FAMILY:
			return "BeOS";
		case B_ANY_FORMAT_FAMILY:
			return "any";
		case B_QUICKTIME_FORMAT_FAMILY:
			return "QuickTime";
		case B_AVI_FORMAT_FAMILY:
			return "AVI";
		case B_ASF_FORMAT_FAMILY:
			return "ASF";
		case B_MPEG_FORMAT_FAMILY:
			return "MPEG";
		case B_WAV_FORMAT_FAMILY:
			return "WAV";
		case B_AIFF_FORMAT_FAMILY:
			return "AIFF";
		case B_AVR_FORMAT_FAMILY:
			return "AVR";
		case B_MISC_FORMAT_FAMILY:
			return "misc";
// these are Haiku specific:
//		case B_OGG_FORMAT_FAMILY:
//			return "OGG";
//		case B_META_FORMAT_FAMILY:
//			return "meta";
		default:
			return "unknown";
	}
}


static const char *
get_mpeg_string(int32 id)
{
	switch (id) {
		case B_MPEG_ANY:
			return "any";
		case B_MPEG_1_AUDIO_LAYER_1:
			return "mpeg 1 audio layer 1";
		case B_MPEG_1_AUDIO_LAYER_2:
			return "mpeg 1 audio layer 2";
		case B_MPEG_1_AUDIO_LAYER_3:
			return "mpeg 1 audio layer 3 (mp3)";
		case B_MPEG_1_VIDEO:
			return "mpeg 1 video";
// these are Haiku specific:
/*		case B_MPEG_2_AUDIO_LAYER_1:
			return "mpeg 2 audio layer 1";
		case B_MPEG_2_AUDIO_LAYER_2:
			return "mpeg 2 audio layer 2";
		case B_MPEG_2_AUDIO_LAYER_3:
			return "mpeg 2 audio layer 3";
		case B_MPEG_2_VIDEO:
			return "mpeg 2 video";
		case B_MPEG_2_5_AUDIO_LAYER_1:
			return "mpeg 2.5 audio layer 1";
		case B_MPEG_2_5_AUDIO_LAYER_2:
			return "mpeg 2.5 audio layer 2";
		case B_MPEG_2_5_AUDIO_LAYER_3:
			return "mpeg 2.5 audio layer 3";
*/		default:
			return "unknown";
	}
}


static void
print_fourcc(uint32 id)
{
	char string[5];
	for (int32 i = 0; i < 4; i++) {
		uint8 c = uint8((id >> (24 - i * 8)) & 0xff);
		if (c < ' ' || c > 0x7f)
			string[i] = '.';
		else
			string[i] = (char)c;
	}
	string[4] = '\0';
	printf("%s (0x%lx)\n", string, id);
}


void
dump_media_format_description(media_format_description &description)
{
	printf("media_format_description:\n");
	printf("\tfamily:\t%s\n", get_family_string(description.family));
	
	switch (description.family) {
		case B_BEOS_FORMAT_FAMILY:
			printf("\tformat:\t");
			print_fourcc(description.u.beos.format);
			break;
		case B_AVI_FORMAT_FAMILY:
		case B_AIFF_FORMAT_FAMILY:
		case B_WAV_FORMAT_FAMILY:
			printf("\tcodec:\t");
			print_fourcc(description.u.avi.codec);
			break;
		case B_AVR_FORMAT_FAMILY:
			printf("\tid:\t");
			print_fourcc(description.u.avr.id);
			break;
		case B_QUICKTIME_FORMAT_FAMILY:
			printf("\tcodec:\t");
			print_fourcc(description.u.quicktime.codec);
			printf("\tvendor:\t");
			print_fourcc(description.u.quicktime.vendor);
			break;
		case B_MISC_FORMAT_FAMILY:
			printf("\tcodec:\t\t");
			print_fourcc(description.u.misc.file_format);
			printf("\tfile format:\t");
			print_fourcc(description.u.misc.codec);
			break;
		case B_MPEG_FORMAT_FAMILY:
			printf("\ttype:\t%s\n", get_mpeg_string(description.u.mpeg.id));
			break;
		case B_ASF_FORMAT_FAMILY:
			// note, this is endian depended - you shouldn't do it this way for real...
			printf("\tguid:\t0x%Lx%Lx\n", *(uint64 *)&description.u.asf.guid.data[0], *(uint64 *)&description.u.asf.guid.data[8]);
		default:
			break;
	}
}


int
main(int argc, char **argv)
{
	BMediaFormats formats;

	status_t status = formats.InitCheck();
	if (status != B_OK) {
		fprintf(stderr, "BMediaFormats::InitCheck() failed: %s\n", strerror(status));
		return -1;
	}

	media_format format;
	status = formats.GetAVIFormatFor('DIVX', &format, B_MEDIA_ENCODED_VIDEO);
	if (status != B_OK) {
		fprintf(stderr, "BMediaFormats::GetAVIFormatFor() failed: %s\n", strerror(status));
		return -1;
	}
	
	media_format_description description;
	status = formats.GetCodeFor(format, B_AVI_FORMAT_FAMILY, &description);
	if (status != B_OK) {
		fprintf(stderr, "BMediaFormats::GetCodeFor() failed: %s\n", strerror(status));
		return -1;
	}
	dump_media_format_description(description);

	char desc[256];
	string_for_format(format, desc, sizeof(desc));
	printf("\tformat:\t%s\n", desc);

	status = formats.GetCodeFor(format, B_MPEG_FORMAT_FAMILY, &description);
	if (status == B_OK) {
		fprintf(stderr, "BMediaFormats::GetCodeFor() succeded with wrong family!\n");
		return -1;
	}

	puts("\n***** all supported formats *****");

	// Rewind() should only work when the formats object is locked
	status = formats.RewindFormats();
	if (status == B_OK) {
		fprintf(stderr, "BMediaFormats::RewindFormats() succeded unlocked!\n");
		return -1;
	}

	if (!formats.Lock()) {
		fprintf(stderr, "BMediaFormats::Lock() failed!\n");
		return -1;		
	}

	status = formats.RewindFormats();
	if (status != B_OK) {
		fprintf(stderr, "BMediaFormats::RewindFormats() failed: %s\n", strerror(status));
		return -1;
	}

	int32 count = 0;
	while ((status = formats.GetNextFormat(&format, &description)) == B_OK) {
		dump_media_format_description(description);
		string_for_format(format, desc, sizeof(desc));
		printf("\tformat:\t%s\n", desc);
		count++;
	}
	if (status != B_BAD_INDEX)
		fprintf(stderr, "BMediaFormats::GetNextFormat() failed: %s\n", strerror(status));

	printf("***** %ld supported formats *****\n", count);

	formats.Unlock();
	return 0;
}