DRAFT HLSStreamESP32

Author: pschatzmann

src/AudioTools/AudioLibs/HLSStream.h

@@ -1,9 +1,9 @@
 #pragma once
-#include "AudioToolsConfig.h"
 #include "AudioTools/AudioCodecs/AudioEncoded.h"
 #include "AudioTools/CoreAudio/AudioBasic/Str.h"
 #include "AudioTools/CoreAudio/AudioHttp/URLStream.h"
 #include "AudioTools/CoreAudio/StreamCopy.h"
+#include "AudioToolsConfig.h"
 
 #define MAX_HLS_LINE 512
 #define START_URLS_LIMIT 4
@@ -24,6 +24,7 @@ namespace audio_tools_hls {
  * @copyright GPLv3
  */
 
+template <typename URLStream>
 class URLLoaderHLS {
  public:
   URLLoaderHLS() = default;
@@ -81,15 +82,13 @@ class URLLoaderHLS {
     return url_stream.httpRequest().reply().get(CONTENT_TYPE);
   }
 
-  int contentLength() {
-    return url_stream.contentLength();
-  }
+  int contentLength() { return url_stream.contentLength(); }
 
   void setBufferSize(int size, int count) {
     buffer_size = size;
     buffer_count = count;
     // support call after begin()!
-    if (buffer.size()!=0){
+    if (buffer.size() != 0) {
       buffer.resize(buffer_size * buffer_count);
     }
   }
@@ -176,7 +175,7 @@ class URLLoaderHLS {
 class URLHistory {
  public:
   bool add(const char *url) {
-    if (url==nullptr) return true;
+    if (url == nullptr) return true;
     bool found = false;
     StrView url_str(url);
     for (int j = 0; j < history.size(); j++) {
@@ -206,10 +205,11 @@ class URLHistory {
 };
 
 /**
- * @brief Simple Parser for HLS data. 
+ * @brief Simple Parser for HLS data.
  * @author Phil Schatzmann
  * @copyright GPLv3
  */
+template <typename URLStream>
 class HLSParser {
  public:
   // loads the index url
@@ -222,6 +222,7 @@ class HLSParser {
     TRACEI();
     segments_url_str = "";
     bandwidth = 0;
+    total_read = 0;
 
     if (!parseIndex()) {
       TRACEE();
@@ -262,14 +263,13 @@ class HLSParser {
     reloadSegments();
 
     if (active) result = url_loader.readBytes(data, len);
+    total_read += result;
     return result;
   }
 
   const char *indexUrl() { return index_url_str; }
 
-  const char *segmentsUrl() {
-    return segments_url_str.c_str();
-  }
+  const char *segmentsUrl() { return segments_url_str.c_str(); }
 
   /// Provides the codec
   const char *getCodec() { return codec.c_str(); }
@@ -310,20 +310,26 @@ class HLSParser {
                                         const char *reqURL)) {
     resolve_url = cb;
   }
+  /// Provides the hls url as string
+  const char *urlStr() { return url_str.c_str(); }
 
- protected:
+  /// Povides the number of bytes read 
+  size_t totalRead() { return total_read; };
+ 
+  protected:
   enum class URLType { Undefined, Index, Segment };
   URLType next_url_type = URLType::Undefined;
   int bandwidth = 0;
   int url_count = 5;
+  size_t total_read = 0;
   bool url_active = false;
   bool is_extm3u = false;
   Str codec;
   Str segments_url_str;
   Str url_str;
   const char *index_url_str = nullptr;
   URLStream url_stream;
-  URLLoaderHLS url_loader;
+  URLLoaderHLS<URLStream> url_loader;
   URLHistory url_history;
   bool active = false;
   bool parse_segments_active = false;
@@ -531,7 +537,8 @@ class HLSParser {
     memset(tmp, 0, MAX_HLS_LINE);
     while (true) {
       memset(tmp, 0, MAX_HLS_LINE);
-      size_t len = url_stream.httpRequest().readBytesUntil('\n', tmp, MAX_HLS_LINE);
+      size_t len =
+          url_stream.httpRequest().readBytesUntil('\n', tmp, MAX_HLS_LINE);
       if (len == 0 && url_stream.available() == 0) break;
       StrView str(tmp);
 
@@ -633,13 +640,14 @@ namespace audio_tools {
  * @ingroup http *@copyright GPLv3
  */
 
-class HLSStream : public AbstractURLStream {
+template <typename URLStream>
+class HLSStreamT : public AbstractURLStream {
  public:
   /// Empty constructor
-  HLSStream() = default;
+  HLSStreamT() = default;
 
   /// Convenience constructor which logs in to the WiFi
-  HLSStream(const char *ssid, const char *password) {
+  HLSStreamT(const char *ssid, const char *password) {
     setSSID(ssid);
     setPassword(password);
   }
@@ -719,8 +727,16 @@ class HLSStream : public AbstractURLStream {
     parser.setURLResolver(cb);
   }
 
+  const char *urlStr() override { return parser.urlStr(); }
+
+  size_t totalRead() override { return parser.totalRead(); };
+  /// not implemented
+  void setConnectionClose(bool flag) override {};
+  /// not implemented
+  bool waitForData(int timeout) override { return false; }
+
  protected:
-  audio_tools_hls::HLSParser parser;
+  audio_tools_hls::HLSParser<URLStream> parser;
   const char *ssid = nullptr;
   const char *password = nullptr;
 
@@ -759,4 +775,6 @@ class HLSStream : public AbstractURLStream {
   void addRequestHeader(const char *header, const char *value) {}
 };
 
+using HLSStream = HLSStreamT<URLStream>;
+
 }  // namespace audio_tools

src/AudioTools/AudioLibs/HLSStreamESP32.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "AudioTools/CoreAudio/AudioHttp/URLStreamESP32.h"
+#include "HLSStream.h"
+
+namespace audio_tools {
+
+using HLSStreamESP32 = HLSStreamT<URLStreamESP32>;
+
+}  // namespace audio_tools

src/AudioTools/CoreAudio/AudioHttp/AbstractURLStream.h

@@ -52,9 +52,26 @@ class AbstractURLStream : public AudioStream {
 
   /// provides access to the HttpRequest
   virtual HttpRequest& httpRequest() = 0;
+
   /// (Re-)defines the client
   virtual void setClient(Client& clientPar) = 0;
 
+  /// Add Connection: close to request header
+  virtual void setConnectionClose(bool flag) = 0;
+
+  /// Provides the url as string
+  virtual const char* urlStr() = 0;
+
+  /// Total amout of data that was consumed so far
+  virtual size_t totalRead() = 0;
+
+  /// Provides the reported data size from the http reply
+  virtual int contentLength() = 0;
+ 
+  /// Waits the indicated time for the data to be available
+  /// waits for some data - returns false if the request has failed
+  virtual bool waitForData(int timeout) = 0;
+
 };
 
 

src/AudioTools/CoreAudio/AudioHttp/URLStream.h

@@ -230,12 +230,11 @@ class URLStream : public AbstractURLStream {
 
   void setWaitForData(bool flag) { wait_for_data = flag; }
 
-  int contentLength() { return size; }
-
-  size_t totalRead() { return total_read; }
+  int contentLength() override { return size; }
 
+  size_t totalRead() override { return total_read; }
   /// waits for some data - returns false if the request has failed
-  virtual bool waitForData(int timeout) {
+  bool waitForData (int timeout) override{
     TRACED();
     uint32_t end = millis() + timeout;
     if (request.available() == 0) {
@@ -254,10 +253,11 @@ class URLStream : public AbstractURLStream {
     return request.available() > 0;
   }
 
-  const char* urlStr() { return url_str.c_str(); }
+
+  const char* urlStr() override { return url_str.c_str(); }
 
 /// Define the Root PEM Certificate for SSL
-  void setCACert(const char* cert){
+  void setCACert(const char* cert) override{
   #ifdef USE_WIFI_CLIENT_SECURE
     if (clientSecure!=nullptr) clientSecure->setCACert(cert);
   #endif

src/AudioTools/CoreAudio/AudioHttp/URLStreamESP32.h

@@ -4,7 +4,6 @@
 #include "AudioTools/CoreAudio/AudioHttp/HttpRequest.h"
 #include "AudioTools/CoreAudio/AudioHttp/ICYStreamT.h"
 #include "AudioTools/CoreAudio/AudioHttp/URLStreamBufferedT.h"
-
 #include "esp_http_client.h"
 #include "esp_idf_version.h"
 #include "esp_system.h"
@@ -175,6 +174,9 @@ class URLStreamESP32 : public AbstractURLStream {
                      MethodID action = GET, const char* reqMime = "",
                      const char* reqData = "") {
     TRACED();
+    total_read = 0;
+    url_str = urlStr;
+    content_length = 0;
     // start wifi if necessary and possible
     if (ssid != nullptr) {
       if (!IDF_WIFI.begin(ssid, password)) {
@@ -263,7 +265,7 @@ class URLStreamESP32 : public AbstractURLStream {
     }
 
     // Determine the result
-    int content_length = esp_http_client_fetch_headers(client_handle);
+    content_length = esp_http_client_fetch_headers(client_handle);
     int status_code = esp_http_client_get_status_code(client_handle);
     LOGI("status_code: %d / content_length: %d", status_code, content_length);
 
@@ -302,7 +304,9 @@ class URLStreamESP32 : public AbstractURLStream {
 
   size_t readBytes(uint8_t* data, size_t len) override {
     TRACED();
-    return esp_http_client_read(client_handle, (char*)data, len);
+    size_t read = esp_http_client_read(client_handle, (char*)data, len);
+    total_read += read;
+    return read;
   }
 
   /// Adds/Updates a request header
@@ -324,21 +328,31 @@ class URLStreamESP32 : public AbstractURLStream {
 
   /// Attach and enable use of a bundle for certificate verification  e.g.
   /// esp_crt_bundle_attach or arduino_esp_crt_bundle_attach
-  void setCACert(esp_err_t (*cb)(void *conf)){
-    crt_bundle_attach = cb;
-  }
+  void setCACert(esp_err_t (*cb)(void* conf)) { crt_bundle_attach = cb; }
 
   /// Defines the read buffer size
-  void setReadBufferSize(int size) {
-    buffer_size = size; }
+  void setReadBufferSize(int size) { buffer_size = size; }
 
   /// Used for request and reply header parameters
-  HttpRequest& httpRequest() override {
-    return request; }
+  HttpRequest& httpRequest() override { return request; }
 
   /// Does nothing
   void setClient(Client& client) override {}
 
+  /// Provides the url as string
+  const char* urlStr() override { return  (char*)url_str; }
+
+  /// Total amout of data that was consumed so far
+  size_t totalRead() override { return total_read; }
+
+  /// Provides the reported data size from the http reply
+  int contentLength() override { return content_length; }
+
+  /// Not used
+  virtual bool waitForData(int timeout) override{ return false; }
+  /// Not used
+  void setConnectionClose(bool flag) override {}
+
  protected:
   int id = 0;
   HttpRequest request;
@@ -349,11 +363,13 @@ class URLStreamESP32 : public AbstractURLStream {
   int buffer_size = DEFAULT_BUFFER_SIZE;
   const uint8_t* pem_cert = nullptr;
   int pem_cert_len = 0;
-  esp_err_t (*crt_bundle_attach)(void *conf) = nullptr;
-
+  esp_err_t (*crt_bundle_attach)(void* conf) = nullptr;
+  size_t total_read = 0;
+  const char* url_str = nullptr;
+  int content_length = 0;
 
-  /// Define the Root PEM Certificate for SSL: the last byte must be null, the
-  /// len is including the ending null
+  /// Define the Root PEM Certificate for SSL: the last byte must be null,
+  /// the len is including the ending null
   void setCACert(const uint8_t* cert, int len) {
     pem_cert_len = len;
     pem_cert = cert;