apps/plugins/test_sampr.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2006 Michael Sevakis
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "plugin.h"
  22
  23 /* This plugin generates a 1kHz tone + noise in order to quickly verify
  24  * hardware samplerate setup is operating correctly.
  25  *
  26  * While switching to different frequencies, the pitch of the tone should
  27  * remain constant whereas the upper harmonics of the noise should vary
  28  * with sample rate.
  29  */
  30
  31 PLUGIN_HEADER
  32 PLUGIN_IRAM_DECLARE;
  33
  34 static int hw_freq IDATA_ATTR = HW_FREQ_DEFAULT;
  35 static unsigned long hw_sampr IDATA_ATTR = HW_SAMPR_DEFAULT;
  36
  37 static int gen_thread_stack[DEFAULT_STACK_SIZE/sizeof(int)] IBSS_ATTR;
  38 static bool gen_quit IBSS_ATTR;
  39 static unsigned int gen_thread_id;
  40
  41 #define OUTPUT_CHUNK_COUNT (1 << 1)
  42 #define OUTPUT_CHUNK_MASK (OUTPUT_CHUNK_COUNT-1)
  43 #define OUTPUT_CHUNK_SAMPLES 1152
  44 #define OUTPUT_CHUNK_SIZE (OUTPUT_CHUNK_SAMPLES*sizeof(int16_t)*2)
  45 static uint16_t output_buf[OUTPUT_CHUNK_COUNT][OUTPUT_CHUNK_SAMPLES*2]
  46         __attribute__((aligned(4)));
  47 static int output_head IBSS_ATTR;
  48 static int output_tail IBSS_ATTR;
  49 static int output_step IBSS_ATTR;
  50
  51 static uint32_t gen_phase_step IBSS_ATTR;
  52 static const uint32_t gen_frequency = 1000;
  53
  54 /* fsin shamelessly stolen from signal_gen.c by Thom Johansen (preglow) */
  55
  56 /* Good quality sine calculated by linearly interpolating
  57  * a 128 sample sine table. First harmonic has amplitude of about -84 dB.
  58  * phase has range from 0 to 0xffffffff, representing 0 and
  59  * 2*pi respectively.
  60  * Return value is a signed value from LONG_MIN to LONG_MAX, representing
  61  * -1 and 1 respectively.
  62  */
  63 static int16_t ICODE_ATTR fsin(uint32_t phase)
  64 {
  65     /* 128 sixteen bit sine samples + guard point */
  66     static const int16_t sinetab[129] ICONST_ATTR =
  67     {
  68              0,   1607,   3211,   4807,   6392,   7961,   9511,  11038,
  69          12539,  14009,  15446,  16845,  18204,  19519,  20787,  22004,
  70          23169,  24278,  25329,  26318,  27244,  28105,  28897,  29621,
  71          30272,  30851,  31356,  31785,  32137,  32412,  32609,  32727,
  72          32767,  32727,  32609,  32412,  32137,  31785,  31356,  30851,
  73          30272,  29621,  28897,  28105,  27244,  26318,  25329,  24278,
  74          23169,  22004,  20787,  19519,  18204,  16845,  15446,  14009,
  75          12539,  11038,   9511,   7961,   6392,   4807,   3211,   1607,
  76              0,  -1607,  -3211,  -4807,  -6392,  -7961,  -9511, -11038,
  77         -12539, -14009, -15446, -16845, -18204, -19519, -20787, -22004,
  78         -23169, -24278, -25329, -26318, -27244, -28105, -28897, -29621,
  79         -30272, -30851, -31356, -31785, -32137, -32412, -32609, -32727,
  80         -32767, -32727, -32609, -32412, -32137, -31785, -31356, -30851,
  81         -30272, -29621, -28897, -28105, -27244, -26318, -25329, -24278,
  82         -23169, -22004, -20787, -19519, -18204, -16845, -15446, -14009,
  83         -12539, -11038, -9511,   -7961,  -6392,  -4807,  -3211,  -1607,
  84              0,
  85     };
  86
  87     unsigned int pos = phase >> 25;
  88     unsigned short frac = (phase & 0x01ffffff) >> 9;
  89     short diff = sinetab[pos + 1] - sinetab[pos];
  90
  91     return sinetab[pos] + (frac*diff >> 16);
  92 }
  93
  94 /* ISR handler to get next block of data */
  95 static void get_more(unsigned char **start, size_t *size)
  96 {
  97     /* Free previous buffer */
  98     output_head += output_step;
  99     output_step = 0;
 100
 101     *start = (unsigned char *)output_buf[output_head & OUTPUT_CHUNK_MASK];
 102     *size  = OUTPUT_CHUNK_SIZE;
 103
 104     /* Keep repeating previous if source runs low */
 105     if (output_head != output_tail)
 106         output_step = 1;
 107 }
 108
 109 static void ICODE_ATTR gen_thread_func(void)
 110 {
 111     uint32_t gen_random = *rb->current_tick;
 112     uint32_t gen_phase = 0;
 113
 114     while (!gen_quit)
 115     {
 116         int16_t *p = output_buf[output_tail & OUTPUT_CHUNK_MASK];
 117         int i = OUTPUT_CHUNK_SAMPLES;
 118
 119         while (output_tail - output_head >= OUTPUT_CHUNK_COUNT)
 120         {
 121             rb->sleep(0);
 122             if (gen_quit)
 123                 return;
 124         }
 125
 126         while (--i >= 0)
 127         {
 128             int32_t val = fsin(gen_phase);
 129             int32_t rnd = (int16_t)gen_random;
 130
 131             gen_random = gen_random*0x0019660dL + 0x3c6ef35fL;
 132
 133             val = (rnd + 2*val) / 3;
 134
 135             *p++ = val;
 136             *p++ = val;
 137
 138             gen_phase += gen_phase_step;
 139         }
 140
 141         output_tail++;
 142
 143         rb->yield();
 144     }
 145 }
 146
 147 static void update_gen_step(void)
 148 {
 149     gen_phase_step = 0x100000000ull*gen_frequency / hw_sampr;
 150 }
 151
 152 static void output_clear(void)
 153 {
 154     rb->pcm_play_lock();
 155
 156     rb->memset(output_buf, 0, sizeof (output_buf));
 157     output_head = 0;
 158     output_tail = 0;
 159
 160     rb->pcm_play_unlock();
 161 }
 162
 163 /* Called to switch samplerate on the fly */
 164 static void set_frequency(int index)
 165 {
 166     hw_freq = index;
 167     hw_sampr = rb->hw_freq_sampr[index];
 168
 169     output_clear();
 170     update_gen_step();
 171
 172     rb->pcm_set_frequency(hw_sampr);
 173     rb->pcm_apply_settings();
 174 }
 175
 176 #ifndef HAVE_VOLUME_IN_LIST
 177 static void set_volume(int value)
 178 {
 179     rb->global_settings->volume = value;
 180     rb->sound_set(SOUND_VOLUME, value);
 181 }
 182
 183 static void format_volume(char *buf, size_t len, int value, const char *unit)
 184 {
 185     rb->snprintf(buf, len, "%d %s", rb->sound_val2phys(SOUND_VOLUME, value),
 186                  rb->sound_unit(SOUND_VOLUME));
 187     (void)unit;
 188 }
 189 #endif /* HAVE_VOLUME_IN_LIST */
 190
 191 static void play_tone(bool volume_set)
 192 {
 193     static struct opt_items names[HW_NUM_FREQ] =
 194     {
 195         HW_HAVE_96_([HW_FREQ_96] = { "96kHz",     -1 },)
 196         HW_HAVE_88_([HW_FREQ_88] = { "88.2kHz",   -1 },)
 197         HW_HAVE_64_([HW_FREQ_64] = { "64kHz",     -1 },)
 198         HW_HAVE_48_([HW_FREQ_48] = { "48kHz",     -1 },)
 199         HW_HAVE_44_([HW_FREQ_44] = { "44.1kHz",   -1 },)
 200         HW_HAVE_32_([HW_FREQ_32] = { "32kHz",     -1 },)
 201         HW_HAVE_24_([HW_FREQ_24] = { "24kHz",     -1 },)
 202         HW_HAVE_22_([HW_FREQ_22] = { "22.05kHz",  -1 },)
 203         HW_HAVE_16_([HW_FREQ_16] = { "16kHz",     -1 },)
 204         HW_HAVE_12_([HW_FREQ_12] = { "12kHz",     -1 },)
 205         HW_HAVE_11_([HW_FREQ_11] = { "11.025kHz", -1 },)
 206         HW_HAVE_8_( [HW_FREQ_8 ] = { "8kHz",      -1 },)
 207     };
 208
 209     int freq = hw_freq;
 210
 211     rb->audio_stop();
 212
 213 #if INPUT_SRC_CAPS != 0
 214     /* Select playback */
 215     rb->audio_set_input_source(AUDIO_SRC_PLAYBACK, SRCF_PLAYBACK);
 216 #endif
 217
 218 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 219     rb->cpu_boost(true);
 220 #endif
 221
 222     rb->pcm_set_frequency(rb->hw_freq_sampr[freq]);
 223
 224 #if INPUT_SRC_CAPS != 0
 225     /* Recordable targets can play back from other sources */
 226     rb->audio_set_output_source(AUDIO_SRC_PLAYBACK);
 227 #endif
 228
 229     gen_quit = false;
 230     output_clear();
 231     update_gen_step();
 232
 233     gen_thread_id = rb->create_thread(gen_thread_func, gen_thread_stack,
 234                                       sizeof(gen_thread_stack), 0,
 235                                       "test_sampr generator"
 236                                       IF_PRIO(, PRIORITY_PLAYBACK)
 237                                       IF_COP(, CPU));
 238
 239     rb->pcm_play_data(get_more, NULL, 0);
 240
 241 #ifndef HAVE_VOLUME_IN_LIST
 242     if (volume_set)
 243     {
 244         int volume = rb->global_settings->volume;
 245
 246         rb->set_int("Volume", NULL, -1, &volume,
 247                     set_volume, 1, rb->sound_min(SOUND_VOLUME),
 248                     rb->sound_max(SOUND_VOLUME), format_volume);
 249     }
 250     else
 251 #endif /* HAVE_VOLUME_IN_LIST */
 252     {
 253         rb->set_option("Sample Rate", &freq, INT, names,
 254                        HW_NUM_FREQ, set_frequency);
 255         (void)volume_set;
 256     }
 257
 258     gen_quit = true;
 259
 260     rb->thread_wait(gen_thread_id);
 261
 262     rb->pcm_play_stop();
 263
 264 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 265     rb->cpu_boost(false);
 266 #endif
 267
 268     /* restore default - user of apis is responsible for restoring
 269        default state - normally playback at 44100Hz */
 270     rb->pcm_set_frequency(HW_FREQ_DEFAULT);
 271 }
 272
 273 /* Tests hardware sample rate switching */
 274 /* TODO: needs a volume control */
 275 enum plugin_status plugin_start(const void *parameter)
 276 {
 277     enum
 278     {
 279         __TEST_SAMPR_MENUITEM_FIRST = -1,
 280 #ifndef HAVE_VOLUME_IN_LIST
 281         MENU_VOL_SET,
 282 #endif /* HAVE_VOLUME_IN_LIST */
 283         MENU_SAMPR_SET,
 284         MENU_QUIT,
 285     };
 286
 287     MENUITEM_STRINGLIST(menu, "Test Sampr Menu", NULL,
 288 #ifndef HAVE_VOLUME_IN_LIST
 289                         "Set Volume",
 290 #endif /* HAVE_VOLUME_IN_LIST */
 291                         "Set Samplerate", "Quit");
 292
 293     bool exit = false;
 294     int selected = 0;
 295
 296     /* Disable all talking before initializing IRAM */
 297     rb->talk_disable(true);
 298
 299     PLUGIN_IRAM_INIT(rb);
 300
 301     while (!exit)
 302     {
 303         int result = rb->do_menu(&menu, &selected, NULL, false);
 304
 305         switch (result)
 306         {
 307 #ifndef HAVE_VOLUME_IN_LIST
 308         case MENU_VOL_SET:
 309             play_tone(true);
 310             break;
 311 #endif /* HAVE_VOLUME_IN_LIST */
 312         case MENU_SAMPR_SET:
 313             play_tone(false);
 314             break;
 315
 316         case MENU_QUIT:
 317             exit = true;
 318             break;
 319         }
 320     }
 321
 322     rb->talk_disable(false);
 323
 324     return PLUGIN_OK;
 325     (void)parameter;
 326 }