From 60f767713227b5405b855e6e6e2a0475ecd96bcc Mon Sep 17 00:00:00 2001 From: jacqueline Date: Fri, 4 Aug 2023 20:07:44 +1000 Subject: Do our own resampling --- src/audio/CMakeLists.txt | 2 +- src/audio/audio_task.cpp | 12 +- src/audio/i2s_audio_output.cpp | 7 + src/audio/include/fir.h | 131 ++++++++++++++++++ src/audio/include/resample.hpp | 41 ++++++ src/audio/include/sink_mixer.hpp | 31 +---- src/audio/include/stream_info.hpp | 2 +- src/audio/resample.cpp | 260 +++++++++++++++++++++++++++++++++++ src/audio/sink_mixer.cpp | 211 +++++++++-------------------- src/codecs/foxenflac.cpp | 6 +- src/codecs/include/codec.hpp | 6 +- src/codecs/include/foxenflac.hpp | 3 +- src/codecs/include/mad.hpp | 3 +- src/codecs/include/sample.hpp | 59 ++++++++ src/codecs/mad.cpp | 40 ++---- src/codecs/sample.cpp | 275 ++++++++++++++++++++++++++++++++++++++ 16 files changed, 872 insertions(+), 217 deletions(-) create mode 100644 src/audio/include/fir.h create mode 100644 src/audio/include/resample.hpp create mode 100644 src/audio/resample.cpp create mode 100644 src/codecs/include/sample.hpp create mode 100644 src/codecs/sample.cpp (limited to 'src') diff --git a/src/audio/CMakeLists.txt b/src/audio/CMakeLists.txt index 9e50f8ff..ddfc7eb4 100644 --- a/src/audio/CMakeLists.txt +++ b/src/audio/CMakeLists.txt @@ -5,7 +5,7 @@ idf_component_register( SRCS "audio_task.cpp" "chunk.cpp" "fatfs_audio_input.cpp" "stream_message.cpp" "i2s_audio_output.cpp" "stream_buffer.cpp" "track_queue.cpp" - "stream_event.cpp" "stream_info.cpp" "audio_fsm.cpp" "sink_mixer.cpp" + "stream_event.cpp" "stream_info.cpp" "audio_fsm.cpp" "sink_mixer.cpp" "resample.cpp" INCLUDE_DIRS "include" REQUIRES "codecs" "drivers" "cbor" "result" "tasks" "span" "memory" "tinyfsm" "database" "system_fsm" "playlist" "libsamplerate") diff --git a/src/audio/audio_task.cpp b/src/audio/audio_task.cpp index c3498965..d7c0c209 100644 --- a/src/audio/audio_task.cpp +++ b/src/audio/audio_task.cpp @@ -34,6 +34,7 @@ #include "freertos/queue.h" #include "freertos/ringbuf.h" #include "pipeline.hpp" +#include "sample.hpp" #include "sink_mixer.hpp" #include "span.hpp" @@ -225,7 +226,7 @@ auto AudioTask::BeginDecoding(InputStream& stream) -> bool { codecs::ICodec::OutputFormat format = res.second.value(); StreamInfo::Pcm new_format{ .channels = format.num_channels, - .bits_per_sample = format.bits_per_sample, + .bits_per_sample = 32, .sample_rate = format.sample_rate_hz, }; @@ -255,7 +256,8 @@ auto AudioTask::ContinueDecoding(InputStream& stream) -> bool { while (!stream.data().empty()) { OutputStream writer{codec_buffer_.get()}; - auto res = codec_->ContinueStream(stream.data(), writer.data()); + auto res = + codec_->ContinueStream(stream.data(), writer.data_as()); stream.consume(res.first); @@ -266,7 +268,7 @@ auto AudioTask::ContinueDecoding(InputStream& stream) -> bool { return false; } } else { - writer.add(res.second->bytes_written); + writer.add(res.second->samples_written * sizeof(sample::Sample)); InputStream reader{codec_buffer_.get()}; SendToSink(reader); @@ -295,12 +297,12 @@ auto AudioTask::FinishDecoding(InputStream& stream) -> void { InputStream padded_stream{mad_buffer.get()}; OutputStream writer{codec_buffer_.get()}; - auto res = codec_->ContinueStream(stream.data(), writer.data()); + auto res = codec_->ContinueStream(stream.data(), writer.data_as()); if (res.second.has_error()) { return; } - writer.add(res.second->bytes_written); + writer.add(res.second->samples_written * sizeof(sample::Sample)); InputStream reader{codec_buffer_.get()}; SendToSink(reader); diff --git a/src/audio/i2s_audio_output.cpp b/src/audio/i2s_audio_output.cpp index e53dbe2a..4eab3e02 100644 --- a/src/audio/i2s_audio_output.cpp +++ b/src/audio/i2s_audio_output.cpp @@ -117,11 +117,18 @@ auto I2SAudioOutput::AdjustVolumeDown() -> bool { auto I2SAudioOutput::PrepareFormat(const StreamInfo::Pcm& orig) -> StreamInfo::Pcm { + /* return StreamInfo::Pcm{ .channels = std::min(orig.channels, 2), .bits_per_sample = std::clamp(orig.bits_per_sample, 16, 32), .sample_rate = std::clamp(orig.sample_rate, 8000, 96000), }; + */ + return StreamInfo::Pcm{ + .channels = std::min(orig.channels, 2), + .bits_per_sample = 16, + .sample_rate = 48000, + }; } auto I2SAudioOutput::Configure(const StreamInfo::Pcm& pcm) -> void { diff --git a/src/audio/include/fir.h b/src/audio/include/fir.h new file mode 100644 index 00000000..e50c3eff --- /dev/null +++ b/src/audio/include/fir.h @@ -0,0 +1,131 @@ +/* + * FIR filter coefficients from resample-1.x smallfilter.h + * see Digital Audio Resampling Home Page located at + * http://ccrma.stanford.edu/~jos/resample/ + */ +32767, 32766, 32764, 32760, 32755, 32749, 32741, 32731, 32721, 32708, +32695, 32679, 32663, 32645, 32625, 32604, 32582, 32558, 32533, 32506, +32478, 32448, 32417, 32385, 32351, 32316, 32279, 32241, 32202, 32161, +32119, 32075, 32030, 31984, 31936, 31887, 31836, 31784, 31731, 31676, +31620, 31563, 31504, 31444, 31383, 31320, 31256, 31191, 31124, 31056, +30987, 30916, 30845, 30771, 30697, 30621, 30544, 30466, 30387, 30306, +30224, 30141, 30057, 29971, 29884, 29796, 29707, 29617, 29525, 29433, +29339, 29244, 29148, 29050, 28952, 28852, 28752, 28650, 28547, 28443, +28338, 28232, 28125, 28017, 27908, 27797, 27686, 27574, 27461, 27346, +27231, 27115, 26998, 26879, 26760, 26640, 26519, 26398, 26275, 26151, +26027, 25901, 25775, 25648, 25520, 25391, 25262, 25131, 25000, 24868, +24735, 24602, 24467, 24332, 24197, 24060, 23923, 23785, 23647, 23507, +23368, 23227, 23086, 22944, 22802, 22659, 22515, 22371, 22226, 22081, +21935, 21789, 21642, 21494, 21346, 21198, 21049, 20900, 20750, 20600, +20449, 20298, 20146, 19995, 19842, 19690, 19537, 19383, 19230, 19076, +18922, 18767, 18612, 18457, 18302, 18146, 17990, 17834, 17678, 17521, +17365, 17208, 17051, 16894, 16737, 16579, 16422, 16264, 16106, 15949, +15791, 15633, 15475, 15317, 15159, 15001, 14843, 14685, 14527, 14369, +14212, 14054, 13896, 13739, 13581, 13424, 13266, 13109, 12952, 12795, +12639, 12482, 12326, 12170, 12014, 11858, 11703, 11548, 11393, 11238, +11084, 10929, 10776, 10622, 10469, 10316, 10164, 10011, 9860, 9708, +9557, 9407, 9256, 9106, 8957, 8808, 8659, 8511, 8364, 8216, 8070, +7924, 7778, 7633, 7488, 7344, 7200, 7057, 6914, 6773, 6631, 6490, +6350, 6210, 6071, 5933, 5795, 5658, 5521, 5385, 5250, 5115, 4981, +4848, 4716, 4584, 4452, 4322, 4192, 4063, 3935, 3807, 3680, 3554, +3429, 3304, 3180, 3057, 2935, 2813, 2692, 2572, 2453, 2335, 2217, +2101, 1985, 1870, 1755, 1642, 1529, 1418, 1307, 1197, 1088, 979, 872, +765, 660, 555, 451, 348, 246, 145, 44, -54, -153, -250, -347, -443, +-537, -631, -724, -816, -908, -998, -1087, -1175, -1263, -1349, -1435, +-1519, -1603, -1685, -1767, -1848, -1928, -2006, -2084, -2161, -2237, +-2312, -2386, -2459, -2531, -2603, -2673, -2742, -2810, -2878, -2944, +-3009, -3074, -3137, -3200, -3261, -3322, -3381, -3440, -3498, -3554, +-3610, -3665, -3719, -3772, -3824, -3875, -3925, -3974, -4022, -4069, +-4116, -4161, -4205, -4249, -4291, -4333, -4374, -4413, -4452, -4490, +-4527, -4563, -4599, -4633, -4666, -4699, -4730, -4761, -4791, -4820, +-4848, -4875, -4901, -4926, -4951, -4974, -4997, -5019, -5040, -5060, +-5080, -5098, -5116, -5133, -5149, -5164, -5178, -5192, -5205, -5217, +-5228, -5238, -5248, -5257, -5265, -5272, -5278, -5284, -5289, -5293, +-5297, -5299, -5301, -5303, -5303, -5303, -5302, -5300, -5298, -5295, +-5291, -5287, -5282, -5276, -5270, -5263, -5255, -5246, -5237, -5228, +-5217, -5206, -5195, -5183, -5170, -5157, -5143, -5128, -5113, -5097, +-5081, -5064, -5047, -5029, -5010, -4991, -4972, -4952, -4931, -4910, +-4889, -4867, -4844, -4821, -4797, -4774, -4749, -4724, -4699, -4673, +-4647, -4620, -4593, -4566, -4538, -4510, -4481, -4452, -4422, -4393, +-4363, -4332, -4301, -4270, -4238, -4206, -4174, -4142, -4109, -4076, +-4042, -4009, -3975, -3940, -3906, -3871, -3836, -3801, -3765, -3729, +-3693, -3657, -3620, -3584, -3547, -3510, -3472, -3435, -3397, -3360, +-3322, -3283, -3245, -3207, -3168, -3129, -3091, -3052, -3013, -2973, +-2934, -2895, -2855, -2816, -2776, -2736, -2697, -2657, -2617, -2577, +-2537, -2497, -2457, -2417, -2377, -2337, -2297, -2256, -2216, -2176, +-2136, -2096, -2056, -2016, -1976, -1936, -1896, -1856, -1817, -1777, +-1737, -1698, -1658, -1619, -1579, -1540, -1501, -1462, -1423, -1384, +-1345, -1306, -1268, -1230, -1191, -1153, -1115, -1077, -1040, -1002, +-965, -927, -890, -854, -817, -780, -744, -708, -672, -636, -600, +-565, -530, -494, -460, -425, -391, -356, -322, -289, -255, -222, +-189, -156, -123, -91, -59, -27, 4, 35, 66, 97, 127, 158, 188, 218, +247, 277, 306, 334, 363, 391, 419, 447, 474, 501, 528, 554, 581, 606, +632, 657, 683, 707, 732, 756, 780, 803, 827, 850, 872, 895, 917, 939, +960, 981, 1002, 1023, 1043, 1063, 1082, 1102, 1121, 1139, 1158, 1176, +1194, 1211, 1228, 1245, 1262, 1278, 1294, 1309, 1325, 1340, 1354, +1369, 1383, 1397, 1410, 1423, 1436, 1448, 1461, 1473, 1484, 1496, +1507, 1517, 1528, 1538, 1548, 1557, 1566, 1575, 1584, 1592, 1600, +1608, 1616, 1623, 1630, 1636, 1643, 1649, 1654, 1660, 1665, 1670, +1675, 1679, 1683, 1687, 1690, 1694, 1697, 1700, 1702, 1704, 1706, +1708, 1709, 1711, 1712, 1712, 1713, 1713, 1713, 1713, 1712, 1711, +1710, 1709, 1708, 1706, 1704, 1702, 1700, 1697, 1694, 1691, 1688, +1685, 1681, 1677, 1673, 1669, 1664, 1660, 1655, 1650, 1644, 1639, +1633, 1627, 1621, 1615, 1609, 1602, 1596, 1589, 1582, 1575, 1567, +1560, 1552, 1544, 1536, 1528, 1520, 1511, 1503, 1494, 1485, 1476, +1467, 1458, 1448, 1439, 1429, 1419, 1409, 1399, 1389, 1379, 1368, +1358, 1347, 1337, 1326, 1315, 1304, 1293, 1282, 1271, 1260, 1248, +1237, 1225, 1213, 1202, 1190, 1178, 1166, 1154, 1142, 1130, 1118, +1106, 1094, 1081, 1069, 1057, 1044, 1032, 1019, 1007, 994, 981, 969, +956, 943, 931, 918, 905, 892, 879, 867, 854, 841, 828, 815, 802, 790, +777, 764, 751, 738, 725, 713, 700, 687, 674, 662, 649, 636, 623, 611, +598, 585, 573, 560, 548, 535, 523, 510, 498, 486, 473, 461, 449, 437, +425, 413, 401, 389, 377, 365, 353, 341, 330, 318, 307, 295, 284, 272, +261, 250, 239, 228, 217, 206, 195, 184, 173, 163, 152, 141, 131, 121, +110, 100, 90, 80, 70, 60, 51, 41, 31, 22, 12, 3, -5, -14, -23, -32, +-41, -50, -59, -67, -76, -84, -93, -101, -109, -117, -125, -133, -140, +-148, -156, -163, -170, -178, -185, -192, -199, -206, -212, -219, +-226, -232, -239, -245, -251, -257, -263, -269, -275, -280, -286, +-291, -297, -302, -307, -312, -317, -322, -327, -332, -336, -341, +-345, -349, -354, -358, -362, -366, -369, -373, -377, -380, -384, +-387, -390, -394, -397, -400, -402, -405, -408, -411, -413, -416, +-418, -420, -422, -424, -426, -428, -430, -432, -433, -435, -436, +-438, -439, -440, -442, -443, -444, -445, -445, -446, -447, -447, +-448, -448, -449, -449, -449, -449, -449, -449, -449, -449, -449, +-449, -449, -448, -448, -447, -447, -446, -445, -444, -443, -443, +-442, -441, -440, -438, -437, -436, -435, -433, -432, -430, -429, +-427, -426, -424, -422, -420, -419, -417, -415, -413, -411, -409, +-407, -405, -403, -400, -398, -396, -393, -391, -389, -386, -384, +-381, -379, -376, -374, -371, -368, -366, -363, -360, -357, -355, +-352, -349, -346, -343, -340, -337, -334, -331, -328, -325, -322, +-319, -316, -313, -310, -307, -304, -301, -298, -294, -291, -288, +-285, -282, -278, -275, -272, -269, -265, -262, -259, -256, -252, +-249, -246, -243, -239, -236, -233, -230, -226, -223, -220, -217, +-213, -210, -207, -204, -200, -197, -194, -191, -187, -184, -181, +-178, -175, -172, -168, -165, -162, -159, -156, -153, -150, -147, +-143, -140, -137, -134, -131, -128, -125, -122, -120, -117, -114, +-111, -108, -105, -102, -99, -97, -94, -91, -88, -86, -83, -80, -78, +-75, -72, -70, -67, -65, -62, -59, -57, -55, -52, -50, -47, -45, -43, +-40, -38, -36, -33, -31, -29, -27, -25, -22, -20, -18, -16, -14, -12, +-10, -8, -6, -4, -2, 0, 0, 2, 4, 6, 8, 9, 11, 13, 14, 16, 17, 19, 21, +22, 24, 25, 27, 28, 29, 31, 32, 33, 35, 36, 37, 38, 40, 41, 42, 43, +44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, +59, 60, 61, 62, 62, 63, 63, 64, 64, 65, 66, 66, 66, 67, 67, 68, 68, +69, 69, 69, 70, 70, 70, 70, 71, 71, 71, 71, 71, 72, 72, 72, 72, 72, +72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, +72, 71, 71, 71, 71, 71, 70, 70, 70, 70, 69, 69, 69, 69, 68, 68, 68, +67, 67, 67, 66, 66, 66, 65, 65, 64, 64, 64, 63, 63, 62, 62, 62, 61, +61, 60, 60, 59, 59, 58, 58, 58, 57, 57, 56, 56, 55, 55, 54, 54, 53, +53, 52, 52, 51, 51, 50, 50, 49, 48, 48, 47, 47, 46, 46, 45, 45, 44, +44, 43, 43, 42, 42, 41, 41, 40, 39, 39, 38, 38, 37, 37, 36, 36, 35, +35, 34, 34, 33, 33, 32, 32, 31, 31, 30, 30, 29, 29, 28, 28, 27, 27, +26, 26, 25, 25, 24, 24, 23, 23, 23, 22, 22, 21, 21, 20, 20, 20, 19, +19, 18, 18, 17, 17, 17, 16, 16, 15, 15, 15, 14, 14, 14, 13, 13, 12, +12, 12, 11, 11, 11, 10, 10, 10, 9, 9, 9, 9, 8, 8, 8, 7, 7, 7, 7, 6, 6, +6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 1, 1, 1, +1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -1, -1, +-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -2, -2, -2, -2, -2, -2, -2, +-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, +-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, +-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, +-2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, +-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, diff --git a/src/audio/include/resample.hpp b/src/audio/include/resample.hpp new file mode 100644 index 00000000..d7933470 --- /dev/null +++ b/src/audio/include/resample.hpp @@ -0,0 +1,41 @@ +#pragma once + +#include +#include + +#include "span.hpp" + +#include "sample.hpp" + +namespace audio { + +class Channel; + +class Resampler { + public: + Resampler(uint32_t source_sample_rate, + uint32_t target_sample_rate, + uint8_t num_channels); + + ~Resampler(); + + auto source_sample_rate() -> uint32_t { return source_sample_rate_; } + auto target_sample_rate() -> uint32_t { return target_sample_rate_; } + auto channels() -> uint_fast8_t { return num_channels_; } + + auto Process(cpp::span input, + cpp::span output, + bool end_of_data) -> std::pair; + + private: + auto ApplyDither(cpp::span) -> void; + + uint32_t source_sample_rate_; + uint32_t target_sample_rate_; + uint32_t factor_; + + uint8_t num_channels_; + std::vector channels_; +}; + +} // namespace audio \ No newline at end of file diff --git a/src/audio/include/sink_mixer.hpp b/src/audio/include/sink_mixer.hpp index 632ffa2e..1bf12016 100644 --- a/src/audio/include/sink_mixer.hpp +++ b/src/audio/include/sink_mixer.hpp @@ -10,6 +10,8 @@ #include #include +#include "resample.hpp" +#include "sample.hpp" #include "samplerate.h" #include "audio_decoder.hpp" @@ -38,12 +40,10 @@ class SinkMixer { auto SetTargetFormat(const StreamInfo::Pcm& format) -> void; auto HandleBytes() -> void; - template - auto ConvertFixedToFloating(InputStream&, OutputStream&) -> void; - auto Resample(float, int, InputStream&, OutputStream&) -> void; - template - auto Quantise(InputStream&) -> std::size_t; - + auto Resample(InputStream&, OutputStream&) -> bool; + auto ApplyDither(cpp::span samples, uint_fast8_t bits) -> void; + auto Downscale(cpp::span, cpp::span) -> void; + enum class Command { kReadBytes, kSetSourceFormat, @@ -58,31 +58,14 @@ class SinkMixer { QueueHandle_t commands_; SemaphoreHandle_t is_idle_; - SRC_STATE* resampler_; + std::unique_ptr resampler_; std::unique_ptr input_stream_; - std::unique_ptr floating_point_stream_; std::unique_ptr resampled_stream_; - cpp::span quantisation_buffer_; - cpp::span quantisation_buffer_as_shorts_; - cpp::span quantisation_buffer_as_ints_; - StreamInfo::Pcm target_format_; StreamBufferHandle_t source_; StreamBufferHandle_t sink_; }; -template <> -auto SinkMixer::ConvertFixedToFloating(InputStream&, OutputStream&) - -> void; -template <> -auto SinkMixer::ConvertFixedToFloating(InputStream&, OutputStream&) - -> void; - -template <> -auto SinkMixer::Quantise(InputStream&) -> std::size_t; -template <> -auto SinkMixer::Quantise(InputStream&) -> std::size_t; - } // namespace audio diff --git a/src/audio/include/stream_info.hpp b/src/audio/include/stream_info.hpp index 7cf9e847..01dd282a 100644 --- a/src/audio/include/stream_info.hpp +++ b/src/audio/include/stream_info.hpp @@ -77,7 +77,7 @@ class StreamInfo { // The sample rate. uint32_t sample_rate; - auto real_bytes_per_sample() const -> uint8_t { + auto bytes_per_sample() const -> uint8_t { return bits_per_sample == 16 ? 2 : 4; } diff --git a/src/audio/resample.cpp b/src/audio/resample.cpp new file mode 100644 index 00000000..93ea1034 --- /dev/null +++ b/src/audio/resample.cpp @@ -0,0 +1,260 @@ +#include "resample.hpp" + +#include +#include +#include +#include +#include + +#include "esp_log.h" + +#include "sample.hpp" +#include "stream_info.hpp" + +namespace audio { + +static constexpr size_t kFilterSize = 1536; + +constexpr auto calc_deltas(const std::array& filter) + -> std::array { + std::array deltas; + for (size_t n = 0; n < kFilterSize - 1; n++) + deltas[n] = filter[n + 1] - filter[n]; + return deltas; +} + +static const std::array kFilter{ +#include "fir.h" +}; + +static const std::array kFilterDeltas = + calc_deltas(kFilter); + +class Channel { + public: + Channel(uint32_t src_rate, + uint32_t dest_rate, + size_t chunk_size, + size_t skip); + ~Channel(); + + auto output_chunk_size() -> size_t { return output_chunk_size_; } + + auto FlushSamples(cpp::span out) -> size_t; + auto AddSample(sample::Sample, cpp::span out) -> std::size_t; + auto ApplyFilter() -> sample::Sample; + + private: + size_t output_chunk_size_; + size_t skip_; + + uint32_t factor_; /* factor */ + + uint32_t time_; /* time */ + + uint32_t time_per_filter_iteration_; /* output step */ + uint32_t filter_step_; /* filter step */ + uint32_t filter_end_; /* filter end */ + + int32_t unity_scale_; /* unity scale */ + + int32_t samples_per_filter_wing_; /* extra samples */ + int32_t latest_sample_; /* buffer index */ + cpp::span sample_buffer_; /* the buffer */ +}; + +enum { + Nl = 8, /* 2^Nl samples per zero crossing in fir */ + Nη = 8, /* phase bits for filter interpolation */ + kPhaseBits = Nl + Nη, /* phase bits (fract of fixed point) */ + One = 1 << kPhaseBits, +}; + +Channel::Channel(uint32_t irate, uint32_t orate, size_t count, size_t skip) + : skip_(skip) { + factor_ = ((uint64_t)orate << kPhaseBits) / irate; + if (factor_ != One) { + time_per_filter_iteration_ = ((uint64_t)irate << kPhaseBits) / orate; + filter_step_ = 1 << (Nl + Nη); + filter_end_ = kFilterSize << Nη; + samples_per_filter_wing_ = 1 + (filter_end_ / filter_step_); + unity_scale_ = 13128; /* unity scale factor for fir */ + if (factor_ < One) { + unity_scale_ *= factor_; + unity_scale_ >>= kPhaseBits; + filter_step_ *= factor_; + filter_step_ >>= kPhaseBits; + samples_per_filter_wing_ *= time_per_filter_iteration_; + samples_per_filter_wing_ >>= kPhaseBits; + } + latest_sample_ = samples_per_filter_wing_; + time_ = latest_sample_ << kPhaseBits; + + size_t buf_size = samples_per_filter_wing_ * 2 + count; + int32_t* buf = new int32_t[buf_size]; + sample_buffer_ = {buf, buf_size}; + count += buf_size; /* account for buffer accumulation */ + } + output_chunk_size_ = ((uint64_t)count * factor_) >> kPhaseBits; +} + +Channel::~Channel() { + delete sample_buffer_.data(); +} + +auto Channel::ApplyFilter() -> sample::Sample { + uint32_t iteration, p, i; + int32_t *sample, a; + + int64_t value = 0; + + // I did my best, but I'll be honest with you I've no idea about any of this + // maths stuff. + + // Left wing of the filter. + sample = &sample_buffer_[time_ >> kPhaseBits]; + p = time_ & ((1 << kPhaseBits) - 1); + iteration = factor_ < One ? (factor_ * p) >> kPhaseBits : p; + while (iteration < filter_end_) { + i = iteration >> Nη; + a = iteration & ((1 << Nη) - 1); + iteration += filter_step_; + a *= kFilterDeltas[i]; + a >>= Nη; + a += kFilter[i]; + value += static_cast(*--sample) * a; + } + + // Right wing of the filter. + sample = &sample_buffer_[time_ >> kPhaseBits]; + p = (One - p) & ((1 << kPhaseBits) - 1); + iteration = factor_ < One ? (factor_ * p) >> kPhaseBits : p; + if (p == 0) /* skip h[0] as it was already been summed above if p == 0 */ + iteration += filter_step_; + while (iteration < filter_end_) { + i = iteration >> Nη; + a = iteration & ((1 << Nη) - 1); + iteration += filter_step_; + a *= kFilterDeltas[i]; + a >>= Nη; + a += kFilter[i]; + value += static_cast(*sample++) * a; + } + + /* scale */ + value >>= 2; + value *= unity_scale_; + value >>= 27; + + return sample::Clip(value); +} + +auto Channel::FlushSamples(cpp::span out) -> size_t { + size_t zeroes_needed = (2 * samples_per_filter_wing_) - latest_sample_; + size_t produced = 0; + while (zeroes_needed > 0) { + produced += AddSample(0, out.subspan(produced)); + zeroes_needed--; + } + return produced; +} + +auto Channel::AddSample(sample::Sample in, cpp::span out) + -> size_t { + // Add the latest sample to our working buffer. + sample_buffer_[latest_sample_++] = in; + + // If we don't have enough samples to run the filter, then bail out and wait + // for more. + if (latest_sample_ < 2 * samples_per_filter_wing_) { + return 0; + } + + // Apply the filter to the buffered samples. First, we work out how long (in + // samples) we can run the filter for before running out. This isn't as + // trivial as it might look; e.g. depending on the resampling factor we might + // be doubling the number of samples, or halving them. + uint32_t max_time = (latest_sample_ - samples_per_filter_wing_) << kPhaseBits; + size_t samples_output = 0; + while (time_ < max_time) { + out[skip_ * samples_output++] = ApplyFilter(); + time_ += time_per_filter_iteration_; + } + + // If we are approaching the end of our buffer, we need to shift all the data + // in it down to the front to make room for more samples. + int32_t current_sample = time_ >> kPhaseBits; + if (current_sample >= (sample_buffer_.size() - samples_per_filter_wing_)) { + // NB: bit shifting back and forth means we're only modifying `time` by + // whole samples. + time_ -= current_sample << kPhaseBits; + time_ += samples_per_filter_wing_ << kPhaseBits; + + int32_t new_current_sample = time_ >> kPhaseBits; + new_current_sample -= samples_per_filter_wing_; + current_sample -= samples_per_filter_wing_; + + int32_t samples_to_move = latest_sample_ - current_sample; + if (samples_to_move > 0) { + auto samples = sample_buffer_.subspan(current_sample, samples_to_move); + std::copy_backward(samples.begin(), samples.end(), + sample_buffer_.first(new_current_sample).end()); + latest_sample_ = new_current_sample + samples_to_move; + } else { + latest_sample_ = new_current_sample; + } + } + + return samples_output; +} + +static const size_t kChunkSizeSamples = 256; + +Resampler::Resampler(uint32_t source_sample_rate, + uint32_t target_sample_rate, + uint8_t num_channels) + : source_sample_rate_(source_sample_rate), + target_sample_rate_(target_sample_rate), + factor_(((uint64_t)target_sample_rate << kPhaseBits) / + source_sample_rate), + num_channels_(num_channels), + channels_() { + for (int i = 0; i < num_channels; i++) { + channels_.emplace_back(source_sample_rate, target_sample_rate, + kChunkSizeSamples, num_channels); + } +} + +Resampler::~Resampler() {} + +auto Resampler::Process(cpp::span input, + cpp::span output, + bool end_of_data) -> std::pair { + size_t samples_used = 0; + std::vector samples_produced = {num_channels_, 0}; + size_t total_samples_produced = 0; + + size_t slop = (factor_ >> kPhaseBits) + 1; + + uint_fast8_t cur_channel = 0; + + while (input.size() > samples_used && + output.size() > total_samples_produced + slop) { + // Work out where the next set of samples should be placed. + size_t next_output_index = + (samples_produced[cur_channel] * num_channels_) + cur_channel; + + // Generate the next samples + size_t new_samples = channels_[cur_channel].AddSample( + input[samples_used++], output.subspan(next_output_index)); + + samples_produced[cur_channel] += new_samples; + total_samples_produced += new_samples; + + cur_channel = (cur_channel + 1) % num_channels_; + } + + return {samples_used, total_samples_produced}; +} + +} // namespace audio diff --git a/src/audio/sink_mixer.cpp b/src/audio/sink_mixer.cpp index 79e6f3d3..ba306626 100644 --- a/src/audio/sink_mixer.cpp +++ b/src/audio/sink_mixer.cpp @@ -13,6 +13,8 @@ #include "esp_log.h" #include "freertos/portmacro.h" #include "freertos/projdefs.h" +#include "resample.hpp" +#include "sample.hpp" #include "samplerate.h" #include "stream_info.hpp" @@ -21,10 +23,7 @@ static constexpr char kTag[] = "mixer"; static constexpr std::size_t kSourceBufferLength = 2 * 1024; -static constexpr std::size_t kInputBufferLength = 2 * 1024; -static constexpr std::size_t kReformatBufferLength = 8 * 1024; -static constexpr std::size_t kResampleBufferLength = kReformatBufferLength; -static constexpr std::size_t kQuantisedBufferLength = 1 * 1024; +static constexpr std::size_t kSampleBufferLength = 4 * 1024; namespace audio { @@ -34,20 +33,8 @@ SinkMixer::SinkMixer(StreamBufferHandle_t dest) resampler_(nullptr), source_(xStreamBufferCreate(kSourceBufferLength, 1)), sink_(dest) { - input_stream_.reset(new RawStream(kInputBufferLength)); - floating_point_stream_.reset(new RawStream(kReformatBufferLength, MALLOC_CAP_SPIRAM)); - resampled_stream_.reset(new RawStream(kResampleBufferLength, MALLOC_CAP_SPIRAM)); - - quantisation_buffer_ = { - reinterpret_cast(heap_caps_malloc( - kQuantisedBufferLength, MALLOC_CAP_INTERNAL | MALLOC_CAP_8BIT)), - kQuantisedBufferLength}; - quantisation_buffer_as_ints_ = { - reinterpret_cast(quantisation_buffer_.data()), - quantisation_buffer_.size_bytes() / 4}; - quantisation_buffer_as_shorts_ = { - reinterpret_cast(quantisation_buffer_.data()), - quantisation_buffer_.size_bytes() / 2}; + input_stream_.reset(new RawStream(kSampleBufferLength)); + resampled_stream_.reset(new RawStream(kSampleBufferLength)); tasks::StartPersistent([&]() { Main(); }); } @@ -56,10 +43,6 @@ SinkMixer::~SinkMixer() { vQueueDelete(commands_); vSemaphoreDelete(is_idle_); vStreamBufferDelete(source_); - heap_caps_free(quantisation_buffer_.data()); - if (resampler_ != nullptr) { - src_delete(resampler_); - } } auto SinkMixer::MixAndSend(InputStream& input, const StreamInfo::Pcm& target) @@ -109,10 +92,12 @@ auto SinkMixer::Main() -> void { case Command::kSetSourceFormat: ESP_LOGI(kTag, "setting source format"); input_receiver.prepare(args.format, {}); + resampler_.reset(); break; case Command::kSetTargetFormat: ESP_LOGI(kTag, "setting target format"); target_format_ = args.format; + resampler_.reset(); break; case Command::kReadBytes: xSemaphoreTake(is_idle_, 0); @@ -150,152 +135,84 @@ auto SinkMixer::HandleBytes() -> void { return; } - // Work out the resampling ratio using floating point arithmetic, since - // relying on the FPU for this will be much faster, and the difference in - // accuracy is unlikely to be noticeable. - float src_ratio = static_cast(target_format_.sample_rate) / - static_cast(pcm->sample_rate); - - // Loop until we don't have any complete frames left in the input stream, - // where a 'frame' is one complete sample per channel. while (!input_stream_->empty()) { - // The first step of both resampling and requantising is to convert the - // fixed point pcm input data into 32 bit floating point samples. - OutputStream floating_writer{floating_point_stream_.get()}; - if (pcm->bits_per_sample == 16) { - ConvertFixedToFloating(input, floating_writer); + RawStream* output_source; + if (pcm->sample_rate != target_format_.sample_rate) { + OutputStream resampled_writer{resampled_stream_.get()}; + if (Resample(input, resampled_writer)) { + // Zero samples used or written. We need more input. + break; + } + output_source = resampled_stream_.get(); } else { - // FIXME: We should consider treating 24 bit and 32 bit samples - // differently. - ConvertFixedToFloating(input, floating_writer); + output_source = input_stream_.get(); } - InputStream floating_reader{floating_point_stream_.get()}; + if (target_format_.bits_per_sample == 16) { + // This is slightly scary; we're basically reaching into the internals of + // the stream buffer to do in-place conversion of samples. Saving an + // extra buffer + copy into that buffer is certainly worth it however. + cpp::span src = + output_source->data_as().first( + output_source->info().bytes_in_stream() / sizeof(sample::Sample)); + cpp::span dest = output_source->data_as().first( + output_source->info().bytes_in_stream() / sizeof(int16_t)); - while (!floating_point_stream_->empty()) { - RawStream* quantisation_source; - if (pcm->sample_rate != target_format_.sample_rate) { - // The input data needs to be resampled before being sent to the sink. - OutputStream resample_writer{resampled_stream_.get()}; - Resample(src_ratio, pcm->channels, floating_reader, resample_writer); - quantisation_source = resampled_stream_.get(); - } else { - // The input data already has an acceptable sample rate. All we need to - // do is quantise it. - quantisation_source = floating_point_stream_.get(); - } + ApplyDither(src, 16); + Downscale(src, dest); - InputStream quantise_reader{quantisation_source}; - while (!quantisation_source->empty()) { - std::size_t samples_available; - if (target_format_.bits_per_sample == 16) { - samples_available = Quantise(quantise_reader); - } else { - samples_available = Quantise(quantise_reader); - } + output_source->info().bytes_in_stream() /= 2; + } - assert(samples_available * target_format_.real_bytes_per_sample() <= - quantisation_buffer_.size_bytes()); + InputStream output{output_source}; + cpp::span buf = output.data(); - std::size_t bytes_sent = xStreamBufferSend( - sink_, quantisation_buffer_.data(), - samples_available * target_format_.real_bytes_per_sample(), - portMAX_DELAY); - assert(bytes_sent == - samples_available * target_format_.real_bytes_per_sample()); - } + size_t bytes_sent = 0; + while (bytes_sent < buf.size_bytes()) { + auto cropped = buf.subspan(bytes_sent); + bytes_sent += xStreamBufferSend(sink_, cropped.data(), + cropped.size_bytes(), portMAX_DELAY); } + output.consume(bytes_sent); } } -template <> -auto SinkMixer::ConvertFixedToFloating(InputStream& in_str, - OutputStream& out_str) -> void { - auto in = in_str.data_as(); - auto out = out_str.data_as(); - std::size_t samples_converted = std::min(in.size(), out.size()); +auto SinkMixer::Resample(InputStream& in, OutputStream& out) -> bool { + if (resampler_ == nullptr) { + ESP_LOGI(kTag, "creating new resampler"); + auto format = in.info().format_as(); + resampler_.reset(new Resampler( + format->sample_rate, target_format_.sample_rate, format->channels)); + } - src_short_to_float_array(in.data(), out.data(), samples_converted); + auto res = resampler_->Process(in.data_as(), + out.data_as(), false); - in_str.consume(samples_converted * sizeof(short)); - out_str.add(samples_converted * sizeof(float)); -} + ESP_LOGI(kTag, "resampler sent %u samples, consumed %u, produced %u", + in.data().size(), res.first, res.second); -template <> -auto SinkMixer::ConvertFixedToFloating(InputStream& in_str, - OutputStream& out_str) -> void { - auto in = in_str.data_as(); - auto out = out_str.data_as(); - std::size_t samples_converted = std::min(in.size(), out.size()); + in.consume(res.first * sizeof(sample::Sample)); + out.add(res.first * sizeof(sample::Sample)); - src_int_to_float_array(in.data(), out.data(), samples_converted); - - in_str.consume(samples_converted * sizeof(int)); - out_str.add(samples_converted * sizeof(float)); + return res.first == 0 && res.second == 0; } -auto SinkMixer::Resample(float src_ratio, - int channels, - InputStream& in, - OutputStream& out) -> void { - if (resampler_ == nullptr || src_get_channels(resampler_) != channels) { - if (resampler_ != nullptr) { - src_delete(resampler_); - } - - ESP_LOGI(kTag, "creating new resampler with %u channels", channels); - - int err = 0; - resampler_ = src_new(SRC_LINEAR, channels, &err); - assert(resampler_ != NULL); - assert(err == 0); +auto SinkMixer::Downscale(cpp::span samples, + cpp::span output) -> void { + for (size_t i = 0; i < samples.size(); i++) { + output[i] = sample::ToSigned16Bit(samples[i]); } - - auto in_buf = in.data_as(); - auto out_buf = out.data_as(); - - src_set_ratio(resampler_, src_ratio); - SRC_DATA args{ - .data_in = in_buf.data(), - .data_out = out_buf.data(), - .input_frames = static_cast(in_buf.size()), - .output_frames = static_cast(out_buf.size()), - .input_frames_used = 0, - .output_frames_gen = 0, - .end_of_input = 0, - .src_ratio = src_ratio, - }; - int err = src_process(resampler_, &args); - if (err != 0) { - ESP_LOGE(kTag, "resampler error: %s", src_strerror(err)); - } - - in.consume(args.input_frames_used * sizeof(float)); - out.add(args.output_frames_gen * sizeof(float)); } -template <> -auto SinkMixer::Quantise(InputStream& in) -> std::size_t { - auto src = in.data_as(); - cpp::span dest = quantisation_buffer_as_shorts_; - dest = dest.first(std::min(src.size(), dest.size())); - - src_float_to_short_array(src.data(), dest.data(), dest.size()); - - in.consume(dest.size() * sizeof(float)); - return dest.size(); -} - -template <> -auto SinkMixer::Quantise(InputStream& in) -> std::size_t { - auto src = in.data_as(); - cpp::span dest = quantisation_buffer_as_ints_; - dest = dest.first(std::min(src.size(), dest.size())); - - src_float_to_int_array(src.data(), dest.data(), dest.size()); - - in.consume(dest.size() * sizeof(float)); - return dest.size(); +auto SinkMixer::ApplyDither(cpp::span samples, + uint_fast8_t bits) -> void { + static uint32_t prnd; + for (auto& s : samples) { + prnd = (prnd * 0x19660dL + 0x3c6ef35fL) & 0xffffffffL; + s = sample::Clip( + static_cast(s) + + (static_cast(prnd) >> (sizeof(sample::Sample) - bits))); + } } } // namespace audio diff --git a/src/codecs/foxenflac.cpp b/src/codecs/foxenflac.cpp index 3a727ce2..b676f82a 100644 --- a/src/codecs/foxenflac.cpp +++ b/src/codecs/foxenflac.cpp @@ -12,6 +12,7 @@ #include "esp_log.h" #include "foxen/flac.h" +#include "sample.hpp" namespace codecs { @@ -47,7 +48,6 @@ auto FoxenFlacDecoder::BeginStream(const cpp::span input) OutputFormat format{ .num_channels = static_cast(channels), - .bits_per_sample = 32, // libfoxenflac output is fixed-size. .sample_rate_hz = static_cast(fs), .duration_seconds = {}, .bits_per_second = {}, @@ -62,7 +62,7 @@ auto FoxenFlacDecoder::BeginStream(const cpp::span input) } auto FoxenFlacDecoder::ContinueStream(cpp::span input, - cpp::span output) + cpp::span output) -> Result { cpp::span output_as_samples{ reinterpret_cast(output.data()), output.size_bytes() / 4}; @@ -78,7 +78,7 @@ auto FoxenFlacDecoder::ContinueStream(cpp::span input, if (samples_written > 0) { return {bytes_read, - OutputInfo{.bytes_written = samples_written * 4, + OutputInfo{.samples_written = samples_written, .is_finished_writing = state == FLAC_END_OF_FRAME}}; } diff --git a/src/codecs/include/codec.hpp b/src/codecs/include/codec.hpp index e8be8f0a..f260aca4 100644 --- a/src/codecs/include/codec.hpp +++ b/src/codecs/include/codec.hpp @@ -16,6 +16,7 @@ #include #include +#include "sample.hpp" #include "result.hpp" #include "span.hpp" #include "types.hpp" @@ -61,7 +62,6 @@ class ICodec { struct OutputFormat { uint8_t num_channels; - uint8_t bits_per_sample; uint32_t sample_rate_hz; std::optional duration_seconds; @@ -76,7 +76,7 @@ class ICodec { -> Result = 0; struct OutputInfo { - std::size_t bytes_written; + std::size_t samples_written; bool is_finished_writing; }; @@ -84,7 +84,7 @@ class ICodec { * Writes PCM samples to the given output buffer. */ virtual auto ContinueStream(cpp::span input, - cpp::span output) + cpp::span output) -> Result = 0; virtual auto SeekStream(cpp::span input, diff --git a/src/codecs/include/foxenflac.hpp b/src/codecs/include/foxenflac.hpp index cce1b762..abfa6d80 100644 --- a/src/codecs/include/foxenflac.hpp +++ b/src/codecs/include/foxenflac.hpp @@ -14,6 +14,7 @@ #include #include "foxen/flac.h" +#include "sample.hpp" #include "span.hpp" #include "codec.hpp" @@ -26,7 +27,7 @@ class FoxenFlacDecoder : public ICodec { ~FoxenFlacDecoder(); auto BeginStream(cpp::span) -> Result override; - auto ContinueStream(cpp::span, cpp::span) + auto ContinueStream(cpp::span, cpp::span) -> Result override; auto SeekStream(cpp::span input, std::size_t target_sample) -> Result override; diff --git a/src/codecs/include/mad.hpp b/src/codecs/include/mad.hpp index fbae560c..b81e4acb 100644 --- a/src/codecs/include/mad.hpp +++ b/src/codecs/include/mad.hpp @@ -13,6 +13,7 @@ #include #include "mad.h" +#include "sample.hpp" #include "span.hpp" #include "codec.hpp" @@ -35,7 +36,7 @@ class MadMp3Decoder : public ICodec { * Writes samples for the current frame. */ auto ContinueStream(cpp::span input, - cpp::span output) + cpp::span output) -> Result override; auto SeekStream(cpp::span input, std::size_t target_sample) diff --git a/src/codecs/include/sample.hpp b/src/codecs/include/sample.hpp new file mode 100644 index 00000000..7209673b --- /dev/null +++ b/src/codecs/include/sample.hpp @@ -0,0 +1,59 @@ +#pragma once + +#include + +#include + +#include + +namespace sample { + +// A signed, 32-bit PCM sample. +typedef int32_t Sample; + +constexpr auto Clip(int64_t v) -> Sample { + if (v > INT32_MAX) + return INT32_MAX; + if (v < INT32_MIN) + return INT32_MIN; + return v; +} + +constexpr auto FromSigned(int32_t src, uint_fast8_t bits) -> Sample { + // Left-align samples, effectively scaling them up to 32 bits. + return src << (sizeof(Sample) * 8 - bits); +} + +constexpr auto FromUnsigned(uint32_t src, uint_fast8_t bits) -> Sample { + // Left-align, then substract the max value / 2 to make the sample centred + // around zero. + return (src << (sizeof(uint32_t) * 8 - bits)) - (~0UL >> 1); +} + +constexpr auto FromFloat(float src) -> Sample { + return std::clamp(src, -1.0f, 1.0f) * static_cast(INT32_MAX); +} + +constexpr auto FromDouble(double src) -> Sample { + return std::clamp(src, -1.0, 1.0) * static_cast(INT32_MAX); +} + +constexpr auto FromMad(mad_fixed_t src) -> Sample { + // Round the bottom bits. + src += (1L << (MAD_F_FRACBITS - 24)); + + // Clip the leftover bits to within range. + if (src >= MAD_F_ONE) + src = MAD_F_ONE - 1; + else if (src < -MAD_F_ONE) + src = -MAD_F_ONE; + + // Quantize. + return FromSigned(src >> (MAD_F_FRACBITS + 1 - 24), 24); +} + +constexpr auto ToSigned16Bit(Sample src) -> uint16_t { + return src >> 16; +} + +} // namespace sample diff --git a/src/codecs/mad.cpp b/src/codecs/mad.cpp index 29e34a0f..a2739bcd 100644 --- a/src/codecs/mad.cpp +++ b/src/codecs/mad.cpp @@ -17,24 +17,11 @@ #include "codec.hpp" #include "esp_log.h" #include "result.hpp" +#include "sample.hpp" #include "types.hpp" namespace codecs { -static uint32_t mad_fixed_to_pcm(mad_fixed_t sample, uint8_t bits) { - // Round the bottom bits. - sample += (1L << (MAD_F_FRACBITS - bits)); - - // 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 - bits); -} - MadMp3Decoder::MadMp3Decoder() { mad_stream_init(&stream_); mad_frame_init(&frame_); @@ -83,7 +70,6 @@ auto MadMp3Decoder::BeginStream(const cpp::span input) uint8_t channels = MAD_NCHANNELS(&header); OutputFormat output{ .num_channels = channels, - .bits_per_sample = 24, // We always scale to 24 bits .sample_rate_hz = header.samplerate, .duration_seconds = {}, .bits_per_second = {}, @@ -100,7 +86,7 @@ auto MadMp3Decoder::BeginStream(const cpp::span input) } auto MadMp3Decoder::ContinueStream(cpp::span input, - cpp::span output) + cpp::span output) -> Result { std::size_t bytes_read = 0; if (current_sample_ < 0) { @@ -133,32 +119,24 @@ auto MadMp3Decoder::ContinueStream(cpp::span input, bytes_read = GetBytesUsed(input.size_bytes()); } - size_t output_byte = 0; + size_t output_sample = 0; while (current_sample_ < synth_.pcm.length) { - if (output_byte + (4 * synth_.pcm.channels) >= output.size()) { - // We can't fit the next sample into the buffer. Stop now, and also avoid - // writing the sample for only half the channels. - return {bytes_read, OutputInfo{.bytes_written = output_byte, + if (output_sample + synth_.pcm.channels >= output.size()) { + // We can't fit the next full frame into the buffer. + return {bytes_read, OutputInfo{.samples_written = output_sample, .is_finished_writing = false}}; } for (int channel = 0; channel < synth_.pcm.channels; channel++) { - uint32_t sample_24 = - mad_fixed_to_pcm(synth_.pcm.samples[channel][current_sample_], 24); - - // 24 bit samples must still be aligned to 32 bits. The LSB is ignored. - output[output_byte++] = static_cast(0); - - output[output_byte++] = static_cast((sample_24)&0xFF); - output[output_byte++] = static_cast((sample_24 >> 8) & 0xFF); - output[output_byte++] = static_cast((sample_24 >> 16) & 0xFF); + output[output_sample++] = + sample::FromMad(synth_.pcm.samples[channel][current_sample_]); } current_sample_++; } // We wrote everything! Reset, ready for the next frame. current_sample_ = -1; - return {bytes_read, OutputInfo{.bytes_written = output_byte, + return {bytes_read, OutputInfo{.samples_written = output_sample, .is_finished_writing = true}}; } diff --git a/src/codecs/sample.cpp b/src/codecs/sample.cpp new file mode 100644 index 00000000..7bf14197 --- /dev/null +++ b/src/codecs/sample.cpp @@ -0,0 +1,275 @@ +#include "sample.hpp" + +namespace audio { + +namespace sample { + +void siconv(int* dst, uint8_t* src, int bits, int skip, int count) { + int i, v, s, b; + + b = (bits + 7) / 8; + s = sizeof(int) * 8 - bits; + while (count--) { + v = 0; + i = b; + switch (b) { + case 4: + v = src[--i]; + case 3: + v = (v << 8) | src[--i]; + case 2: + v = (v << 8) | src[--i]; + case 1: + v = (v << 8) | src[--i]; + } + *dst++ = v << s; + src += skip; + } +} + +void Siconv(int* dst, uint8_t* src, int bits, int skip, int count) { + int i, v, s, b; + + b = (bits + 7) / 8; + s = sizeof(int) * 8 - bits; + while (count--) { + v = 0; + i = 0; + switch (b) { + case 4: + v = src[i++]; + case 3: + v = (v << 8) | src[i++]; + case 2: + v = (v << 8) | src[i++]; + case 1: + v = (v << 8) | src[i]; + } + *dst++ = v << s; + src += skip; + } +} + +void uiconv(int* dst, uint8_t* src, int bits, int skip, int count) { + int i, s, b; + uint32_t v; + + b = (bits + 7) / 8; + s = sizeof(uint32_t) * 8 - bits; + while (count--) { + v = 0; + i = b; + switch (b) { + case 4: + v = src[--i]; + case 3: + v = (v << 8) | src[--i]; + case 2: + v = (v << 8) | src[--i]; + case 1: + v = (v << 8) | src[--i]; + } + *dst++ = (v << s) - (~0UL >> 1); + src += skip; + } +} + +void Uiconv(int* dst, uint8_t* src, int bits, int skip, int count) { + int i, s, b; + uint32_t v; + + b = (bits + 7) / 8; + s = sizeof(uint32_t) * 8 - bits; + while (count--) { + v = 0; + i = 0; + switch (b) { + case 4: + v = src[i++]; + case 3: + v = (v << 8) | src[i++]; + case 2: + v = (v << 8) | src[i++]; + case 1: + v = (v << 8) | src[i]; + } + *dst++ = (v << s) - (~0UL >> 1); + src += skip; + } +} + +void ficonv(int* dst, uint8_t* src, int bits, int skip, int count) { + if (bits == 32) { + while (count--) { + float f; + + f = *((float*)src), src += skip; + if (f > 1.0) + *dst++ = INT32_MAX; + else if (f < -1.0) + *dst++ = INT32_MIN; + else + *dst++ = f * ((float)INT32_MAX); + } + } else { + while (count--) { + double d; + + d = *((double*)src), src += skip; + if (d > 1.0) + *dst++ = INT32_MAX; + else if (d < -1.0) + *dst++ = INT32_MIN; + else + *dst++ = d * ((double)INT32_MAX); + } + } +} + +void aiconv(int* dst, uint8_t* src, int, int skip, int count) { + int t, seg; + uint8_t a; + + while (count--) { + a = *src, src += skip; + a ^= 0x55; + t = (a & 0xf) << 4; + seg = (a & 0x70) >> 4; + switch (seg) { + case 0: + t += 8; + break; + case 1: + t += 0x108; + break; + default: + t += 0x108; + t <<= seg - 1; + } + t = (a & 0x80) ? t : -t; + *dst++ = t << (sizeof(int) * 8 - 16); + } +} + +void µiconv(int* dst, uint8_t* src, int, int skip, int count) { + int t; + uint8_t u; + + while (count--) { + u = *src, src += skip; + u = ~u; + t = ((u & 0xf) << 3) + 0x84; + t <<= (u & 0x70) >> 4; + t = u & 0x80 ? 0x84 - t : t - 0x84; + *dst++ = t << (sizeof(int) * 8 - 16); + } +} + +void soconv(int* src, uint8_t* dst, int bits, int skip, int count) { + int i, v, s, b; + + b = (bits + 7) / 8; + s = sizeof(int) * 8 - bits; + while (count--) { + v = *src++ >> s; + i = 0; + switch (b) { + case 4: + dst[i++] = v, v >>= 8; + case 3: + dst[i++] = v, v >>= 8; + case 2: + dst[i++] = v, v >>= 8; + case 1: + dst[i] = v; + } + dst += skip; + } +} + +void Soconv(int* src, uint8_t* dst, int bits, int skip, int count) { + int i, v, s, b; + + b = (bits + 7) / 8; + s = sizeof(int) * 8 - bits; + while (count--) { + v = *src++ >> s; + i = b; + switch (b) { + case 4: + dst[--i] = v, v >>= 8; + case 3: + dst[--i] = v, v >>= 8; + case 2: + dst[--i] = v, v >>= 8; + case 1: + dst[--i] = v; + } + dst += skip; + } +} + +void uoconv(int* src, uint8_t* dst, int bits, int skip, int count) { + int i, s, b; + uint32_t v; + + b = (bits + 7) / 8; + s = sizeof(uint32_t) * 8 - bits; + while (count--) { + v = ((~0UL >> 1) + *src++) >> s; + i = 0; + switch (b) { + case 4: + dst[i++] = v, v >>= 8; + case 3: + dst[i++] = v, v >>= 8; + case 2: + dst[i++] = v, v >>= 8; + case 1: + dst[i] = v; + } + dst += skip; + } +} + +void Uoconv(int* src, uint8_t* dst, int bits, int skip, int count) { + int i, s, b; + uint32_t v; + + b = (bits + 7) / 8; + s = sizeof(uint32_t) * 8 - bits; + while (count--) { + v = ((~0UL >> 1) + *src++) >> s; + i = b; + switch (b) { + case 4: + dst[--i] = v, v >>= 8; + case 3: + dst[--i] = v, v >>= 8; + case 2: + dst[--i] = v, v >>= 8; + case 1: + dst[--i] = v; + } + dst += skip; + } +} + +void foconv(int* src, uint8_t* dst, int bits, int skip, int count) { + if (bits == 32) { + while (count--) { + *((float*)dst) = *src++ / ((float)INT32_MAX); + dst += skip; + } + } else { + while (count--) { + *((double*)dst) = *src++ / ((double)INT32_MAX); + dst += skip; + } + } +} + + + } + +} -- cgit v1.2.3