/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. 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.
 *
 * 3. 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 TITLE, NON-INFRINGEMENT, 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.
 */


// MediaString.cpp

#include "MediaString.h"

// Media Kit
#include <MediaFormats.h>
// Support Kit
#include <String.h>
#include <StringFormat.h>
// Locale Kit
#undef B_CATALOG
#define B_CATALOG (&sCatalog)
#include <Catalog.h>

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "MediaString"

__USE_CORTEX_NAMESPACE

#include <Debug.h>
#define D_METHOD(x) //PRINT (x)

static BCatalog sCatalog("x-vnd.Cortex.support");

// -------------------------------------------------------- //
// *** media_node strings (public)
// -------------------------------------------------------- //

BString	MediaString::getStringFor(
	node_kind kinds,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(node_kind)\n"));

	BString list, last;
	bool first = true;

	if (kinds & B_BUFFER_PRODUCER) {
		if (first) {
			list = B_TRANSLATE("Buffer producer");
			first = false;
		}
	}
	if (kinds & B_BUFFER_CONSUMER) {
		if (first) {
			list = B_TRANSLATE("Buffer consumer");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Buffer consumer");
		}
	}
	if (kinds & B_TIME_SOURCE) {
		if (first) {
			list = B_TRANSLATE("Time source");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Time source");
		}
	}
	if (kinds & B_CONTROLLABLE) {
		if (first) {
			list = B_TRANSLATE("Controllable");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Controllable");
		}
	}
	if (kinds & B_FILE_INTERFACE) {
		if (first) {
			list = B_TRANSLATE("File interface");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("File interface");
		}
	}
	if (kinds & B_ENTITY_INTERFACE) {
		if (first) {
			list = B_TRANSLATE("Entity interface");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Entity interface");
		}
	}
	if (kinds & B_PHYSICAL_INPUT) {
		if (first) {
			list = B_TRANSLATE("Physical input");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Physical input");
		}
	}
	if (kinds & B_PHYSICAL_OUTPUT) {
		if (first) {
			list = B_TRANSLATE("Physical output");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Physical output");
		}
	}
	if (kinds & B_SYSTEM_MIXER) {
		if (first) {
			list = B_TRANSLATE("System mixer");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("System mixer");
		}
	}

	if (last != "")
		list << " & " << last;
	return list;
}

BString MediaString::getStringFor(
	BMediaNode::run_mode runMode,
	bool complete)
{
	D_METHOD(("MediaString::getStringFor(run_mode)\n"));

	switch (runMode) {
		case BMediaNode::B_OFFLINE:
			return B_TRANSLATE("Offline");
		case BMediaNode::B_RECORDING:
			return B_TRANSLATE("Recording");
		case BMediaNode::B_DECREASE_PRECISION:
			return B_TRANSLATE("Decrease precision");
		case BMediaNode::B_INCREASE_LATENCY:
			return B_TRANSLATE("Increase latency");
		case BMediaNode::B_DROP_DATA:
			return B_TRANSLATE("Drop data");
		default:
			return B_TRANSLATE("(unknown run mode)");
	}
}

// -------------------------------------------------------- //
// *** media_format strings (public)
// -------------------------------------------------------- //

BString	MediaString::getStringFor(
	media_type type,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(media_type)\n"));

	switch (type) {
		case B_MEDIA_NO_TYPE:
			return B_TRANSLATE("Typeless media");
		case B_MEDIA_UNKNOWN_TYPE:
			return B_TRANSLATE("Unknown media type");
		case B_MEDIA_RAW_AUDIO:
			return B_TRANSLATE("Raw audio");
		case B_MEDIA_RAW_VIDEO:
			return B_TRANSLATE("Raw video");
		case B_MEDIA_VBL:
			return B_TRANSLATE("Raw data from VBL area");
		case B_MEDIA_TIMECODE:
			return B_TRANSLATE("Timecode");
		case B_MEDIA_MIDI:
			return B_TRANSLATE("MIDI");
		case B_MEDIA_TEXT:
			return B_TRANSLATE("Text");
		case B_MEDIA_HTML:
			return B_TRANSLATE("HTML");
		case B_MEDIA_MULTISTREAM:
			return B_TRANSLATE("Multistream media");
		case B_MEDIA_PARAMETERS:
			return B_TRANSLATE("Parameters");
		case B_MEDIA_ENCODED_AUDIO:
			return B_TRANSLATE("Encoded audio");
		case B_MEDIA_ENCODED_VIDEO:
			return B_TRANSLATE("Encoded video");
		default: {
			if (type >= B_MEDIA_FIRST_USER_TYPE) {
				return B_TRANSLATE("User-defined media type");
			}
			if (type >= B_MEDIA_PRIVATE) {
				return B_TRANSLATE("Private Be media type");
			}
		}
	}
	return B_TRANSLATE("Unknown media type");
}

BString	MediaString::getStringFor(
	media_format_family family,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(media_format_family)\n"));

	switch (family) {
		case B_ANY_FORMAT_FAMILY:
			return B_TRANSLATE("Any format family");
		case B_BEOS_FORMAT_FAMILY:
			return B_TRANSLATE("BeOS format family");
		case B_QUICKTIME_FORMAT_FAMILY:
			return B_TRANSLATE("QuickTime format family");
		case B_AVI_FORMAT_FAMILY:
			return B_TRANSLATE("AVI format family");
		case B_ASF_FORMAT_FAMILY:
			return B_TRANSLATE("ASF format family");
		case B_MPEG_FORMAT_FAMILY:
			return B_TRANSLATE("MPEG format family");
		case B_WAV_FORMAT_FAMILY:
			return B_TRANSLATE("WAV format family");
		case B_AIFF_FORMAT_FAMILY:
			return B_TRANSLATE("AIFF format family");
		default:
			return B_TRANSLATE("Miscellaneous format family");
	}
}

BString MediaString::getStringFor(
	const media_multi_audio_format &format,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(media_raw_audio_format)\n"));

	BString s = "";
	bool empty = true;

	// sample rate
	if (format.frame_rate != media_raw_audio_format::wildcard.frame_rate) {
		s << (empty ? "" : ", ") << forAudioFrameRate(format.frame_rate);
		empty = false;
	}

	// format
	if (format.format != media_raw_audio_format::wildcard.format) {
		s << (empty ? "" : ", ") << forAudioFormat(format.format, format.valid_bits);
		empty = false;
	}

	// channels
	if (format.channel_count != media_raw_audio_format::wildcard.channel_count) {
		s << (empty ? "" : ", ") << forAudioChannelCount(format.channel_count);
		empty = false;
	}

	if (complete) {
		// channel mask
		if (format.channel_mask != media_multi_audio_format::wildcard.channel_mask) {
			s << (empty ? "" : " ") << "(" << forAudioChannelMask(format.channel_mask) << ")";
			empty = false;
		}

		// matrix mask
		if (format.matrix_mask != media_multi_audio_format::wildcard.matrix_mask) {
			s << (empty ? "" : " ") << "(" << forAudioMatrixMask(format.matrix_mask) << ")";
			empty = false;
		}

		// endianess
		if (format.byte_order != media_raw_audio_format::wildcard.byte_order) {
			s << (empty ? "" : ", ") << forAudioByteOrder(format.byte_order);
			empty = false;
		}

		// buffer size
		if (format.buffer_size != media_raw_audio_format::wildcard.buffer_size) {
			s << (empty ? "" : ", ") << forAudioBufferSize(format.buffer_size);
			empty = false;
		}
	}

	return s;
}

BString MediaString::getStringFor(
	const media_raw_video_format &format,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(media_raw_video_format)\n"));

	BString s = "";
	bool empty = true;

	// format / color space
	if (format.display.format != media_video_display_info::wildcard.format) {
		s << (empty ? "" : ", ") << forVideoFormat(format.display.format);
		empty = false;
	}

	// resolution
	if ((format.display.line_width != media_video_display_info::wildcard.line_width)
	 && (format.display.line_count != media_video_display_info::wildcard.line_count)) {
		s << (empty ? "" : ", ") << forVideoResolution(format.display.line_width,
													   format.display.line_count);
	}

	// field rate / interlace
	if (format.field_rate != media_raw_video_format::wildcard.field_rate) {
		s << (empty ? "" : ", ") << forVideoFieldRate(format.field_rate,
													  format.interlace);
		empty = false;
	}

	if (complete) {

		// aspect ratio
		if ((format.pixel_width_aspect != media_raw_video_format::wildcard.pixel_width_aspect)
		 && (format.pixel_height_aspect != media_raw_video_format::wildcard.pixel_height_aspect)) {
			s << (empty ? "" : ", ") << forVideoAspectRatio(format.pixel_width_aspect,
															format.pixel_height_aspect);
			empty = false;
		}

		// orientation
		if (format.orientation != media_raw_video_format::wildcard.orientation) {
			s << (empty ? "" : ", ") << forVideoOrientation(format.orientation);
			empty = false;
		}

		// active lines
		if ((format.first_active != media_raw_video_format::wildcard.first_active)
		 && (format.last_active != media_raw_video_format::wildcard.last_active)) {
			s << (empty ? "" : ", ") << forVideoActiveLines(format.first_active,
															format.last_active);
			empty = false;
		}
	}
	return s;
}

BString MediaString::getStringFor(
	const media_encoded_audio_format &format,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(media_encoded_audio_format)\n"));

	BString s = "";
	bool empty = true;

	// bit rate
	if (format.bit_rate != media_encoded_audio_format::wildcard.bit_rate) {
		s << (empty ? "" : ", ") << forAudioBitRate(format.bit_rate);
		empty = false;
	}

	// frame size
	if (format.frame_size != media_encoded_audio_format::wildcard.frame_size) {
		s << (empty ? "" : ", ") << forAudioFrameSize(format.frame_size);
		empty = false;
	}
	return s;
}

BString MediaString::getStringFor(
	const media_encoded_video_format &format,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(media_encoded_video_format)\n"));

	BString s = "";
	bool empty = true;

	// bit rate
	if ((format.avg_bit_rate != media_encoded_video_format::wildcard.avg_bit_rate)
	 && (format.max_bit_rate != media_encoded_video_format::wildcard.max_bit_rate))	{
		s << (empty ? "" : ", ") << forVideoBitRate(format.avg_bit_rate,
													format.max_bit_rate);
		empty = false;
	}

	if (complete) {

		// frame size
		if (format.frame_size != media_encoded_video_format::wildcard.frame_size) {
			s << (empty ? "" : ", ") << forVideoFrameSize(format.frame_size);
			empty = false;
		}

		// history
		if ((format.forward_history != media_encoded_video_format::wildcard.forward_history)
		 && (format.backward_history != media_encoded_video_format::wildcard.backward_history)) {
			s << (empty ? "" : ", ") << forVideoHistory(format.forward_history,
														format.backward_history);
			empty = false;
		}
	}

	return s;
}

BString MediaString::getStringFor(
	const media_multistream_format &format,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(media_multistream_format)\n"));

	BString s = "";
	bool empty = true;
	
	// format
	if (format.format != media_multistream_format::wildcard.format) {
		s << (empty ? "" : ", ") << forMultistreamFormat(format.format);
		empty = false;
	}

	// bit rate
	if ((format.avg_bit_rate != media_multistream_format::wildcard.avg_bit_rate)
	 && (format.max_bit_rate != media_multistream_format::wildcard.max_bit_rate)) {
		s << (empty ? "" : ", ") << forMultistreamBitRate(format.avg_bit_rate,
														  format.max_bit_rate);
		empty = false;
	}

	if (complete) {

		// chunk size
		if ((format.avg_chunk_size != media_multistream_format::wildcard.avg_chunk_size)
		 && (format.max_chunk_size != media_multistream_format::wildcard.max_chunk_size)) {
			s << (empty ? "" : ", ") << forMultistreamChunkSize(format.avg_chunk_size,
																format.max_chunk_size);
			empty = false;
		}

		// flags
		if (format.flags != media_multistream_format::wildcard.flags) {
			s << (empty ? "" : ", ") << forMultistreamFlags(format.flags);
			empty = false;
		}
	}

	return s;
}

BString MediaString::getStringFor(
	const media_format &format,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(media_format)\n"));

	BString s = getStringFor(format.type, complete);
	switch (format.type) {
		case B_MEDIA_RAW_AUDIO:	{
			BString formatInfo = getStringFor(format.u.raw_audio, complete);
			if (formatInfo.Length() > 0)
				s << " (" << formatInfo << ")";
			break;
		}
		case B_MEDIA_RAW_VIDEO:	{
			BString formatInfo = getStringFor(format.u.raw_video, complete);
			if (formatInfo.Length() > 0)
				s << " (" << formatInfo << ")";
			break;
		}
		case B_MEDIA_ENCODED_AUDIO:	{
			BString formatInfo = getStringFor(format.u.encoded_audio, complete);
			if (formatInfo.Length() > 0)
				s << " (" << formatInfo << ")";
			break;
		}
		case B_MEDIA_ENCODED_VIDEO: {
			BString formatInfo = getStringFor(format.u.encoded_video, complete);
			if (formatInfo.Length() > 0)
				s << " (" << formatInfo << ")";
			break;
		}
		case B_MEDIA_MULTISTREAM: {
			BString formatInfo = getStringFor(format.u.multistream, complete);
			if (formatInfo.Length() > 0)
				s << " (" << formatInfo << ")";
			break;
		}
		default: {
			break;
		}
	}
	return s;
}

// -------------------------------------------------------- //
// *** media_source / media_destination strings (public)
// -------------------------------------------------------- //

BString MediaString::getStringFor(
	const media_source &source,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(media_source)\n"));

	BString s;
	if ((source.port != media_source::null.port)
	 && (source.id != media_source::null.id)) {
		s << B_TRANSLATE("Port") << " "
			<< source.port << ", "
			<< B_TRANSLATE("ID") << " "
			<< source.id;
	}
	else {
		s = B_TRANSLATE("(none)");
	}
	return s;
}

BString MediaString::getStringFor(
	const media_destination &destination,
	bool complete) {
	D_METHOD(("MediaString::getStringFor(media_destination)\n"));

	BString s;
	if ((destination.port != media_destination::null.port)
	 && (destination.id != media_destination::null.id)) {
		s << B_TRANSLATE("Port") << " "
			<< destination.port << ", "
			<< B_TRANSLATE("ID") << " "
			<< destination.id;
	}
	else {
		s = B_TRANSLATE("(none)");
	}
	return s;
}

// -------------------------------------------------------- //
// *** strings for single fields in media_raw_audio_format 
// 	   (public)
// -------------------------------------------------------- //

BString MediaString::forAudioFormat(
	uint32 format,
	int32 validBits) {
	D_METHOD(("MediaString::forAudioFormat()\n"));

	if (format == media_raw_audio_format::wildcard.format) {
		return "*";
	}

	switch (format) {
		case media_raw_audio_format::B_AUDIO_UCHAR: {
			return B_TRANSLATE("8 bit integer");
		}
		case media_raw_audio_format::B_AUDIO_SHORT:	{
			return B_TRANSLATE("16 bit integer");
		}
		case media_raw_audio_format::B_AUDIO_FLOAT:	{
			return B_TRANSLATE("32 bit float");
		}
		case media_raw_audio_format::B_AUDIO_INT: {
			BString s = "";
			if (validBits != media_multi_audio_format::wildcard.valid_bits) {
				static BStringFormat format(
					B_TRANSLATE("{0, plural, other{# bit integer}}"));
				format.Format(s, validBits);
			} else
				s = B_TRANSLATE("32 bit integer");
			return s;
		}
		default: {
			return B_TRANSLATE("(unknown format)");
		}
	}
}

BString MediaString::forAudioFrameRate(
	float frameRate)
{
	D_METHOD(("MediaString::forAudioFrameRate()\n"));

	if (frameRate == media_raw_audio_format::wildcard.frame_rate) {
		return "*";
	}
	
	BString s;
	s << (frameRate / 1000) << B_TRANSLATE(" kHz");
	return s;
}

BString MediaString::forAudioChannelCount(
	uint32 channelCount)
{
	D_METHOD(("MediaString::forAudioChannelCount()\n"));

	if (channelCount == media_raw_audio_format::wildcard.channel_count) {
		return "*";
	}

	switch (channelCount) {
		case 1: {
			return B_TRANSLATE("Mono");
		}
		case 2: {
			return B_TRANSLATE("Stereo");
		}
		default: {
			BString s = "";
			static BStringFormat format(
				B_TRANSLATE("{0, plural, one{# channel}"
					"other{# channels}}"));
			format.Format(s, channelCount);
			return s;
		}
	}
}

BString MediaString::forAudioByteOrder(
	uint32 byteOrder)
{
	D_METHOD(("MediaString::forAudioByteOrder()\n"));

	if (byteOrder == media_raw_audio_format::wildcard.byte_order) {
		return "*";
	}

	switch (byteOrder) {
		case B_MEDIA_BIG_ENDIAN: {
			return B_TRANSLATE("Big endian");
		}
		case B_MEDIA_LITTLE_ENDIAN: {
			return B_TRANSLATE("Little endian");
		}
		default: {
			return B_TRANSLATE("(unknown byte order)");
		}
	}
}

BString MediaString::forAudioBufferSize(
	size_t bufferSize)
{
	D_METHOD(("MediaString::forAudioBufferSize()\n"));

	if (bufferSize == media_raw_audio_format::wildcard.buffer_size) {
		return "*";
	}

	BString s = "";
	static BStringFormat format(B_TRANSLATE(
		"{0, plural, one{# byte per buffer} other{# bytes per buffer}}"));
	format.Format(s, bufferSize);
	return s;
}

BString MediaString::forAudioChannelMask(
	uint32 channelMask) {
	D_METHOD(("MediaString::forAudioChannelMask()\n"));

	BString list, last;
	bool first = true;

	if (channelMask & B_CHANNEL_LEFT) {
		if (first) {
			list = B_TRANSLATE("Left");
			first = false;
		}
	}
	if (channelMask & B_CHANNEL_RIGHT) {
		if (first) {
			list = B_TRANSLATE("Right");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Right");
		}
	}
	if (channelMask & B_CHANNEL_CENTER) {
		if (first) {
			list = B_TRANSLATE("Center");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Center");
		}
	}
	if (channelMask & B_CHANNEL_SUB) {
		if (first) {
			list = B_TRANSLATE("Sub");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Sub");
		}
	}
	if (channelMask & B_CHANNEL_REARLEFT) {
		if (first) {
			list = B_TRANSLATE("Rear-left");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Rear-left");
		}
	}
	if (channelMask & B_CHANNEL_REARRIGHT) {
		if (first) {
			list = B_TRANSLATE("Rear-right");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Rear-right");
		}
	}
	if (channelMask & B_CHANNEL_FRONT_LEFT_CENTER) {
		if (first) {
			list = B_TRANSLATE("Front-left-center");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Front-left-center");
		}
	}
	if (channelMask & B_CHANNEL_FRONT_RIGHT_CENTER) {
		if (first) {
			list = B_TRANSLATE("Front-right-center");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Front-right-center");
		}
	}
	if (channelMask & B_CHANNEL_BACK_CENTER) {
		if (first) {
			list = B_TRANSLATE("Back-center");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Back-center");
		}
	}
	if (channelMask & B_CHANNEL_SIDE_LEFT) {
		if (first) {
			list = B_TRANSLATE("Side-left");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Side-left");
		}
	}
	if (channelMask & B_CHANNEL_SIDE_RIGHT) {
		if (first) {
			list = B_TRANSLATE("Side-right");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Side-right");
		}
	}
	if (channelMask & B_CHANNEL_TOP_CENTER) {
		if (first) {
			list = B_TRANSLATE("Top-center");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Top-center");
		}
	}
	if (channelMask & B_CHANNEL_TOP_FRONT_LEFT) {
		if (first) {
			list = B_TRANSLATE("Top-Front-left");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Top-Front-left");
		}
	}
	if (channelMask & B_CHANNEL_TOP_FRONT_CENTER) {
		if (first) {
			list = B_TRANSLATE("Top-Front-center");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Top-Front-center");
		}
	}
	if (channelMask & B_CHANNEL_TOP_FRONT_RIGHT) {
		if (first) {
			list = B_TRANSLATE("Top-Front-right");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Top-Front-right");
		}
	}
	if (channelMask & B_CHANNEL_TOP_BACK_LEFT) {
		if (first) {
			list = B_TRANSLATE("Top-Back-left");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Top-Back-left");
		}
	}
	if (channelMask & B_CHANNEL_TOP_BACK_CENTER) {
		if (first) {
			list = B_TRANSLATE("Top-Back-center");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Top-Back-center");
		}
	}
	if (channelMask & B_CHANNEL_TOP_BACK_RIGHT) {
		if (first) {
			list = B_TRANSLATE("Top-Back-right");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Top-Back-right");
		}
	}
	if (last != "") {
		list << " & " << last;
	}
	if (list == "") {
		list = B_TRANSLATE("(none)");
	}

	return list;
}

BString MediaString::forAudioMatrixMask(
	uint16 matrixMask) {
	D_METHOD(("MediaString::forAudioMatrixMask()\n"));

	switch (matrixMask) {
		case 0:
			return B_TRANSLATE("(none)");
		case B_MATRIX_PROLOGIC_LR:
			return B_TRANSLATE("ProLogic LR");
		case B_MATRIX_AMBISONIC_WXYZ:
			return B_TRANSLATE("Ambisonic WXYZ");
		default:
			return B_TRANSLATE("(unknown matrix mask)");
	}
}

// -------------------------------------------------------- //
// *** strings for single fields in media_encoded_audio_format 
// 	   (public)
// -------------------------------------------------------- //

BString MediaString::forAudioBitRate(
	float bitRate)
{
	D_METHOD(("MediaString::forAudioBufferSize()\n"));

	if (bitRate == media_encoded_audio_format::wildcard.bit_rate) {
		return "*";
	}

	BString s = "";
	s << bitRate / 1000.0f << B_TRANSLATE(" kb/s");
	return s;
}

BString MediaString::forAudioFrameSize(
	size_t frameSize)
{
	D_METHOD(("MediaString::forAudioFrameSize()\n"));

	if (frameSize == media_encoded_audio_format::wildcard.frame_size) {
		return "*";
	}

	BString s = "";
	static BStringFormat format(B_TRANSLATE("{0, plural,"
			"one{# byte per frame}"
			"other{# bytes per frame}}"));
	format.Format(s, frameSize);
	return s;
}

// -------------------------------------------------------- //
// *** strings for single fields in media_raw_video_format 
// 	   (public)
// -------------------------------------------------------- //

BString MediaString::forVideoFormat(
	color_space format)
{
	D_METHOD(("MediaString::forVideoFormat()\n"));

	if (format == media_video_display_info::wildcard.format) {
		return "*";
	}

	switch (format) {
		case B_RGB32:
		case B_RGB32_BIG:
			return B_TRANSLATE("32 bit RGB");
		case B_RGBA32:
		case B_RGBA32_BIG:
			return B_TRANSLATE("32 bit RGBA");
		case B_RGB24:
		case B_RGB24_BIG:
			return B_TRANSLATE("24 bit RGB");
		case B_RGB16:
		case B_RGB16_BIG:
			return B_TRANSLATE("16 bit RGB");
		case B_RGB15:
		case B_RGB15_BIG:
			return B_TRANSLATE("15 bit RGB");
		case B_RGBA15:
		case B_RGBA15_BIG:
			return B_TRANSLATE("15 bit RGBA");
		case B_CMAP8:
			return B_TRANSLATE("8 bit color-index");
		case B_GRAY8:
			return B_TRANSLATE("8 bit grayscale-index");
		case B_GRAY1:
			return B_TRANSLATE("Monochrome");
		case B_YUV422:
			return B_TRANSLATE("YUV422");
		case B_YUV411:
			return B_TRANSLATE("YUV411");
		case B_YUV420:
			return B_TRANSLATE("YUV420");
		case B_YUV444:
			return B_TRANSLATE("YUV444");
		case B_YUV9:
			return B_TRANSLATE("YUV9");
		case B_YUV12:
			return B_TRANSLATE("YUV12");
		case B_YCbCr422:
			return B_TRANSLATE("YCbCr422");
		case B_YCbCr411:
			return B_TRANSLATE("YCbCr411");
		case B_YCbCr444:
			return B_TRANSLATE("YCbCr444");
		case B_YCbCr420:
			return B_TRANSLATE("YCbCr420");
		case B_UVL24:
			return B_TRANSLATE("24 bit UVL");
		case B_UVL32:
			return B_TRANSLATE("32 bit UVL");
		case B_UVLA32:
			return B_TRANSLATE("32 bit UVLA");
		case B_LAB24:
			return B_TRANSLATE("24 bit LAB");
		case B_LAB32:
			return B_TRANSLATE("32 bit LAB");
		case B_LABA32:
			return B_TRANSLATE("32 bit LABA");
		case B_HSI24:
			return B_TRANSLATE("24 bit HSI");
		case B_HSI32:
			return B_TRANSLATE("32 bit HSI");
		case B_HSIA32:
			return B_TRANSLATE("32 bit HSIA");
		case B_HSV24:
			return B_TRANSLATE("24 bit HSV");
		case B_HSV32:
			return B_TRANSLATE("32 bit HSV");
		case B_HSVA32:
			return B_TRANSLATE("32 bit HSVA");
		case B_HLS24:
			return B_TRANSLATE("24 bit HLS");
		case B_HLS32:
			return B_TRANSLATE("32 bit HLS");
		case B_HLSA32:
			return B_TRANSLATE("32 bit HLSA");
		case B_CMY24:
			return B_TRANSLATE("24 bit CMY");
		case B_CMY32:
			return B_TRANSLATE("32 bit CMY");
		case B_CMYA32:
			return B_TRANSLATE("32 bit CMYA");
		case B_CMYK32:
			return B_TRANSLATE("32 bit CMYK");
		default: {
			return B_TRANSLATE("(unknown video format)");
		}
	}
}

BString MediaString::forVideoResolution(
	uint32 lineWidth,
	uint32 lineCount)
{
	D_METHOD(("MediaString::forVideoResolution()\n"));

	if ((lineWidth == media_video_display_info::wildcard.line_width)
	 || (lineCount == media_video_display_info::wildcard.line_count)) {
		return "*";
	}

	BString s = "";
	s << lineWidth << " x " << lineCount;
	return s;
}

BString MediaString::forVideoFieldRate(
	float fieldRate,
	uint32 interlace)
{
	D_METHOD(("MediaString::forVideoFieldRate()\n"));

	if (fieldRate == media_raw_video_format::wildcard.field_rate) {
		return "*";
	}

	BString s = "";
	if (interlace == 1) {
		s << B_TRANSLATE("Non-interlaced ");
	}
	else {
		s << B_TRANSLATE("Interlaced ");
	}
	s << fieldRate << B_TRANSLATE(" Hz");
	if ((fieldRate > 49.9) && (fieldRate < 50.1)) {
		s << B_TRANSLATE(" (PAL)");
	}
	else if (((interlace == 2) && (fieldRate > 59.9) && (fieldRate < 60.0))
		  || ((interlace == 1) && (fieldRate > 29.9) && (fieldRate < 30.0))) {
		s << B_TRANSLATE(" (NTSC)");
	}

	return s;	
}

BString MediaString::forVideoOrientation(
	uint32 orientation)
{
	D_METHOD(("MediaString::forVideoOrientation()\n"));

	if (orientation == media_raw_video_format::wildcard.orientation) {
		return "*";
	}

	switch (orientation) {
		case B_VIDEO_TOP_LEFT_RIGHT: {
			return B_TRANSLATE("Top to bottom, left to right");
		}
		case B_VIDEO_BOTTOM_LEFT_RIGHT: {
			return B_TRANSLATE("Bottom to top, left to right");
		}
		default: {
			return B_TRANSLATE("(unkown video orientation)");
		}
	}
}

BString MediaString::forVideoAspectRatio(
	uint16 pixelWidth,
	uint16 pixelHeight)
{
	D_METHOD(("MediaString::forVideoPixelAspect()\n"));

	if ((pixelWidth == media_raw_video_format::wildcard.pixel_width_aspect)
	 || (pixelHeight == media_raw_video_format::wildcard.pixel_height_aspect)) {
		return "*";
	}

	BString s = "";
	s << static_cast<uint32>(pixelWidth);
	s << ":" << static_cast<uint32>(pixelHeight);
	return s;
}

BString MediaString::forVideoActiveLines(
	uint32 firstActive,
	uint32 lastActive)
{
	D_METHOD(("MediaString::forVideoActiveLines()\n"));

	if ((firstActive == media_raw_video_format::wildcard.first_active)
	 || (lastActive == media_raw_video_format::wildcard.last_active)) {
	 	return "*";
	}

	BString s = "";
	s.SetToFormat(
		B_TRANSLATE("Video data between line " B_PRIu32 " and " B_PRIu32),
		firstActive, lastActive);
	return s;
}

BString MediaString::forVideoBytesPerRow(
	uint32 bytesPerRow)
{
	D_METHOD(("MediaString::forVideoBytesPerRow()\n"));

	if (bytesPerRow == media_video_display_info::wildcard.bytes_per_row) {
		return "*";
	}

	BString s = "";
	static BStringFormat format(B_TRANSLATE("{0, plural, one{# byte per row}"
			"other{# bytes per row}}"));
	format.Format(s, bytesPerRow);
	return s;
}

BString MediaString::forVideoOffset(
	uint32 pixelOffset,
	uint32 lineOffset)
{
	D_METHOD(("MediaString::forVideoResolution()\n"));

	BString s = "";
	if (pixelOffset != media_video_display_info::wildcard.pixel_offset) {
		static BStringFormat format(
			B_TRANSLATE("{0, plural, one{# pixel} other{# pixels}}"));
		format.Format(s, pixelOffset);
	}
	if (lineOffset != media_video_display_info::wildcard.line_offset) {
		if (s != "") {
			s << ", ";
		}
		BString t = "";
		static BStringFormat format(
			B_TRANSLATE("{0, plural, one{# line} other{# lines}}"));
		format.Format(t, lineOffset);
		s += t;
	}
	if (s == "") {
		s = "*";
	}
	return s;
}

// -------------------------------------------------------- //
// *** strings for single fields in media_encoded_video_format 
// 	   (public)
// -------------------------------------------------------- //

BString MediaString::forVideoBitRate(
	float avgBitRate,
	float maxBitRate)
{
	D_METHOD(("MediaString::forVideoBitRate()\n"));

	BString s = "";
	if (avgBitRate != media_encoded_video_format::wildcard.avg_bit_rate) {
		s << avgBitRate / 1000.0f << B_TRANSLATE(" kb/s (avg)");
	}
	if (maxBitRate != media_encoded_video_format::wildcard.max_bit_rate) {
		if (s != "") {
			s << ", ";
		}
		s << maxBitRate / 1000.0f << B_TRANSLATE(" kb/s (max)");
	}
	if (s == "") {
		s = "*";
	}
	return s;
}

BString MediaString::forVideoFrameSize(
	size_t frameSize)
{
	D_METHOD(("MediaString::forVideoFrameSize()\n"));

	if (frameSize == media_encoded_video_format::wildcard.frame_size) {
		return "*";
	}

	BString s = "";
	static BStringFormat format(B_TRANSLATE("{0, plural,"
			"one{# byte per frame}"
			"other{# bytes per frame}}"));
	format.Format(s, frameSize);
	return s;
}

BString MediaString::forVideoHistory(
	int16 forwardHistory,
	int16 backwardHistory)
{
	D_METHOD(("MediaString::forVideoHistory()\n"));

	BString s = "";
	if (forwardHistory != media_encoded_video_format::wildcard.forward_history) {
		static BStringFormat format(B_TRANSLATE("{0, plural,"
				"one{# frame forward}"
				"other{# frames forward}}"));
		format.Format(s, static_cast<int32>(forwardHistory));
	}
	if (backwardHistory != media_encoded_video_format::wildcard.backward_history) {
		if (s != "") {
			s << ", ";
		}
		BString t = "";
		static BStringFormat format(B_TRANSLATE("{0, plural,"
				"one{# frame backward}"
				"other{# frames backward}}"));
		format.Format(t, static_cast<int32>(backwardHistory));
		s += t;
	}
	if (s == "") {
		s = "*";
	}
	return s;
}

// -------------------------------------------------------- //
// *** strings for single fields in media_multistream_format 
// 	   (public)
// -------------------------------------------------------- //

BString MediaString::forMultistreamFormat(
	int32 format)
{
	D_METHOD(("MediaString::forMultistreamFormat()\n"));

	if (format == media_multistream_format::wildcard.format) {
		return "*";
	}

	switch (format) {
		case media_multistream_format::B_VID:
			return B_TRANSLATE("BeOS video");
		case media_multistream_format::B_AVI:
			return B_TRANSLATE("AVI");
		case media_multistream_format::B_MPEG1:
			return B_TRANSLATE("MPEG1");
		case media_multistream_format::B_MPEG2:
			return B_TRANSLATE("MPEG2");
		case media_multistream_format::B_QUICKTIME:
			return B_TRANSLATE("QuickTime");
		default:
			return B_TRANSLATE("(unknown multistream format)");
	}
}

BString MediaString::forMultistreamBitRate(
	float avgBitRate,
	float maxBitRate)
{
	D_METHOD(("MediaString::forMultistreamFormat()\n"));

	BString s = "";
	if (avgBitRate != media_multistream_format::wildcard.avg_bit_rate) {
		s << avgBitRate / 1000.0f << B_TRANSLATE(" kb/s (avg)");
	}
	if (maxBitRate != media_multistream_format::wildcard.max_bit_rate) {
		if (s != "") {
			s << ", ";
		}
		s << maxBitRate / 1000.0f << B_TRANSLATE(" kb/s (max)");
	}
	if (s == "") {
		s = "*";
	}
	return s;
}

BString MediaString::forMultistreamChunkSize(
	uint32 avgChunkSize,
	uint32 maxChunkSize)
{
	D_METHOD(("MediaString::forMultistreamChunkSize()\n"));

	BString s = "";
	if (avgChunkSize != media_multistream_format::wildcard.avg_chunk_size) {
		static BStringFormat format(B_TRANSLATE("{0, plural,"
				"one{# byte (avg)}"
				"other{# bytes (avg)}}"));
		format.Format(s, avgChunkSize);
	}
	if (maxChunkSize != media_multistream_format::wildcard.max_chunk_size) {
		if (s != "") {
			s << ", ";
		}
		static BStringFormat format(B_TRANSLATE("{0, plural,"
				"one{# byte (max)}"
				"other{# bytes (max)}}"));
		format.Format(s, maxChunkSize);
	}
	if (s == "") {
		s = "*";
	}
	return s;
}

BString MediaString::forMultistreamFlags(
	uint32 flags)
{
	D_METHOD(("MediaString::forMultistreamFlags()\n"));

	BString list, last;
	bool first = true;

	if (flags & media_multistream_format::B_HEADER_HAS_FLAGS) {
		if (first) {
			list = B_TRANSLATE("Header has flags");
			first = false;
		}
	}
	if (flags & media_multistream_format::B_CLEAN_BUFFERS) {
		if (first) {
			list = B_TRANSLATE("Clean buffers");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Clean buffers");
		}
	}
	if (flags & media_multistream_format::B_HOMOGENOUS_BUFFERS) {
		if (first) {
			list = B_TRANSLATE("Homogenous buffers");
			first = false;
		}
		else {
			if (last != "")
				list << ", " << last;
			last = B_TRANSLATE("Homogenous buffers");
		}
	}

	if (last != "")
		list << " & " << last;

	if (list == "")
		list = B_TRANSLATE("(none)");

	return list;
}

// END -- MediaString.cpp --