Merge pull request #202 from dvdli/tinyalsa-float-dev

floating-point PCM support

6 files changed, 175 insertions, 77 deletions

diff --git a/Android.bp b/Android.bp
index 330393c..d6fec57 100644
--- a/Android.bp
+++ b/Android.bp
@@ -67,7 +67,7 @@ cc_binary {
     name: "tinyplay2",
     host_supported: true,
     srcs: ["utils/tinyplay.c"],
-    shared_libs: ["libtinyalsav2"],
+    static_libs: ["libtinyalsav2"],
     cflags: ["-Werror"],
     target: {
         darwin: {
@@ -79,20 +79,20 @@ cc_binary {
 cc_binary {
     name: "tinycap2",
     srcs: ["utils/tinycap.c"],
-    shared_libs: ["libtinyalsav2"],
+    static_libs: ["libtinyalsav2"],
     cflags: ["-Werror"],
 }
 
 cc_binary {
     name: "tinymix2",
     srcs: ["utils/tinymix.c"],
-    shared_libs: ["libtinyalsav2"],
+    static_libs: ["libtinyalsav2"],
     cflags: ["-Werror", "-Wall"],
 }
 
 cc_binary {
     name: "tinypcminfo2",
     srcs: ["utils/tinypcminfo.c"],
-    shared_libs: ["libtinyalsav2"],
+    static_libs: ["libtinyalsav2"],
     cflags: ["-Werror"],
 }
diff --git a/include/tinyalsa/pcm.h b/include/tinyalsa/pcm.h
index b40550c..5c11e2a 100644
--- a/include/tinyalsa/pcm.h
+++ b/include/tinyalsa/pcm.h
@@ -178,6 +178,10 @@ enum pcm_format {
     PCM_FORMAT_S24_3BE,
     /** Signed, 32-bit, big endian */
     PCM_FORMAT_S32_BE,
+    /** 32-bit float, little endian */
+    PCM_FORMAT_FLOAT_LE,
+    /** 32-bit float, big endian */
+    PCM_FORMAT_FLOAT_BE,
     /** Max of the enumeration list, not an actual format. */
     PCM_FORMAT_MAX
 };
diff --git a/src/pcm.c b/src/pcm.c
index 10e477b..63ca65f 100644
--- a/src/pcm.c
+++ b/src/pcm.c
@@ -282,6 +282,11 @@ static unsigned int pcm_format_to_alsa(enum pcm_format format)
         return SNDRV_PCM_FORMAT_S32_LE;
     case PCM_FORMAT_S32_BE:
         return SNDRV_PCM_FORMAT_S32_BE;
+
+    case PCM_FORMAT_FLOAT_LE:
+        return SNDRV_PCM_FORMAT_FLOAT_LE;
+    case PCM_FORMAT_FLOAT_BE:
+        return SNDRV_PCM_FORMAT_FLOAT_BE;
     };
 }
 
@@ -556,6 +561,8 @@ unsigned int pcm_format_to_bits(enum pcm_format format)
     case PCM_FORMAT_S32_BE:
     case PCM_FORMAT_S24_LE:
     case PCM_FORMAT_S24_BE:
+    case PCM_FORMAT_FLOAT_LE:
+    case PCM_FORMAT_FLOAT_BE:
         return 32;
     case PCM_FORMAT_S24_3LE:
     case PCM_FORMAT_S24_3BE:
@@ -1404,7 +1411,8 @@ again:
 
 int pcm_state(struct pcm *pcm)
 {
-    int err = pcm_sync_ptr(pcm, 0);
+    // Update the state only. Do not sync HW sync.
+    int err = pcm_sync_ptr(pcm, SNDRV_PCM_SYNC_PTR_APPL | SNDRV_PCM_SYNC_PTR_AVAIL_MIN);
     if (err < 0)
         return err;
 
diff --git a/tests/src/pcm_loopback_test.cc b/tests/src/pcm_loopback_test.cc
index 6a3ffb8..5c6ff4d 100644
--- a/tests/src/pcm_loopback_test.cc
+++ b/tests/src/pcm_loopback_test.cc
@@ -64,6 +64,7 @@ public:
 template<pcm_format F>
 struct PcmFormat {
     using Type = void;
+    static constexpr pcm_format kFormat = F;
     static constexpr int32_t kMax = 0;
     static constexpr int32_t kMin = 0;
 };
@@ -71,10 +72,19 @@ struct PcmFormat {
 template<>
 struct PcmFormat<PCM_FORMAT_S16_LE> {
     using Type = int16_t;
+    static constexpr pcm_format kFormat = PCM_FORMAT_S16_LE;
     static constexpr Type kMax = std::numeric_limits<Type>::max();
     static constexpr Type kMin = std::numeric_limits<Type>::min();
 };
 
+template<>
+struct PcmFormat<PCM_FORMAT_FLOAT_LE> {
+    using Type = float;
+    static constexpr pcm_format kFormat = PCM_FORMAT_FLOAT_LE;
+    static constexpr Type kMax = 1.0;
+    static constexpr Type kMin = -1.0;
+};
+
 // CH: channels
 // SR: sampling rate
 // FQ: sine wave frequency
@@ -139,43 +149,77 @@ static double Energy(T *buffer, size_t samples) {
     return sum;
 }
 
-TEST(PcmLoopbackTest, LoopbackS16le) {
+template<typename F>
+class PcmLoopbackTest : public ::testing::Test {
+  protected:
+    PcmLoopbackTest() = default;
+    virtual ~PcmLoopbackTest() = default;
+
+    void SetUp() override {
+        static constexpr pcm_config kInConfig = {
+            .channels = kDefaultChannels,
+            .rate = kDefaultSamplingRate,
+            .period_size = kDefaultPeriodSize,
+            .period_count = kDefaultPeriodCount,
+            .format = kPcmForamt,
+            .start_threshold = 0,
+            .stop_threshold = 0,
+            .silence_threshold = 0,
+            .silence_size = 0,
+        };
+        pcm_in = pcm_open(kLoopbackCard, kLoopbackCaptureDevice, PCM_IN, &kInConfig);
+        ASSERT_TRUE(pcm_is_ready(pcm_in));
+
+        static constexpr pcm_config kOutConfig = {
+            .channels = kDefaultChannels,
+            .rate = kDefaultSamplingRate,
+            .period_size = kDefaultPeriodSize,
+            .period_count = kDefaultPeriodCount,
+            .format = kPcmForamt,
+            .start_threshold = kDefaultPeriodSize,
+            .stop_threshold = kDefaultPeriodSize * kDefaultPeriodCount,
+            .silence_threshold = 0,
+            .silence_size = 0,
+        };
+        pcm_out = pcm_open(kLoopbackCard, kLoopbackPlaybackDevice, PCM_OUT, &kOutConfig);
+        ASSERT_TRUE(pcm_is_ready(pcm_out));
+        ASSERT_EQ(pcm_link(pcm_in, pcm_out), 0);
+    }
+
+    void TearDown() override {
+        ASSERT_EQ(pcm_unlink(pcm_in), 0);
+        pcm_close(pcm_in);
+        pcm_close(pcm_out);
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
+
     static constexpr unsigned int kDefaultChannels = 2;
     static constexpr unsigned int kDefaultSamplingRate = 48000;
     static constexpr unsigned int kDefaultPeriodSize = 1024;
     static constexpr unsigned int kDefaultPeriodCount = 3;
     static constexpr unsigned int kDefaultPeriodTimeInMs =
             kDefaultPeriodSize * 1000 / kDefaultSamplingRate;
+    static constexpr pcm_format kPcmForamt = F::Format;
+    pcm *pcm_in;
+    pcm *pcm_out;
+};
 
-    static constexpr pcm_config kInConfig = {
-        .channels = kDefaultChannels,
-        .rate = kDefaultSamplingRate,
-        .period_size = kDefaultPeriodSize,
-        .period_count = kDefaultPeriodCount,
-        .format = PCM_FORMAT_S16_LE,
-        .start_threshold = 0,
-        .stop_threshold = 0,
-        .silence_threshold = 0,
-        .silence_size = 0,
-    };
-    pcm *pcm_in = pcm_open(kLoopbackCard, kLoopbackCaptureDevice, PCM_IN, &kInConfig);
-    ASSERT_TRUE(pcm_is_ready(pcm_in));
-
-    static constexpr pcm_config kOutConfig = {
-        .channels = kDefaultChannels,
-        .rate = kDefaultSamplingRate,
-        .period_size = kDefaultPeriodSize,
-        .period_count = kDefaultPeriodCount,
-        .format = PCM_FORMAT_S16_LE,
-        .start_threshold = kDefaultPeriodSize,
-        .stop_threshold = kDefaultPeriodSize * kDefaultPeriodCount,
-        .silence_threshold = 0,
-        .silence_size = 0,
-    };
-    pcm *pcm_out = pcm_open(kLoopbackCard, kLoopbackPlaybackDevice, PCM_OUT, &kOutConfig);
-    ASSERT_TRUE(pcm_is_ready(pcm_out));
+using S16bitlePcmFormat = PcmFormat<PCM_FORMAT_S16_LE>;
+using FloatPcmFormat = PcmFormat<PCM_FORMAT_FLOAT_LE>;
 
-    ASSERT_EQ(pcm_link(pcm_in, pcm_out), 0);
+using Formats = ::testing::Types<S16bitlePcmFormat, FloatPcmFormat>;
+
+TYPED_TEST_SUITE(PcmLoopbackTest, Formats);
+
+TYPED_TEST(PcmLoopbackTest, Loopback) {
+    static constexpr unsigned int kDefaultChannels = this->kDefaultChannels;
+    static constexpr unsigned int kDefaultSamplingRate = this->kDefaultSamplingRate;
+    static constexpr unsigned int kDefaultPeriodSize = this->kDefaultPeriodSize;
+    // static constexpr unsigned int kDefaultPeriodCount = this->kDefaultPeriodCount;
+    static constexpr unsigned int kDefaultPeriodTimeInMs = this->kDefaultPeriodTimeInMs;
+    static constexpr pcm_format kPcmForamt = this->kPcmForamt;
+    pcm *pcm_in = this->pcm_in;
+    pcm *pcm_out = this->pcm_out;
 
     bool stopping = false;
     ASSERT_EQ(pcm_get_subdevice(pcm_in), pcm_get_subdevice(pcm_out));
@@ -190,23 +234,26 @@ TEST(PcmLoopbackTest, LoopbackS16le) {
             if (res == -1) {
                 std::cout << pcm_get_error(pcm_in) << std::endl;
                 std::this_thread::sleep_for(std::chrono::milliseconds(kDefaultPeriodTimeInMs));
+                counter++;
                 continue;
             }
-            EXPECT_EQ(pcm_readi(pcm_in, buffer.get(), frames), frames) << counter;
+
             // Test the energy of the buffer after the sine tone samples fill in the buffer.
             // Therefore, check the buffer 5 times later.
             if (counter >= 5) {
-                double e = Energy(buffer.get(), frames * kInConfig.channels);
+                double e = Energy(buffer.get(), frames * kDefaultChannels);
                 EXPECT_GT(e, 0.0) << counter;
             }
             counter++;
         }
+        std::cout << "read count = " << counter << std::endl;
     });
 
     std::thread playback([pcm_out, &stopping] {
-        SineToneGenerator<2, 48000, 1000, 0, PCM_FORMAT_S16_LE> generator;
+        SineToneGenerator<kDefaultChannels, kDefaultSamplingRate, 1000, 0, kPcmForamt> generator;
         size_t buffer_size = pcm_frames_to_bytes(pcm_out, kDefaultPeriodSize);
         unsigned int frames = pcm_bytes_to_frames(pcm_out, buffer_size);
+        std::cout << buffer_size << std::endl;
         auto buffer = std::make_unique<unsigned char[]>(buffer_size);
         int32_t counter = 0;
         while (!stopping) {
@@ -214,16 +261,13 @@ TEST(PcmLoopbackTest, LoopbackS16le) {
             EXPECT_EQ(pcm_writei(pcm_out, buffer.get(), frames), frames) << counter;
             counter++;
         }
+        std::cout << "write count = " << counter << std::endl;
     });
 
-    std::this_thread::sleep_for(std::chrono::seconds(1));
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
     stopping = true;
     capture.join();
     playback.join();
-
-    ASSERT_EQ(pcm_unlink(pcm_in), 0);
-    pcm_close(pcm_in);
-    pcm_close(pcm_out);
 }
 
 } // namespace testing
diff --git a/tests/src/pcm_test.cc b/tests/src/pcm_test.cc
index 2668350..da114de 100644
--- a/tests/src/pcm_test.cc
+++ b/tests/src/pcm_test.cc
@@ -49,6 +49,8 @@ TEST(PcmTest, FormatToBits) {
     ASSERT_EQ(pcm_format_to_bits(PCM_FORMAT_S24_BE), 32);
     ASSERT_EQ(pcm_format_to_bits(PCM_FORMAT_S24_3BE), 24);
     ASSERT_EQ(pcm_format_to_bits(PCM_FORMAT_S32_BE), 32);
+    ASSERT_EQ(pcm_format_to_bits(PCM_FORMAT_FLOAT_LE), 32);
+    ASSERT_EQ(pcm_format_to_bits(PCM_FORMAT_FLOAT_BE), 32);
 }
 
 TEST(PcmTest, OpenAndCloseOutPcm) {
diff --git a/utils/tinyplay.c b/utils/tinyplay.c
index 4c7ccf6..96d0f60 100644
--- a/utils/tinyplay.c
+++ b/utils/tinyplay.c
@@ -27,11 +27,12 @@
 */
 
 #include <tinyalsa/asoundlib.h>
+#include <signal.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdint.h>
 #include <string.h>
-#include <signal.h>
 
 #define OPTPARSE_IMPLEMENTATION
 #include "optparse.h"
@@ -44,6 +45,7 @@ struct cmd {
     int flags;
     struct pcm_config config;
     unsigned int bits;
+    bool is_float;
 };
 
 void cmd_init(struct cmd *cmd)
@@ -63,6 +65,7 @@ void cmd_init(struct cmd *cmd)
     cmd->config.stop_threshold = cmd->config.period_size * cmd->config.period_count;
     cmd->config.start_threshold = cmd->config.period_size;
     cmd->bits = 16;
+    cmd->is_float = false;
 }
 
 #define ID_RIFF 0x46464952
@@ -70,6 +73,9 @@ void cmd_init(struct cmd *cmd)
 #define ID_FMT  0x20746d66
 #define ID_DATA 0x61746164
 
+#define WAVE_FORMAT_PCM 0x0001
+#define WAVE_FORMAT_IEEE_FLOAT 0x0003
+
 struct riff_wave_header {
     uint32_t riff_id;
     uint32_t riff_sz;
@@ -100,10 +106,32 @@ struct ctx {
     FILE *file;
 };
 
-int ctx_init(struct ctx* ctx, const struct cmd *cmd)
+static bool is_wave_file(const char *filetype)
+{
+    return filetype != NULL && strcmp(filetype, "wav") == 0;
+}
+
+static bool signed_pcm_bits_to_format(int bits)
+{
+    switch (bits) {
+    case 8:
+        return PCM_FORMAT_S8;
+    case 16:
+        return PCM_FORMAT_S16_LE;
+    case 24:
+        return PCM_FORMAT_S24_3LE;
+    case 32:
+        return PCM_FORMAT_S32_LE;
+    default:
+        return -1;
+    }
+}
+
+static int ctx_init(struct ctx* ctx, struct cmd *cmd)
 {
     unsigned int bits = cmd->bits;
-    struct pcm_config config = cmd->config;
+    struct pcm_config *config = &cmd->config;
+    bool is_float = cmd->is_float;
 
     if (cmd->filename == NULL) {
         fprintf(stderr, "filename not specified\n");
@@ -120,7 +148,7 @@ int ctx_init(struct ctx* ctx, const struct cmd *cmd)
         return -1;
     }
 
-    if ((cmd->filetype != NULL) && (strcmp(cmd->filetype, "wav") == 0)) {
+    if (is_wave_file(cmd->filetype)) {
         if (fread(&ctx->wave_header, sizeof(ctx->wave_header), 1, ctx->file) != 1){
             fprintf(stderr, "error: '%s' does not contain a riff/wave header\n", cmd->filename);
             fclose(ctx->file);
@@ -159,35 +187,31 @@ int ctx_init(struct ctx* ctx, const struct cmd *cmd)
                 fseek(ctx->file, ctx->chunk_header.sz, SEEK_CUR);
             }
         } while (more_chunks);
-        config.channels = ctx->chunk_fmt.num_channels;
-        config.rate = ctx->chunk_fmt.sample_rate;
+        config->channels = ctx->chunk_fmt.num_channels;
+        config->rate = ctx->chunk_fmt.sample_rate;
         bits = ctx->chunk_fmt.bits_per_sample;
+        is_float = ctx->chunk_fmt.audio_format == WAVE_FORMAT_IEEE_FLOAT;
     }
 
-    if (bits == 8) {
-        config.format = PCM_FORMAT_S8;
-    } else if (bits == 16) {
-        config.format = PCM_FORMAT_S16_LE;
-    } else if (bits == 24) {
-        config.format = PCM_FORMAT_S24_3LE;
-    } else if (bits == 32) {
-        config.format = PCM_FORMAT_S32_LE;
+    if (is_float) {
+        config->format = PCM_FORMAT_FLOAT_LE;
     } else {
-        fprintf(stderr, "bit count '%u' not supported\n", bits);
-        fclose(ctx->file);
-        return -1;
+        config->format = signed_pcm_bits_to_format(bits);
+        if (config->format == -1) {
+            fprintf(stderr, "bit count '%u' not supported\n", bits);
+            fclose(ctx->file);
+            return -1;
+        }
     }
 
     ctx->pcm = pcm_open(cmd->card,
                         cmd->device,
                         cmd->flags,
-                        &config);
-    if (ctx->pcm == NULL) {
-        fprintf(stderr, "failed to allocate memory for pcm\n");
-        fclose(ctx->file);
-        return -1;
-    } else if (!pcm_is_ready(ctx->pcm)) {
-        fprintf(stderr, "failed to open for pcm %u,%u\n", cmd->card, cmd->device);
+                        config);
+    if (!pcm_is_ready(ctx->pcm)) {
+        fprintf(stderr, "failed to open for pcm %u,%u. %s\n",
+                cmd->card, cmd->device,
+                pcm_get_error(ctx->pcm));
         fclose(ctx->file);
         pcm_close(ctx->pcm);
         return -1;
@@ -228,10 +252,11 @@ void print_usage(const char *argv0)
     fprintf(stderr, "-d | --device <device number>  The device to receive the audio\n");
     fprintf(stderr, "-p | --period-size <size>      The size of the PCM's period\n");
     fprintf(stderr, "-n | --period-count <count>    The number of PCM periods\n");
-    fprintf(stderr, "-i | --file-type <file-type >  The type of file to read (raw or wav)\n");
+    fprintf(stderr, "-i | --file-type <file-type>   The type of file to read (raw or wav)\n");
     fprintf(stderr, "-c | --channels <count>        The amount of channels per frame\n");
     fprintf(stderr, "-r | --rate <rate>             The amount of frames per second\n");
     fprintf(stderr, "-b | --bits <bit-count>        The number of bits in one sample\n");
+    fprintf(stderr, "-f | --float                   The frames are in floating-point PCM\n");
     fprintf(stderr, "-M | --mmap                    Use memory mapped IO to play audio\n");
 }
 
@@ -250,6 +275,7 @@ int main(int argc, char **argv)
         { "channels",     'c', OPTPARSE_REQUIRED },
         { "rate",         'r', OPTPARSE_REQUIRED },
         { "bits",         'b', OPTPARSE_REQUIRED },
+        { "float",        'f', OPTPARSE_NONE     },
         { "mmap",         'M', OPTPARSE_NONE     },
         { "help",         'h', OPTPARSE_NONE     },
         { 0, 0, 0 }
@@ -303,6 +329,15 @@ int main(int argc, char **argv)
         case 'i':
             cmd.filetype = opts.optarg;
             break;
+        case 'b':
+            if (sscanf(opts.optarg, "%u", &cmd.bits) != 1) {
+                fprintf(stderr, "failed parsing bits per one sample '%s'\n", argv[1]);
+                return EXIT_FAILURE;
+            }
+            break;
+        case 'f':
+            cmd.is_float = true;
+            break;
         case 'M':
             cmd.flags |= PCM_MMAP;
             break;
@@ -329,12 +364,13 @@ int main(int argc, char **argv)
         return EXIT_FAILURE;
     }
 
-    /* TODO get parameters from context */
-    printf("playing '%s': %u ch, %u hz, %u bit\n",
-           cmd.filename,
-           cmd.config.channels,
-           cmd.config.rate,
-           cmd.bits);
+    printf("playing '%s': %u ch, %u hz, %u-bit ", cmd.filename, cmd.config.channels,
+            cmd.config.rate, pcm_format_to_bits(cmd.config.format));
+    if (cmd.config.format == PCM_FORMAT_FLOAT_LE) {
+        printf("floating-point PCM\n");
+    } else {
+        printf("signed PCM\n");
+    }
 
     if (play_sample(&ctx) < 0) {
         ctx_free(&ctx);
@@ -399,6 +435,7 @@ int play_sample(struct ctx *ctx)
     size_t buffer_size = 0;
     size_t num_read = 0;
     size_t remaining_data_size = ctx->chunk_header.sz;
+    size_t played_data_size = 0;
     size_t read_size = 0;
     const struct pcm_config *config = pcm_get_config(ctx->pcm);
 
@@ -421,15 +458,18 @@ int play_sample(struct ctx *ctx)
         read_size = remaining_data_size > buffer_size ? buffer_size : remaining_data_size;
         num_read = fread(buffer, 1, read_size, ctx->file);
         if (num_read > 0) {
-            if (pcm_writei(ctx->pcm, buffer,
-                pcm_bytes_to_frames(ctx->pcm, num_read)) < 0) {
-                fprintf(stderr, "error playing sample\n");
+            int written_frames = pcm_writei(ctx->pcm, buffer,
+                    pcm_bytes_to_frames(ctx->pcm, num_read));
+            if (written_frames < 0) {
+                fprintf(stderr, "error playing sample. %s\n", pcm_get_error(ctx->pcm));
                 break;
             }
             remaining_data_size -= num_read;
+            played_data_size += pcm_frames_to_bytes(ctx->pcm, written_frames);
         }
     } while (!close && num_read > 0 && remaining_data_size > 0);
 
+    printf("Played %zu bytes. Remains %zu bytes.\n", played_data_size, remaining_data_size);
     pcm_wait(ctx->pcm, -1);
 
     free(buffer);