path: root/Src/external_dependencies/openmpt-trunk/mptrack/StreamEncoderMP3.cpp

/*
 * StreamEncoder.cpp
 * -----------------
 * Purpose: Exporting streamed music files.
 * Notes  : none
 * Authors: Joern Heusipp
 *          OpenMPT Devs
 * The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
 */

#include "stdafx.h"

#include "StreamEncoder.h"
#include "StreamEncoderMP3.h"

#include "Mptrack.h"

#include "../soundlib/Sndfile.h"

#include "../common/misc_util.h"
#include "../common/mptStringBuffer.h"

#ifdef MPT_WITH_LAME
#if defined(MPT_BUILD_MSVC)
#include <lame.h>
#else
#include <lame/lame.h>
#endif
#endif // MPT_WITH_LAME



OPENMPT_NAMESPACE_BEGIN



///////////////////////////////////////////////////////////////////////////////////////////////////
// ID3v2.4 Tags

struct ID3v2Header
{
	uint8    signature[3];
	uint8    version[2];
	uint8be  flags;
	uint32be size;
};

MPT_BINARY_STRUCT(ID3v2Header, 10)

struct ID3v2Frame
{
	char     frameid[4];
	uint32be size;
	uint16be flags;
};

MPT_BINARY_STRUCT(ID3v2Frame, 10)


// charset... choose text ending accordingly.
// $00 = ISO-8859-1. Terminated with $00.
// $01 = UTF-16 with BOM. Terminated with $00 00.
// $02 = UTF-16BE without BOM. Terminated with $00 00.
// $03 = UTF-8. Terminated with $00.
#define ID3v2_CHARSET '\3'
#define ID3v2_TEXTENDING '\0'

struct ReplayGain
{
	enum GainTag
	{
		TagSkip,
		TagReserve,
		TagWrite
	};
	GainTag Tag;
	float TrackPeak;
	bool TrackPeakValid;
	float TrackGaindB;
	bool TrackGaindBValid;
	ReplayGain()
		: Tag(TagSkip)
		, TrackPeak(0.0f)
		, TrackPeakValid(false)
		, TrackGaindB(0.0f)
		, TrackGaindBValid(false)
	{
		return;
	}
};

class ID3V2Tagger
{
private:
	Encoder::StreamSettings settings;
public:
	// Write Tags
	void WriteID3v2Tags(std::ostream &s, const FileTags &tags, ReplayGain replayGain = ReplayGain());

	ID3V2Tagger(const Encoder::StreamSettings &settings_);

private:
	// Convert Integer to Synchsafe Integer (see ID3v2.4 specs)
	uint32 intToSynchsafe(uint32 in);
	// Return maximum value that fits into a syncsafe int
	uint32 GetMaxSynchsafeInt() const;
	// Write a frame
	void WriteID3v2Frame(const char cFrameID[4], std::string sFramecontent, std::ostream &s);
	// Return an upper bound for the size of all replay gain frames
	uint32 GetMaxReplayGainFramesSizes();
	uint32 GetMaxReplayGainTxxxTrackGainFrameSize();
	uint32 GetMaxReplayGainTxxxTrackPeakFrameSize();
	// Write out all ReplayGain frames
	void WriteID3v2ReplayGainFrames(ReplayGain replaygain, std::ostream &s);
	// Size of our tag
	uint32 totalID3v2Size;
};

///////////////////////////////////////////////////
// CFileTagging - helper class for writing tags

ID3V2Tagger::ID3V2Tagger(const Encoder::StreamSettings &settings_)
	: settings(settings_)
	, totalID3v2Size(0)
{
	return;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
// ID3v2.4 Tags

// Convert Integer to Synchsafe Integer (see ID3v2.4 specs)
// Basically, it's a BigEndian integer, but the MSB of all bytes is 0.
// Thus, a 32-bit integer turns into a 28-bit integer.
uint32 ID3V2Tagger::intToSynchsafe(uint32 in)
{
	uint32 out = 0, steps = 0;
	do
	{
		out |= (in & 0x7F) << steps;
		steps += 8;
	} while(in >>= 7);
	return out;
}

// Return maximum value that fits into a syncsafe int
uint32 ID3V2Tagger::GetMaxSynchsafeInt() const
{
	return 0x0fffffffu;
}

// Write Tags
void ID3V2Tagger::WriteID3v2Tags(std::ostream &s, const FileTags &tags, ReplayGain replayGain)
{
	if(!s) return;
	
	ID3v2Header tHeader;
	std::streampos fOffset = s.tellp();
	uint32 paddingSize = 0;

	totalID3v2Size = 0;

	// Correct header will be written later (tag size missing)
	memcpy(tHeader.signature, "ID3", 3);
	tHeader.version[0] = 0x04; // Version 2.4.0
	tHeader.version[1] = 0x00; // Ditto
	tHeader.flags = 0; // No flags
	tHeader.size  = 0; // will be filled later
	s.write(reinterpret_cast<const char*>(&tHeader), sizeof(tHeader));
	totalID3v2Size += sizeof(tHeader);

	WriteID3v2Frame("TIT2", mpt::ToCharset(mpt::Charset::UTF8, tags.title), s);
	WriteID3v2Frame("TPE1", mpt::ToCharset(mpt::Charset::UTF8, tags.artist), s);
	WriteID3v2Frame("TCOM", mpt::ToCharset(mpt::Charset::UTF8, tags.artist), s);
	WriteID3v2Frame("TALB", mpt::ToCharset(mpt::Charset::UTF8, tags.album), s);
	WriteID3v2Frame("TCON", mpt::ToCharset(mpt::Charset::UTF8, tags.genre), s);
	//WriteID3v2Frame("TYER", mpt::ToCharset(mpt::Charset::UTF8, tags.year), s);		// Deprecated
	WriteID3v2Frame("TDRC", mpt::ToCharset(mpt::Charset::UTF8, tags.year), s);
	WriteID3v2Frame("TBPM", mpt::ToCharset(mpt::Charset::UTF8, tags.bpm), s);
	WriteID3v2Frame("WXXX", mpt::ToCharset(mpt::Charset::UTF8, tags.url), s);
	WriteID3v2Frame("TENC", mpt::ToCharset(mpt::Charset::UTF8, tags.encoder), s);
	WriteID3v2Frame("COMM", mpt::ToCharset(mpt::Charset::UTF8, tags.comments), s);
	if(replayGain.Tag == ReplayGain::TagReserve)
	{
		paddingSize += GetMaxReplayGainFramesSizes();
	} else if(replayGain.Tag == ReplayGain::TagWrite)
	{
		std::streampos replayGainBeg = s.tellp();
		WriteID3v2ReplayGainFrames(replayGain, s);
		std::streampos replayGainEnd = s.tellp();
		paddingSize += GetMaxReplayGainFramesSizes() - static_cast<uint32>(replayGainEnd - replayGainBeg);
	}

	// Write Padding
	uint32 totalID3v2SizeWithoutPadding = totalID3v2Size;
	paddingSize += settings.MP3ID3v2MinPadding;
	totalID3v2Size += paddingSize;
	if(settings.MP3ID3v2PaddingAlignHint > 0)
	{
		totalID3v2Size = mpt::align_up<uint32>(totalID3v2Size, settings.MP3ID3v2PaddingAlignHint);
		paddingSize = totalID3v2Size - totalID3v2SizeWithoutPadding;
	}
	for(size_t i = 0; i < paddingSize; i++)
	{
		char c = 0;
		s.write(&c, 1);
	}

	// Write correct header (update tag size)
	tHeader.size = intToSynchsafe(totalID3v2Size - sizeof(tHeader));
	s.seekp(fOffset);
	s.write(reinterpret_cast<const char*>(&tHeader), sizeof(tHeader));
	s.seekp(totalID3v2Size - sizeof(tHeader), std::ios::cur);

}

uint32 ID3V2Tagger::GetMaxReplayGainTxxxTrackGainFrameSize()
{
	return mpt::saturate_cast<uint32>(sizeof(ID3v2Frame) + 1 + std::strlen("REPLAYGAIN_TRACK_GAIN") + 1 + std::strlen("-123.45 dB") + 1); // should be enough
}

uint32 ID3V2Tagger::GetMaxReplayGainTxxxTrackPeakFrameSize()
{
	return mpt::saturate_cast<uint32>(sizeof(ID3v2Frame) + 1 + std::strlen("REPLAYGAIN_TRACK_PEAK") + 1 + std::strlen("2147483648.123456") + 1); // unrealistic worst case
}

uint32 ID3V2Tagger::GetMaxReplayGainFramesSizes()
{
	uint32 size = 0;
	if(settings.MP3ID3v2WriteReplayGainTXXX)
	{
		size += GetMaxReplayGainTxxxTrackGainFrameSize();
		size += GetMaxReplayGainTxxxTrackPeakFrameSize();
	}
	return size;
}

void ID3V2Tagger::WriteID3v2ReplayGainFrames(ReplayGain replayGain, std::ostream &s)
{

	if(settings.MP3ID3v2WriteReplayGainTXXX && replayGain.TrackGaindBValid)
	{

		std::string content;

		content += std::string(1, 0x00); // ISO-8859-1
		content += std::string("REPLAYGAIN_TRACK_GAIN");
		content += std::string(1, '\0');

		int32 gainTimes100 = mpt::saturate_round<int32>(replayGain.TrackGaindB * 100.0f);
		if(gainTimes100 < 0)
		{
			content += "-";
			gainTimes100 = std::abs(gainTimes100);
		}
		content += mpt::afmt::dec(gainTimes100 / 100);
		content += ".";
		content += mpt::afmt::dec0<2>(gainTimes100 % 100);
		content += " ";
		content += "dB";

		content += std::string(1, '\0');

		if(sizeof(ID3v2Frame) + content.size() <= GetMaxReplayGainTxxxTrackGainFrameSize())
		{
			ID3v2Frame frame;
			std::memset(&frame, 0, sizeof(ID3v2Frame));
			std::memcpy(&frame.frameid, "TXXX", 4);
			frame.size = intToSynchsafe(static_cast<uint32>(content.size()));
			frame.flags = 0x4000; // discard if audio data changed
			s.write(reinterpret_cast<const char*>(&frame), sizeof(ID3v2Frame));
			s.write(content.data(), content.size());
		}

	}


	if(settings.MP3ID3v2WriteReplayGainTXXX && replayGain.TrackPeakValid)
	{

		std::string content;

		content += std::string(1, 0x00); // ISO-8859-1
		content += std::string("REPLAYGAIN_TRACK_PEAK");
		content += std::string(1, '\0');

		int32 peakTimes1000000 = mpt::saturate_round<int32>(std::fabs(replayGain.TrackPeak) * 1000000.0f);
		std::string number;
		number += mpt::afmt::dec(peakTimes1000000 / 1000000);
		number += ".";
		number += mpt::afmt::dec0<6>(peakTimes1000000 % 1000000);
		content += number;

		content += std::string(1, '\0');

		if(sizeof(ID3v2Frame) + content.size() <= GetMaxReplayGainTxxxTrackPeakFrameSize())
		{
			ID3v2Frame frame;
			std::memset(&frame, 0, sizeof(ID3v2Frame));
			std::memcpy(&frame.frameid, "TXXX", 4);
			frame.size = intToSynchsafe(static_cast<uint32>(content.size()));
			frame.flags = 0x4000; // discard if audio data changed
			s.write(reinterpret_cast<const char*>(&frame), sizeof(ID3v2Frame));
			s.write(content.data(), content.size());
		}

	}

}

// Write a ID3v2 frame
void ID3V2Tagger::WriteID3v2Frame(const char cFrameID[4], std::string sFramecontent, std::ostream &s)
{
	if(!cFrameID[0] || sFramecontent.empty() || !s) return;

	if(!memcmp(cFrameID, "COMM", 4))
	{
		// English language for comments - no description following (hence the text ending nullchar(s))
		// For language IDs, see https://en.wikipedia.org/wiki/ISO-639-2
		sFramecontent = "eng" + (ID3v2_TEXTENDING + sFramecontent);
	}
	if(!memcmp(cFrameID, "WXXX", 4))
	{
		// User-defined URL field (we have no description for the URL, so we leave it out)
		sFramecontent = ID3v2_TEXTENDING + sFramecontent;
	}
	sFramecontent = ID3v2_CHARSET + sFramecontent;
	sFramecontent += ID3v2_TEXTENDING;

	if(sFramecontent.size() <= GetMaxSynchsafeInt())
	{
		ID3v2Frame tFrame;
		std::memset(&tFrame, 0, sizeof(ID3v2Frame));
		std::memcpy(&tFrame.frameid, cFrameID, 4); // ID
		tFrame.size = intToSynchsafe(static_cast<uint32>(sFramecontent.size())); // Text size
		tFrame.flags = 0x0000; // No flags
		s.write(reinterpret_cast<const char*>(&tFrame), sizeof(tFrame));
		s.write(sFramecontent.c_str(), sFramecontent.size());

		totalID3v2Size += static_cast<uint32>((sizeof(tFrame) + sFramecontent.size()));
	}
}




#ifdef MPT_WITH_LAME


using lame_t = lame_global_flags *;


static void GenreEnumCallback(int num, const char *name, void *cookie)
{
	MPT_UNREFERENCED_PARAMETER(num);
	Encoder::Traits &traits = *reinterpret_cast<Encoder::Traits*>(cookie);
	if(name)
	{
		traits.genres.push_back(mpt::ToUnicode(mpt::Charset::ISO8859_1, name));
	}
}


static Encoder::Traits BuildTraits(bool compatible)
{
	Encoder::Traits traits;
	traits.fileExtension = P_("mp3");
	traits.fileShortDescription = (compatible ? U_("Compatible MP3") : U_("MP3"));
	traits.encoderSettingsName = (compatible ? U_("MP3LameCompatible") : U_("MP3Lame"));
	traits.fileDescription = (compatible ? U_("MPEG-1 Layer 3") : U_("MPEG-1/2 Layer 3"));
	traits.canTags = true;
	traits.genres.clear();
	id3tag_genre_list(&GenreEnumCallback, &traits);
	traits.modesWithFixedGenres = (compatible ? Encoder::ModeCBR : Encoder::ModeInvalid);
	traits.maxChannels = 2;
	traits.samplerates = (compatible
		? mpt::make_vector(mpeg1layer3_samplerates)
		: mpt::make_vector(layer3_samplerates)
		);
	traits.modes = (compatible ? Encoder::ModeCBR : (Encoder::ModeABR | Encoder::ModeQuality));
	traits.bitrates = (compatible
		? mpt::make_vector(mpeg1layer3_bitrates)
		: mpt::make_vector(layer3_bitrates)
		);
	traits.defaultSamplerate = 44100;
	traits.defaultChannels = 2;
	traits.defaultMode = (compatible ? Encoder::ModeCBR : Encoder::ModeQuality);
	traits.defaultBitrate = 256;
	traits.defaultQuality = 0.8f;
	return traits;
}


class MP3LameStreamWriter : public StreamWriterBase
{
private:
	bool compatible;
	Encoder::Settings settings;
	Encoder::Mode Mode;
	bool gfp_inited;
	lame_t gfp;
	enum ID3Type
	{
		ID3None,
		ID3v1,
		ID3v2Lame,
		ID3v2OpenMPT,
	};
	ID3Type id3type;
	std::streamoff id3v2Size;
	FileTags Tags;
public:
	MP3LameStreamWriter(std::ostream &stream, bool compatible, const Encoder::Settings &settings_, const FileTags &tags)
		: StreamWriterBase(stream)
		, compatible(compatible)
		, settings(settings_)
	{
		Mode = Encoder::ModeInvalid;
		gfp_inited = false;
		gfp = lame_t();
		id3type = ID3v2Lame;
		id3v2Size = 0;

		if(!gfp)
		{
			gfp = lame_init();
		}

		uint32 samplerate = settings.Samplerate;
		uint16 channels = settings.Channels;
		if(settings.Tags)
		{
			if(compatible)
			{
				id3type = ID3v1;
			} else if(settings.Details.MP3LameID3v2UseLame)
			{
				id3type = ID3v2Lame;
			} else
			{
				id3type = ID3v2OpenMPT;
			}
		} else
		{
			id3type = ID3None;
		}
		id3v2Size = 0;

		lame_set_in_samplerate(gfp, samplerate);
		lame_set_num_channels(gfp, channels);

		int lameQuality = settings.Details.MP3LameQuality;
		lame_set_quality(gfp, lameQuality);

		if(settings.Mode == Encoder::ModeCBR)
		{

			if(compatible)
			{
				if(settings.Bitrate >= 32)
				{
					// For maximum compatibility,
					// force samplerate to a samplerate supported by MPEG1 streams.
					if(samplerate <= 32000)
					{
						samplerate = 32000;
					} else if(samplerate >= 48000)
					{
						samplerate = 48000;
					} else
					{
						samplerate = 44100;
					}
					lame_set_out_samplerate(gfp, samplerate);
				} else
				{
					// A very low bitrate was chosen,
					// force samplerate to lowest possible for MPEG2.
					// Disable unofficial MPEG2.5 however.
					lame_set_out_samplerate(gfp, 16000);
				}
			}

			lame_set_brate(gfp, settings.Bitrate);
			lame_set_VBR(gfp, vbr_off);

			if(compatible)
			{
				lame_set_bWriteVbrTag(gfp, 0);
				lame_set_strict_ISO(gfp, 1);
				lame_set_disable_reservoir(gfp, 1);
			} else
			{
				lame_set_bWriteVbrTag(gfp, 1);
			}

		} else if(settings.Mode == Encoder::ModeABR)
		{

			lame_set_brate(gfp, settings.Bitrate);
			lame_set_VBR(gfp, vbr_abr);

			lame_set_bWriteVbrTag(gfp, 1);

		} else
		{

			float lame_quality = 10.0f - (settings.Quality * 10.0f);
			Limit(lame_quality, 0.0f, 9.999f);
			lame_set_VBR_quality(gfp, lame_quality);
			lame_set_VBR(gfp, vbr_default);

			lame_set_bWriteVbrTag(gfp, 1);

		}

		lame_set_decode_on_the_fly(gfp, settings.Details.MP3LameCalculatePeakSample ? 1 : 0); // see LAME docs for why
		lame_set_findReplayGain(gfp, settings.Details.MP3LameCalculateReplayGain ? 1 : 0);

		switch(id3type)
		{
		case ID3None:
			lame_set_write_id3tag_automatic(gfp, 0);
			break;
		case ID3v1:
			id3tag_init(gfp);
			id3tag_v1_only(gfp);
			break;
		case ID3v2Lame:
			id3tag_init(gfp);
			id3tag_add_v2(gfp);
			id3tag_v2_only(gfp);
			id3tag_set_pad(gfp, settings.Details.MP3ID3v2MinPadding);
			break;
		case ID3v2OpenMPT:
			lame_set_write_id3tag_automatic(gfp, 0);
			break;
		}

		Mode = settings.Mode;

		if(settings.Tags)
		{
			if(id3type == ID3v2Lame || id3type == ID3v1)
			{
				// Lame API expects Latin1, which is sad, but we cannot change that.
				if(!tags.title.empty())    id3tag_set_title(  gfp, mpt::ToCharset(mpt::Charset::ISO8859_1, tags.title   ).c_str());
				if(!tags.artist.empty())   id3tag_set_artist( gfp, mpt::ToCharset(mpt::Charset::ISO8859_1, tags.artist  ).c_str());
				if(!tags.album.empty())    id3tag_set_album(  gfp, mpt::ToCharset(mpt::Charset::ISO8859_1, tags.album   ).c_str());
				if(!tags.year.empty())     id3tag_set_year(   gfp, mpt::ToCharset(mpt::Charset::ISO8859_1, tags.year    ).c_str());
				if(!tags.comments.empty()) id3tag_set_comment(gfp, mpt::ToCharset(mpt::Charset::ISO8859_1, tags.comments).c_str());
				if(!tags.trackno.empty())  id3tag_set_track(  gfp, mpt::ToCharset(mpt::Charset::ISO8859_1, tags.trackno ).c_str());
				if(!tags.genre.empty())    id3tag_set_genre(  gfp, mpt::ToCharset(mpt::Charset::ISO8859_1, tags.genre   ).c_str());
			} else if(id3type == ID3v2OpenMPT)
			{
				Tags = tags;
				std::streampos id3beg = f.tellp();
				ID3V2Tagger tagger(settings.Details);
				ReplayGain replayGain;
				if(settings.Details.MP3LameCalculatePeakSample || settings.Details.MP3LameCalculateReplayGain)
				{
					replayGain.Tag = ReplayGain::TagReserve;
				}
				tagger.WriteID3v2Tags(f, tags, replayGain);
				std::streampos id3end = f.tellp();
				id3v2Size = id3end - id3beg;
			}
		}

	}
	void WriteInterleaved(size_t count, const float *interleaved) override
	{
		if(!gfp_inited)
		{
			lame_init_params(gfp);
			gfp_inited = true;
		}
		const int count_max = 0xffff;
		while(count > 0)
		{
			int count_chunk = std::clamp(mpt::saturate_cast<int>(count), int(0), count_max);
			buf.resize(count_chunk + (count_chunk+3)/4 + 7200);
			int result = 0;
			if(lame_get_num_channels(gfp) == 1)
			{
				// lame always assumes stereo input with interleaved interface, so use non-interleaved for mono
				result = lame_encode_buffer_ieee_float(gfp, interleaved, nullptr, count_chunk, mpt::byte_cast<unsigned char*>(buf.data()), mpt::saturate_cast<int>(buf.size()));
			} else
			{
				result = lame_encode_buffer_interleaved_ieee_float(gfp, interleaved, count_chunk, mpt::byte_cast<unsigned char*>(buf.data()), mpt::saturate_cast<int>(buf.size()));
			}
			buf.resize((result >= 0) ? result : 0);
			if(result == -2)
			{
				throw std::bad_alloc();
			}
			WriteBuffer();
			count -= static_cast<size_t>(count_chunk);
		}
	}
	void WriteFinalize() override
	{
		if(!gfp_inited)
		{
			lame_init_params(gfp);
			gfp_inited = true;
		}
		buf.resize(7200);
		buf.resize(lame_encode_flush(gfp, mpt::byte_cast<unsigned char*>(buf.data()), mpt::saturate_cast<int>(buf.size())));
		WriteBuffer();
		ReplayGain replayGain;
		if(settings.Details.MP3LameCalculatePeakSample)
		{
			replayGain.TrackPeak = std::fabs(lame_get_PeakSample(gfp)) / 32768.0f;
			replayGain.TrackPeakValid = true;
		}
		if(settings.Details.MP3LameCalculateReplayGain)
		{
			replayGain.TrackGaindB = lame_get_RadioGain(gfp) / 10.0f;
			replayGain.TrackGaindBValid = true;
		}
		if(id3type == ID3v2OpenMPT && (settings.Details.MP3LameCalculatePeakSample || settings.Details.MP3LameCalculateReplayGain))
		{ // update ID3v2 tag with replay gain information
			replayGain.Tag = ReplayGain::TagWrite;
			std::streampos endPos = f.tellp();
			f.seekp(fStart);
			std::string tagdata(static_cast<std::size_t>(id3v2Size), '\0');
			f.write(tagdata.data(), id3v2Size); // clear out the old tag
			f.seekp(fStart);
			ID3V2Tagger tagger(settings.Details);
			tagger.WriteID3v2Tags(f, Tags, replayGain);
			f.seekp(endPos);
		}
		if(id3type == ID3v2Lame)
		{
			id3v2Size = lame_get_id3v2_tag(gfp, nullptr, 0);
		} else if(id3type == ID3v2OpenMPT)
		{
			// id3v2Size already set
		}
		if(!compatible)
		{
			std::streampos endPos = f.tellp();
			f.seekp(fStart + id3v2Size);
			buf.resize(lame_get_lametag_frame(gfp, nullptr, 0));
			buf.resize(lame_get_lametag_frame(gfp, (unsigned char*)buf.data(), buf.size()));
			WriteBuffer();
			f.seekp(endPos);
		}
	}
	virtual ~MP3LameStreamWriter()
	{
		if(!gfp)
		{
			return;
		}
		lame_close(gfp);
		gfp = lame_t();
		gfp_inited = false;
	}
};

#endif // MPT_WITH_LAME



MP3Encoder::MP3Encoder(MP3EncoderType type)
	: m_Type(type)
{
#ifdef MPT_WITH_LAME
	if(type == MP3EncoderLame)
	{
		m_Type = MP3EncoderLame;
		SetTraits(BuildTraits(false));
		return;
	}
	if(type == MP3EncoderLameCompatible)
	{
		m_Type = MP3EncoderLameCompatible;
		SetTraits(BuildTraits(true));
		return;
	}
#endif // MPT_WITH_LAME
}


bool MP3Encoder::IsAvailable() const
{
	return false
#ifdef MPT_WITH_LAME
		|| (m_Type == MP3EncoderLame)
		|| (m_Type == MP3EncoderLameCompatible)
#endif // MPT_WITH_LAME
		;
}


std::unique_ptr<IAudioStreamEncoder> MP3Encoder::ConstructStreamEncoder(std::ostream &file, const Encoder::Settings &settings, const FileTags &tags) const
{
	std::unique_ptr<IAudioStreamEncoder> result = nullptr;
	if(false)
	{
		// nothing
#ifdef MPT_WITH_LAME
	} else if(m_Type == MP3EncoderLame || m_Type == MP3EncoderLameCompatible)
	{
		result = std::make_unique<MP3LameStreamWriter>(file, (m_Type == MP3EncoderLameCompatible), settings, tags);
#endif // MPT_WITH_LAME
	}
	return result;
}


mpt::ustring MP3Encoder::DescribeQuality(float quality) const
{
#ifdef MPT_WITH_LAME
	if(m_Type == MP3EncoderLame)
	{
		static constexpr int q_table[11] = { 240, 220, 190, 170, 160, 130, 120, 100, 80, 70, 50 }; // http://wiki.hydrogenaud.io/index.php?title=LAME
		int q = mpt::saturate_round<int>((1.0f - quality) * 10.0f);
		if(q < 0) q = 0;
		if(q >= 10)
		{
			return MPT_UFORMAT("VBR -V{} (~{} kbit)")(U_("9.999"), q_table[q]);
		} else
		{
			return MPT_UFORMAT("VBR -V{} (~{} kbit)")(q, q_table[q]);
		}
	}
#endif // MPT_WITH_LAME
	return EncoderFactoryBase::DescribeQuality(quality);
}

mpt::ustring MP3Encoder::DescribeBitrateABR(int bitrate) const
{
	return EncoderFactoryBase::DescribeBitrateABR(bitrate);
}



OPENMPT_NAMESPACE_END