arduino-audio-tools
All Classes Namespaces Files Functions Variables Typedefs Enumerations Friends Modules Pages
URLStreamBufferedT.h
1#pragma once
2#include "AudioConfig.h"
3#if defined(USE_CONCURRENCY)
4#include "AudioTools/AudioLibs/Concurrency.h"
5#include "AudioTools/CoreAudio/AudioHttp/AbstractURLStream.h"
6#include "AudioTools/CoreAudio/BaseStream.h"
7
8#ifndef URL_STREAM_CORE
9#define URL_STREAM_CORE 0
10#endif
11
12#ifndef URL_STREAM_PRIORITY
13#define URL_STREAM_PRIORITY 2
14#endif
15
16#ifndef URL_STREAM_BUFFER_COUNT
17#define URL_STREAM_BUFFER_COUNT 10
18#endif
19
20#ifndef STACK_SIZE
21#define STACK_SIZE 30000
22#endif
23
24namespace audio_tools {
25
34 public:
35 BufferedTaskStream() { TRACEI(); };
36
38 TRACEI();
39 setInput(input);
40 }
41
43 TRACEI();
44 stop();
45 }
46
48 void setBufferSize(int bufferSize, int bufferCount) {
49 buffers.resize(bufferSize, bufferCount);
50 }
51
52 virtual void begin(bool wait = true) {
53 TRACED();
54 active = true;
55 ready = false;
56 task.begin(std::bind(&BufferedTaskStream::processTask, this));
57 if (!wait) ready = true;
58 }
59
60 virtual void end() {
61 TRACED();
62 task.end();
63 active = false;
64 ready = false;
65 }
66
67 virtual void setInput(AudioStream &input) {
68 TRACED();
69 p_stream = &input;
70 }
71
73 virtual size_t write(uint8_t c) override { return 0; }
74
76 virtual size_t write(const uint8_t *data, size_t len) override { return 0; }
77
79 virtual void flush() override {}
80
82 virtual int read() override {
83 // if (!ready) return -1;
84 int result = -1;
85 result = buffers.read();
86 return result;
87 }
88
90 virtual int peek() override {
91 // if (!ready) return -1;
92 int result = -1;
93 result = buffers.peek();
94 return result;
95 };
96
98 virtual size_t readBytes(uint8_t *data, size_t len) override {
99 // if (!ready) return 0;
100 size_t result = 0;
101 result = buffers.readArray(data, len);
102 LOGD("%s: %zu -> %zu", LOG_METHOD, len, result);
103 return result;
104 }
105
107 virtual int available() override {
108 // if (!ready) return 0;
109 int result = 0;
110 result = buffers.available();
111 return result;
112 }
113
114 protected:
115 AudioStream *p_stream = nullptr;
116 bool active = false;
117 Task task{"BufferedTaskStream", STACK_SIZE, URL_STREAM_PRIORITY,
118 URL_STREAM_CORE};
119 SynchronizedNBuffer buffers{DEFAULT_BUFFER_SIZE, URL_STREAM_BUFFER_COUNT};
120 bool ready = false;
121
122 void processTask() {
123 size_t available_to_write = this->buffers.availableForWrite();
124 if (*(this->p_stream) && available_to_write > 0) {
125 size_t to_read = min(available_to_write, (size_t)512);
126 uint8_t buffer[to_read];
127 size_t avail_read = this->p_stream->readBytes((uint8_t *)buffer, to_read);
128 size_t written = this->buffers.writeArray(buffer, avail_read);
129
130 if (written != avail_read) {
131 LOGE("DATA Lost! %zu reqested, %zu written!", avail_read, written);
132 }
133
134 } else {
135 // 3ms at 44100 stereo is about 529.2 bytes
136 delay(3);
137 }
138 // buffer is full we start to provide data
139 if (available_to_write == 0) {
140 this->ready = true;
141 }
142 }
143};
144
153template <class T>
155 public:
156 URLStreamBufferedT(int readBufferSize = DEFAULT_BUFFER_SIZE) {
157 TRACED();
158 urlStream.setReadBufferSize(readBufferSize);
159 taskStream.setInput(urlStream);
160 }
161
162 URLStreamBufferedT(const char *network, const char *password,
163 int readBufferSize = DEFAULT_BUFFER_SIZE) {
164 TRACED();
165 urlStream.setReadBufferSize(readBufferSize);
166 setSSID(network);
167 setPassword(password);
168 taskStream.setInput(urlStream);
169 }
170
171#ifdef ARDUINO
172
174 int readBufferSize = DEFAULT_BUFFER_SIZE) {
175 TRACED();
176 urlStream.setReadBufferSize(readBufferSize);
178 taskStream.setInput(urlStream);
179 }
180#endif
181
183 void setBufferSize(int bufferSize, int bufferCount) {
184 taskStream.setBufferSize(bufferSize, bufferCount);
185 }
186
187 bool begin(const char *urlStr, const char *acceptMime = nullptr,
188 MethodID action = GET, const char *reqMime = "",
189 const char *reqData = "") {
190 TRACED();
191 // start real stream
192 bool result = urlStream.begin(urlStr, acceptMime, action, reqMime, reqData);
193 // start buffer task
194 taskStream.begin();
195 return result;
196 }
197
198 virtual int available() { return taskStream.available(); }
199
200 virtual size_t readBytes(uint8_t *data, size_t len) {
201 size_t result = taskStream.readBytes(data, len);
202 LOGD("%s: %zu -> %zu", LOG_METHOD, len, result);
203 return result;
204 }
205
206 virtual int read() { return taskStream.read(); }
207
208 virtual int peek() { return taskStream.peek(); }
209
210 virtual void flush() {}
211
212 void end() {
213 TRACED();
214 taskStream.end();
215 urlStream.end();
216 }
217
219 void setSSID(const char *ssid) override { urlStream.setSSID(ssid); }
220
222 void setPassword(const char *password) override {
223 urlStream.setPassword(password);
224 }
225
227 void setPowerSave(bool ps) override { urlStream.setPowerSave(ps); }
228
230 void setCACert(const char *cert) { urlStream.setCACert(cert); }
231
233 void addRequestHeader(const char* key, const char* value) override {
234 urlStream.addRequestHeader(key, value);
235 }
237 const char* getReplyHeader(const char* key) override {
238 return urlStream.getReplyHeader(key);
239 }
240
242 HttpRequest &httpRequest() { return urlStream.httpRequest(); }
243
245 void setClient(Client &client) override { urlStream.setClient(client); }
246
247 protected:
248 BufferedTaskStream taskStream;
249 T urlStream;
250};
251
252} // namespace audio_tools
253
254#endif
Abstract Base class for all URLStream implementations.
Definition AbstractURLStream.h:17
Base class for all Audio Streams. It support the boolean operator to test if the object is ready with...
Definition BaseStream.h:115
A FreeRTOS task is filling the buffer from the indicated stream. Only to be used on the ESP32.
Definition URLStreamBufferedT.h:33
virtual size_t write(const uint8_t *data, size_t len) override
Use this method: write an array.
Definition URLStreamBufferedT.h:76
void setBufferSize(int bufferSize, int bufferCount)
Define an explicit the buffer size in bytes.
Definition URLStreamBufferedT.h:48
virtual int read() override
reads a byte - to be avoided
Definition URLStreamBufferedT.h:82
virtual size_t readBytes(uint8_t *data, size_t len) override
Use this method !!
Definition URLStreamBufferedT.h:98
virtual int peek() override
peeks a byte - to be avoided
Definition URLStreamBufferedT.h:90
virtual size_t write(uint8_t c) override
writes a byte to the buffer
Definition URLStreamBufferedT.h:73
virtual void flush() override
empties the buffer
Definition URLStreamBufferedT.h:79
virtual int available() override
Returns the available bytes in the buffer: to be avoided.
Definition URLStreamBufferedT.h:107
Definition NoArduino.h:167
Simple API to process get, put, post, del http requests I tried to use Arduino HttpClient,...
Definition HttpRequest.h:25
FreeRTOS task.
Definition Task.h:20
void end()
suspends the task
Definition Task.h:64
URLStream implementation for the ESP32 based on a separate FreeRTOS task: the.
Definition URLStreamBufferedT.h:154
void setBufferSize(int bufferSize, int bufferCount)
Defines the buffer that holds the with encoded data.
Definition URLStreamBufferedT.h:183
HttpRequest & httpRequest()
provides access to the HttpRequest
Definition URLStreamBufferedT.h:242
void setPowerSave(bool ps) override
ESP32 only: PowerSave off (= default setting) is much faster.
Definition URLStreamBufferedT.h:227
void addRequestHeader(const char *key, const char *value) override
Adds/Updates a request header.
Definition URLStreamBufferedT.h:233
void setCACert(const char *cert)
Define the Root PEM Certificate for SSL.
Definition URLStreamBufferedT.h:230
void setSSID(const char *ssid) override
Sets the ssid that will be used for logging in (when calling begin)
Definition URLStreamBufferedT.h:219
void setClient(Client &client) override
(Re-)defines the client
Definition URLStreamBufferedT.h:245
void setPassword(const char *password) override
Sets the password that will be used for logging in (when calling begin)
Definition URLStreamBufferedT.h:222
const char * getReplyHeader(const char *key) override
Provides reply header info.
Definition URLStreamBufferedT.h:237
Vector implementation which provides the most important methods as defined by std::vector....
Definition Vector.h:21
void stop()
Public generic methods.
Definition AudioRuntime.h:28
Generic Implementation of sound input and output for desktop environments using portaudio.
Definition AudioConfig.h:885