From 161a80be5f7af7b9cbfe34137fd2ffd8d9c455ad Mon Sep 17 00:00:00 2001 From: Moonchild Date: Sun, 22 Aug 2021 17:39:55 +0000 Subject: Revert "Issue mcp-graveyard/UXP#1806 - Update libcubeb" This reverts commit 741fd8b61ccc5b3a01ccf8ff154ccb8ce80ecc38. --- media/libcubeb/src/cubeb_ringbuffer.h | 468 ---------------------------------- 1 file changed, 468 deletions(-) delete mode 100644 media/libcubeb/src/cubeb_ringbuffer.h (limited to 'media/libcubeb/src/cubeb_ringbuffer.h') diff --git a/media/libcubeb/src/cubeb_ringbuffer.h b/media/libcubeb/src/cubeb_ringbuffer.h deleted file mode 100644 index 28381849fc..0000000000 --- a/media/libcubeb/src/cubeb_ringbuffer.h +++ /dev/null @@ -1,468 +0,0 @@ -/* - * Copyright © 2016 Mozilla Foundation - * - * This program is made available under an ISC-style license. See the - * accompanying file LICENSE for details. - */ - -#ifndef CUBEB_RING_BUFFER_H -#define CUBEB_RING_BUFFER_H - -#include "cubeb_utils.h" -#include -#include -#include -#include -#include - -/** - * Single producer single consumer lock-free and wait-free ring buffer. - * - * This data structure allows producing data from one thread, and consuming it - * on another thread, safely and without explicit synchronization. If used on - * two threads, this data structure uses atomics for thread safety. It is - * possible to disable the use of atomics at compile time and only use this data - * structure on one thread. - * - * The role for the producer and the consumer must be constant, i.e., the - * producer should always be on one thread and the consumer should always be on - * another thread. - * - * Some words about the inner workings of this class: - * - Capacity is fixed. Only one allocation is performed, in the constructor. - * When reading and writing, the return value of the method allows checking if - * the ring buffer is empty or full. - * - We always keep the read index at least one element ahead of the write - * index, so we can distinguish between an empty and a full ring buffer: an - * empty ring buffer is when the write index is at the same position as the - * read index. A full buffer is when the write index is exactly one position - * before the read index. - * - We synchronize updates to the read index after having read the data, and - * the write index after having written the data. This means that the each - * thread can only touch a portion of the buffer that is not touched by the - * other thread. - * - Callers are expected to provide buffers. When writing to the queue, - * elements are copied into the internal storage from the buffer passed in. - * When reading from the queue, the user is expected to provide a buffer. - * Because this is a ring buffer, data might not be contiguous in memory, - * providing an external buffer to copy into is an easy way to have linear - * data for further processing. - */ -template class ring_buffer_base { -public: - /** - * Constructor for a ring buffer. - * - * This performs an allocation, but is the only allocation that will happen - * for the life time of a `ring_buffer_base`. - * - * @param capacity The maximum number of element this ring buffer will hold. - */ - ring_buffer_base(int capacity) - /* One more element to distinguish from empty and full buffer. */ - : capacity_(capacity + 1) - { - assert(storage_capacity() < std::numeric_limits::max() / 2 && - "buffer too large for the type of index used."); - assert(capacity_ > 0); - - data_.reset(new T[storage_capacity()]); - /* If this queue is using atomics, initializing those members as the last - * action in the constructor acts as a full barrier, and allow capacity() to - * be thread-safe. */ - write_index_ = 0; - read_index_ = 0; - } - /** - * Push `count` zero or default constructed elements in the array. - * - * Only safely called on the producer thread. - * - * @param count The number of elements to enqueue. - * @return The number of element enqueued. - */ - int enqueue_default(int count) { return enqueue(nullptr, count); } - /** - * @brief Put an element in the queue - * - * Only safely called on the producer thread. - * - * @param element The element to put in the queue. - * - * @return 1 if the element was inserted, 0 otherwise. - */ - int enqueue(T & element) { return enqueue(&element, 1); } - /** - * Push `count` elements in the ring buffer. - * - * Only safely called on the producer thread. - * - * @param elements a pointer to a buffer containing at least `count` elements. - * If `elements` is nullptr, zero or default constructed elements are - * enqueued. - * @param count The number of elements to read from `elements` - * @return The number of elements successfully coped from `elements` and - * inserted into the ring buffer. - */ - int enqueue(T * elements, int count) - { -#ifndef NDEBUG - assert_correct_thread(producer_id); -#endif - - int rd_idx = read_index_.load(std::memory_order_relaxed); - int wr_idx = write_index_.load(std::memory_order_relaxed); - - if (full_internal(rd_idx, wr_idx)) { - return 0; - } - - int to_write = std::min(available_write_internal(rd_idx, wr_idx), count); - - /* First part, from the write index to the end of the array. */ - int first_part = std::min(storage_capacity() - wr_idx, to_write); - /* Second part, from the beginning of the array */ - int second_part = to_write - first_part; - - if (elements) { - Copy(data_.get() + wr_idx, elements, first_part); - Copy(data_.get(), elements + first_part, second_part); - } else { - ConstructDefault(data_.get() + wr_idx, first_part); - ConstructDefault(data_.get(), second_part); - } - - write_index_.store(increment_index(wr_idx, to_write), - std::memory_order_release); - - return to_write; - } - /** - * Retrieve at most `count` elements from the ring buffer, and copy them to - * `elements`, if non-null. - * - * Only safely called on the consumer side. - * - * @param elements A pointer to a buffer with space for at least `count` - * elements. If `elements` is `nullptr`, `count` element will be discarded. - * @param count The maximum number of elements to dequeue. - * @return The number of elements written to `elements`. - */ - int dequeue(T * elements, int count) - { -#ifndef NDEBUG - assert_correct_thread(consumer_id); -#endif - - int wr_idx = write_index_.load(std::memory_order_acquire); - int rd_idx = read_index_.load(std::memory_order_relaxed); - - if (empty_internal(rd_idx, wr_idx)) { - return 0; - } - - int to_read = std::min(available_read_internal(rd_idx, wr_idx), count); - - int first_part = std::min(storage_capacity() - rd_idx, to_read); - int second_part = to_read - first_part; - - if (elements) { - Copy(elements, data_.get() + rd_idx, first_part); - Copy(elements + first_part, data_.get(), second_part); - } - - read_index_.store(increment_index(rd_idx, to_read), - std::memory_order_relaxed); - - return to_read; - } - /** - * Get the number of available element for consuming. - * - * Only safely called on the consumer thread. - * - * @return The number of available elements for reading. - */ - int available_read() const - { -#ifndef NDEBUG - assert_correct_thread(consumer_id); -#endif - return available_read_internal( - read_index_.load(std::memory_order_relaxed), - write_index_.load(std::memory_order_relaxed)); - } - /** - * Get the number of available elements for consuming. - * - * Only safely called on the producer thread. - * - * @return The number of empty slots in the buffer, available for writing. - */ - int available_write() const - { -#ifndef NDEBUG - assert_correct_thread(producer_id); -#endif - return available_write_internal( - read_index_.load(std::memory_order_relaxed), - write_index_.load(std::memory_order_relaxed)); - } - /** - * Get the total capacity, for this ring buffer. - * - * Can be called safely on any thread. - * - * @return The maximum capacity of this ring buffer. - */ - int capacity() const { return storage_capacity() - 1; } - /** - * Reset the consumer and producer thread identifier, in case the thread are - * being changed. This has to be externally synchronized. This is no-op when - * asserts are disabled. - */ - void reset_thread_ids() - { -#ifndef NDEBUG - consumer_id = producer_id = std::thread::id(); -#endif - } - -private: - /** Return true if the ring buffer is empty. - * - * @param read_index the read index to consider - * @param write_index the write index to consider - * @return true if the ring buffer is empty, false otherwise. - **/ - bool empty_internal(int read_index, int write_index) const - { - return write_index == read_index; - } - /** Return true if the ring buffer is full. - * - * This happens if the write index is exactly one element behind the read - * index. - * - * @param read_index the read index to consider - * @param write_index the write index to consider - * @return true if the ring buffer is full, false otherwise. - **/ - bool full_internal(int read_index, int write_index) const - { - return (write_index + 1) % storage_capacity() == read_index; - } - /** - * Return the size of the storage. It is one more than the number of elements - * that can be stored in the buffer. - * - * @return the number of elements that can be stored in the buffer. - */ - int storage_capacity() const { return capacity_; } - /** - * Returns the number of elements available for reading. - * - * @return the number of available elements for reading. - */ - int available_read_internal(int read_index, int write_index) const - { - if (write_index >= read_index) { - return write_index - read_index; - } else { - return write_index + storage_capacity() - read_index; - } - } - /** - * Returns the number of empty elements, available for writing. - * - * @return the number of elements that can be written into the array. - */ - int available_write_internal(int read_index, int write_index) const - { - /* We substract one element here to always keep at least one sample - * free in the buffer, to distinguish between full and empty array. */ - int rv = read_index - write_index - 1; - if (write_index >= read_index) { - rv += storage_capacity(); - } - return rv; - } - /** - * Increments an index, wrapping it around the storage. - * - * @param index a reference to the index to increment. - * @param increment the number by which `index` is incremented. - * @return the new index. - */ - int increment_index(int index, int increment) const - { - assert(increment >= 0); - return (index + increment) % storage_capacity(); - } - /** - * @brief This allows checking that enqueue (resp. dequeue) are always called - * by the right thread. - * - * @param id the id of the thread that has called the calling method first. - */ -#ifndef NDEBUG - static void assert_correct_thread(std::thread::id & id) - { - if (id == std::thread::id()) { - id = std::this_thread::get_id(); - return; - } - assert(id == std::this_thread::get_id()); - } -#endif - /** Index at which the oldest element is at, in samples. */ - std::atomic read_index_; - /** Index at which to write new elements. `write_index` is always at - * least one element ahead of `read_index_`. */ - std::atomic write_index_; - /** Maximum number of elements that can be stored in the ring buffer. */ - const int capacity_; - /** Data storage */ - std::unique_ptr data_; -#ifndef NDEBUG - /** The id of the only thread that is allowed to read from the queue. */ - mutable std::thread::id consumer_id; - /** The id of the only thread that is allowed to write from the queue. */ - mutable std::thread::id producer_id; -#endif -}; - -/** - * Adapter for `ring_buffer_base` that exposes an interface in frames. - */ -template class audio_ring_buffer_base { -public: - /** - * @brief Constructor. - * - * @param channel_count Number of channels. - * @param capacity_in_frames The capacity in frames. - */ - audio_ring_buffer_base(int channel_count, int capacity_in_frames) - : channel_count(channel_count), - ring_buffer(frames_to_samples(capacity_in_frames)) - { - assert(channel_count > 0); - } - /** - * @brief Enqueue silence. - * - * Only safely called on the producer thread. - * - * @param frame_count The number of frames of silence to enqueue. - * @return The number of frames of silence actually written to the queue. - */ - int enqueue_default(int frame_count) - { - return samples_to_frames( - ring_buffer.enqueue(nullptr, frames_to_samples(frame_count))); - } - /** - * @brief Enqueue `frames_count` frames of audio. - * - * Only safely called from the producer thread. - * - * @param [in] frames If non-null, the frames to enqueue. - * Otherwise, silent frames are enqueued. - * @param frame_count The number of frames to enqueue. - * - * @return The number of frames enqueued - */ - - int enqueue(T * frames, int frame_count) - { - return samples_to_frames( - ring_buffer.enqueue(frames, frames_to_samples(frame_count))); - } - - /** - * @brief Removes `frame_count` frames from the buffer, and - * write them to `frames` if it is non-null. - * - * Only safely called on the consumer thread. - * - * @param frames If non-null, the frames are copied to `frames`. - * Otherwise, they are dropped. - * @param frame_count The number of frames to remove. - * - * @return The number of frames actually dequeud. - */ - int dequeue(T * frames, int frame_count) - { - return samples_to_frames( - ring_buffer.dequeue(frames, frames_to_samples(frame_count))); - } - /** - * Get the number of available frames of audio for consuming. - * - * Only safely called on the consumer thread. - * - * @return The number of available frames of audio for reading. - */ - int available_read() const - { - return samples_to_frames(ring_buffer.available_read()); - } - /** - * Get the number of available frames of audio for consuming. - * - * Only safely called on the producer thread. - * - * @return The number of empty slots in the buffer, available for writing. - */ - int available_write() const - { - return samples_to_frames(ring_buffer.available_write()); - } - /** - * Get the total capacity, for this ring buffer. - * - * Can be called safely on any thread. - * - * @return The maximum capacity of this ring buffer. - */ - int capacity() const { return samples_to_frames(ring_buffer.capacity()); } - -private: - /** - * @brief Frames to samples conversion. - * - * @param frames The number of frames. - * - * @return A number of samples. - */ - int frames_to_samples(int frames) const { return frames * channel_count; } - /** - * @brief Samples to frames conversion. - * - * @param samples The number of samples. - * - * @return A number of frames. - */ - int samples_to_frames(int samples) const { return samples / channel_count; } - /** Number of channels of audio that will stream through this ring buffer. */ - int channel_count; - /** The underlying ring buffer that is used to store the data. */ - ring_buffer_base ring_buffer; -}; - -/** - * Lock-free instantiation of the `ring_buffer_base` type. This is safe to use - * from two threads, one producer, one consumer (that never change role), - * without explicit synchronization. - */ -template using lock_free_queue = ring_buffer_base; -/** - * Lock-free instantiation of the `audio_ring_buffer` type. This is safe to use - * from two threads, one producer, one consumer (that never change role), - * without explicit synchronization. - */ -template -using lock_free_audio_ring_buffer = audio_ring_buffer_base; - -#endif // CUBEB_RING_BUFFER_H -- cgit v1.2.3