Implement using libmad to decode

src/codecs/CMakeLists.txt

@@ -1,4 +1,6 @@
-idf_component_register(INCLUDE_DIRS "include")
+idf_component_register(
+  SRCS "mad.cpp"
+  INCLUDE_DIRS "include")
 
-#target_compile_options(${COMPONENT_LIB} PRIVATE ${EXTRA_WARNINGS})
+target_compile_options(${COMPONENT_LIB} PRIVATE ${EXTRA_WARNINGS})
 add_dependencies("${COMPONENT_LIB}" libmad)

src/codecs/codec.cpp

@@ -0,0 +1,9 @@
+#include "codec.hpp"
+
+namespace codecs {
+
+auto CreateCodecForExtension(std::string extension) -> cpp::result<std::unique_ptr<ICodec>, CreateCodecError> {
+  return cpp::fail(UNKNOWN_EXTENSION);
+}
+
+} // namespace codecs

src/codecs/include/codec.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <stdint.h>
 #include <cstddef>
 #include <cstdint>
 
@@ -7,7 +8,9 @@
 
 namespace codecs {
 
-  enum CreateCodecError {};
+  enum CreateCodecError {
+    UNKNOWN_EXTENSION
+  };
 
   auto CreateCodecForExtension(std::string extension) -> cpp::result<std::unique_ptr<ICodec>, CreateCodecError>;
 
@@ -17,13 +20,39 @@ namespace codecs {
 
       virtual auto CanHandleExtension(std::string extension) -> bool = 0;
 
+      struct OutputFormat {
+        uint8_t num_channels;
+        uint8_t bits_per_sample;
+        int sample_rate_hz;
+      };
+
+      virtual auto GetOutputFormat() -> OutputFormat = 0;
+
       enum Error {};
 
+      struct Result {
+        bool need_more_input;
+        /*
+         * For need_more_input, this is how far we got in the input buffer
+         * before we were unable to process more data. Any remaining data in the
+         * buffer should be moved to the start before the next call.
+         */
+          std::size_t input_processed;
+
+        bool flush_output;
+         /*
+         * For flush_output, this is how far we got in the output buffer before
+         * we ran out of space for samples. The caller should flush this many
+         * bytes downstream.
+         */
+          std::size_t output_written;
+      };
+
       virtual auto Process(
           uint8_t *input,
           std::size_t input_len,
           uint8_t *output,
-	  std::size_t output_length) -> cpp::result<size_t, Error>  = 0;
+	  std::size_t output_length) -> cpp::result<Result, Error>  = 0;
   };
 
 } // namespace codecs

src/codecs/include/mad.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "codec.hpp"
+
+namespace codecs {
+
+  class MadMp3Decoder : public ICodec {
+    public:
+      MadMp3Decoder();
+      ~MadMp3Decoder();
+
+      auto ProcessInput(Result *res, uint8_t *input, std::size_t input_len) -> void;
+      auto WriteOutputSamples(Result *res, uint8_t *output, std::size_t output_length) -> void;
+
+    private:
+      mad_stream stream_;
+      mad_frame	frame_;
+      mad_synth	synth_;
+
+      mad_header header_;
+      bool has_decoded_header_;
+
+      int current_sample_ = -1;
+  };
+
+} // namespace codecs

src/codecs/mad.cpp

@@ -0,0 +1,154 @@
+#include "mad.hpp"
+#include <cstdint>
+
+#include "mad.h"
+
+namespace codecs {
+
+  static int32_t scaleTo24Bits(mad_fixed_t sample) {
+    // Round the bottom bits.
+    sample += (1L << (MAD_F_FRACBITS - 24));
+
+    // Clip the leftover bits to within range.
+    if (sample >= MAD_F_ONE)
+      sample = MAD_F_ONE - 1;
+    else if (sample < -MAD_F_ONE)
+      sample = -MAD_F_ONE;
+
+    /* quantize */
+    return sample >> (MAD_F_FRACBITS + 1 - 24);
+  }
+
+  MadMp3Decoder::MadMp3Decoder() {
+    mad_stream_init(&stream_);
+    mad_frame_init(&frame_);
+    mad_synth_init(&synth_);
+    mad_header_init(&header_);
+  }
+  MadMp3Decoder::~MadMp3Decoder() {
+    mad_stream_finish(&stream_);
+    mad_frame_finish(&frame_);
+    mad_synth_finish(&synth_);
+    mad_header_finish(&header_);
+  }
+
+      auto MadMp3Decoder::CanHandleExtension(std::string extension) -> bool {
+      return extension == "mp3";
+      }
+
+      auto GetOutputFormat() -> OutputFormat {
+        return OutputFormat {
+          .num_channels = synth_.pcm.channels,
+          .bits_per_sample = 24,
+          .sample_rate_hz = synth_.pcm.samplerate,
+        };
+      }
+
+      auto MadMp3Decoder::Process(
+          uint8_t *input,
+          std::size_t input_len,
+          uint8_t *output,
+	  std::size_t output_length) -> cpp::result<Result, Error> {
+
+        Result res {
+          .need_more_input = false,
+          .input_processed = 0,
+          .flush_output = false,
+          .output_written = 0,
+        }
+        while (true) {
+          // Only process more of the input if we're done sending off the
+          // samples for the previous frame.
+          if (current_sample_ == -1) {
+            ProcessInput(&res, input, input_len);
+          }
+
+          // Write PCM samples to the output buffer. This always needs to be
+          // done, even if we ran out of input, so that we don't keep the last
+          // few samples buffered if the input stream has actually finished.
+          WriteOutputSamples(&res, output, output_length);
+
+          if (res.need_more_input || res.flush_output) {
+            return res;
+          }
+      }
+
+      auto MadMp3Decoder::ProcessInput(
+          Result *res, uint8_t *input, std::size_t input_len) -> void {
+
+        if (input != stream_.buffer) {
+          mad_stream_buffer(&stream_, input, input_len);
+        }
+
+          if (!has_decoded_header_) {
+            // The header of any given frame should be representative of the
+            // entire stream, so only need to read it once.
+            mad_header_decode(&header_, &stream);
+            has_decoded_header_ = true;
+
+            // TODO: Use the info in the header for something. I think the
+            // duration will help with seeking?
+          }
+
+
+          // Decode the next frame. To signal errors, this returns -1 and
+          // stashes an error code in the stream structure.
+          if (mad_frame_decode(&frame_, &stream_) < 0) {
+            if (MAD_RECOVERABLE(stream_.error)) {
+              // Recoverable errors are usually malformed parts of the stream.
+              // We can recover from them by just retrying the decode.
+              continue;
+            }
+
+            if (stream_.error = MAD_ERROR_BUFLEN) {
+              // The decoder ran out of bytes before it completed a frame. We
+              // need to return back to the caller to give us more data. Note
+              // that there might still be some unused data in the input, so we
+              // should calculate that amount and return it.
+              size_t remaining_bytes = stream.bufend - stream_.next_frame;
+              return remaining_bytes;
+            }
+
+            // The error is unrecoverable. Give up.
+            return cpp::fail(MALFORMED_DATA);
+          }
+
+          // We've successfully decoded a frame!
+          // Now we need to synthesize PCM samples based on the frame, and send
+          // them downstream.
+          mad_synth_frame(&synth_, &frame_);
+          up_to_sample = 0;
+      }
+
+      auto MadMp3Decoder::WriteOutputSamples(
+          Result *res,
+          uint8_t *output,
+	  std::size_t output_length) -> void {
+        size_t output_byte = 0;
+        // First ensure that we actually have some samples to send off.
+        if (current_sample_ < 0) {
+          return;
+        }
+        res->flush_output = true;
+
+        while (current_sample_ < synth_.pcm.length) {
+          if (output_byte + (3 * synth_.pcm.channels) >= output_length) {
+            res->output_written = output_byte;
+            return;
+          }
+
+          for (int channel = 0; channel < synth_.pcm.channels; channel++) {
+            uint32_t sample_24 = scaleTo24Bits(synth_.pcm.samples[channel][sample]);
+            output[output_byte++] = (sample_24 >> 0) & 0xff;
+            output[output_byte++] = (sample_24 >> 8) & 0xff;
+            output[output_byte++] = (sample_24 >> 16) & 0xff;
+          }
+          current_sample_++;
+        }
+
+        // We wrote everything! Reset, ready for the next frame.
+        current_sample_ = -1;
+        res->output_written = output_byte;
+      }
+
+} // namespace codecs