Issue with HttpRequest stream upload or API usage error?

[djfm]

Problem Description

Can't seem to post audio stream to server using i2s as input and AudioTool's HttpRequest for upload, while the other direction works fine (getting stream from server and playing it with on the ESP32 device using URLStream).

I have based my code on this example: https://github.com/pschatzmann/arduino-audio-tools/blob/main/examples/examples-communication/http-client/streams-http_post/streams-http_post.ino

and the above example doesn't seem to work for me either.

The server is made in node with express and is as basic as can be:

import express from 'express';

const app = express();

app.post('/listen', (req, res) => {
    console.log('[/listen]: Receiving audio data...');
    console.log('Headers:', req.headers);
    console.log('Body:', req.body);

    req.setTimeout(0);

    req.on('data', (chunk) => {
        console.log(`Received ${chunk.length} bytes of audio data.`);
    });

    res.on('close', () => {
        console.log('Connection closed.');
    });
});

const port = 6556;

app.listen(port, () => {
    console.log(`Server is running on port ${port}`);
});

The minimal arduino sketch is included in the dedicated form field, but I get the same results from the example quoted from this repository.

In both cases the Serial output of the ESP32 says:

[I] StreamCopy.h : 414 - try write  - 12 (open 1024 bytes) 
[I] StreamCopy.h : 414 - try write  - 13 (open 1024 bytes) 
[I] StreamCopy.h : 414 - try write  - 14 (open 1024 bytes) 
[I] StreamCopy.h : 414 - try write  - 15 (open 1024 bytes) 
[I] StreamCopy.h : 414 - try write  - 16 (open 1024 bytes) 
[I] StreamCopy.h : 414 - try write  - 17 (open 1024 bytes) 
[I] StreamCopy.h : 414 - try write  - 18 (open 1024 bytes) 
[I] StreamCopy.h : 414 - try write  - 19 (open 1024 bytes) 
[I] StreamCopy.h : 414 - try write  - 20 (open 1024 bytes) 
[I] StreamCopy.h : 414 - try write  - 21 (open 1024 bytes) 
[E] StreamCopy.h : 407 - write  to target has failed after 22 retries! (1024 bytes)

and the server displays:

Server is running on port 6556
[/listen]: Receiving audio data...
Headers: {
  host: '192.168.1.1',
  connection: 'keep-alive',
  'accept-encoding': 'identity',
  accept: '*/*',
  'content-type': 'audio/pcm'
}
Body: undefined
Connection closed.

While I am expecting it to emit 'data' events as it receives the stream.

For some reason that I do not understand the connection gets closed immediately.

Am I missing something obvious here? What is the server expected to reply?

Device Description

esp32dev

Sketch

#include "AudioTools.h"
#include "AudioTools/AudioLibs/I2SCodecStream.h"

WiFiClient client;
HttpRequest http(client);
const AudioInfo info(44100, 1, 16);
Url target;
I2SCodecStream audioStream(AudioKitEs8388V2);
StreamCopy copier(client, audioStream);

void setup() {
    Serial.begin(115200);
    AudioLogger::instance().begin(Serial, AudioLogger::Debug);

    WiFi.mode(WIFI_STA);
    WiFi.begin("***", "***");
    while (WiFi.status() != WL_CONNECTED) {
        Serial.print('.');
        delay(1000);
    }
    Serial.println();
    Serial.println(WiFi.localIP());

    auto audioConfig = audioStream.defaultConfig(RX_MODE);
    audioConfig.copyFrom(info);
    audioStream.begin(audioConfig);

    // this doesn't seem to change anything
    // http.addRequestHeader("Transfer-Encoding", "chunked");

    Url url("http://192.168.1.1:6556/listen");
    if (!http.processBegin(POST, url, "audio/pcm")){
        Serial.println("post failed");
        stop();
    }
}

void loop() {
    if (copier.copy() == 0) {
        http.processEnd();
    }
}

### Other Steps to Reproduce

Also tried with polka instead of express as a server, no change.

Also tried to add "Transfer-Encoding: chunked" to the request headers, no change.

### What is your development environment

Development environment: PlatformIO under Ubuntu.
Platform: espressif32
Framework: arduino

### I have checked existing issues, discussions and online documentation

- [X] I confirm I have checked existing issues, discussions and online documentation

[pschatzmann]

I think your server expects chunked data but you don't provide it in this format!

[djfm]

As far as I know that's how node handles requests which do not have a content-length header specified. Do you have an example of server you're using for your tests? I couldn't find one.

…

On Mon, Nov 4, 2024, 15:29 Phil Schatzmann ***@***.***> wrote: Closed #1773 <#1773> as completed. — Reply to this email directly, view it on GitHub <#1773 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AALESE7C6VHBBZH2352NPXDZ66AF7AVCNFSM6AAAAABREMARHSVHI2DSMVQWIX3LMV45UABCJFZXG5LFIV3GK3TUJZXXI2LGNFRWC5DJN5XDWMJVGEYDIOJTHA4DOOI> . You are receiving this because you authored the thread.Message ID: ***@***.*** .com>

[ffaerber]

@djfm i am working on the same problem.
i have a working client(nodejs) to server(nodejs) version working with streaming
now i try to do a client(arduino) to server(nodejs) version.

// server.js
const express = require('express');
const fs = require('fs');
const path = require('path');

const app = express();
const port = 3000;

app.post('/stream-audio', (req, res) => {
  console.log('Receiving audio stream...');
  console.log('Headers:', req.headers);
  console.log('Body:', req.body);
  const filePath = path.join(__dirname, 'uploads', 'audio.wav');
  const fileStream = fs.createWriteStream(filePath);

  req.pipe(fileStream);

  req.on('end', () => {
    console.log('Audio stream received and saved.', filePath);
    res.status(200).send('Stream received successfully');
  });

  req.on('error', (err) => {
    console.error('Error receiving stream:', err);
    res.status(500).send('Error processing stream');
  });
});

app.listen(port, () => {
  console.log(`Server listening at http://localhost:${port}`);
});

//client.js
const recorder = require('node-record-lpcm16');  // For recording audio
const request = require('request');  
const fs = require('fs');                        // For file system access
const path = require('path');                    // For path handling

const apiUrl = `http://localhost:3000/stream-audio`;  // Your API endpoint for receiving audio data

const recording = recorder.record({
  recorder: 'arecord'
});

function parseResult (err, resp, body) {
  if (err) console.error(err)
  console.log(body)
}

recording.stream().pipe(request.post({
    url: apiUrl,
    headers: {
      'Accept': 'application/json',
      'Content-Type': 'audio/wav'
    },
  }, parseResult))

 
setTimeout(() => {
    recording.stop()
}, 3000) // Stop after three seconds of recording

[djfm]

Just a note: sometimes AI's will suggest to add req.setEncoding('binary'); - don't do it! It messes all the data up.

[pschatzmann]

But isn't this just a simple chuned post ?

[ffaerber]

is the data send in hexadecimal? followed by the chunk data and a CRLF (\r\n).
https://chatgpt.com/share/673dc576-1414-8011-8a8c-ca9a665e2977

[djfm]

Not exactly:

• the first part of the chunk is the length of the data (excluding the first line containing the size and the trailing CRLF) expressed in hexadecimal
• then you have a CRLF
• then the chunk itself, raw, as a simple sequence of unaltered bytes (x.write(data, data_length);, where x is the request's stream - the length may need to be multiplied by the sizeof(T) where T is the type of your data elements, if T is not one byte long, e.g. if it's int16_t)
• and finally another CRLF

a convenient way to write the size header is:

x.printf("%x\r\n", size_in_bytes_base_10);

Where x is pretty much anything with a printf method. Streams usually have it.

[pschatzmann]

This is currently implemented in HttpRequest write. The only issue that I see is that this is not a subclass of print, so it cant be used as copy target. But this is easy to change!

[ffaerber]

i have added more debug info to the server.js

server.js
const express = require('express');
const fs = require('fs');
const path = require('path');

const app = express();
const port = 3000;

app.post('/stream-audio', (req, res) => {
  console.log('Receiving audio stream...');
  console.log('Headers:', req.headers);
  
  const filePath = path.join(__dirname, 'uploads', 'audio.wav');
  const fileStream = fs.createWriteStream(filePath);

  req.pipe(fileStream);

  req.on('data', chunk => {
    console.log('Received chunk:', chunk.length);
  });

  req.on('end', () => {
    console.log('Audio stream received and saved.', filePath);
    res.status(200).send('Stream received successfully');
  });

  req.on('close', () => {
    console.error('Client connection closed');
  });

  req.on('error', (err) => {
    console.error('Error receiving stream:', err);
    res.status(500).send('Error processing stream');
  });
});

app.listen(port, () => {
  console.log(`Server listening at http://localhost:${port}`);
});

and if i stream a file from the client.js i get on the server.js this output

node server.js
Server listening at http://localhost:3000
Receiving audio stream...
Headers: {
  accept: 'application/json',
  'content-type': 'audio/wav',
  host: 'localhost:3000',
  connection: 'keep-alive',
  'transfer-encoding': 'chunked'
}
Received chunk: 44
Received chunk: 4000
Received chunk: 4000
Received chunk: 8000
Received chunk: 4000
Received chunk: 8000
Received chunk: 8000
Received chunk: 4000
Received chunk: 8000
Received chunk: 8000
Received chunk: 4000
Received chunk: 8000
Received chunk: 8000
Received chunk: 4000
Received chunk: 8000
Received chunk: 4000
Audio stream received and saved. /xxx/audio.wav
Client connection closed

if i run the streams-http_post.ino

in get on the server.js this

Receiving audio stream...
Headers: {
  'transfer-encoding': 'chunked',
  host: 'ffaerber-ubuntu',
  connection: 'keep-alive',
  'accept-encoding': 'identity',
  accept: 'application/json',
  'content-type': 'audio/wav'
}
Error receiving stream: Error: aborted
    at abortIncoming (node:_http_server:793:17)
    at socketOnClose (node:_http_server:787:3)
    at Socket.emit (node:events:531:35)
    at TCP.<anonymous> (node:net:337:12) {
  code: 'ECONNRESET'
}
Client connection closed

[djfm]

i have added more debug info to the server.js

server.js
const express = require('express');
const fs = require('fs');
const path = require('path');

const app = express();
const port = 3000;

app.post('/stream-audio', (req, res) => {
  console.log('Receiving audio stream...');
  console.log('Headers:', req.headers);
  
  const filePath = path.join(__dirname, 'uploads', 'audio.wav');
  const fileStream = fs.createWriteStream(filePath);

  req.pipe(fileStream);

  req.on('data', chunk => {
    console.log('Received chunk:', chunk.length);
  });

  req.on('end', () => {
    console.log('Audio stream received and saved.', filePath);
    res.status(200).send('Stream received successfully');
  });

  req.on('close', () => {
    console.error('Client connection closed');
  });

  req.on('error', (err) => {
    console.error('Error receiving stream:', err);
    res.status(500).send('Error processing stream');
  });
});

app.listen(port, () => {
  console.log(`Server listening at http://localhost:${port}`);
});

and if i stream a file from the client.js i get on the server.js this output

node server.js
Server listening at http://localhost:3000
Receiving audio stream...
Headers: {
  accept: 'application/json',
  'content-type': 'audio/wav',
  host: 'localhost:3000',
  connection: 'keep-alive',
  'transfer-encoding': 'chunked'
}
Received chunk: 44
Received chunk: 4000
Received chunk: 4000
Received chunk: 8000
Received chunk: 4000
Received chunk: 8000
Received chunk: 8000
Received chunk: 4000
Received chunk: 8000
Received chunk: 8000
Received chunk: 4000
Received chunk: 8000
Received chunk: 8000
Received chunk: 4000
Received chunk: 8000
Received chunk: 4000
Audio stream received and saved. /xxx/audio.wav
Client connection closed

if i run the streams-http_post.ino

in get on the server.js this

Receiving audio stream...
Headers: {
  'transfer-encoding': 'chunked',
  host: 'ffaerber-ubuntu',
  connection: 'keep-alive',
  'accept-encoding': 'identity',
  accept: 'application/json',
  'content-type': 'audio/wav'
}
Error receiving stream: Error: aborted
    at abortIncoming (node:_http_server:793:17)
    at socketOnClose (node:_http_server:787:3)
    at Socket.emit (node:events:531:35)
    at TCP.<anonymous> (node:net:337:12) {
  code: 'ECONNRESET'
}
Client connection closed

Yeah I struggled with this for a while, I was expecting the HTTP stream to be a stream as defined in HTTP, but it is not. I ended up writing my own class to stream requests since I stopped using this library, but taking another look at it I think you might get away with it by (unless the API improved since I last tried or if I missed something):

1. adding the Transfer-Encoding: chunked header using the request's addRequestHeader method if I remember correctly
2. using HttpRequest::processBegin(... ) to start the request (be sure not to send a body with this call, as it would add a Content-Length header which will not play well with Transfer-Encoding: chunked)
3. in your loop, call [write()] (

   arduino-audio-tools/src/AudioTools/CoreAudio/AudioHttp/HttpRequest.h

   Line 271 in abc42d5

   virtual size_t write(uint8_t *data, size_t len) {

   ) to send your data, but you will need to construct the chunk yourself, it's easy though: you need to write the length (in bytes) of the chunk in hexadecimal format, then a line break (windows style, \r\n), and then your chunk's data without changing it at all, finally followed by another \r\n
4. you can repeat 3.) as many times as you want
5. once you're done uploading, send a chunk of length zero, i.e. write 0\r\n to the stream
6. finally you can call HttpRequest::processEnd(), I think it does the right thing

Hope this helps! Let me know.

EDIT: pschatzmann's reply probably works, I don't remember seeing this API at the time

[ffaerber]

thank you. I'll try it out

[pschatzmann]

If you need chuned data, you will need to activate it in my API.
By default is is not chunked!

If I remember right you would do this by adding the transfer-encoding chunked to the request header, e.g like this:

 http.header().put(TRANSFER_ENCODING, CHUNKED); 

When adding this, all logic is in place for writing chunked data.

[ffaerber]

this http.header().put(TRANSFER_ENCODING, CHUNKED);
and http.addRequestHeader("transfer-encoding", "chunked"); are not making a difference

[djfm]

Yes the stream approach is really nice. I actually stopped using your libraries when I discovered that it was not possible to apply the same logic for upload as for download (and because the quality of the recorded audio was really bad, but that one might have been my fault).

…

On Wed, Nov 20, 2024, 14:55 Phil Schatzmann ***@***.***> wrote: This is currently implemented in HttpRequest write. The only issue that I see is that this is not a subclass of print, so it cant be used as copy target. But this is easy to change! — Reply to this email directly, view it on GitHub <#1803 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AALESE62BUTAKGDSA6XK3MT2BSIFDAVCNFSM6AAAAABSEKXMT2VHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTCMZSGMYDMOI> . You are receiving this because you were mentioned.Message ID: <pschatzmann/arduino-audio-tools/repo-discussions/1803/comments/11323069@ github.com>

[pschatzmann]

I committed a correction: a test with a python server and this sketch with the TRANSFER_ENCODING uncommented is working properly now!

• the chunk length was not written in decimal instead of hex
• HttpRequest is as subclass from BaseStream now so that it can be used in a copy target
• in the example the copy target is http and not client to use the write implementation that supports chunked data

[ffaerber]

it's working now. thank you so much