diff --git a/Userland/Applications/Piano/Track.cpp b/Userland/Applications/Piano/Track.cpp index 0743db4e6e..40899e4568 100644 --- a/Userland/Applications/Piano/Track.cpp +++ b/Userland/Applications/Piano/Track.cpp @@ -167,7 +167,7 @@ Audio::Sample Track::sine(size_t note) double sin_step = pos * 2 * M_PI; double w = sin(m_pos[note]); m_pos[note] += sin_step; - return w; + return Audio::Sample { w }; } Audio::Sample Track::saw(size_t note) @@ -176,7 +176,7 @@ Audio::Sample Track::saw(size_t note) double t = m_pos[note]; double w = (0.5 - (t - floor(t))) * 2; m_pos[note] += saw_step; - return w; + return Audio::Sample { w }; } Audio::Sample Track::square(size_t note) @@ -185,7 +185,7 @@ Audio::Sample Track::square(size_t note) double square_step = pos * 2 * M_PI; double w = AK::sin(m_pos[note]) >= 0 ? 1 : -1; m_pos[note] += square_step; - return w; + return Audio::Sample { w }; } Audio::Sample Track::triangle(size_t note) @@ -194,7 +194,7 @@ Audio::Sample Track::triangle(size_t note) double t = m_pos[note]; double w = AK::fabs(AK::fmod((4 * t) + 1, 4.) - 2) - 1.; m_pos[note] += triangle_step; - return w; + return Audio::Sample { w }; } Audio::Sample Track::noise(size_t note) @@ -207,14 +207,14 @@ Audio::Sample Track::noise(size_t note) m_last_w[note] = (random_percentage * 2) - 1; m_pos[note] = 0; } - return m_last_w[note]; + return Audio::Sample { m_last_w[note] }; } Audio::Sample Track::recorded_sample(size_t note) { int t = m_pos[note]; if (t >= static_cast(m_recorded_sample.size())) - return 0; + return {}; double w_left = m_recorded_sample[t].left; double w_right = m_recorded_sample[t].right; if (t + 1 < static_cast(m_recorded_sample.size())) { diff --git a/Userland/Libraries/LibAudio/ClientConnection.cpp b/Userland/Libraries/LibAudio/ClientConnection.cpp index 07d4312d5c..22581b1511 100644 --- a/Userland/Libraries/LibAudio/ClientConnection.cpp +++ b/Userland/Libraries/LibAudio/ClientConnection.cpp @@ -6,9 +6,14 @@ #include #include +#include namespace Audio { +// FIXME: We don't know what is a good value for this. +// Real-time audio may be improved with a lower value. +static timespec g_enqueue_wait_time { 0, 10'000'000 }; + ClientConnection::ClientConnection() : IPC::ServerConnection(*this, "/tmp/portal/audio") { @@ -20,9 +25,7 @@ void ClientConnection::enqueue(Buffer const& buffer) auto success = enqueue_buffer(buffer.anonymous_buffer(), buffer.id(), buffer.sample_count()); if (success) break; - // FIXME: We don't know what is a good value for this. - // For now, decrease it to enable better real-time audio. - usleep(10000); + nanosleep(&g_enqueue_wait_time, nullptr); } } diff --git a/Userland/Libraries/LibAudio/FlacLoader.cpp b/Userland/Libraries/LibAudio/FlacLoader.cpp index e64c1fd028..af463fbebc 100644 --- a/Userland/Libraries/LibAudio/FlacLoader.cpp +++ b/Userland/Libraries/LibAudio/FlacLoader.cpp @@ -85,7 +85,7 @@ bool FlacLoaderPlugin::parse_header() } while (0) // Magic number - u32 flac = bit_input.read_bits_big_endian(32); + u32 flac = static_cast(bit_input.read_bits_big_endian(32)); m_data_start_location += 4; ok = ok && flac == 0x664C6143; // "flaC" CHECK_OK("FLAC magic number"); @@ -102,20 +102,20 @@ bool FlacLoaderPlugin::parse_header() ScopeGuard clear_streaminfo_errors([&streaminfo_data] { streaminfo_data.handle_any_error(); }); // STREAMINFO block - m_min_block_size = streaminfo_data.read_bits_big_endian(16); + m_min_block_size = static_cast(streaminfo_data.read_bits_big_endian(16)); ok = ok && (m_min_block_size >= 16); CHECK_OK("Minimum block size"); - m_max_block_size = streaminfo_data.read_bits_big_endian(16); + m_max_block_size = static_cast(streaminfo_data.read_bits_big_endian(16)); ok = ok && (m_max_block_size >= 16); CHECK_OK("Maximum block size"); - m_min_frame_size = streaminfo_data.read_bits_big_endian(24); - m_max_frame_size = streaminfo_data.read_bits_big_endian(24); - m_sample_rate = streaminfo_data.read_bits_big_endian(20); + m_min_frame_size = static_cast(streaminfo_data.read_bits_big_endian(24)); + m_max_frame_size = static_cast(streaminfo_data.read_bits_big_endian(24)); + m_sample_rate = static_cast(streaminfo_data.read_bits_big_endian(20)); ok = ok && (m_sample_rate <= 655350); CHECK_OK("Sample rate"); - m_num_channels = streaminfo_data.read_bits_big_endian(3) + 1; // 0 ^= one channel + m_num_channels = static_cast(streaminfo_data.read_bits_big_endian(3)) + 1; // 0 ^= one channel - u8 bits_per_sample = streaminfo_data.read_bits_big_endian(5) + 1; + u8 bits_per_sample = static_cast(streaminfo_data.read_bits_big_endian(5)) + 1; if (bits_per_sample == 8) { // FIXME: Signed/Unsigned issues? m_sample_format = PcmSampleFormat::Uint8; @@ -130,7 +130,7 @@ bool FlacLoaderPlugin::parse_header() CHECK_OK("Sample bit depth"); } - m_total_samples = streaminfo_data.read_bits_big_endian(36); + m_total_samples = static_cast(streaminfo_data.read_bits_big_endian(36)); ok = ok && (m_total_samples > 0); CHECK_OK("Number of samples"); // Parse checksum into a buffer first @@ -164,7 +164,7 @@ bool FlacLoaderPlugin::parse_header() for (unsigned int i = 0; i < md5_checksum.size(); ++i) { checksum_string.appendff("{:0X}", md5_checksum[i]); } - dbgln("Parsed FLAC header: blocksize {}-{}{}, framesize {}-{}, {}Hz, {}bit, {} channels, {} samples total ({:.2f}s), MD5 {}, data start at {:x} bytes, {} headers total (skipped {})", m_min_block_size, m_max_block_size, is_fixed_blocksize_stream() ? " (constant)" : "", m_min_frame_size, m_max_frame_size, m_sample_rate, pcm_bits_per_sample(m_sample_format), m_num_channels, m_total_samples, m_total_samples / static_cast(m_sample_rate), checksum_string.to_string(), m_data_start_location, total_meta_blocks, total_meta_blocks - meta_blocks_parsed); + dbgln("Parsed FLAC header: blocksize {}-{}{}, framesize {}-{}, {}Hz, {}bit, {} channels, {} samples total ({:.2f}s), MD5 {}, data start at {:x} bytes, {} headers total (skipped {})", m_min_block_size, m_max_block_size, is_fixed_blocksize_stream() ? " (constant)" : "", m_min_frame_size, m_max_frame_size, m_sample_rate, pcm_bits_per_sample(m_sample_format), m_num_channels, m_total_samples, static_cast(m_total_samples) / static_cast(m_sample_rate), checksum_string.to_string(), m_data_start_location, total_meta_blocks, total_meta_blocks - meta_blocks_parsed); } return true; @@ -192,7 +192,7 @@ FlacRawMetadataBlock FlacLoaderPlugin::next_meta_block(InputBitStream& bit_input } m_data_start_location += 1; - u32 block_length = bit_input.read_bits_big_endian(24); + u32 block_length = static_cast(bit_input.read_bits_big_endian(24)); m_data_start_location += 3; CHECK_IO_ERROR(); auto block_data_result = ByteBuffer::create_uninitialized(block_length); @@ -232,7 +232,7 @@ void FlacLoaderPlugin::seek(const int position) RefPtr FlacLoaderPlugin::get_more_samples(size_t max_bytes_to_read_from_input) { Vector samples; - ssize_t remaining_samples = m_total_samples - m_loaded_samples; + ssize_t remaining_samples = static_cast(m_total_samples - m_loaded_samples); if (remaining_samples <= 0) { return nullptr; } @@ -247,7 +247,7 @@ RefPtr FlacLoaderPlugin::get_more_samples(size_t max_bytes_to_read_from_ } } samples.append(m_current_frame_data.take_first()); - if (m_current_frame_data.size() == 0) { + if (m_current_frame_data.is_empty()) { m_current_frame.clear(); } --samples_to_read; @@ -283,7 +283,7 @@ void FlacLoaderPlugin::next_frame() // TODO: Check the CRC-16 checksum (and others) by keeping track of read data // FLAC frame sync code starts header - u16 sync_code = bit_stream.read_bits_big_endian(14); + u16 sync_code = static_cast(bit_stream.read_bits_big_endian(14)); ok = ok && (sync_code == 0b11111111111110); CHECK_OK("Sync code"); bool reserved_bit = bit_stream.read_bit_big_endian(); @@ -291,20 +291,20 @@ void FlacLoaderPlugin::next_frame() CHECK_OK("Reserved frame header bit"); [[maybe_unused]] bool blocking_strategy = bit_stream.read_bit_big_endian(); - u32 sample_count = convert_sample_count_code(bit_stream.read_bits_big_endian(4)); + u32 sample_count = convert_sample_count_code(static_cast(bit_stream.read_bits_big_endian(4))); CHECK_ERROR_STRING; - u32 frame_sample_rate = convert_sample_rate_code(bit_stream.read_bits_big_endian(4)); + u32 frame_sample_rate = convert_sample_rate_code(static_cast(bit_stream.read_bits_big_endian(4))); CHECK_ERROR_STRING; - u8 channel_type_num = bit_stream.read_bits_big_endian(4); + u8 channel_type_num = static_cast(bit_stream.read_bits_big_endian(4)); if (channel_type_num >= 0b1011) { ok = false; CHECK_OK("Channel assignment"); } FlacFrameChannelType channel_type = (FlacFrameChannelType)channel_type_num; - PcmSampleFormat bit_depth = convert_bit_depth_code(bit_stream.read_bits_big_endian(3)); + PcmSampleFormat bit_depth = convert_bit_depth_code(static_cast(bit_stream.read_bits_big_endian(3))); CHECK_ERROR_STRING; reserved_bit = bit_stream.read_bit_big_endian(); @@ -316,21 +316,21 @@ void FlacLoaderPlugin::next_frame() // Conditional header variables if (sample_count == FLAC_BLOCKSIZE_AT_END_OF_HEADER_8) { - sample_count = bit_stream.read_bits_big_endian(8) + 1; + sample_count = static_cast(bit_stream.read_bits_big_endian(8)) + 1; } else if (sample_count == FLAC_BLOCKSIZE_AT_END_OF_HEADER_16) { - sample_count = bit_stream.read_bits_big_endian(16) + 1; + sample_count = static_cast(bit_stream.read_bits_big_endian(16)) + 1; } if (frame_sample_rate == FLAC_SAMPLERATE_AT_END_OF_HEADER_8) { - frame_sample_rate = bit_stream.read_bits_big_endian(8) * 1000; + frame_sample_rate = static_cast(bit_stream.read_bits_big_endian(8)) * 1000; } else if (frame_sample_rate == FLAC_SAMPLERATE_AT_END_OF_HEADER_16) { - frame_sample_rate = bit_stream.read_bits_big_endian(16); + frame_sample_rate = static_cast(bit_stream.read_bits_big_endian(16)); } else if (frame_sample_rate == FLAC_SAMPLERATE_AT_END_OF_HEADER_16X10) { - frame_sample_rate = bit_stream.read_bits_big_endian(16) * 10; + frame_sample_rate = static_cast(bit_stream.read_bits_big_endian(16)) * 10; } // TODO: check header checksum, see above - [[maybe_unused]] u8 checksum = bit_stream.read_bits(8); + [[maybe_unused]] u8 checksum = static_cast(bit_stream.read_bits(8)); dbgln_if(AFLACLOADER_DEBUG, "Frame: {} samples, {}bit {}Hz, channeltype {:x}, {} number {}, header checksum {}", sample_count, pcm_bits_per_sample(bit_depth), frame_sample_rate, channel_type_num, blocking_strategy ? "sample" : "frame", m_current_sample_or_frame, checksum); @@ -356,9 +356,10 @@ void FlacLoaderPlugin::next_frame() bit_stream.align_to_byte_boundary(); // TODO: check checksum, see above - [[maybe_unused]] u16 footer_checksum = bit_stream.read_bits_big_endian(16); + [[maybe_unused]] u16 footer_checksum = static_cast(bit_stream.read_bits_big_endian(16)); - Vector left, right; + Vector left; + Vector right; switch (channel_type) { case FlacFrameChannelType::Mono: @@ -514,7 +515,7 @@ u8 frame_channel_type_to_channel_count(FlacFrameChannelType channel_type) FlacSubframeHeader FlacLoaderPlugin::next_subframe_header(InputBitStream& bit_stream, u8 channel_index) { - u8 bits_per_sample = pcm_bits_per_sample(m_current_frame->bit_depth); + u8 bits_per_sample = static_cast(pcm_bits_per_sample(m_current_frame->bit_depth)); // For inter-channel correlation, the side channel needs an extra bit for its samples switch (m_current_frame->channels) { @@ -541,7 +542,7 @@ FlacSubframeHeader FlacLoaderPlugin::next_subframe_header(InputBitStream& bit_st }; // subframe type (encoding) - u8 subframe_code = bit_stream.read_bits_big_endian(6); + u8 subframe_code = static_cast(bit_stream.read_bits_big_endian(6)); if ((subframe_code >= 0b000010 && subframe_code <= 0b000111) || (subframe_code > 0b001100 && subframe_code < 0b100000)) { m_error_string = "Subframe type"; return {}; @@ -590,8 +591,10 @@ Vector FlacLoaderPlugin::parse_subframe(FlacSubframeHeader& subframe_header dbgln_if(AFLACLOADER_DEBUG, "Constant subframe: {}", constant_value); samples.ensure_capacity(m_current_frame->sample_count); + VERIFY(subframe_header.bits_per_sample - subframe_header.wasted_bits_per_sample != 0); + i32 constant = sign_extend(static_cast(constant_value), subframe_header.bits_per_sample - subframe_header.wasted_bits_per_sample); for (u32 i = 0; i < m_current_frame->sample_count; ++i) { - samples.unchecked_append(sign_extend(constant_value, subframe_header.bits_per_sample - subframe_header.wasted_bits_per_sample)); + samples.unchecked_append(constant); } break; } @@ -632,8 +635,11 @@ Vector FlacLoaderPlugin::decode_verbatim(FlacSubframeHeader& subframe, Inpu Vector decoded; decoded.ensure_capacity(m_current_frame->sample_count); + VERIFY(subframe.bits_per_sample - subframe.wasted_bits_per_sample != 0); for (size_t i = 0; i < m_current_frame->sample_count; ++i) { - decoded.unchecked_append(sign_extend(bit_input.read_bits_big_endian(subframe.bits_per_sample - subframe.wasted_bits_per_sample), subframe.bits_per_sample - subframe.wasted_bits_per_sample)); + decoded.unchecked_append(sign_extend( + static_cast(bit_input.read_bits_big_endian(subframe.bits_per_sample - subframe.wasted_bits_per_sample)), + subframe.bits_per_sample - subframe.wasted_bits_per_sample)); } return decoded; @@ -645,13 +651,16 @@ Vector FlacLoaderPlugin::decode_custom_lpc(FlacSubframeHeader& subframe, In Vector decoded; decoded.ensure_capacity(m_current_frame->sample_count); + VERIFY(subframe.bits_per_sample - subframe.wasted_bits_per_sample != 0); // warm-up samples for (auto i = 0; i < subframe.order; ++i) { - decoded.unchecked_append(sign_extend(bit_input.read_bits_big_endian(subframe.bits_per_sample - subframe.wasted_bits_per_sample), subframe.bits_per_sample - subframe.wasted_bits_per_sample)); + decoded.unchecked_append(sign_extend( + static_cast(bit_input.read_bits_big_endian(subframe.bits_per_sample - subframe.wasted_bits_per_sample)), + subframe.bits_per_sample - subframe.wasted_bits_per_sample)); } // precision of the coefficients - u8 lpc_precision = bit_input.read_bits_big_endian(4); + u8 lpc_precision = static_cast(bit_input.read_bits_big_endian(4)); if (lpc_precision == 0b1111) { m_error_string = "Invalid linear predictor coefficient precision"; return {}; @@ -659,14 +668,14 @@ Vector FlacLoaderPlugin::decode_custom_lpc(FlacSubframeHeader& subframe, In lpc_precision += 1; // shift needed on the data (signed!) - i8 lpc_shift = sign_extend(bit_input.read_bits_big_endian(5), 5); + i8 lpc_shift = sign_extend(static_cast(bit_input.read_bits_big_endian(5)), 5); Vector coefficients; coefficients.ensure_capacity(subframe.order); // read coefficients for (auto i = 0; i < subframe.order; ++i) { - u32 raw_coefficient = bit_input.read_bits_big_endian(lpc_precision); - i32 coefficient = sign_extend(raw_coefficient, lpc_precision); + u32 raw_coefficient = static_cast(bit_input.read_bits_big_endian(lpc_precision)); + i32 coefficient = static_cast(sign_extend(raw_coefficient, lpc_precision)); coefficients.unchecked_append(coefficient); } @@ -694,9 +703,12 @@ Vector FlacLoaderPlugin::decode_fixed_lpc(FlacSubframeHeader& subframe, Inp Vector decoded; decoded.ensure_capacity(m_current_frame->sample_count); + VERIFY(subframe.bits_per_sample - subframe.wasted_bits_per_sample != 0); // warm-up samples for (auto i = 0; i < subframe.order; ++i) { - decoded.unchecked_append(sign_extend(bit_input.read_bits_big_endian(subframe.bits_per_sample - subframe.wasted_bits_per_sample), subframe.bits_per_sample - subframe.wasted_bits_per_sample)); + decoded.unchecked_append(sign_extend( + static_cast(bit_input.read_bits_big_endian(subframe.bits_per_sample - subframe.wasted_bits_per_sample)), + subframe.bits_per_sample - subframe.wasted_bits_per_sample)); } decode_residual(decoded, subframe, bit_input); @@ -740,8 +752,8 @@ Vector FlacLoaderPlugin::decode_fixed_lpc(FlacSubframeHeader& subframe, Inp // Decode the residual, the "error" between the function approximation and the actual audio data Vector FlacLoaderPlugin::decode_residual(Vector& decoded, FlacSubframeHeader& subframe, InputBitStream& bit_input) { - u8 residual_mode = bit_input.read_bits_big_endian(2); - u8 partition_order = bit_input.read_bits_big_endian(4); + u8 residual_mode = static_cast(bit_input.read_bits_big_endian(2)); + u8 partition_order = static_cast(bit_input.read_bits_big_endian(4)); size_t partitions = 1 << partition_order; if (residual_mode == FlacResidualMode::Rice4Bit) { @@ -768,7 +780,7 @@ Vector FlacLoaderPlugin::decode_residual(Vector& decoded, FlacSubframe ALWAYS_INLINE Vector FlacLoaderPlugin::decode_rice_partition(u8 partition_type, u32 partitions, u32 partition_index, FlacSubframeHeader& subframe, InputBitStream& bit_input) { // Rice parameter / Exp-Golomb order - u8 k = bit_input.read_bits_big_endian(partition_type); + u8 k = static_cast(bit_input.read_bits_big_endian(partition_type)); u32 residual_sample_count; if (partitions == 0) @@ -783,9 +795,9 @@ ALWAYS_INLINE Vector FlacLoaderPlugin::decode_rice_partition(u8 partition_t // escape code for unencoded binary partition if (k == (1 << partition_type) - 1) { - u8 unencoded_bps = bit_input.read_bits_big_endian(5); + u8 unencoded_bps = static_cast(bit_input.read_bits_big_endian(5)); for (size_t r = 0; r < residual_sample_count; ++r) { - rice_partition[r] = bit_input.read_bits_big_endian(unencoded_bps); + rice_partition[r] = static_cast(bit_input.read_bits_big_endian(unencoded_bps)); } } else { for (size_t r = 0; r < residual_sample_count; ++r) { @@ -804,8 +816,8 @@ ALWAYS_INLINE i32 decode_unsigned_exp_golomb(u8 k, InputBitStream& bit_input) ++q; // least significant bits (remainder) - u32 rem = bit_input.read_bits_big_endian(k); - u32 value = (u32)(q << k | rem); + u32 rem = static_cast(bit_input.read_bits_big_endian(k)); + u32 value = q << k | rem; return rice_to_signed(value); } @@ -853,8 +865,8 @@ i32 rice_to_signed(u32 x) { // positive numbers are even, negative numbers are odd // bitmask for conditionally inverting the entire number, thereby "negating" it - i32 sign = -(x & 1); + i32 sign = -static_cast(x & 1); // copies the sign's sign onto the actual magnitude of x - return (i32)(sign ^ (x >> 1)); + return static_cast(sign ^ (x >> 1)); } } diff --git a/Userland/Libraries/LibAudio/FlacLoader.h b/Userland/Libraries/LibAudio/FlacLoader.h index 9464204d8a..dd7da0e423 100644 --- a/Userland/Libraries/LibAudio/FlacLoader.h +++ b/Userland/Libraries/LibAudio/FlacLoader.h @@ -69,8 +69,8 @@ ALWAYS_INLINE i32 decode_unsigned_exp_golomb(u8 order, InputBitStream& bit_input class FlacLoaderPlugin : public LoaderPlugin { public: - FlacLoaderPlugin(StringView path); - FlacLoaderPlugin(const ByteBuffer& buffer); + explicit FlacLoaderPlugin(StringView path); + explicit FlacLoaderPlugin(const ByteBuffer& buffer); ~FlacLoaderPlugin() { if (m_stream) @@ -87,8 +87,8 @@ public: virtual void reset() override; virtual void seek(const int position) override; - virtual int loaded_samples() override { return m_loaded_samples; } - virtual int total_samples() override { return m_total_samples; } + virtual int loaded_samples() override { return static_cast(m_loaded_samples); } + virtual int total_samples() override { return static_cast(m_total_samples); } virtual u32 sample_rate() override { return m_sample_rate; } virtual u16 num_channels() override { return m_num_channels; } virtual PcmSampleFormat pcm_format() override { return m_sample_format; } diff --git a/Userland/Libraries/LibAudio/Loader.h b/Userland/Libraries/LibAudio/Loader.h index 11d284e1df..276811e5a6 100644 --- a/Userland/Libraries/LibAudio/Loader.h +++ b/Userland/Libraries/LibAudio/Loader.h @@ -78,8 +78,8 @@ public: RefPtr file() const { return m_plugin ? m_plugin->file() : nullptr; } private: - Loader(StringView path); - Loader(const ByteBuffer& buffer); + explicit Loader(StringView path); + explicit Loader(const ByteBuffer& buffer); mutable OwnPtr m_plugin; }; diff --git a/Userland/Libraries/LibAudio/Sample.h b/Userland/Libraries/LibAudio/Sample.h index 50e3c84907..e6b00b8456 100644 --- a/Userland/Libraries/LibAudio/Sample.h +++ b/Userland/Libraries/LibAudio/Sample.h @@ -10,7 +10,8 @@ #include namespace Audio { -using namespace AK::Exponentials; +using AK::Exponentials::exp; +using AK::Exponentials::log; // Constants for logarithmic volume. See Sample::linear_to_log // Corresponds to 60dB constexpr double DYNAMIC_RANGE = 1000; @@ -23,7 +24,7 @@ struct Sample { constexpr Sample() = default; // For mono - constexpr Sample(double left) + constexpr explicit Sample(double left) : left(left) , right(left) { @@ -63,13 +64,13 @@ struct Sample { // - Linear: 0.0 to 1.0 // - Logarithmic: 0.0 to 1.0 - ALWAYS_INLINE double linear_to_log(double const change) + ALWAYS_INLINE double linear_to_log(double const change) const { // TODO: Add linear slope around 0 return VOLUME_A * exp(VOLUME_B * change); } - ALWAYS_INLINE double log_to_linear(double const val) + ALWAYS_INLINE double log_to_linear(double const val) const { // TODO: Add linear slope around 0 return log(val / VOLUME_A) / VOLUME_B; diff --git a/Userland/Libraries/LibAudio/WavLoader.h b/Userland/Libraries/LibAudio/WavLoader.h index 1ae39dffb4..2a2976536b 100644 --- a/Userland/Libraries/LibAudio/WavLoader.h +++ b/Userland/Libraries/LibAudio/WavLoader.h @@ -33,8 +33,8 @@ class Buffer; // Parses a WAV file and produces an Audio::Buffer. class WavLoaderPlugin : public LoaderPlugin { public: - WavLoaderPlugin(StringView path); - WavLoaderPlugin(const ByteBuffer& buffer); + explicit WavLoaderPlugin(StringView path); + explicit WavLoaderPlugin(const ByteBuffer& buffer); virtual bool sniff() override { return valid; } diff --git a/Userland/Libraries/LibAudio/WavWriter.cpp b/Userland/Libraries/LibAudio/WavWriter.cpp index b4d7f0873e..4428a38f9d 100644 --- a/Userland/Libraries/LibAudio/WavWriter.cpp +++ b/Userland/Libraries/LibAudio/WavWriter.cpp @@ -8,7 +8,7 @@ namespace Audio { -WavWriter::WavWriter(StringView path, int sample_rate, int num_channels, int bits_per_sample) +WavWriter::WavWriter(StringView path, int sample_rate, u16 num_channels, u16 bits_per_sample) : m_sample_rate(sample_rate) , m_num_channels(num_channels) , m_bits_per_sample(bits_per_sample) @@ -16,7 +16,7 @@ WavWriter::WavWriter(StringView path, int sample_rate, int num_channels, int bit set_file(path); } -WavWriter::WavWriter(int sample_rate, int num_channels, int bits_per_sample) +WavWriter::WavWriter(int sample_rate, u16 num_channels, u16 bits_per_sample) : m_sample_rate(sample_rate) , m_num_channels(num_channels) , m_bits_per_sample(bits_per_sample) diff --git a/Userland/Libraries/LibAudio/WavWriter.h b/Userland/Libraries/LibAudio/WavWriter.h index 555bc09cc2..d36059ab12 100644 --- a/Userland/Libraries/LibAudio/WavWriter.h +++ b/Userland/Libraries/LibAudio/WavWriter.h @@ -6,15 +6,19 @@ #pragma once +#include #include #include namespace Audio { class WavWriter { + AK_MAKE_NONCOPYABLE(WavWriter); + AK_MAKE_NONMOVABLE(WavWriter); + public: - WavWriter(StringView path, int sample_rate = 44100, int num_channels = 2, int bits_per_sample = 16); - WavWriter(int sample_rate = 44100, int num_channels = 2, int bits_per_sample = 16); + WavWriter(StringView path, int sample_rate = 44100, u16 num_channels = 2, u16 bits_per_sample = 16); + WavWriter(int sample_rate = 44100, u16 num_channels = 2, u16 bits_per_sample = 16); ~WavWriter(); bool has_error() const { return !m_error_string.is_null(); } diff --git a/Userland/Libraries/LibDSP/Music.h b/Userland/Libraries/LibDSP/Music.h index 30059f22b1..fed5112571 100644 --- a/Userland/Libraries/LibDSP/Music.h +++ b/Userland/Libraries/LibDSP/Music.h @@ -40,8 +40,11 @@ struct Signal : public Variant { using Variant::Variant; ALWAYS_INLINE SignalType type() const { - return has() ? SignalType::Sample : has() ? SignalType::Note - : SignalType::Invalid; + if (has()) + return SignalType::Sample; + if (has()) + return SignalType::Note; + return SignalType::Invalid; } }; diff --git a/Userland/Libraries/LibDSP/Track.h b/Userland/Libraries/LibDSP/Track.h index af873f791c..0b902cff89 100644 --- a/Userland/Libraries/LibDSP/Track.h +++ b/Userland/Libraries/LibDSP/Track.h @@ -19,7 +19,6 @@ class Track : public Core::Object { public: Track(NonnullRefPtr transport) : m_transport(move(transport)) - , m_current_signal(Sample {}) { } virtual ~Track() override = default; @@ -42,7 +41,7 @@ protected: NonnullRefPtrVector m_processor_chain; NonnullRefPtr m_transport; // The current signal is stored here, to prevent unnecessary reallocation. - Signal m_current_signal; + Signal m_current_signal { Audio::Sample {} }; }; class NoteTrack final : public Track { @@ -53,7 +52,7 @@ public: NonnullRefPtrVector const& clips() const { return m_clips; } protected: - virtual void compute_current_clips_signal() override; + void compute_current_clips_signal() override; private: NonnullRefPtrVector m_clips; @@ -67,7 +66,7 @@ public: NonnullRefPtrVector const& clips() const { return m_clips; } protected: - virtual void compute_current_clips_signal() override; + void compute_current_clips_signal() override; private: NonnullRefPtrVector m_clips; diff --git a/Userland/Services/AudioServer/Mixer.cpp b/Userland/Services/AudioServer/Mixer.cpp index 99d6038930..52a5761735 100644 --- a/Userland/Services/AudioServer/Mixer.cpp +++ b/Userland/Services/AudioServer/Mixer.cpp @@ -114,7 +114,7 @@ void Mixer::mix() // Even though it's not realistic, the user expects no sound at 0%. if (m_main_volume < 0.01) - mixed_sample = { 0 }; + mixed_sample = Audio::Sample { 0 }; else mixed_sample.log_multiply(m_main_volume); mixed_sample.clip();