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

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