Work

test/test_minimp3_decoder.cpp

@@ -0,0 +1,144 @@
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+static void* testMp3Scratch();
+#define MINIMP3_ONLY_MP3
+#define MINIMP3_NO_SIMD
+#define MINIMP3_SCRATCH ((mp3dec_scratch_t*)testMp3Scratch())
+#define MINIMP3_IMPLEMENTATION
+#include "../lib/minimp3/minimp3.h"
+
+static mp3dec_scratch_t g_scratch;
+static void* testMp3Scratch() { return &g_scratch; }
+
+struct DecodeBuffer {
+  uint8_t input[16 * 1024];
+  mp3d_sample_t pcm[MINIMP3_MAX_SAMPLES_PER_FRAME];
+};
+
+static uint32_t readLe32(const uint8_t* value) {
+  return (uint32_t)value[0] | ((uint32_t)value[1] << 8) |
+         ((uint32_t)value[2] << 16) | ((uint32_t)value[3] << 24);
+}
+
+static long mp3DataEnd(FILE* file) {
+  assert(fseek(file, 0, SEEK_END) == 0);
+  long end = ftell(file);
+  assert(end >= 0);
+  uint8_t footer[128];
+  if (end >= 128 && fseek(file, end - 128, SEEK_SET) == 0 &&
+      fread(footer, 1, 3, file) == 3 && !memcmp(footer, "TAG", 3)) {
+    end -= 128;
+  }
+  if (end >= 32 && fseek(file, end - 32, SEEK_SET) == 0 &&
+      fread(footer, 1, 32, file) == 32 && !memcmp(footer, "APETAGEX", 8)) {
+    const uint32_t version = readLe32(footer + 8);
+    const uint32_t tag_size = readLe32(footer + 12);
+    const uint32_t flags = readLe32(footer + 20);
+    const uint64_t total_size = (uint64_t)tag_size + ((flags & 0x80000000u) ? 32u : 0u);
+    if ((version == 1000 || version == 2000) && tag_size >= 32 && total_size <= (uint64_t)end)
+      end -= (long)total_size;
+  }
+  rewind(file);
+  return end;
+}
+
+static bool decodeFile(const char* path) {
+  FILE* file = fopen(path, "rb");
+  if (!file) {
+    fprintf(stderr, "%s: could not open\n", path);
+    return false;
+  }
+  const long data_end = mp3DataEnd(file);
+  if (data_end <= 0) { fclose(file); return false; }
+
+  DecodeBuffer buffer;
+  mp3dec_t decoder;
+  mp3dec_init(&decoder);
+  size_t input_start = 0, input_count = 0;
+  uint64_t samples_total = 0;
+  int frames = 0, sample_rate = 0, channels = 0, bitrate_changes = 0;
+  int last_bitrate = 0;
+  bool eof = false, ok = true;
+
+  while (ok) {
+    if (!eof && input_count < 4096) {
+      if (input_start && input_start + input_count + 4096 > sizeof buffer.input) {
+        memmove(buffer.input, buffer.input + input_start, input_count);
+        input_start = 0;
+      }
+      size_t room = sizeof buffer.input - (input_start + input_count);
+      const long position = ftell(file);
+      const size_t remaining = position < data_end ? (size_t)(data_end - position) : 0;
+      if (room > remaining) room = remaining;
+      const size_t got = fread(buffer.input + input_start + input_count, 1, room, file);
+      if (got > 0) {
+        input_count += got;
+        eof = ftell(file) >= data_end;
+      }
+      else if (ferror(file)) ok = false;
+      else eof = true;
+    }
+
+    if (!ok || !input_count) break;
+
+    mp3dec_frame_info_t info = {};
+    const int samples = mp3dec_decode_frame(&decoder, buffer.input + input_start,
+      (int)input_count, buffer.pcm, &info);
+    if (info.frame_bytes < 0 || (size_t)info.frame_bytes > input_count) {
+      ok = false;
+      break;
+    }
+    if (info.frame_bytes > 0) {
+      input_start += (size_t)info.frame_bytes;
+      input_count -= (size_t)info.frame_bytes;
+      if (!input_count) input_start = 0;
+    } else if (eof) {
+      break;
+    } else if (input_start + input_count == sizeof buffer.input) {
+      ok = false;
+      break;
+    } else {
+      continue;
+    }
+
+    if (samples <= 0) continue;
+    if (info.layer != 3 || (info.channels != 1 && info.channels != 2) ||
+        info.hz < 8000 || info.hz > 48000) {
+      ok = false;
+      break;
+    }
+    if (!sample_rate) {
+      sample_rate = info.hz;
+      channels = info.channels;
+    } else if (sample_rate != info.hz) {
+      ok = false;
+      break;
+    }
+    if (last_bitrate && last_bitrate != info.bitrate_kbps) ++bitrate_changes;
+    last_bitrate = info.bitrate_kbps;
+    samples_total += (uint64_t)samples;
+    ++frames;
+  }
+
+  fclose(file);
+  if (!ok || frames == 0 || samples_total == 0) {
+    fprintf(stderr, "%s: decode failed after %d frames\n", path, frames);
+    return false;
+  }
+  printf("%s: %d frames, %llu samples/channel, %d Hz, %d channel(s), %d bitrate changes\n",
+         path, frames, (unsigned long long)samples_total, sample_rate, channels,
+         bitrate_changes);
+  return true;
+}
+
+int main(int argc, char** argv) {
+  if (argc < 2) {
+    fprintf(stderr, "usage: %s file.mp3 [file.mp3 ...]\n", argv[0]);
+    return 2;
+  }
+  for (int i = 1; i < argc; ++i) assert(decodeFile(argv[i]));
+  return 0;
+}