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 <string.h>
  31
  32 #include <pulse/xmalloc.h>
  33 #include <pulsecore/macro.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     pa_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     pa_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     pa_assert(m);
  69     pa_assert(c);
  70
  71     pa_assert(c->memblock);
  72     pa_assert(c->length > 0);
  73
  74     pa_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             pa_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             pa_assert(m->leftover.length <= m->base);
 114             pa_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     pa_assert(m);
 138     pa_assert(c);
 139
 140     /* First test if there's a leftover memory block available */
 141     if (m->leftover.memblock) {
 142         pa_assert(m->leftover.length > 0);
 143         pa_assert(m->leftover.length <= m->base);
 144
 145         /* The leftover memory block is not yet complete */
 146         if (m->leftover.length < m->base)
 147             return -1;
 148
 149         /* Return the leftover memory block */
 150         *c = m->leftover;
 151         pa_memchunk_reset(&m->leftover);
 152
 153         /* If the current memblock is too small move it the leftover */
 154         if (m->current.memblock && m->current.length < m->base) {
 155             m->leftover = m->current;
 156             pa_memchunk_reset(&m->current);
 157         }
 158
 159         return 0;
 160     }
 161
 162     /* Now let's see if there is other data available */
 163     if (m->current.memblock) {
 164         size_t l;
 165         pa_assert(m->current.length >= m->base);
 166
 167         /* The length of the returned memory block */
 168         l = m->current.length;
 169         l /= m->base;
 170         l *= m->base;
 171         pa_assert(l > 0);
 172
 173         /* Prepare the returned block */
 174         *c = m->current;
 175         pa_memblock_ref(c->memblock);
 176         c->length = l;
 177
 178         /* Drop that from the current memory block */
 179         pa_assert(l <= m->current.length);
 180         m->current.index += l;
 181         m->current.length -= l;
 182
 183         /* In case the whole block was dropped ... */
 184         if (m->current.length == 0)
 185             pa_memblock_unref(m->current.memblock);
 186         else {
 187             /* Move the raimainder to leftover */
 188             pa_assert(m->current.length < m->base && !m->leftover.memblock);
 189
 190             m->leftover = m->current;
 191         }
 192
 193         pa_memchunk_reset(&m->current);
 194
 195         return 0;
 196     }
 197
 198     /* There's simply nothing */
 199     return -1;
 200 }
 201
 202 size_t pa_mcalign_csize(pa_mcalign *m, size_t l) {
 203     pa_assert(m);
 204     pa_assert(l > 0);
 205
 206     pa_assert(!m->current.memblock);
 207
 208     if (m->leftover.memblock)
 209         l += m->leftover.length;
 210
 211     return (l/m->base)*m->base;
 212 }
 213
 214 void pa_mcalign_flush(pa_mcalign *m) {
 215     pa_memchunk chunk;
 216     pa_assert(m);
 217
 218     while (pa_mcalign_pop(m, &chunk) >= 0)
 219         pa_memblock_unref(chunk.memblock);
 220 }