code.delx.au - pulseaudio/blob - src/pulsecore/mcalign.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of PulseAudio.
   5
   6   Copyright 2004-2006 Lennart Poettering
   7
   8   PulseAudio is free software; you can redistribute it and/or modify
   9   it under the terms of the GNU Lesser General Public License as
  10   published by the Free Software Foundation; either version 2.1 of the
  11   License, or (at your option) any later version.
  12
  13   PulseAudio is distributed in the hope that it will be useful, but
  14   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 PulseAudio; if not, write to the Free Software
  20   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  21   USA.
  22 ***/
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <assert.h>
  31 #include <string.h>
  32
  33 #include <pulse/xmalloc.h>
  34
  35 #include "mcalign.h"
  36
  37 struct pa_mcalign {
  38     size_t base;
  39     pa_memchunk leftover, current;
  40 };
  41
  42 pa_mcalign *pa_mcalign_new(size_t base) {
  43     pa_mcalign *m;
  44     assert(base);
  45
  46     m = pa_xnew(pa_mcalign, 1);
  47
  48     m->base = base;
  49     pa_memchunk_reset(&m->leftover);
  50     pa_memchunk_reset(&m->current);
  51
  52     return m;
  53 }
  54
  55 void pa_mcalign_free(pa_mcalign *m) {
  56     assert(m);
  57
  58     if (m->leftover.memblock)
  59         pa_memblock_unref(m->leftover.memblock);
  60
  61     if (m->current.memblock)
  62         pa_memblock_unref(m->current.memblock);
  63
  64     pa_xfree(m);
  65 }
  66
  67 void pa_mcalign_push(pa_mcalign *m, const pa_memchunk *c) {
  68     assert(m);
  69     assert(c);
  70
  71     assert(c->memblock);
  72     assert(c->length > 0);
  73
  74     assert(!m->current.memblock);
  75
  76     /* Append to the leftover memory block */
  77     if (m->leftover.memblock) {
  78
  79         /* Try to merge */
  80         if (m->leftover.memblock == c->memblock &&
  81             m->leftover.index + m->leftover.length == c->index) {
  82
  83             /* Merge */
  84             m->leftover.length += c->length;
  85
  86             /* If the new chunk is larger than m->base, move it to current */
  87             if (m->leftover.length >= m->base) {
  88                 m->current = m->leftover;
  89                 pa_memchunk_reset(&m->leftover);
  90             }
  91
  92         } else {
  93             size_t l;
  94             void *lo_data, *m_data;
  95
  96             /* We have to copy */
  97             assert(m->leftover.length < m->base);
  98             l = m->base - m->leftover.length;
  99
 100             if (l > c->length)
 101                 l = c->length;
 102
 103             /* Can we use the current block? */
 104             pa_memchunk_make_writable(&m->leftover, m->base);
 105
 106             lo_data = pa_memblock_acquire(m->leftover.memblock);
 107             m_data = pa_memblock_acquire(c->memblock);
 108             memcpy((uint8_t*) lo_data + m->leftover.index + m->leftover.length, (uint8_t*) m_data + c->index, l);
 109             pa_memblock_release(m->leftover.memblock);
 110             pa_memblock_release(c->memblock);
 111             m->leftover.length += l;
 112
 113             assert(m->leftover.length <= m->base);
 114             assert(m->leftover.length <= pa_memblock_get_length(m->leftover.memblock));
 115
 116             if (c->length > l) {
 117                 /* Save the remainder of the memory block */
 118                 m->current = *c;
 119                 m->current.index += l;
 120                 m->current.length -= l;
 121                 pa_memblock_ref(m->current.memblock);
 122             }
 123         }
 124     } else {
 125         /* Nothing to merge or copy, just store it */
 126
 127         if (c->length >= m->base)
 128             m->current = *c;
 129         else
 130             m->leftover = *c;
 131
 132         pa_memblock_ref(c->memblock);
 133     }
 134 }
 135
 136 int pa_mcalign_pop(pa_mcalign *m, pa_memchunk *c) {
 137     assert(m);
 138     assert(c);
 139
 140     /* First test if there's a leftover memory block available */
 141     if (m->leftover.memblock) {
 142         assert(m->leftover.length > 0 && m->leftover.length <= m->base);
 143
 144         /* The leftover memory block is not yet complete */
 145         if (m->leftover.length < m->base)
 146             return -1;
 147
 148         /* Return the leftover memory block */
 149         *c = m->leftover;
 150         pa_memchunk_reset(&m->leftover);
 151
 152         /* If the current memblock is too small move it the leftover */
 153         if (m->current.memblock && m->current.length < m->base) {
 154             m->leftover = m->current;
 155             pa_memchunk_reset(&m->current);
 156         }
 157
 158         return 0;
 159     }
 160
 161     /* Now let's see if there is other data available */
 162     if (m->current.memblock) {
 163         size_t l;
 164         assert(m->current.length >= m->base);
 165
 166         /* The length of the returned memory block */
 167         l = m->current.length;
 168         l /= m->base;
 169         l *= m->base;
 170         assert(l > 0);
 171
 172         /* Prepare the returned block */
 173         *c = m->current;
 174         pa_memblock_ref(c->memblock);
 175         c->length = l;
 176
 177         /* Drop that from the current memory block */
 178         assert(l <= m->current.length);
 179         m->current.index += l;
 180         m->current.length -= l;
 181
 182         /* In case the whole block was dropped ... */
 183         if (m->current.length == 0)
 184             pa_memblock_unref(m->current.memblock);
 185         else {
 186             /* Move the raimainder to leftover */
 187             assert(m->current.length < m->base && !m->leftover.memblock);
 188
 189             m->leftover = m->current;
 190         }
 191
 192         pa_memchunk_reset(&m->current);
 193
 194         return 0;
 195     }
 196
 197     /* There's simply nothing */
 198     return -1;
 199
 200 }
 201
 202 size_t pa_mcalign_csize(pa_mcalign *m, size_t l) {
 203     assert(m);
 204     assert(l > 0);
 205
 206     assert(!m->current.memblock);
 207
 208     if (m->leftover.memblock)
 209         l += m->leftover.length;
 210
 211     return (l/m->base)*m->base;
 212 }