From ad7302a032847636d6462946a662f441bdfaaf56 Mon Sep 17 00:00:00 2001 From: Max Kellermann Date: Thu, 5 Dec 2013 11:09:04 +0100 Subject: util/DynamicFifoBuffer: new class replacing growing_fifo --- src/encoder/FlacEncoderPlugin.cxx | 30 ++---- src/encoder/NullEncoderPlugin.cxx | 30 ++---- src/encoder/WaveEncoderPlugin.cxx | 37 +++---- src/util/DynamicFifoBuffer.hxx | 199 ++++++++++++++++++++++++++++++++++++++ src/util/growing_fifo.c | 90 ----------------- src/util/growing_fifo.h | 73 -------------- 6 files changed, 229 insertions(+), 230 deletions(-) create mode 100644 src/util/DynamicFifoBuffer.hxx delete mode 100644 src/util/growing_fifo.c delete mode 100644 src/util/growing_fifo.h (limited to 'src') diff --git a/src/encoder/FlacEncoderPlugin.cxx b/src/encoder/FlacEncoderPlugin.cxx index 2569ca95f..91c9382ad 100644 --- a/src/encoder/FlacEncoderPlugin.cxx +++ b/src/encoder/FlacEncoderPlugin.cxx @@ -23,15 +23,10 @@ #include "AudioFormat.hxx" #include "pcm/PcmBuffer.hxx" #include "ConfigError.hxx" +#include "util/Manual.hxx" +#include "util/DynamicFifoBuffer.hxx" #include "util/Error.hxx" #include "util/Domain.hxx" -#include "util/fifo_buffer.h" - -extern "C" { -#include "util/growing_fifo.h" -} - -#include #include @@ -53,7 +48,7 @@ struct flac_encoder { * This buffer will hold encoded data from libFLAC until it is * picked up with flac_encoder_read(). */ - struct fifo_buffer *output_buffer; + Manual> output_buffer; flac_encoder():encoder(flac_encoder_plugin) {} }; @@ -140,7 +135,7 @@ flac_write_callback(gcc_unused const FLAC__StreamEncoder *fse, struct flac_encoder *encoder = (struct flac_encoder *) client_data; //transfer data to buffer - growing_fifo_append(&encoder->output_buffer, data, bytes); + encoder->output_buffer->Append((const uint8_t *)data, bytes); return FLAC__STREAM_ENCODER_WRITE_STATUS_OK; } @@ -153,7 +148,7 @@ flac_encoder_close(Encoder *_encoder) FLAC__stream_encoder_delete(encoder->fse); encoder->expand_buffer.Clear(); - fifo_buffer_free(encoder->output_buffer); + encoder->output_buffer.Destruct(); } static bool @@ -195,7 +190,7 @@ flac_encoder_open(Encoder *_encoder, AudioFormat &audio_format, Error &error) return false; } - encoder->output_buffer = growing_fifo_new(); + encoder->output_buffer.Construct(8192); /* this immediately outputs data through callback */ @@ -304,18 +299,7 @@ flac_encoder_read(Encoder *_encoder, void *dest, size_t length) { struct flac_encoder *encoder = (struct flac_encoder *)_encoder; - size_t max_length; - const char *src = (const char *) - fifo_buffer_read(encoder->output_buffer, &max_length); - if (src == nullptr) - return 0; - - if (length > max_length) - length = max_length; - - memcpy(dest, src, length); - fifo_buffer_consume(encoder->output_buffer, length); - return length; + return encoder->output_buffer->Read((uint8_t *)dest, length); } static const char * diff --git a/src/encoder/NullEncoderPlugin.cxx b/src/encoder/NullEncoderPlugin.cxx index 3b1aae5e2..d35d880d4 100644 --- a/src/encoder/NullEncoderPlugin.cxx +++ b/src/encoder/NullEncoderPlugin.cxx @@ -20,21 +20,19 @@ #include "config.h" #include "NullEncoderPlugin.hxx" #include "EncoderAPI.hxx" -#include "util/fifo_buffer.h" -extern "C" { -#include "util/growing_fifo.h" -} +#include "util/Manual.hxx" +#include "util/DynamicFifoBuffer.hxx" #include "Compiler.h" #include -#include struct NullEncoder final { Encoder encoder; - struct fifo_buffer *buffer; + Manual> buffer; - NullEncoder():encoder(null_encoder_plugin) {} + NullEncoder() + :encoder(null_encoder_plugin) {} }; static Encoder * @@ -58,7 +56,7 @@ null_encoder_close(Encoder *_encoder) { NullEncoder *encoder = (NullEncoder *)_encoder; - fifo_buffer_free(encoder->buffer); + encoder->buffer.Destruct(); } @@ -68,7 +66,7 @@ null_encoder_open(Encoder *_encoder, gcc_unused Error &error) { NullEncoder *encoder = (NullEncoder *)_encoder; - encoder->buffer = growing_fifo_new(); + encoder->buffer.Construct(8192); return true; } @@ -79,7 +77,7 @@ null_encoder_write(Encoder *_encoder, { NullEncoder *encoder = (NullEncoder *)_encoder; - growing_fifo_append(&encoder->buffer, data, length); + encoder->buffer->Append((const uint8_t *)data, length); return length; } @@ -88,17 +86,7 @@ null_encoder_read(Encoder *_encoder, void *dest, size_t length) { NullEncoder *encoder = (NullEncoder *)_encoder; - size_t max_length; - const void *src = fifo_buffer_read(encoder->buffer, &max_length); - if (src == nullptr) - return 0; - - if (length > max_length) - length = max_length; - - memcpy(dest, src, length); - fifo_buffer_consume(encoder->buffer, length); - return length; + return encoder->buffer->Read((uint8_t *)dest, length); } const EncoderPlugin null_encoder_plugin = { diff --git a/src/encoder/WaveEncoderPlugin.cxx b/src/encoder/WaveEncoderPlugin.cxx index acae0be9e..083d25f95 100644 --- a/src/encoder/WaveEncoderPlugin.cxx +++ b/src/encoder/WaveEncoderPlugin.cxx @@ -21,10 +21,8 @@ #include "WaveEncoderPlugin.hxx" #include "EncoderAPI.hxx" #include "system/ByteOrder.hxx" -#include "util/fifo_buffer.h" -extern "C" { -#include "util/growing_fifo.h" -} +#include "util/Manual.hxx" +#include "util/DynamicFifoBuffer.hxx" #include #include @@ -33,7 +31,7 @@ struct WaveEncoder { Encoder encoder; unsigned bits; - struct fifo_buffer *buffer; + Manual> buffer; WaveEncoder():encoder(wave_encoder_plugin) {} }; @@ -128,9 +126,11 @@ wave_encoder_open(Encoder *_encoder, break; } - encoder->buffer = growing_fifo_new(); - wave_header *header = (wave_header *) - growing_fifo_write(&encoder->buffer, sizeof(*header)); + encoder->buffer.Construct(8192); + + auto range = encoder->buffer->Write(); + assert(range.size >= sizeof(wave_header)); + wave_header *header = (wave_header *)range.data; /* create PCM wave header in initial buffer */ fill_wave_header(header, @@ -138,7 +138,8 @@ wave_encoder_open(Encoder *_encoder, encoder->bits, audio_format.sample_rate, (encoder->bits / 8) * audio_format.channels); - fifo_buffer_append(encoder->buffer, sizeof(*header)); + + encoder->buffer->Append(sizeof(*header)); return true; } @@ -148,7 +149,7 @@ wave_encoder_close(Encoder *_encoder) { WaveEncoder *encoder = (WaveEncoder *)_encoder; - fifo_buffer_free(encoder->buffer); + encoder->buffer.Destruct(); } static size_t @@ -198,7 +199,7 @@ wave_encoder_write(Encoder *_encoder, { WaveEncoder *encoder = (WaveEncoder *)_encoder; - uint8_t *dst = (uint8_t *)growing_fifo_write(&encoder->buffer, length); + uint8_t *dst = encoder->buffer->Write(length); if (IsLittleEndian()) { switch (encoder->bits) { @@ -230,7 +231,7 @@ wave_encoder_write(Encoder *_encoder, } } - fifo_buffer_append(encoder->buffer, length); + encoder->buffer->Append(length); return true; } @@ -239,17 +240,7 @@ wave_encoder_read(Encoder *_encoder, void *dest, size_t length) { WaveEncoder *encoder = (WaveEncoder *)_encoder; - size_t max_length; - const void *src = fifo_buffer_read(encoder->buffer, &max_length); - if (src == NULL) - return 0; - - if (length > max_length) - length = max_length; - - memcpy(dest, src, length); - fifo_buffer_consume(encoder->buffer, length); - return length; + return encoder->buffer->Read((uint8_t *)dest, length); } static const char * diff --git a/src/util/DynamicFifoBuffer.hxx b/src/util/DynamicFifoBuffer.hxx new file mode 100644 index 000000000..ead7389e9 --- /dev/null +++ b/src/util/DynamicFifoBuffer.hxx @@ -0,0 +1,199 @@ +/* + * Copyright (C) 2003-2013 Max Kellermann + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * - Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, + * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef FIFO_BUFFER_HPP +#define FIFO_BUFFER_HPP + +#include "WritableBuffer.hxx" + +#include +#include + +#include +#include +#include + +/** + * A first-in-first-out buffer: you can append data at the end, and + * read data from the beginning. This class automatically shifts the + * buffer as needed. It is not thread safe. + */ +template +class DynamicFifoBuffer { +public: + typedef size_t size_type; + typedef WritableBuffer Range; + typedef typename Range::pointer_type pointer_type; + typedef typename Range::const_pointer_type const_pointer_type; + +protected: + size_type head, tail, capacity; + T *data; + +public: + DynamicFifoBuffer(size_type _capacity) + :head(0), tail(0), capacity(_capacity), + data(new T[capacity]) {} + ~DynamicFifoBuffer() { + delete[] data; + } + + DynamicFifoBuffer(const DynamicFifoBuffer &) = delete; + + size_type GetCapacity() { + return capacity; + } + + void Grow(size_type new_capacity) { + assert(new_capacity > capacity); + + T *new_data = new T[new_capacity]; + std::move(data + head, data + tail, new_data); + delete[] data; + data = new_data; + capacity = new_capacity; + tail -= head; + head = 0; + } + + void Clear() { + head = tail = 0; + } + + bool IsEmpty() const { + return head == tail; + } + + bool IsFull() const { + return head == 0 && tail == capacity; + } + + /** + * Prepares writing. Returns a buffer range which may be written. + * When you are finished, call append(). + */ + Range Write() { + Shift(); + return Range(data + tail, capacity - tail); + } + + /** + * Expands the tail of the buffer, after data has been written to + * the buffer returned by write(). + */ + void Append(size_type n) { + assert(tail <= capacity); + assert(n <= capacity); + assert(tail + n <= capacity); + + tail += n; + } + + void WantWrite(size_type n) { + if (tail + n <= capacity) + /* enough space after the tail */ + return; + + const size_type in_use = tail - head; + const size_type required_capacity = in_use + n; + if (capacity >= required_capacity) { + Shift(); + } else { + size_type new_capacity = capacity; + do { + new_capacity <<= 1; + } while (new_capacity < required_capacity); + + Grow(new_capacity); + } + } + + /** + * Write data to the bfufer, growing it as needed. Returns a + * writable pointer. + */ + pointer_type Write(size_type n) { + WantWrite(n); + return data + tail; + } + + /** + * Append data to the buffer, growing it as needed. + */ + void Append(const_pointer_type p, size_type n) { + std::copy_n(p, n, Write(n)); + Append(n); + } + + /** + * Return a buffer range which may be read. The buffer pointer is + * writable, to allow modifications while parsing. + */ + Range Read() { + return Range(data + head, tail - head); + } + + /** + * Marks a chunk as consumed. + */ + void Consume(size_type n) { + assert(tail <= capacity); + assert(head <= tail); + assert(n <= tail); + assert(head + n <= tail); + + head += n; + } + + size_type Read(pointer_type p, size_type n) { + auto range = Read(); + if (n > range.size) + n = range.size; + std::copy_n(range.data, n, p); + Consume(n); + return n; + } + +protected: + void Shift() { + if (head == 0) + return; + + assert(head <= capacity); + assert(tail <= capacity); + assert(tail >= head); + + std::move(data + head, data + tail, data); + + tail -= head; + head = 0; + } +}; + +#endif diff --git a/src/util/growing_fifo.c b/src/util/growing_fifo.c deleted file mode 100644 index 88431f60e..000000000 --- a/src/util/growing_fifo.c +++ /dev/null @@ -1,90 +0,0 @@ -/* - * Copyright (C) 2003-2011 The Music Player Daemon Project - * http://www.musicpd.org - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the - * distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED - * OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "growing_fifo.h" -#include "fifo_buffer.h" - -#include -#include - -/** - * Align buffer sizes at 8 kB boundaries. Must be a power of two. - */ -static const size_t GROWING_FIFO_ALIGN = 8192; - -/** - * Align the specified size to the next #GROWING_FIFO_ALIGN boundary. - */ -static size_t -align(size_t size) -{ - return ((size - 1) | (GROWING_FIFO_ALIGN - 1)) + 1; -} - -struct fifo_buffer * -growing_fifo_new(void) -{ - return fifo_buffer_new(GROWING_FIFO_ALIGN); -} - -void * -growing_fifo_write(struct fifo_buffer **buffer_p, size_t length) -{ - assert(buffer_p != NULL); - - struct fifo_buffer *buffer = *buffer_p; - assert(buffer != NULL); - - size_t max_length; - void *p = fifo_buffer_write(buffer, &max_length); - if (p != NULL && max_length >= length) - return p; - - /* grow */ - size_t new_size = fifo_buffer_available(buffer) + length; - assert(new_size > fifo_buffer_capacity(buffer)); - *buffer_p = buffer = fifo_buffer_realloc(buffer, align(new_size)); - - /* try again */ - p = fifo_buffer_write(buffer, &max_length); - assert(p != NULL); - assert(max_length >= length); - - return p; -} - -void -growing_fifo_append(struct fifo_buffer **buffer_p, - const void *data, size_t length) -{ - void *p = growing_fifo_write(buffer_p, length); - memcpy(p, data, length); - fifo_buffer_append(*buffer_p, length); -} diff --git a/src/util/growing_fifo.h b/src/util/growing_fifo.h deleted file mode 100644 index 723c3b3ff..000000000 --- a/src/util/growing_fifo.h +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright (C) 2003-2011 The Music Player Daemon Project - * http://www.musicpd.org - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * - Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the - * distribution. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE - * FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED - * OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** \file - * - * Helper functions for our FIFO buffer library (fifo_buffer.h) that - * allows growing the buffer on demand. - * - * This library is not thread safe. - */ - -#ifndef MPD_GROWING_FIFO_H -#define MPD_GROWING_FIFO_H - -#include - -struct fifo_buffer; - -/** - * Allocate a new #fifo_buffer with the default size. - */ -struct fifo_buffer * -growing_fifo_new(void); - -/** - * Prepares writing to the buffer, see fifo_buffer_write() for - * details. The difference is that this function will automatically - * grow the buffer if it is too small. - * - * The caller is responsible for limiting the capacity of the buffer. - * - * @param length the number of bytes that will be written - * @return a pointer to the end of the buffer (will not be NULL) - */ -void * -growing_fifo_write(struct fifo_buffer **buffer_p, size_t length); - -/** - * A helper function that combines growing_fifo_write(), memcpy(), - * fifo_buffer_append(). - */ -void -growing_fifo_append(struct fifo_buffer **buffer_p, - const void *data, size_t length); - -#endif -- cgit v1.2.3