eff923b90a6ef4a766254808cccee56020e58932
[profile/ivi/pulseaudio-panda.git] / src / memblockq.c
1 /* $Id$ */
2
3 /***
4   This file is part of polypaudio.
5  
6   polypaudio is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published
8   by the Free Software Foundation; either version 2 of the License,
9   or (at your option) any later version.
10  
11   polypaudio is distributed in the hope that it will be useful, but
12   WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14   General Public License for more details.
15  
16   You should have received a copy of the GNU General Public License
17   along with polypaudio; if not, write to the Free Software
18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19   USA.
20 ***/
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <sys/time.h>
27 #include <time.h>
28 #include <stdio.h>
29 #include <assert.h>
30 #include <stdlib.h>
31
32 #include "memblockq.h"
33
34 struct memblock_list {
35     struct memblock_list *next;
36     struct pa_memchunk chunk;
37     struct timeval stamp;
38 };
39
40 struct pa_memblockq {
41     struct memblock_list *blocks, *blocks_tail;
42     unsigned n_blocks;
43     size_t current_length, maxlength, tlength, base, prebuf, minreq;
44     int measure_delay;
45     uint32_t delay;
46     struct pa_mcalign *mcalign;
47 };
48
49 struct pa_memblockq* pa_memblockq_new(size_t maxlength, size_t tlength, size_t base, size_t prebuf, size_t minreq) {
50     struct pa_memblockq* bq;
51     assert(maxlength && base && maxlength);
52     
53     bq = malloc(sizeof(struct pa_memblockq));
54     assert(bq);
55     bq->blocks = bq->blocks_tail = 0;
56     bq->n_blocks = 0;
57
58     bq->current_length = 0;
59
60     fprintf(stderr, "memblockq requested: maxlength=%u, tlength=%u, base=%u, prebuf=%u, minreq=%u\n", maxlength, tlength, base, prebuf, minreq);
61     
62     bq->base = base;
63
64     bq->maxlength = ((maxlength+base-1)/base)*base;
65     assert(bq->maxlength >= base);
66
67     bq->tlength = ((tlength+base-1)/base)*base;
68     if (bq->tlength == 0 || bq->tlength >= bq->maxlength)
69         bq->tlength = bq->maxlength;
70     
71     bq->prebuf = (prebuf == (size_t) -1) ? bq->maxlength/2 : prebuf;
72     bq->prebuf = (bq->prebuf/base)*base;
73     if (bq->prebuf > bq->maxlength)
74         bq->prebuf = bq->maxlength;
75     
76     bq->minreq = (minreq/base)*base;
77     if (bq->minreq == 0)
78         bq->minreq = 1;
79
80     fprintf(stderr, "memblockq sanitized: maxlength=%u, tlength=%u, base=%u, prebuf=%u, minreq=%u\n", bq->maxlength, bq->tlength, bq->base, bq->prebuf, bq->minreq);
81     
82     bq->measure_delay = 0;
83     bq->delay = 0;
84
85     bq->mcalign = NULL;
86     
87     return bq;
88 }
89
90 void pa_memblockq_free(struct pa_memblockq* bq) {
91     struct memblock_list *l;
92     assert(bq);
93
94     if (bq->mcalign)
95         pa_mcalign_free(bq->mcalign);
96
97     while ((l = bq->blocks)) {
98         bq->blocks = l->next;
99         pa_memblock_unref(l->chunk.memblock);
100         free(l);
101     }
102     
103     free(bq);
104 }
105
106 void pa_memblockq_push(struct pa_memblockq* bq, const struct pa_memchunk *chunk, size_t delta) {
107     struct memblock_list *q;
108     assert(bq && chunk && chunk->memblock && chunk->length && (chunk->length % bq->base) == 0);
109
110     if (bq->blocks_tail && bq->blocks_tail->chunk.memblock == chunk->memblock) {
111         /* Try to merge memory chunks */
112
113         if (bq->blocks_tail->chunk.index+bq->blocks_tail->chunk.length == chunk->index) {
114             bq->blocks_tail->chunk.length += chunk->length;
115             bq->current_length += chunk->length;
116
117     /*        fprintf(stderr, __FILE__": merge succeeded: %u\n", chunk->length);*/
118             return;
119         }
120     }
121     
122     q = malloc(sizeof(struct memblock_list));
123     assert(q);
124
125     if (bq->measure_delay)
126         gettimeofday(&q->stamp, NULL);
127     else
128         timerclear(&q->stamp);
129
130     q->chunk = *chunk;
131     pa_memblock_ref(q->chunk.memblock);
132     assert(q->chunk.index+q->chunk.length <= q->chunk.memblock->length);
133     q->next = NULL;
134     
135     if (bq->blocks_tail)
136         bq->blocks_tail->next = q;
137     else
138         bq->blocks = q;
139     
140     bq->blocks_tail = q;
141
142     bq->n_blocks++;
143     bq->current_length += chunk->length;
144
145     pa_memblockq_shorten(bq, bq->maxlength);
146 }
147
148 int pa_memblockq_peek(struct pa_memblockq* bq, struct pa_memchunk *chunk) {
149     assert(bq && chunk);
150
151     if (!bq->blocks || bq->current_length < bq->prebuf)
152         return -1;
153
154     bq->prebuf = 0;
155
156     *chunk = bq->blocks->chunk;
157     pa_memblock_ref(chunk->memblock);
158
159 /*     if (chunk->memblock->ref != 2) */
160 /*         fprintf(stderr, "block %p with ref %u peeked.\n", chunk->memblock, chunk->memblock->ref); */
161     
162     return 0;
163 }
164
165 /*
166 int memblockq_pop(struct memblockq* bq, struct pa_memchunk *chunk) {
167     struct memblock_list *q;
168     
169     assert(bq && chunk);
170
171     if (!bq->blocks || bq->current_length < bq->prebuf)
172         return -1;
173
174     bq->prebuf = 0;
175
176     q = bq->blocks;
177     bq->blocks = bq->blocks->next;
178
179     *chunk = q->chunk;
180
181     bq->n_blocks--;
182     bq->current_length -= chunk->length;
183
184     free(q);
185     return 0;
186 }
187 */
188
189 static uint32_t age(struct timeval *tv) {
190     assert(tv);
191     struct timeval now;
192     uint32_t r;
193
194     if (tv->tv_sec == 0)
195         return 0;
196
197     gettimeofday(&now, NULL);
198     
199     r = (now.tv_sec-tv->tv_sec) * 1000000;
200
201     if (now.tv_usec >= tv->tv_usec)
202         r += now.tv_usec - tv->tv_usec;
203     else
204         r -= tv->tv_usec - now.tv_usec;
205
206     return r;
207 }
208
209 void pa_memblockq_drop(struct pa_memblockq *bq, size_t length) {
210     assert(bq && length && (length % bq->base) == 0);
211
212     while (length > 0) {
213         size_t l = length;
214         assert(bq->blocks && bq->current_length >= length);
215         
216         if (l > bq->blocks->chunk.length)
217             l = bq->blocks->chunk.length;
218
219         if (bq->measure_delay)
220             bq->delay = age(&bq->blocks->stamp);
221         
222         bq->blocks->chunk.index += l;
223         bq->blocks->chunk.length -= l;
224         bq->current_length -= l;
225         
226         if (bq->blocks->chunk.length == 0) {
227             struct memblock_list *q;
228             
229             q = bq->blocks;
230             bq->blocks = bq->blocks->next;
231             if (bq->blocks == NULL)
232                 bq->blocks_tail = NULL;
233             pa_memblock_unref(q->chunk.memblock);
234             free(q);
235             
236             bq->n_blocks--;
237         }
238
239         length -= l;
240     }
241 }
242
243 void pa_memblockq_shorten(struct pa_memblockq *bq, size_t length) {
244     size_t l;
245     assert(bq);
246
247     if (bq->current_length <= length)
248         return;
249
250     fprintf(stderr, "Warning! pa_memblockq_shorten()\n");
251     
252     l = bq->current_length - length;
253     l /= bq->base;
254     l *= bq->base;
255
256     pa_memblockq_drop(bq, l);
257 }
258
259
260 void pa_memblockq_empty(struct pa_memblockq *bq) {
261     assert(bq);
262     pa_memblockq_shorten(bq, 0);
263 }
264
265 int pa_memblockq_is_readable(struct pa_memblockq *bq) {
266     assert(bq);
267
268     return bq->current_length && (bq->current_length >= bq->prebuf);
269 }
270
271 int pa_memblockq_is_writable(struct pa_memblockq *bq, size_t length) {
272     assert(bq);
273
274     return bq->current_length + length <= bq->tlength;
275 }
276
277 uint32_t pa_memblockq_get_delay(struct pa_memblockq *bq) {
278     assert(bq);
279     return bq->delay;
280 }
281
282 uint32_t pa_memblockq_get_length(struct pa_memblockq *bq) {
283     assert(bq);
284     return bq->current_length;
285 }
286
287 uint32_t pa_memblockq_missing(struct pa_memblockq *bq) {
288     size_t l;
289     assert(bq);
290
291     if (bq->current_length >= bq->tlength)
292         return 0;
293
294     l = bq->tlength - bq->current_length;
295     assert(l);
296
297     return (l >= bq->minreq) ? l : 0;
298 }
299
300 void pa_memblockq_push_align(struct pa_memblockq* bq, const struct pa_memchunk *chunk, size_t delta) {
301     struct pa_memchunk rchunk;
302     assert(bq && chunk && bq->base);
303
304     if (bq->base == 1) {
305         pa_memblockq_push(bq, chunk, delta);
306         return;
307     }
308
309     if (!bq->mcalign) {
310         bq->mcalign = pa_mcalign_new(bq->base);
311         assert(bq->mcalign);
312     }
313     
314     pa_mcalign_push(bq->mcalign, chunk);
315
316     while (pa_mcalign_pop(bq->mcalign, &rchunk) >= 0) {
317         pa_memblockq_push(bq, &rchunk, delta);
318         pa_memblock_unref(rchunk.memblock);
319         delta = 0;
320     }
321 }
322
323 uint32_t pa_memblockq_get_minreq(struct pa_memblockq *bq) {
324     assert(bq);
325     return bq->minreq;
326 }