Rename onChunkRead to onNewChunk

client/stream.cpp

@@ -27,6 +27,7 @@
 #include <iostream>
 #include <string.h>
 
+
 using namespace std;
 namespace cs = chronos;
 

common/message/pcm_chunk.hpp

@@ -134,7 +134,7 @@ public:
     SampleFormat format;
 
 private:
-    uint32_t idx_;
+    uint32_t idx_ = 0;
 };
 } // namespace msg
 

server/encoder/pcm_encoder.cpp

@@ -49,6 +49,7 @@ PcmEncoder::PcmEncoder(const std::string& codecOptions) : Encoder(codecOptions)
 
 void PcmEncoder::encode(const msg::PcmChunk* chunk)
 {
+    // copy the chunk into a shared_ptr
     auto pcmChunk = std::make_shared<msg::PcmChunk>(*chunk);
     listener_->onChunkEncoded(this, pcmChunk, pcmChunk->durationMs());
 }

server/streamreader/asio_stream.hpp

@@ -197,7 +197,7 @@ void AsioStream<ReadStream>::do_read()
                                     nextTick_ = std::chrono::steady_clock::now();
                                 }
 
-                                encoder_->encode(chunk_.get());
+                                onChunkRead(chunk_.get());
                                 nextTick_ += chunk_->duration<std::chrono::nanoseconds>();
                                 auto currentTick = std::chrono::steady_clock::now();
 

server/streamreader/pcm_stream.cpp

@@ -133,13 +133,21 @@ void PcmStream::onChunkEncoded(const encoder::Encoder* /*encoder*/, std::shared_
     if (duration <= 0)
         return;
 
+    // absolute start timestamp is the tvEncodedChunk_
     auto microsecs = std::chrono::duration_cast<std::chrono::microseconds>(tvEncodedChunk_.time_since_epoch()).count();
     chunk->timestamp.sec = microsecs / 1000000;
     chunk->timestamp.usec = microsecs % 1000000;
 
+    // update tvEncodedChunk_ to the next chunk start by adding the current chunk duration
     tvEncodedChunk_ += std::chrono::nanoseconds(static_cast<std::chrono::nanoseconds::rep>(duration * 1000000));
     if (pcmListener_)
-        pcmListener_->onChunkRead(this, chunk, duration);
+        pcmListener_->onNewChunk(this, chunk, duration);
+}
+
+
+void PcmStream::onChunkRead(const msg::PcmChunk* chunk)
+{
+    encoder_->encode(chunk);
 }
 
 

server/streamreader/pcm_stream.hpp

@@ -61,7 +61,7 @@ class PcmListener
 public:
     virtual void onMetaChanged(const PcmStream* pcmStream) = 0;
     virtual void onStateChanged(const PcmStream* pcmStream, const ReaderState& state) = 0;
-    virtual void onChunkRead(const PcmStream* pcmStream, std::shared_ptr<msg::PcmChunk> chunk, double duration) = 0;
+    virtual void onNewChunk(const PcmStream* pcmStream, std::shared_ptr<msg::PcmChunk> chunk, double duration) = 0;
     virtual void onResync(const PcmStream* pcmStream, double ms) = 0;
 };
 
@@ -102,6 +102,7 @@ protected:
     std::atomic<bool> active_;
 
     void setState(const ReaderState& newState);
+    virtual void onChunkRead(const msg::PcmChunk* chunk);
 
     std::chrono::time_point<std::chrono::steady_clock> tvEncodedChunk_;
     PcmListener* pcmListener_;

server/streamreader/posix_stream.cpp

@@ -123,7 +123,7 @@ void PosixStream::do_read()
         if ((idle_bytes_ == 0) || (idle_bytes_ <= max_idle_bytes_))
         {
             // the encoder will update the tvEncodedChunk when a chunk is encoded
-            encoder_->encode(chunk_.get());
+            onChunkRead(chunk_.get());
         }
         else
         {