winamp/Src/external_dependencies/openmpt-trunk/mptrack/StreamEncoderFLAC.cpp

220 lines
7.4 KiB
C++

/*
* 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 "StreamEncoderFLAC.h"
#include "Mptrack.h"
#include "TrackerSettings.h"
#include <FLAC/metadata.h>
#include <FLAC/format.h>
#include <FLAC/stream_encoder.h>
OPENMPT_NAMESPACE_BEGIN
class FLACStreamWriter : public StreamWriterBase
{
private:
const FLACEncoder &enc;
Encoder::Settings settings;
FLAC__StreamMetadata *flac_metadata[1];
FLAC__StreamEncoder *encoder;
std::vector<FLAC__int32> sampleBuf;
private:
static FLAC__StreamEncoderWriteStatus FLACWriteCallback(const FLAC__StreamEncoder *flacenc, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame, void *client_data)
{
return reinterpret_cast<FLACStreamWriter*>(client_data)->WriteCallback(flacenc, buffer, bytes, samples, current_frame);
}
static FLAC__StreamEncoderSeekStatus FLACSeekCallback(const FLAC__StreamEncoder *flacenc, FLAC__uint64 absolute_byte_offset, void *client_data)
{
return reinterpret_cast<FLACStreamWriter*>(client_data)->SeekCallback(flacenc, absolute_byte_offset);
}
static FLAC__StreamEncoderTellStatus FLACTellCallback(const FLAC__StreamEncoder *flacenc, FLAC__uint64 *absolute_byte_offset, void *client_data)
{
return reinterpret_cast<FLACStreamWriter*>(client_data)->TellCallback(flacenc, absolute_byte_offset);
}
FLAC__StreamEncoderWriteStatus WriteCallback(const FLAC__StreamEncoder *flacenc, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame)
{
MPT_UNREFERENCED_PARAMETER(flacenc);
MPT_UNREFERENCED_PARAMETER(samples);
MPT_UNREFERENCED_PARAMETER(current_frame);
f.write(reinterpret_cast<const char*>(buffer), bytes);
if(!f) return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
}
FLAC__StreamEncoderSeekStatus SeekCallback(const FLAC__StreamEncoder *flacenc, FLAC__uint64 absolute_byte_offset)
{
MPT_UNREFERENCED_PARAMETER(flacenc);
f.seekp(absolute_byte_offset);
if(!f) return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR;
return FLAC__STREAM_ENCODER_SEEK_STATUS_OK;
}
FLAC__StreamEncoderTellStatus TellCallback(const FLAC__StreamEncoder *flacenc, FLAC__uint64 *absolute_byte_offset)
{
MPT_UNREFERENCED_PARAMETER(flacenc);
if(absolute_byte_offset)
{
*absolute_byte_offset = f.tellp();
}
if(!f) return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR;
return FLAC__STREAM_ENCODER_TELL_STATUS_OK;
}
private:
void AddCommentField(const std::string &field, const mpt::ustring &data)
{
if(!field.empty() && !data.empty())
{
FLAC__StreamMetadata_VorbisComment_Entry entry;
FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, field.c_str(), mpt::ToCharset(mpt::Charset::UTF8, data).c_str());
FLAC__metadata_object_vorbiscomment_append_comment(flac_metadata[0], entry, false);
}
}
public:
FLACStreamWriter(const FLACEncoder &enc_, std::ostream &stream, const Encoder::Settings &settings_, const FileTags &tags)
: StreamWriterBase(stream)
, enc(enc_)
, settings(settings_)
{
flac_metadata[0] = nullptr;
encoder = nullptr;
MPT_ASSERT(settings.Format.GetSampleFormat().IsValid());
MPT_ASSERT(settings.Samplerate > 0);
MPT_ASSERT(settings.Channels > 0);
encoder = FLAC__stream_encoder_new();
FLAC__stream_encoder_set_channels(encoder, settings.Channels);
FLAC__stream_encoder_set_bits_per_sample(encoder, settings.Format.GetSampleFormat().GetBitsPerSample());
FLAC__stream_encoder_set_sample_rate(encoder, settings.Samplerate);
int compressionLevel = settings.Details.FLACCompressionLevel;
FLAC__stream_encoder_set_compression_level(encoder, compressionLevel);
if(settings.Tags)
{
flac_metadata[0] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_VORBIS_COMMENT);
AddCommentField("ENCODER", tags.encoder);
AddCommentField("SOURCEMEDIA", U_("tracked music file"));
AddCommentField("TITLE", tags.title );
AddCommentField("ARTIST", tags.artist );
AddCommentField("ALBUM", tags.album );
AddCommentField("DATE", tags.year );
AddCommentField("COMMENT", tags.comments );
AddCommentField("GENRE", tags.genre );
AddCommentField("CONTACT", tags.url );
AddCommentField("BPM", tags.bpm ); // non-standard
AddCommentField("TRACKNUMBER", tags.trackno );
FLAC__stream_encoder_set_metadata(encoder, flac_metadata, 1);
}
FLAC__stream_encoder_init_stream(encoder, FLACWriteCallback, FLACSeekCallback, FLACTellCallback, nullptr, this);
}
SampleFormat GetSampleFormat() const
{
return settings.Format.GetSampleFormat();
}
template <typename Tsample>
void WriteInterleavedInt(std::size_t frameCount, const Tsample *p)
{
MPT_ASSERT(settings.Format.GetSampleFormat() == SampleFormatTraits<Tsample>::sampleFormat());
sampleBuf.resize(frameCount * settings.Channels);
for(std::size_t frame = 0; frame < frameCount; ++frame)
{
for(int channel = 0; channel < settings.Channels; ++channel)
{
sampleBuf[frame * settings.Channels + channel] = *p;
p++;
}
}
while(frameCount > 0)
{
unsigned int frameCountChunk = mpt::saturate_cast<unsigned int>(frameCount);
FLAC__stream_encoder_process_interleaved(encoder, sampleBuf.data(), frameCountChunk);
frameCount -= frameCountChunk;
}
}
void WriteInterleaved(std::size_t frameCount, const int8 *interleaved) override
{
WriteInterleavedInt(frameCount, interleaved);
}
void WriteInterleaved(std::size_t frameCount, const int16 *interleaved) override
{
WriteInterleavedInt(frameCount, interleaved);
}
void WriteInterleaved(std::size_t frameCount, const int24 *interleaved) override
{
WriteInterleavedInt(frameCount, interleaved);
}
void WriteFinalize() override
{
FLAC__stream_encoder_finish(encoder);
}
virtual ~FLACStreamWriter()
{
FLAC__stream_encoder_delete(encoder);
encoder = nullptr;
if(flac_metadata[0])
{
FLAC__metadata_object_delete(flac_metadata[0]);
flac_metadata[0] = nullptr;
}
}
};
FLACEncoder::FLACEncoder()
{
Encoder::Traits traits;
traits.fileExtension = P_("flac");
traits.fileShortDescription = U_("FLAC");
traits.fileDescription = U_("Free Lossless Audio Codec");
traits.encoderSettingsName = U_("FLAC");
traits.canTags = true;
traits.maxChannels = 4;
traits.samplerates = TrackerSettings::Instance().GetSampleRates();
traits.modes = Encoder::ModeLossless;
traits.formats.push_back({ Encoder::Format::Encoding::Integer, 24, mpt::get_endian() });
traits.formats.push_back({ Encoder::Format::Encoding::Integer, 16, mpt::get_endian() });
traits.formats.push_back({ Encoder::Format::Encoding::Integer, 8, mpt::get_endian() });
traits.defaultSamplerate = 48000;
traits.defaultChannels = 2;
traits.defaultMode = Encoder::ModeLossless;
traits.defaultFormat = { Encoder::Format::Encoding::Integer, 24, mpt::get_endian() };
SetTraits(traits);
}
bool FLACEncoder::IsAvailable() const
{
return true;
}
std::unique_ptr<IAudioStreamEncoder> FLACEncoder::ConstructStreamEncoder(std::ostream &file, const Encoder::Settings &settings, const FileTags &tags) const
{
if(!IsAvailable())
{
return nullptr;
}
return std::make_unique<FLACStreamWriter>(*this, file, settings, tags);
}
OPENMPT_NAMESPACE_END