From c0057d2575d82b10bc31c854338d5078906c5c4e Mon Sep 17 00:00:00 2001 From: badaix Date: Sun, 26 Jul 2015 18:12:06 +0200 Subject: [PATCH] callback based encoding --- server/encoder.h | 36 ++++++++++++++++------ server/encoderFactory.cpp | 65 +++++++++++++++++++++++++++++++++++++++ server/encoderFactory.h | 15 +++++++++ server/flacEncoder.cpp | 56 +++++++++++++++++---------------- server/flacEncoder.h | 19 ++++++------ server/oggEncoder.cpp | 47 ++++++++++++++++------------ server/oggEncoder.h | 11 ++++--- server/pcmEncoder.cpp | 14 +++++++-- server/pcmEncoder.h | 5 +-- 9 files changed, 193 insertions(+), 75 deletions(-) create mode 100644 server/encoderFactory.cpp create mode 100644 server/encoderFactory.h diff --git a/server/encoder.h b/server/encoder.h index d9f8eacb..efc6e709 100644 --- a/server/encoder.h +++ b/server/encoder.h @@ -18,16 +18,29 @@ #ifndef ENCODER_H #define ENCODER_H + +#include +#include + #include "message/pcmChunk.h" #include "message/header.h" #include "message/sampleFormat.h" -#include + + +class Encoder; + +class EncoderListener +{ +public: + virtual void onChunkEncoded(const Encoder* encoder, msg::PcmChunk* chunk, double duration) = 0; +}; + class Encoder { public: - Encoder() : headerChunk_(NULL) + Encoder(const std::string& codecOptions = "") : headerChunk_(NULL), codecOptions_(codecOptions) { } @@ -37,28 +50,30 @@ public: delete headerChunk_; } - virtual void init(const msg::SampleFormat& format, const std::string codecOptions = "") + virtual void init(EncoderListener* listener, const msg::SampleFormat& format) { - sampleFormat_ = format; - codecOptions_ = codecOptions; - if (codecOptions == "") + if (codecOptions_ == "") codecOptions_ = getDefaultOptions(); + listener_ = listener; + sampleFormat_ = format; initEncoder(); } - virtual double encode(msg::PcmChunk* chunk) = 0; + virtual void encode(const msg::PcmChunk* chunk) = 0; - virtual std::string getAvailableOptions() + virtual std::string name() const = 0; + + virtual std::string getAvailableOptions() const { return "No codec options supported"; } - virtual std::string getDefaultOptions() + virtual std::string getDefaultOptions() const { return ""; } - virtual msg::Header* getHeader() + virtual msg::Header* getHeader() const { return headerChunk_; } @@ -68,6 +83,7 @@ protected: msg::SampleFormat sampleFormat_; msg::Header* headerChunk_; + EncoderListener* listener_; std::string codecOptions_; }; diff --git a/server/encoderFactory.cpp b/server/encoderFactory.cpp new file mode 100644 index 00000000..a1fb34f0 --- /dev/null +++ b/server/encoderFactory.cpp @@ -0,0 +1,65 @@ +/*** + This file is part of snapcast + Copyright (C) 2015 Johannes Pohl + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +***/ + +#include "encoderFactory.h" +#include "common/utils.h" +#include "pcmEncoder.h" +#include "oggEncoder.h" +#include "flacEncoder.h" + + +using namespace std; + + +Encoder* EncoderFactory::createEncoder(const std::string& codecSettings) const +{ + Encoder* encoder; + std::string codec(codecSettings); + std::string codecOptions; + if (codec.find(":") != std::string::npos) + { + codecOptions = trim_copy(codec.substr(codec.find(":") + 1)); + codec = trim_copy(codec.substr(0, codec.find(":"))); + } + if (codec == "ogg") + encoder = new OggEncoder(codecOptions); + else if (codec == "pcm") + encoder = new PcmEncoder(codecOptions); + else if (codec == "flac") + encoder = new FlacEncoder(codecOptions); + else + { + cout << "unknown codec: " << codec << "\n"; + return NULL; + } + + return encoder; +/* try + { + encoder->init(NULL, format, codecOptions); + } + catch (const std::exception& e) + { + cout << "Error: " << e.what() << "\n"; + return 1; + } +*/ +} + + + diff --git a/server/encoderFactory.h b/server/encoderFactory.h new file mode 100644 index 00000000..9bdb47f2 --- /dev/null +++ b/server/encoderFactory.h @@ -0,0 +1,15 @@ +#ifndef ENCODER_FACTORY_H +#define ENCODER_FACTORY_H + +#include +#include "encoder.h" + +class EncoderFactory +{ +public: +// EncoderFactory(const std::string& codecSettings); + Encoder* createEncoder(const std::string& codecSettings) const; +}; + + +#endif diff --git a/server/flacEncoder.cpp b/server/flacEncoder.cpp index b4c2d4c9..ec67d0d5 100644 --- a/server/flacEncoder.cpp +++ b/server/flacEncoder.cpp @@ -26,9 +26,9 @@ using namespace std; -FlacEncoder::FlacEncoder() : Encoder(), encoder_(NULL), pcmBufferSize_(0), encodedSamples_(0) +FlacEncoder::FlacEncoder(const std::string& codecOptions) : Encoder(codecOptions), encoder_(NULL), pcmBufferSize_(0), encodedSamples_(0) { - encodedChunk_ = new msg::PcmChunk(); + flacChunk_ = new msg::PcmChunk(); headerChunk_ = new msg::Header("flac"); pcmBuffer_ = (FLAC__int32*)malloc(pcmBufferSize_ * sizeof(FLAC__int32)); } @@ -44,55 +44,57 @@ FlacEncoder::~FlacEncoder() FLAC__stream_encoder_delete(encoder_); } - delete encodedChunk_; + if (flacChunk_) + delete flacChunk_; free(pcmBuffer_); } -std::string FlacEncoder::getAvailableOptions() +std::string FlacEncoder::getAvailableOptions() const { return "compression level: [0..8]"; } -std::string FlacEncoder::getDefaultOptions() +std::string FlacEncoder::getDefaultOptions() const { return "2"; } -double FlacEncoder::encode(msg::PcmChunk* chunk) +std::string FlacEncoder::name() const +{ + return "flac"; +} + + +void FlacEncoder::encode(const msg::PcmChunk* chunk) { int samples = chunk->getSampleCount(); int frames = chunk->getFrameCount(); - logD << "payload: " << chunk->payloadSize << "\tframes: " << frames << "\tsamples: " << samples << "\tduration: " << chunk->duration().count() << "\n"; +// logO << "payload: " << chunk->payloadSize << "\tframes: " << frames << "\tsamples: " << samples << "\tduration: " << chunk->duration().count() << "\n"; if (pcmBufferSize_ < samples) { pcmBufferSize_ = samples; pcmBuffer_ = (FLAC__int32*)realloc(pcmBuffer_, pcmBufferSize_ * sizeof(FLAC__int32)); } - + for(int i=0; ipayload[2*i+1] << 8) | (FLAC__int16)(0x00ff&chunk->payload[2*i])); } - + FLAC__stream_encoder_process_interleaved(encoder_, pcmBuffer_, frames); - double resMs = encodedSamples_ / ((double)sampleFormat_.rate / 1000.); if (encodedSamples_ > 0) { - logD << "encoded: " << chunk->payloadSize << "\tframes: " << encodedSamples_ << "\tres: " << resMs << "\n"; + double resMs = encodedSamples_ / ((double)sampleFormat_.rate / 1000.); +// logO << "encoded: " << chunk->payloadSize << "\tframes: " << encodedSamples_ << "\tres: " << resMs << "\n"; encodedSamples_ = 0; - chunk->payloadSize = encodedChunk_->payloadSize; - chunk->payload = (char*)realloc(chunk->payload, encodedChunk_->payloadSize); - memcpy(chunk->payload, encodedChunk_->payload, encodedChunk_->payloadSize); - encodedChunk_->payloadSize = 0; - encodedChunk_->payload = (char*)realloc(encodedChunk_->payload, 0); + listener_->onChunkEncoded(this, flacChunk_, resMs); + flacChunk_ = new msg::PcmChunk(); } - - return resMs;//chunk->duration().count(); } @@ -102,7 +104,7 @@ FLAC__StreamEncoderWriteStatus FlacEncoder::write_callback(const FLAC__StreamEnc unsigned samples, unsigned current_frame) { - logD << "write_callback: " << bytes << ", " << samples << ", " << current_frame << "\n"; +// logO << "write_callback: " << bytes << ", " << samples << ", " << current_frame << "\n"; if ((current_frame == 0) && (bytes > 0) && (samples == 0)) { headerChunk_->payload = (char*)realloc(headerChunk_->payload, headerChunk_->payloadSize + bytes); @@ -111,9 +113,9 @@ FLAC__StreamEncoderWriteStatus FlacEncoder::write_callback(const FLAC__StreamEnc } else { - encodedChunk_->payload = (char*)realloc(encodedChunk_->payload, encodedChunk_->payloadSize + bytes); - memcpy(encodedChunk_->payload + encodedChunk_->payloadSize, buffer, bytes); - encodedChunk_->payloadSize += bytes; + flacChunk_->payload = (char*)realloc(flacChunk_->payload, flacChunk_->payloadSize + bytes); + memcpy(flacChunk_->payload + flacChunk_->payloadSize, buffer, bytes); + flacChunk_->payloadSize += bytes; encodedSamples_ += samples; } return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; @@ -128,7 +130,7 @@ FLAC__StreamEncoderWriteStatus write_callback(const FLAC__StreamEncoder *encoder void *client_data) { FlacEncoder* flacEncoder = (FlacEncoder*)client_data; - return flacEncoder->write_callback(encoder, buffer, bytes, samples, current_frame); + return flacEncoder->write_callback(encoder, buffer, bytes, samples, current_frame); } @@ -153,7 +155,7 @@ void FlacEncoder::initEncoder() FLAC__StreamMetadata_VorbisComment_Entry entry; // allocate the encoder - if ((encoder_ = FLAC__stream_encoder_new()) == NULL) + if ((encoder_ = FLAC__stream_encoder_new()) == NULL) throw SnapException("error allocating encoder"); ok &= FLAC__stream_encoder_set_verify(encoder_, true); @@ -176,10 +178,10 @@ void FlacEncoder::initEncoder() (metadata_[1] = FLAC__metadata_object_new(FLAC__METADATA_TYPE_PADDING)) == NULL || // there are many tag (vorbiscomment) functions but these are convenient for this particular use: !FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, "TITLE", "SnapStream") || - !FLAC__metadata_object_vorbiscomment_append_comment(metadata_[0], entry, false) || + !FLAC__metadata_object_vorbiscomment_append_comment(metadata_[0], entry, false) || !FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(&entry, "VERSION", VERSION) || !FLAC__metadata_object_vorbiscomment_append_comment(metadata_[0], entry, false) - ) + ) throw SnapException("out of memory or tag error"); metadata_[1]->length = 1234; // set the padding length @@ -189,7 +191,7 @@ void FlacEncoder::initEncoder() // initialize encoder init_status = FLAC__stream_encoder_init_stream(encoder_, ::write_callback, NULL, NULL, NULL, this); - if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) + if(init_status != FLAC__STREAM_ENCODER_INIT_STATUS_OK) throw SnapException("ERROR: initializing encoder: " + string(FLAC__StreamEncoderInitStatusString[init_status])); } diff --git a/server/flacEncoder.h b/server/flacEncoder.h index 7fbab80a..d646b36a 100644 --- a/server/flacEncoder.h +++ b/server/flacEncoder.h @@ -30,24 +30,25 @@ class FlacEncoder : public Encoder { public: - FlacEncoder(); + FlacEncoder(const std::string& codecOptions = ""); ~FlacEncoder(); - virtual double encode(msg::PcmChunk* chunk); - virtual std::string getAvailableOptions(); - virtual std::string getDefaultOptions(); + virtual void encode(const msg::PcmChunk* chunk); + virtual std::string getAvailableOptions() const; + virtual std::string getDefaultOptions() const; + virtual std::string name() const; FLAC__StreamEncoderWriteStatus write_callback(const FLAC__StreamEncoder *encoder, const FLAC__byte buffer[], size_t bytes, unsigned samples, unsigned current_frame); - + protected: virtual void initEncoder(); - + FLAC__StreamEncoder *encoder_; FLAC__StreamMetadata *metadata_[2]; - + FLAC__int32 *pcmBuffer_; int pcmBufferSize_; - - msg::PcmChunk* encodedChunk_; + + msg::PcmChunk* flacChunk_; size_t encodedSamples_; }; diff --git a/server/oggEncoder.cpp b/server/oggEncoder.cpp index a79ac2e3..cefbc67c 100644 --- a/server/oggEncoder.cpp +++ b/server/oggEncoder.cpp @@ -28,24 +28,30 @@ using namespace std; -OggEncoder::OggEncoder() : Encoder(), lastGranulepos(0), eos(0) +OggEncoder::OggEncoder(const std::string& codecOptions) : Encoder(codecOptions), lastGranulepos(0), eos(0) { } -std::string OggEncoder::getAvailableOptions() +std::string OggEncoder::getAvailableOptions() const { return "VBR:[-0.1 - 1.0]"; } -std::string OggEncoder::getDefaultOptions() +std::string OggEncoder::getDefaultOptions() const { return "VBR:0.9"; } -double OggEncoder::encode(msg::PcmChunk* chunk) +std::string OggEncoder::name() const +{ + return "ogg"; +} + + +void OggEncoder::encode(const msg::PcmChunk* chunk) { double res = 0; logD << "payload: " << chunk->payloadSize << "\tframes: " << chunk->getFrameCount() << "\tduration: " << chunk->duration().count() << "\n"; @@ -63,6 +69,8 @@ double OggEncoder::encode(msg::PcmChunk* chunk) /* tell the library how much we actually submitted */ vorbis_analysis_wrote(&vd, bytes); + msg::PcmChunk* oggChunk = new msg::PcmChunk(chunk->format, 0); + /* vorbis does some data preanalysis, then divvies up blocks for more involved (potentially parallel) processing. Get a single block for encoding now */ @@ -88,31 +96,32 @@ double OggEncoder::encode(msg::PcmChunk* chunk) size_t nextLen = pos + og.header_len + og.body_len; // make chunk larger - if (chunk->payloadSize < nextLen) - chunk->payload = (char*)realloc(chunk->payload, nextLen); + if (oggChunk->payloadSize < nextLen) + oggChunk->payload = (char*)realloc(oggChunk->payload, nextLen); - memcpy(chunk->payload + pos, og.header, og.header_len); + memcpy(oggChunk->payload + pos, og.header, og.header_len); pos += og.header_len; - memcpy(chunk->payload + pos, og.body, og.body_len); + memcpy(oggChunk->payload + pos, og.body, og.body_len); pos += og.body_len; - + if (ogg_page_eos(&og)) break; } } } - + if (res > 0) { res /= (sampleFormat_.rate / 1000.); - logD << "res: " << res << "\n"; + logO << "res: " << res << "\n"; lastGranulepos = os.granulepos; - // make chunk smaller - chunk->payload = (char*)realloc(chunk->payload, pos); - chunk->payloadSize = pos; + // make oggChunk smaller + oggChunk->payload = (char*)realloc(oggChunk->payload, pos); + oggChunk->payloadSize = pos; + listener_->onChunkEncoded(this, oggChunk, res); } - - return res; + else + delete oggChunk; } @@ -123,7 +132,7 @@ void OggEncoder::initEncoder() string mode = trim_copy(codecOptions_.substr(0, codecOptions_.find(":"))); if (mode != "VBR") throw SnapException("Unsupported codec mode: \"" + mode + "\". Available: \"VBR\""); - + string qual = trim_copy(codecOptions_.substr(codecOptions_.find(":") + 1)); double quality = 1.0; try @@ -138,7 +147,7 @@ void OggEncoder::initEncoder() { throw SnapException("compression level has to be between -0.1 and 1.0"); } - + /********** Encode setup ************/ vorbis_info_init(&vi); @@ -205,7 +214,7 @@ void OggEncoder::initEncoder() ogg_packet header; ogg_packet header_comm; ogg_packet header_code; - + vorbis_analysis_headerout(&vd,&vc,&header,&header_comm,&header_code); ogg_stream_packetin(&os,&header); ogg_stream_packetin(&os,&header_comm); diff --git a/server/oggEncoder.h b/server/oggEncoder.h index ad426515..59882275 100644 --- a/server/oggEncoder.h +++ b/server/oggEncoder.h @@ -25,13 +25,14 @@ class OggEncoder : public Encoder { public: - OggEncoder(); - virtual double encode(msg::PcmChunk* chunk); - virtual std::string getAvailableOptions(); - virtual std::string getDefaultOptions(); + OggEncoder(const std::string& codecOptions = ""); + virtual void encode(const msg::PcmChunk* chunk); + virtual std::string getAvailableOptions() const; + virtual std::string getDefaultOptions() const; + virtual std::string name() const; protected: - virtual void initEncoder(); + virtual void initEncoder(); private: ogg_stream_state os; /* take physical pages, weld into a logical diff --git a/server/pcmEncoder.cpp b/server/pcmEncoder.cpp index c7541ef4..8ba552da 100644 --- a/server/pcmEncoder.cpp +++ b/server/pcmEncoder.cpp @@ -16,17 +16,19 @@ along with this program. If not, see . ***/ +#include #include "pcmEncoder.h" -PcmEncoder::PcmEncoder() : Encoder() +PcmEncoder::PcmEncoder(const std::string& codecOptions) : Encoder(codecOptions) { headerChunk_ = new msg::Header("pcm"); } -double PcmEncoder::encode(msg::PcmChunk* chunk) +void PcmEncoder::encode(const msg::PcmChunk* chunk) { - return chunk->duration().count(); + msg::PcmChunk* pcmChunk = new msg::PcmChunk(*chunk); + listener_->onChunkEncoded(this, pcmChunk, pcmChunk->duration().count()); } @@ -35,3 +37,9 @@ void PcmEncoder::initEncoder() } +std::string PcmEncoder::name() const +{ + return "pcm"; +} + + diff --git a/server/pcmEncoder.h b/server/pcmEncoder.h index c4e767c7..45447404 100644 --- a/server/pcmEncoder.h +++ b/server/pcmEncoder.h @@ -24,8 +24,9 @@ class PcmEncoder : public Encoder { public: - PcmEncoder(); - virtual double encode(msg::PcmChunk* chunk); + PcmEncoder(const std::string& codecOptions = ""); + virtual void encode(const msg::PcmChunk* chunk); + virtual std::string name() const; protected: virtual void initEncoder();