f2fe93de75ef23d96769b34ab51f6f0f2f853acc
[ffmpeg.git] / libavutil / fifo.c
1 /*
2  * a very simple circular buffer FIFO implementation
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  * Copyright (c) 2006 Roman Shaposhnik
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 #include "avassert.h"
24 #include "common.h"
25 #include "fifo.h"
26
27 static AVFifoBuffer *fifo_alloc_common(void *buffer, size_t size)
28 {
29     AVFifoBuffer *f;
30     if (!buffer)
31         return NULL;
32     f = av_mallocz(sizeof(AVFifoBuffer));
33     if (!f) {
34         av_free(buffer);
35         return NULL;
36     }
37     f->buffer = buffer;
38     f->end    = f->buffer + size;
39     av_fifo_reset(f);
40     return f;
41 }
42
43 AVFifoBuffer *av_fifo_alloc(unsigned int size)
44 {
45     void *buffer = av_malloc(size);
46     return fifo_alloc_common(buffer, size);
47 }
48
49 AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size)
50 {
51     void *buffer = av_malloc_array(nmemb, size);
52     return fifo_alloc_common(buffer, nmemb * size);
53 }
54
55 void av_fifo_free(AVFifoBuffer *f)
56 {
57     if (f) {
58         av_freep(&f->buffer);
59         av_free(f);
60     }
61 }
62
63 void av_fifo_freep(AVFifoBuffer **f)
64 {
65     if (f) {
66         av_fifo_free(*f);
67         *f = NULL;
68     }
69 }
70
71 void av_fifo_reset(AVFifoBuffer *f)
72 {
73     f->wptr = f->rptr = f->buffer;
74     f->wndx = f->rndx = 0;
75 }
76
77 int av_fifo_size(const AVFifoBuffer *f)
78 {
79     return (uint32_t)(f->wndx - f->rndx);
80 }
81
82 int av_fifo_space(const AVFifoBuffer *f)
83 {
84     return f->end - f->buffer - av_fifo_size(f);
85 }
86
87 int av_fifo_realloc2(AVFifoBuffer *f, unsigned int new_size)
88 {
89     unsigned int old_size = f->end - f->buffer;
90
91     if (old_size < new_size) {
92         int len          = av_fifo_size(f);
93         AVFifoBuffer *f2 = av_fifo_alloc(new_size);
94
95         if (!f2)
96             return AVERROR(ENOMEM);
97         av_fifo_generic_read(f, f2->buffer, len, NULL);
98         f2->wptr += len;
99         f2->wndx += len;
100         av_free(f->buffer);
101         *f = *f2;
102         av_free(f2);
103     }
104     return 0;
105 }
106
107 int av_fifo_grow(AVFifoBuffer *f, unsigned int size)
108 {
109     unsigned int old_size = f->end - f->buffer;
110     if(size + (unsigned)av_fifo_size(f) < size)
111         return AVERROR(EINVAL);
112
113     size += av_fifo_size(f);
114
115     if (old_size < size)
116         return av_fifo_realloc2(f, FFMAX(size, 2*size));
117     return 0;
118 }
119
120 /* src must NOT be const as it can be a context for func that may need
121  * updating (like a pointer or byte counter) */
122 int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size,
123                           int (*func)(void *, void *, int))
124 {
125     int total = size;
126     uint32_t wndx= f->wndx;
127     uint8_t *wptr= f->wptr;
128
129     do {
130         int len = FFMIN(f->end - wptr, size);
131         if (func) {
132             len = func(src, wptr, len);
133             if (len <= 0)
134                 break;
135         } else {
136             memcpy(wptr, src, len);
137             src = (uint8_t *)src + len;
138         }
139 // Write memory barrier needed for SMP here in theory
140         wptr += len;
141         if (wptr >= f->end)
142             wptr = f->buffer;
143         wndx    += len;
144         size    -= len;
145     } while (size > 0);
146     f->wndx= wndx;
147     f->wptr= wptr;
148     return total - size;
149 }
150
151 int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size,
152                          void (*func)(void *, void *, int))
153 {
154 // Read memory barrier needed for SMP here in theory
155     do {
156         int len = FFMIN(f->end - f->rptr, buf_size);
157         if (func)
158             func(dest, f->rptr, len);
159         else {
160             memcpy(dest, f->rptr, len);
161             dest = (uint8_t *)dest + len;
162         }
163 // memory barrier needed for SMP here in theory
164         av_fifo_drain(f, len);
165         buf_size -= len;
166     } while (buf_size > 0);
167     return 0;
168 }
169
170 /** Discard data from the FIFO. */
171 void av_fifo_drain(AVFifoBuffer *f, int size)
172 {
173     av_assert2(av_fifo_size(f) >= size);
174     f->rptr += size;
175     if (f->rptr >= f->end)
176         f->rptr -= f->end - f->buffer;
177     f->rndx += size;
178 }
179
180 #ifdef TEST
181
182 int main(void)
183 {
184     /* create a FIFO buffer */
185     AVFifoBuffer *fifo = av_fifo_alloc(13 * sizeof(int));
186     int i, j, n;
187
188     /* fill data */
189     for (i = 0; av_fifo_space(fifo) >= sizeof(int); i++)
190         av_fifo_generic_write(fifo, &i, sizeof(int), NULL);
191
192     /* peek at FIFO */
193     n = av_fifo_size(fifo) / sizeof(int);
194     for (i = -n + 1; i < n; i++) {
195         int *v = (int *)av_fifo_peek2(fifo, i * sizeof(int));
196         printf("%d: %d\n", i, *v);
197     }
198     printf("\n");
199
200     /* read data */
201     for (i = 0; av_fifo_size(fifo) >= sizeof(int); i++) {
202         av_fifo_generic_read(fifo, &j, sizeof(int), NULL);
203         printf("%d ", j);
204     }
205     printf("\n");
206
207     av_fifo_free(fifo);
208
209     return 0;
210 }
211
212 #endif