Cool_Tools/winamp
1
0
Fork 0
mirror of https://github.com/WinampDesktop/winamp.git synced 2024-12-19 18:15:52 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
09cb3a54ed
winamp/Src/external_dependencies/openmpt-trunk/mptrack/StreamEncoderMP3.cpp
Jef 20d28e80a5 Initial community commit
2024-09-24 14:54:57 +02:00

742 lines
20 KiB
C++
Raw Blame History

/*
* 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
Reference in New Issue View Git Blame Copy Permalink