code.delx.au - pulseaudio/blob - src/tests/envelope-test.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of PulseAudio.
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser 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   PulseAudio 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 Lesser General Public License
  17   along with PulseAudio; 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 <stdio.h>
  27 #include <stdlib.h>
  28
  29 #include <pulse/sample.h>
  30 #include <pulse/volume.h>
  31 #include <pulse/timeval.h>
  32
  33 #include <pulsecore/envelope.h>
  34 #include <pulsecore/macro.h>
  35 #include <pulsecore/endianmacros.h>
  36 #include <pulsecore/memblock.h>
  37 #include <pulsecore/sample-util.h>
  38
  39 #include <liboil/liboil.h>
  40
  41 const pa_envelope_def ramp_down = {
  42     .n_points = 2,
  43     .points_x = { 100*PA_USEC_PER_MSEC, 300*PA_USEC_PER_MSEC },
  44     .points_y = {
  45         .f = { 1.0, 0.2 },
  46         .i = { 0x10000, 0x10000/5 }
  47     }
  48 };
  49
  50 const pa_envelope_def ramp_up = {
  51     .n_points = 2,
  52     .points_x = { 100*PA_USEC_PER_MSEC, 300*PA_USEC_PER_MSEC },
  53     .points_y = {
  54         .f = { 0.2, 1.0 },
  55         .i = { 0x10000/5, 0x10000 }
  56     }
  57 };
  58
  59 const pa_envelope_def ramp_down2 = {
  60     .n_points = 2,
  61     .points_x = { 50*PA_USEC_PER_MSEC, 900*PA_USEC_PER_MSEC },
  62     .points_y = {
  63         .f = { 0.8, 0.7 },
  64         .i = { 0x10000*4/5, 0x10000*7/10 }
  65     }
  66 };
  67
  68 const pa_envelope_def ramp_up2 = {
  69     .n_points = 2,
  70     .points_x = { 50*PA_USEC_PER_MSEC, 900*PA_USEC_PER_MSEC },
  71     .points_y = {
  72         .f = { 0.7, 0.9 },
  73         .i = { 0x10000*7/10, 0x10000*9/10 }
  74     }
  75 };
  76
  77 static void dump_block(const pa_sample_spec *ss, const pa_memchunk *chunk) {
  78     void *d;
  79     unsigned i;
  80
  81     static unsigned j = 0;
  82
  83     d = pa_memblock_acquire(chunk->memblock);
  84
  85     switch (ss->format) {
  86
  87         case PA_SAMPLE_U8:
  88         case PA_SAMPLE_ULAW:
  89         case PA_SAMPLE_ALAW: {
  90             uint8_t *u = d;
  91
  92             for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
  93                 printf("0x%02x ", *(u++));
  94
  95             break;
  96         }
  97
  98         case PA_SAMPLE_S16NE:
  99         case PA_SAMPLE_S16RE: {
 100             int16_t *u = d;
 101
 102             for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
 103                 printf("%i\t%i\n", j++, *(u++));
 104
 105             break;
 106         }
 107
 108         case PA_SAMPLE_S32NE:
 109         case PA_SAMPLE_S32RE: {
 110             int32_t *u = d;
 111
 112             for (i = 0; i < chunk->length / pa_frame_size(ss); i++)
 113                 printf("%i\t%i\n", j++, *(u++));
 114
 115             break;
 116         }
 117
 118         case PA_SAMPLE_FLOAT32NE:
 119         case PA_SAMPLE_FLOAT32RE: {
 120             float *u = d;
 121
 122             for (i = 0; i < chunk->length / pa_frame_size(ss); i++) {
 123                 printf("%i\t%1.3g\n", j++, PA_MAYBE_FLOAT32_SWAP(ss->format == PA_SAMPLE_FLOAT32RE, *u));
 124                 u++;
 125             }
 126
 127             break;
 128         }
 129
 130         default:
 131             pa_assert_not_reached();
 132     }
 133
 134     printf("\n");
 135
 136     pa_memblock_release(chunk->memblock);
 137 }
 138
 139 static pa_memblock * generate_block(pa_mempool *pool, const pa_sample_spec *ss) {
 140     pa_memblock *block;
 141     void *d;
 142     unsigned n_samples;
 143
 144     block = pa_memblock_new(pool, pa_bytes_per_second(ss));
 145     n_samples = pa_memblock_get_length(block) / pa_sample_size(ss);
 146
 147     d = pa_memblock_acquire(block);
 148
 149     switch (ss->format) {
 150
 151         case PA_SAMPLE_S16NE:
 152         case PA_SAMPLE_S16RE: {
 153             int16_t *i;
 154
 155             for (i = d; n_samples > 0; n_samples--, i++)
 156                 *i = 0x7FFF;
 157
 158             break;
 159         }
 160
 161         case PA_SAMPLE_S32NE:
 162         case PA_SAMPLE_S32RE: {
 163             int32_t *i;
 164
 165             for (i = d; n_samples > 0; n_samples--, i++)
 166                 *i = 0x7FFFFFFF;
 167
 168             break;
 169         }
 170
 171         case PA_SAMPLE_FLOAT32RE:
 172         case PA_SAMPLE_FLOAT32NE: {
 173             float *f;
 174
 175             for (f = d; n_samples > 0; n_samples--, f++)
 176                 *f = PA_MAYBE_FLOAT32_SWAP(ss->format == PA_SAMPLE_FLOAT32RE, 1.0);
 177
 178             break;
 179         }
 180
 181         default:
 182             pa_assert_not_reached();
 183     }
 184
 185     pa_memblock_release(block);
 186     return block;
 187 }
 188
 189 int main(int argc, char *argv[]) {
 190     pa_mempool *pool;
 191     pa_memblock *block;
 192     pa_memchunk chunk;
 193     pa_envelope *envelope;
 194     pa_envelope_item *item1, *item2;
 195
 196     const pa_sample_spec ss = {
 197         .format = PA_SAMPLE_S16NE,
 198         .channels = 1,
 199         .rate = 200
 200     };
 201
 202     const pa_cvolume v = {
 203         .channels = 1,
 204         .values = { PA_VOLUME_NORM, PA_VOLUME_NORM/2 }
 205     };
 206
 207     oil_init();
 208     pa_log_set_maximal_level(PA_LOG_DEBUG);
 209
 210     pa_assert_se(pool = pa_mempool_new(FALSE));
 211     pa_assert_se(envelope = pa_envelope_new(&ss));
 212
 213     block = generate_block(pool, &ss);
 214
 215     chunk.memblock = pa_memblock_ref(block);
 216     chunk.length = pa_memblock_get_length(block);
 217     chunk.index = 0;
 218
 219     pa_volume_memchunk(&chunk, &ss, &v);
 220
 221     item1 = pa_envelope_add(envelope, &ramp_down);
 222     item2 = pa_envelope_add(envelope, &ramp_down2);
 223     pa_envelope_apply(envelope, &chunk);
 224     dump_block(&ss, &chunk);
 225
 226     pa_memblock_unref(chunk.memblock);
 227
 228     chunk.memblock = pa_memblock_ref(block);
 229     chunk.length = pa_memblock_get_length(block);
 230     chunk.index = 0;
 231
 232     item1 = pa_envelope_replace(envelope, item1, &ramp_up);
 233     item2 = pa_envelope_replace(envelope, item2, &ramp_up2);
 234     pa_envelope_apply(envelope, &chunk);
 235     dump_block(&ss, &chunk);
 236
 237     pa_memblock_unref(chunk.memblock);
 238
 239     pa_envelope_remove(envelope, item1);
 240     pa_envelope_remove(envelope, item2);
 241     pa_envelope_free(envelope);
 242
 243     pa_memblock_unref(block);
 244
 245     pa_mempool_free(pool);
 246
 247     return 0;
 248 }