From b1b3582772dae244e6e3569ca6c0cc5780ffb8f3 Mon Sep 17 00:00:00 2001 From: dvdli Date: Mon, 22 Feb 2021 17:24:30 +0800 Subject: support float config and float wave file playback --- include/tinyalsa/pcm.h | 4 ++++ src/pcm.c | 7 +++++++ tests/src/pcm_test.cc | 2 ++ utils/tinyplay.c | 29 ++++++++++++++++++++--------- 4 files changed, 33 insertions(+), 9 deletions(-) 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..3d50ea7 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: 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..c9e4606 100644 --- a/utils/tinyplay.c +++ b/utils/tinyplay.c @@ -70,6 +70,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; @@ -164,16 +167,24 @@ int ctx_init(struct ctx* ctx, const struct cmd *cmd) bits = ctx->chunk_fmt.bits_per_sample; } - 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 (ctx->chunk_fmt.audio_format == WAVE_FORMAT_PCM) { + 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; + } else { + fprintf(stderr, "bit count '%u' not supported\n", bits); + fclose(ctx->file); + return -1; + } + } else if (ctx->chunk_fmt.audio_format == WAVE_FORMAT_IEEE_FLOAT) { + config.format = PCM_FORMAT_FLOAT_LE; } else { - fprintf(stderr, "bit count '%u' not supported\n", bits); + fprintf(stderr, "format '%hu' not supported\n", ctx->chunk_fmt.audio_format); fclose(ctx->file); return -1; } -- cgit v1.2.3 From 411a7d88e4121e04da1f63fa9072fd6444f753a2 Mon Sep 17 00:00:00 2001 From: dvdli Date: Wed, 10 Mar 2021 18:17:23 +0800 Subject: add a loopback test for floating point PCM --- tests/src/pcm_loopback_test.cc | 118 ++++++++++++++++++++++++++++------------- 1 file changed, 81 insertions(+), 37 deletions(-) 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 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 { using Type = int16_t; + static constexpr pcm_format kFormat = PCM_FORMAT_S16_LE; static constexpr Type kMax = std::numeric_limits::max(); static constexpr Type kMin = std::numeric_limits::min(); }; +template<> +struct PcmFormat { + 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 +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; +using FloatPcmFormat = PcmFormat; - ASSERT_EQ(pcm_link(pcm_in, pcm_out), 0); +using Formats = ::testing::Types; + +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 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(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 -- cgit v1.2.3 From a36d521c328b16b53360a016aa543491d0aad05e Mon Sep 17 00:00:00 2001 From: dvdli Date: Thu, 11 Mar 2021 18:01:56 +0800 Subject: add floating-point PCM supoort to tinyplay This change also fixes overwriting the appl_ptr and avail_min when calling the pcm_state function. --- Android.bp | 8 ++-- src/pcm.c | 3 +- utils/tinyplay.c | 109 +++++++++++++++++++++++++++++++++++-------------------- 3 files changed, 75 insertions(+), 45 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/src/pcm.c b/src/pcm.c index 3d50ea7..63ca65f 100644 --- a/src/pcm.c +++ b/src/pcm.c @@ -1411,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/utils/tinyplay.c b/utils/tinyplay.c index c9e4606..96d0f60 100644 --- a/utils/tinyplay.c +++ b/utils/tinyplay.c @@ -27,11 +27,12 @@ */ #include +#include +#include +#include #include #include -#include #include -#include #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 @@ -103,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"); @@ -123,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); @@ -162,43 +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 (ctx->chunk_fmt.audio_format == WAVE_FORMAT_PCM) { - 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; - } else { + if (is_float) { + config->format = PCM_FORMAT_FLOAT_LE; + } else { + 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; } - } else if (ctx->chunk_fmt.audio_format == WAVE_FORMAT_IEEE_FLOAT) { - config.format = PCM_FORMAT_FLOAT_LE; - } else { - fprintf(stderr, "format '%hu' not supported\n", ctx->chunk_fmt.audio_format); - 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; @@ -239,10 +252,11 @@ void print_usage(const char *argv0) fprintf(stderr, "-d | --device The device to receive the audio\n"); fprintf(stderr, "-p | --period-size The size of the PCM's period\n"); fprintf(stderr, "-n | --period-count The number of PCM periods\n"); - fprintf(stderr, "-i | --file-type The type of file to read (raw or wav)\n"); + fprintf(stderr, "-i | --file-type The type of file to read (raw or wav)\n"); fprintf(stderr, "-c | --channels The amount of channels per frame\n"); fprintf(stderr, "-r | --rate The amount of frames per second\n"); fprintf(stderr, "-b | --bits 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"); } @@ -261,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 } @@ -314,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; @@ -340,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); @@ -410,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); @@ -432,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); -- cgit v1.2.3