rename writeCodecInfo to writeCodecConfig

Author: pschatzmann

examples/tests/codecs/test-codec-alac/test-codec-alac.ino

@@ -0,0 +1,56 @@
+/**
+ * @file test-codec-alac.ino
+ * @author Phil Schatzmann
+ * @brief generate sine wave -> encoder -> decoder -> audiokit (i2s)
+ * @version 0.1
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+#include "AudioTools.h"
+#include "AudioTools/AudioCodecs/CodecALAC.h"
+#include "AudioTools/AudioLibs/AudioBoardStream.h"
+
+SET_LOOP_TASK_STACK_SIZE(16*1024); // 16KB
+
+AudioInfo info(8000, 1, 16);
+SineWaveGenerator<int16_t> sineWave( 32000);  // subclass of SoundGenerator with max amplitude of 32000
+GeneratedSoundStream<int16_t> sound( sineWave); // Stream generated from sine wave
+AudioBoardStream out(AudioKitEs8388V1);
+//I2SStream out; 
+//CsvOutput<int16_t> out(Serial);
+EncoderALAC enc_alac(1024 * 4);
+DecoderALAC dec_alac;
+EncodedAudioStream decoder(&out, &dec_alac); // encode and write
+EncodedAudioStream encoder(&decoder, &enc_alac); // encode and write
+StreamCopy copier(encoder, sound);     
+
+void setup() {
+  Serial.begin(115200);
+  AudioToolsLogger.begin(Serial, AudioToolsLogLevel::Debug);
+
+  // start I2S
+  Serial.println("starting I2S...");
+  auto cfgi = out.defaultConfig(TX_MODE);
+  cfgi.copyFrom(info);
+  out.begin(cfgi);
+
+  // Setup sine wave
+  sineWave.begin(info, N_B4);
+
+  // start encoder
+  encoder.begin(info);
+
+  // start decoder
+  decoder.begin();
+  
+  // copy config from encoder to decoder
+  dec_alac.writeCodecInfo(enc_alac.config());
+
+  Serial.println("Test started...");
+}
+
+
+void loop() { 
+  copier.copy();
+}

src/AudioTools/AudioCodecs/AudioCodecsBase.h

@@ -66,7 +66,7 @@ class AudioDecoder : public AudioWriter, public AudioInfoSource {
   }
 
   /// Some decoders need e.g. a magic cookie to provide the relevant info for decoding
-  virtual size_t writeCodecInfo(const uint8_t* data, size_t len){
+  virtual size_t writeCodecConfig(const uint8_t* data, size_t len){
     LOGE("not implemented");
     return 0;
   }

src/AudioTools/AudioCodecs/CodecALAC.h

@@ -16,7 +16,7 @@ namespace audio_tools {
 class DecoderALAC : public AudioDecoder {
  public:
   /// write Magic Cookie (ALACSpecificConfig)
-  size_t writeCodecInfo(const uint8_t* data, size_t len) override {
+  size_t writeCodecConfig(const uint8_t* data, size_t len) override {
     int32_t rc = dec.Init((void*)data, len);
     if (rc != 0) {
       LOGE("Init failed");
@@ -32,8 +32,13 @@ class DecoderALAC : public AudioDecoder {
   }
 
   // define ALACSpecificConfig
-  size_t writeCodecInfo(ALACSpecificConfig& config) {
-    return writeCodecInfo((uint8_t*)&config, sizeof(config));
+  size_t writeCodecConfig(ALACSpecificConfig config) {
+    return writeCodecConfig((uint8_t*)&config, sizeof(config));
+  }
+
+  bool begin(ALACSpecificConfig config) {
+    size_t written = writeCodecConfig(config);
+    return written == sizeof(ALACSpecificConfig);
   }
 
   /// we expect the write is called for a complete frame!
@@ -46,7 +51,7 @@ class DecoderALAC : public AudioDecoder {
       config.bitDepth = info.bits_per_sample;
       config.numChannels = info.channels;
       config.sampleRate = info.sample_rate;
-      writeCodecInfo((uint8_t*)&config, sizeof(config));
+      writeCodecConfig((uint8_t*)&config, sizeof(config));
       is_init = true;
     }
     // Make sure we have the output buffer set up
@@ -72,7 +77,10 @@ class DecoderALAC : public AudioDecoder {
     // Process result
     size_t outputSize =
         outNumSamples * dec.mConfig.numChannels * dec.mConfig.bitDepth / 8;
-    p_print->write(result_buffer.data(), outputSize);
+    size_t written = p_print->write(result_buffer.data(), outputSize);
+    if (outputSize != written) {
+      LOGE("write error: %d -> %d", outputSize, written);
+    }
     return frameLength;
   }
 
@@ -97,27 +105,33 @@ class DecoderALAC : public AudioDecoder {
  */
 class EncoderALAC : public AudioEncoder {
  public:
+  EncoderALAC(int bytesPerPacket = 1024) {
+    setDefaultBytesPerPacket(bytesPerPacket);
+  }
   void setOutput(Print& out_stream) override { p_print = &out_stream; };
 
   bool begin() override {
     if (p_print == nullptr) {
       LOGE("No output stream set");
       return false;
     }
+    // define input format
     input_format.mSampleRate = info.sample_rate;
     input_format.mFormatID = kALACFormatLinearPCM;
     input_format.mFormatFlags = kALACFormatFlagIsSignedInteger;
     input_format.mBytesPerPacket = default_bytes_per_packet;
-    input_format.mFramesPerPacket = 0;
     input_format.mBytesPerFrame = info.channels * info.bits_per_sample / 8;
+    input_format.mFramesPerPacket =
+        default_bytes_per_packet / input_format.mBytesPerFrame;
     input_format.mChannelsPerFrame = info.channels;
     input_format.mBitsPerChannel = info.bits_per_sample;
-    int rc = enc.InitializeEncoder(input_format);
 
     // define output format
     out_format = input_format;
     out_format.mFormatID = kALACFormatAppleLossless;
 
+    int rc = enc.InitializeEncoder(out_format);
+
     in_buffer.resize(default_bytes_per_packet);
     out_buffer.resize(default_bytes_per_packet);
     is_started = rc == 0;
@@ -131,7 +145,8 @@ class EncoderALAC : public AudioEncoder {
 
   /// Encode the audio samples into ALAC format
   size_t write(const uint8_t* data, size_t len) override {
-    int32_t ioNumBytes;
+    LOGI("write: %d", (int)len);
+    int32_t ioNumBytes = len;
     for (int j = 0; j < len; j++) {
       in_buffer.write(data[j]);
       if (in_buffer.isFull()) {

src/AudioTools/AudioCodecs/ContainerM4A.h

@@ -470,7 +470,7 @@ class ContainerM4A : public ContainerDecoder {
     // Notify decoder about the codec info if available
     if (p_decoder){
       if (p_decoder->selectDecoder(mime())){
-        p_decoder->writeCodecInfo(alac_config, alac_config_size);
+        p_decoder->writeCodecConfig(alac_config, alac_config_size);
       }
     }
   }