AudioEncodedServerT.h

Go to the documentation of this file.

#pragma once
 
#include "AudioServerT.h"
 
namespace audio_tools {
 
template <class Client, class Server>
class AudioEncoderServerT : public AudioServerT<Client, Server> {
 public:
  AudioEncoderServerT(AudioEncoder *encoder, int port = 80) : AudioServerT<Client, Server>(port) {
    this->encoder = encoder;
  }
 
  AudioEncoderServerT(AudioEncoder *encoder, const char *network,
                     const char *password, int port = 80)
      : AudioServerT<Client, Server>(network, password, port) {
    this->encoder = encoder;
  }
 
  virtual ~AudioEncoderServerT() = default;
 
  bool begin(Stream &in, int sample_rate, int channels,
             int bits_per_sample = 16, BaseConverter *converter = nullptr) {
    TRACED();
    this->in = &in;
    AudioServerT<Client, Server>::setConverter(converter);
    audio_info.sample_rate = sample_rate;
    audio_info.channels = channels;
    audio_info.bits_per_sample = bits_per_sample;
    encoder->setAudioInfo(audio_info);
    // encoded_stream.begin(&client_obj, encoder);
    encoded_stream.setOutput(&this->client_obj);
    encoded_stream.setEncoder(encoder);
    encoded_stream.begin(audio_info);
    return AudioServerT<Client, Server>::begin(in, encoder->mime());
  }
 
  bool begin(Stream &in, AudioInfo info, BaseConverter *converter = nullptr) {
    TRACED();
    this->in = &in;
    this->audio_info = info;
    AudioServerT<Client, Server>::setConverter(converter);
    encoder->setAudioInfo(audio_info);
    encoded_stream.setOutput(&this->client_obj);
    encoded_stream.setEncoder(encoder);
    if (!encoded_stream.begin(audio_info)) {
      LOGE("encoder begin failed");
      // stop();
    }
 
    return AudioServerT<Client, Server>::begin(in, encoder->mime());
  }
 
  bool begin(AudioStream &in, BaseConverter *converter = nullptr) {
    TRACED();
    this->in = &in;
    this->audio_info = in.audioInfo();
    AudioServerT<Client, Server>::setConverter(converter);
    encoder->setAudioInfo(audio_info);
    encoded_stream.setOutput(&this->client_obj);
    encoded_stream.setEncoder(encoder);
    encoded_stream.begin(audio_info);
 
    return AudioServerT<Client, Server>::begin(in, encoder->mime());
  }
 
  bool begin(AudioServerDataCallback cb, int sample_rate, int channels,
             int bits_per_sample = 16) {
    TRACED();
    audio_info.sample_rate = sample_rate;
    audio_info.channels = channels;
    audio_info.bits_per_sample = bits_per_sample;
    encoder->setAudioInfo(audio_info);
    encoded_stream.setAudioInfo(audio_info);
 
    return AudioServerT<Client, Server>::begin(cb, encoder->mime());
  }
 
  bool begin(AudioServerDataCallback cb, AudioInfo info) {
    TRACED();
    audio_info = info;
    encoder->setAudioInfo(audio_info);
    encoded_stream.setAudioInfo(audio_info);
 
    return AudioServerT<Client, Server>::begin(cb, encoder->mime());
  }
 
  // provides a pointer to the encoder
  AudioEncoder *audioEncoder() { return encoder; }
 
 protected:
  // Sound Generation - use EncodedAudioOutput with is more efficient then
  // EncodedAudioStream
  EncodedAudioOutput encoded_stream;
  AudioInfo audio_info;
  AudioEncoder *encoder = nullptr;
 
  // moved to be part of reply content to avoid timeout issues in Chrome
  void sendReplyHeader() override {}
 
  void sendReplyContent() override {
    TRACED();
    // restart encoder
    if (encoder) {
      encoder->end();
      encoder->begin();
    }
 
    // if chunked transfer is active, the encoder must write into the
    // chunked framing wrapper instead of directly into the client
    Print *p_out = this->out_ptr();
    if (this->isChunked()) {
      this->chunked_print.begin(*this->out_ptr());
      p_out = &this->chunked_print;
    }
 
    if (this->callback != nullptr) {
      // encoded_stream.begin(out_ptr(), encoder);
      encoded_stream.setOutput(p_out);
      encoded_stream.setEncoder(encoder);
      encoded_stream.begin();
 
      // provide data via Callback to encoded_stream
      LOGI("sendReply - calling callback");
      // Send delayed header
      AudioServerT<Client, Server>::sendReplyHeader();
      this->callback(&encoded_stream);
      this->endChunked();
      this->client_obj.stop();
    } else if (this->in != nullptr) {
      // provide data for stream: in -copy>  encoded_stream -> out
      LOGI("sendReply - Returning encoded stream...");
      // encoded_stream.begin(out_ptr(), encoder);
      encoded_stream.setOutput(p_out);
      encoded_stream.setEncoder(encoder);
      encoded_stream.begin();
 
      this->copier.begin(encoded_stream, *this->in);
      if (!this->client_obj.connected()) {
        LOGE("connection was closed");
      }
      // Send delayed header
      AudioServerT<Client, Server>::sendReplyHeader();
    }
  }
};
 
template <class Client, class Server>
class AudioWAVServerT : public AudioEncoderServerT<Client, Server> {
 public:
  AudioWAVServerT(int port = 80) : AudioEncoderServerT<Client, Server>(new WAVEncoder(), port) {}
 
  AudioWAVServerT(const char *network, const char *password, int port = 80)
      : AudioEncoderServerT<Client, Server>(new WAVEncoder(), network, password, port) {}
 
  ~AudioWAVServerT() {
    AudioEncoder *encoder = AudioEncoderServerT<Client, Server>::audioEncoder();
    if (encoder != nullptr) {
      delete encoder;
    }
  }
 
  // provides a pointer to the encoder
  WAVEncoder &wavEncoder() { return *static_cast<WAVEncoder *>(AudioEncoderServerT<Client, Server>::encoder); }
};
 
 
 
} // namespace audio_tools