X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavutil%2Ffifo.c;h=dffaf54533ae06ffee800774905206eb745fb3e1;hb=32125781487411ed3b1b28b32063d6cd4024d4fc;hp=19ec13e63d0716e7515fbe86c0d82f08ce2e7ff9;hpb=95c76e11805abf8e14ffbec64b9c23d32ea563ef;p=ffmpeg diff --git a/libavutil/fifo.c b/libavutil/fifo.c index 19ec13e63d0..dffaf54533a 100644 --- a/libavutil/fifo.c +++ b/libavutil/fifo.c @@ -1,126 +1,167 @@ /* - * A very simple circular buffer FIFO implementation + * a very simple circular buffer FIFO implementation * Copyright (c) 2000, 2001, 2002 Fabrice Bellard * Copyright (c) 2006 Roman Shaposhnik * - * This file is part of FFmpeg. + * This file is part of Libav. * - * FFmpeg is free software; you can redistribute it and/or + * Libav is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * - * FFmpeg is distributed in the hope that it will be useful, + * Libav is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with FFmpeg; if not, write to the Free Software + * License along with Libav; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "common.h" #include "fifo.h" -int av_fifo_init(AVFifoBuffer *f, int size) +AVFifoBuffer *av_fifo_alloc(unsigned int size) { - f->wptr = f->rptr = + AVFifoBuffer *f = av_mallocz(sizeof(AVFifoBuffer)); + if (!f) + return NULL; f->buffer = av_malloc(size); - f->end = f->buffer + size; + f->end = f->buffer + size; + av_fifo_reset(f); if (!f->buffer) - return -1; - return 0; + av_freep(&f); + return f; } void av_fifo_free(AVFifoBuffer *f) { - av_free(f->buffer); + if (f) { + av_free(f->buffer); + av_free(f); + } +} + +void av_fifo_reset(AVFifoBuffer *f) +{ + f->wptr = f->rptr = f->buffer; + f->wndx = f->rndx = 0; } int av_fifo_size(AVFifoBuffer *f) { - int size = f->wptr - f->rptr; - if (size < 0) - size += f->end - f->buffer; - return size; + return (uint32_t)(f->wndx - f->rndx); } -/** - * Get data from the fifo (returns -1 if not enough data). - */ -int av_fifo_read(AVFifoBuffer *f, uint8_t *buf, int buf_size) +int av_fifo_space(AVFifoBuffer *f) { - return av_fifo_generic_read(f, buf_size, NULL, buf); + return f->end - f->buffer - av_fifo_size(f); } -/** - * Resizes a FIFO. - */ -void av_fifo_realloc(AVFifoBuffer *f, unsigned int new_size) { - unsigned int old_size= f->end - f->buffer; +int av_fifo_realloc2(AVFifoBuffer *f, unsigned int new_size) +{ + unsigned int old_size = f->end - f->buffer; - if(old_size < new_size){ - int len= av_fifo_size(f); - AVFifoBuffer f2; + if (old_size < new_size) { + int len = av_fifo_size(f); + AVFifoBuffer *f2 = av_fifo_alloc(new_size); - av_fifo_init(&f2, new_size); - av_fifo_read(f, f2.buffer, len); - f2.wptr += len; + if (!f2) + return -1; + av_fifo_generic_read(f, f2->buffer, len, NULL); + f2->wptr += len; + f2->wndx += len; av_free(f->buffer); - *f= f2; + *f = *f2; + av_free(f2); } + return 0; } -void av_fifo_write(AVFifoBuffer *f, const uint8_t *buf, int size) -{ - av_fifo_generic_write(f, (void *)buf, size, NULL); -} - -int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void*, void*, int)) +/* src must NOT be const as it can be a context for func that may need + * updating (like a pointer or byte counter) */ +int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, + int (*func)(void *, void *, int)) { int total = size; do { int len = FFMIN(f->end - f->wptr, size); - if(func) { - if(func(src, f->wptr, len) <= 0) + if (func) { + if (func(src, f->wptr, len) <= 0) break; } else { memcpy(f->wptr, src, len); - src = (uint8_t*)src + len; + src = (uint8_t *)src + len; } +// Write memory barrier needed for SMP here in theory f->wptr += len; if (f->wptr >= f->end) f->wptr = f->buffer; - size -= len; + f->wndx += len; + size -= len; } while (size > 0); return total - size; } - -/** get data from the fifo (return -1 if not enough data) */ -int av_fifo_generic_read(AVFifoBuffer *f, int buf_size, void (*func)(void*, void*, int), void* dest) +int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, + void (*func)(void *, void *, int)) { - int size = av_fifo_size(f); - - if (size < buf_size) - return -1; +// Read memory barrier needed for SMP here in theory do { int len = FFMIN(f->end - f->rptr, buf_size); - if(func) func(dest, f->rptr, len); - else{ + if (func) + func(dest, f->rptr, len); + else { memcpy(dest, f->rptr, len); - dest = (uint8_t*)dest + len; + dest = (uint8_t *)dest + len; } +// memory barrier needed for SMP here in theory av_fifo_drain(f, len); buf_size -= len; } while (buf_size > 0); return 0; } -/** discard data from the fifo */ +/** Discard data from the FIFO. */ void av_fifo_drain(AVFifoBuffer *f, int size) { f->rptr += size; if (f->rptr >= f->end) f->rptr -= f->end - f->buffer; + f->rndx += size; +} + +#ifdef TEST + +int main(void) +{ + /* create a FIFO buffer */ + AVFifoBuffer *fifo = av_fifo_alloc(13 * sizeof(int)); + int i, j, n; + + /* fill data */ + for (i = 0; av_fifo_space(fifo) >= sizeof(int); i++) + av_fifo_generic_write(fifo, &i, sizeof(int), NULL); + + /* peek at FIFO */ + n = av_fifo_size(fifo) / sizeof(int); + for (i = -n + 1; i < n; i++) { + int *v = (int *)av_fifo_peek2(fifo, i * sizeof(int)); + printf("%d: %d\n", i, *v); + } + printf("\n"); + + /* read data */ + for (i = 0; av_fifo_size(fifo) >= sizeof(int); i++) { + av_fifo_generic_read(fifo, &j, sizeof(int), NULL); + printf("%d ", j); + } + printf("\n"); + + av_fifo_free(fifo); + + return 0; } + +#endif