Commit

Author: netham45

.gitignore

@@ -1,3 +1,5 @@
+**/secrets.h
 build/
-secrets.h
-managed_components/*/
+spiffs/
+managed_components/
+*.uf2

README.md

@@ -1,3 +1,3 @@
-# ESP32-S3 Scream Receiver
+# ESP32-ScreamReader
 
-This receives scream data over tcp to an esp32-s3 and outputs it to a UAC 1.0 sound device, very much WIP and barely works at this stage
+This is an ESP32 screamreader that can target the ESP32 for SPDIF or ESP32S3 for USB UAC 1.0 Host.

dependencies.lock

@@ -8,7 +8,7 @@ dependencies:
  component_hash: null
  source:
  type: idf
- version: 5.0.6
+ version: 5.4.0
 manifest_hash: 4181ba46eaef906dc497541b34620c1ce46b918c380e8201c75bc7ffc1628d98
 target: esp32s3
 version: 1.0.0

main/CMakeLists.txt

@@ -1,4 +1,4 @@
-idf_component_register(SRCS "audio.c" "buffer.c" "network.c" "usb_audio_player_main.c"
+idf_component_register(SRCS "audio.c" "buffer.c" "network.c" "usb_audio_player_main.c" "spdif.c"
  INCLUDE_DIRS ".")
 
 target_link_libraries(${COMPONENT_LIB} "-L ${CMAKE_CURRENT_SOURCE_DIR}")

main/audio.c

@@ -2,48 +2,87 @@
 #include "buffer.h"
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "usb/uac_host.h"
 #include "esp_log.h"
-
+#ifdef IS_SPDIF
+#include "spdif.h"
+#endif
+#ifdef IS_USB
+#include "usb/uac_host.h"
 uac_host_device_handle_t spkr_handle = NULL;
+#endif
 
 bool playing = false;
 
-uint8_t volume = 2;
+uint8_t volume = 100;
 uint8_t silence[32] = {0};
+bool is_silent = false;
 
-void start_playback(uac_host_device_handle_t _spkr_handle) {
-spkr_handle = _spkr_handle;
+void resume_playback() {
+#ifdef IS_USB
 uac_host_stream_config_t stm_config = {
  .channels = 2,
  .bit_resolution = 16,
  .sample_freq = 48000,
  };
-playing = true;
  ESP_ERROR_CHECK(uac_host_device_start(spkr_handle, &stm_config));
 ESP_ERROR_CHECK(uac_host_device_set_volume(spkr_handle, volume));
+#endif
+ESP_LOGI(TAG, "Resume Playback");
+playing = true;
 }
 
+#ifdef IS_USB
+void start_playback(uac_host_device_handle_t _spkr_handle) {
+spkr_handle = _spkr_handle;
+}
+#endif
+
 void stop_playback() {
 playing = false;
+ESP_LOGI(TAG, "Stop Playback");
+#ifdef IS_USB
 uac_host_device_stop(spkr_handle);
+#endif
+}
+
+void audio_direct_write(uint8_t *data) {
+#ifdef IS_USB
+ uac_host_device_write(spkr_handle, data, PCM_CHUNK_SIZE, portMAX_DELAY);
+#endif
+#ifdef IS_SPDIF
+spdif_write(data, PCM_CHUNK_SIZE);
+#endif
 }
 
 void pcm_handler(void*) {
  while (true) {
  if (playing) {
- uint8_t *data = pop_chunk();
- if (data) {
- int result = uac_host_device_write(spkr_handle, data, PCM_CHUNK_SIZE, portMAX_DELAY);
- }
- else
-for (int i=0;i<1152;i++)
- uac_host_device_write(spkr_handle, silence, 32, portMAX_DELAY);
+uint8_t *data = pop_chunk();
+if (data) {
+#ifdef IS_USB
+uac_host_device_write(spkr_handle, data, PCM_CHUNK_SIZE, portMAX_DELAY);
+#endif
+#ifdef IS_SPDIF
+spdif_write(data, PCM_CHUNK_SIZE);
+#endif
+is_silent = false;
+}
+else if (!is_silent) {
+ESP_LOGI(TAG, "Silent");
+is_silent = true;
+}
+//else
+// for (int i=0;i<1152/32;i++)
+// uac_host_device_write(spkr_handle, silence, 32, portMAX_DELAY);
+//	vTaskDelay(7);
  }
  vTaskDelay(1);
  }
 }
 
 void setup_audio() {
+#ifdef IS_SPDIF
+ spdif_init(48000);
+#endif
  xTaskCreatePinnedToCore(pcm_handler, "pcm_handler", 16384, NULL, 1, NULL, 1);
 }

main/audio.h

@@ -1,8 +1,15 @@
 #pragma once
+#include "config.h"
+#ifdef IS_USB
 #include "usb/uac_host.h"
+#endif
 void process_audio_actions(bool is_startup);
 void register_button(int button,void (*action)(bool, int, void *));
 void setup_audio();
+#ifdef IS_USB
 void start_playback(uac_host_device_handle_t _spkr_handle);
+#endif
 void stop_playback();
-void audio_write(uint8_t* data);
+void audio_write(uint8_t* data);
+void audio_direct_write(uint8_t *data);
+void resume_playback();

main/buffer.c

@@ -7,15 +7,15 @@
 #include "esp_psram.h"
 
 // Flag if the stream is currently underrun and rebuffering
-bool is_underrun = true;
+bool is_underrun  = true;
 // Number of received packets since last underflow
-uint64_t received_packets = 0;
+unsigned int received_packets = 0;
 // Number of packets in ring buffer
 unsigned int packet_buffer_size = 0;
 // Position of ring buffer read head
-uint64_t packet_buffer_pos = 0;
+unsigned int packet_buffer_pos = 0;
 // Number of bytes to buffer
-uint64_t target_buffer_size = INITIAL_BUFFER_SIZE;
+unsigned int target_buffer_size = INITIAL_BUFFER_SIZE;
 // Buffer of packets to send
 uint8_t *packet_buffer[MAX_BUFFER_SIZE] = { 0 };
 portMUX_TYPE buffer_mutex = portMUX_INITIALIZER_UNLOCKED;
@@ -24,20 +24,20 @@ void set_underrun() {
  if (!is_underrun) {
  received_packets = 0;
  target_buffer_size += BUFFER_GROW_STEP_SIZE;
- if (target_buffer_size >= MAX_BUFFER_SIZE)
- target_buffer_size = MAX_BUFFER_SIZE;
- ESP_LOGI(TAG, "Buffer Underflow");
+ if (target_buffer_size >= MAX_GROW_SIZE)
+ target_buffer_size = MAX_GROW_SIZE;
+ ESP_LOGI(TAG, "Buffer Underflow, New Size: %i", target_buffer_size);
  }
  is_underrun = true;
 }
 
 bool push_chunk(uint8_t *chunk) {
  int write_position = (packet_buffer_pos + packet_buffer_size) % MAX_BUFFER_SIZE;
 // ESP_LOGI(TAG, "memcpy(%p, %p, %i)", packet_buffer[write_position], chunk, PCM_CHUNK_SIZE); 
- //taskENTER_CRITICAL(&buffer_mutex);
+ taskENTER_CRITICAL(&buffer_mutex);
  if (packet_buffer_size == MAX_BUFFER_SIZE) {
  packet_buffer_size = target_buffer_size;
- //taskEXIT_CRITICAL(&buffer_mutex);
+ taskEXIT_CRITICAL(&buffer_mutex);
  ESP_LOGI(TAG, "Buffer Overflow");
  return false;
  }
@@ -48,32 +48,38 @@ bool push_chunk(uint8_t *chunk) {
  received_packets++;
  if (received_packets >= target_buffer_size)
  is_underrun = false;
- //taskEXIT_CRITICAL(&buffer_mutex);
+ taskEXIT_CRITICAL(&buffer_mutex);
  return true;
 }
 
 uint8_t *pop_chunk() {
- //taskENTER_CRITICAL(&buffer_mutex);
+ taskENTER_CRITICAL(&buffer_mutex);
  if (packet_buffer_size == 0) {
- //taskEXIT_CRITICAL(&buffer_mutex);
+ taskEXIT_CRITICAL(&buffer_mutex);
  set_underrun();
  return NULL;
  }
  if (is_underrun) {
- //taskEXIT_CRITICAL(&buffer_mutex);
+ taskEXIT_CRITICAL(&buffer_mutex);
  return NULL;
  }
  uint8_t *return_chunk = packet_buffer[packet_buffer_pos];
  packet_buffer_size--;
  packet_buffer_pos = (packet_buffer_pos + 1) % MAX_BUFFER_SIZE;
- //taskEXIT_CRITICAL(&buffer_mutex);
+ taskEXIT_CRITICAL(&buffer_mutex);
  return return_chunk;
 }
 
+void empty_buffer() {
+taskENTER_CRITICAL(&buffer_mutex);
+packet_buffer_size = 0;
+received_packets = 0;
+taskEXIT_CRITICAL(&buffer_mutex);
+}
+
 void setup_buffer() {
  ESP_LOGI(TAG, "Allocating buffer");
  uint8_t *buffer = 0;
-
  buffer = (uint8_t *)malloc(PCM_CHUNK_SIZE * MAX_BUFFER_SIZE);
  memset(buffer, 0, PCM_CHUNK_SIZE * MAX_BUFFER_SIZE);
  for (int i = 0; i < MAX_BUFFER_SIZE; i++)

main/buffer.h

@@ -10,3 +10,4 @@ void setup_buffer();
 bool push_chunk(uint8_t *chunk);
 uint8_t *pop_chunk();
 void setup_buffer();
+void empty_buffer();

main/config.h

@@ -1,15 +1,15 @@
 #pragma once
 // TCP port for Scream server data, configurable
 #define PORT 4010
-// Scream server IP, configurable
-#define SERVER "192.168.3.114"
 
 // Number of chunks to be buffered before playback starts, configurable
-#define INITIAL_BUFFER_SIZE 48
+#define INITIAL_BUFFER_SIZE 4
 // Number of chunks to add each underflow, configurable
-#define BUFFER_GROW_STEP_SIZE 16
+#define BUFFER_GROW_STEP_SIZE 0
 // Max number of chunks to be buffered before packets are dropped, configurable
-#define MAX_BUFFER_SIZE 128
+#define MAX_BUFFER_SIZE 16
+// Max number of chunks to be targeted for buffer
+#define MAX_GROW_SIZE 4
 
 // Sample rate for incoming PCM, configurable
 #define SAMPLE_RATE 48000
@@ -18,4 +18,7 @@
 //Volume 0.0f-1.0f
 #define VOLUME 1.0f
 
+//#define IS_SPDIF
+#define IS_USB
+
 #define TAG "scream_receiver"

main/idf_component.yml

@@ -1,3 +1,3 @@
 dependencies:
- idf: ">=5.0" # The version of the ESP-IDF that esp-audio-player requires
- usb_host_uac: "1.0.*"
+ idf: ">=5.0"
+ usb_host_uac: "1.0.*"