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