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
  32 static int hw_freq IDATA_ATTR = HW_FREQ_DEFAULT;
  33 static unsigned long hw_sampr IDATA_ATTR = HW_SAMPR_DEFAULT;
  34
  35 static int gen_thread_stack[DEFAULT_STACK_SIZE/sizeof(int)] IBSS_ATTR;
  36 static bool gen_quit IBSS_ATTR;
  37 static unsigned int gen_thread_id;
  38
  39 #define OUTPUT_CHUNK_COUNT (1 << 1)
  40 #define OUTPUT_CHUNK_MASK (OUTPUT_CHUNK_COUNT-1)
  41 #define OUTPUT_CHUNK_SAMPLES 1152
  42 #define OUTPUT_CHUNK_SIZE (OUTPUT_CHUNK_SAMPLES*sizeof(int16_t)*2)
  43 static uint16_t output_buf[OUTPUT_CHUNK_COUNT][OUTPUT_CHUNK_SAMPLES*2]
  44         __attribute__((aligned(4)));
  45 static int output_head IBSS_ATTR;
  46 static int output_tail IBSS_ATTR;
  47 static int output_step IBSS_ATTR;
  48
  49 static uint32_t gen_phase_step IBSS_ATTR;
  50 static const uint32_t gen_frequency = 1000;
  51
  52 /* fsin shamelessly stolen from signal_gen.c by Thom Johansen (preglow) */
  53
  54 /* Good quality sine calculated by linearly interpolating
  55  * a 128 sample sine table. First harmonic has amplitude of about -84 dB.
  56  * phase has range from 0 to 0xffffffff, representing 0 and
  57  * 2*pi respectively.
  58  * Return value is a signed value from LONG_MIN to LONG_MAX, representing
  59  * -1 and 1 respectively.
  60  */
  61 static int16_t ICODE_ATTR fsin(uint32_t phase)
  62 {
  63     /* 128 sixteen bit sine samples + guard point */
  64     static const int16_t sinetab[129] ICONST_ATTR =
  65     {
  66              0,   1607,   3211,   4807,   6392,   7961,   9511,  11038,
  67          12539,  14009,  15446,  16845,  18204,  19519,  20787,  22004,
  68          23169,  24278,  25329,  26318,  27244,  28105,  28897,  29621,
  69          30272,  30851,  31356,  31785,  32137,  32412,  32609,  32727,
  70          32767,  32727,  32609,  32412,  32137,  31785,  31356,  30851,
  71          30272,  29621,  28897,  28105,  27244,  26318,  25329,  24278,
  72          23169,  22004,  20787,  19519,  18204,  16845,  15446,  14009,
  73          12539,  11038,   9511,   7961,   6392,   4807,   3211,   1607,
  74              0,  -1607,  -3211,  -4807,  -6392,  -7961,  -9511, -11038,
  75         -12539, -14009, -15446, -16845, -18204, -19519, -20787, -22004,
  76         -23169, -24278, -25329, -26318, -27244, -28105, -28897, -29621,
  77         -30272, -30851, -31356, -31785, -32137, -32412, -32609, -32727,
  78         -32767, -32727, -32609, -32412, -32137, -31785, -31356, -30851,
  79         -30272, -29621, -28897, -28105, -27244, -26318, -25329, -24278,
  80         -23169, -22004, -20787, -19519, -18204, -16845, -15446, -14009,
  81         -12539, -11038, -9511,   -7961,  -6392,  -4807,  -3211,  -1607,
  82              0,
  83     };
  84
  85     unsigned int pos = phase >> 25;
  86     unsigned short frac = (phase & 0x01ffffff) >> 9;
  87     short diff = sinetab[pos + 1] - sinetab[pos];
  88
  89     return sinetab[pos] + (frac*diff >> 16);
  90 }
  91
  92 /* ISR handler to get next block of data */
  93 static void get_more(unsigned char **start, size_t *size)
  94 {
  95     /* Free previous buffer */
  96     output_head += output_step;
  97     output_step = 0;
  98
  99     *start = (unsigned char *)output_buf[output_head & OUTPUT_CHUNK_MASK];
 100     *size  = OUTPUT_CHUNK_SIZE;
 101
 102     /* Keep repeating previous if source runs low */
 103     if (output_head != output_tail)
 104         output_step = 1;
 105 }
 106
 107 static void ICODE_ATTR gen_thread_func(void)
 108 {
 109     uint32_t gen_random = *rb->current_tick;
 110     uint32_t gen_phase = 0;
 111
 112     while (!gen_quit)
 113     {
 114         int16_t *p = output_buf[output_tail & OUTPUT_CHUNK_MASK];
 115         int i = OUTPUT_CHUNK_SAMPLES;
 116
 117         while (output_tail - output_head >= OUTPUT_CHUNK_COUNT)
 118         {
 119             rb->sleep(0);
 120             if (gen_quit)
 121                 return;
 122         }
 123
 124         while (--i >= 0)
 125         {
 126             int32_t val = fsin(gen_phase);
 127             int32_t rnd = (int16_t)gen_random;
 128
 129             gen_random = gen_random*0x0019660dL + 0x3c6ef35fL;
 130
 131             val = (rnd + 2*val) / 3;
 132
 133             *p++ = val;
 134             *p++ = val;
 135
 136             gen_phase += gen_phase_step;
 137         }
 138
 139         output_tail++;
 140
 141         rb->yield();
 142     }
 143 }
 144
 145 static void update_gen_step(void)
 146 {
 147     gen_phase_step = 0x100000000ull*gen_frequency / hw_sampr;
 148 }
 149
 150 static void output_clear(void)
 151 {
 152     rb->pcm_play_lock();
 153
 154     rb->memset(output_buf, 0, sizeof (output_buf));
 155     output_head = 0;
 156     output_tail = 0;
 157
 158     rb->pcm_play_unlock();
 159 }
 160
 161 /* Called to switch samplerate on the fly */
 162 static void set_frequency(int index)
 163 {
 164     hw_freq = index;
 165     hw_sampr = rb->hw_freq_sampr[index];
 166
 167     output_clear();
 168     update_gen_step();
 169
 170     rb->pcm_set_frequency(hw_sampr);
 171     rb->pcm_apply_settings();
 172 }
 173
 174 #ifndef HAVE_VOLUME_IN_LIST
 175 static void set_volume(int value)
 176 {
 177     rb->global_settings->volume = value;
 178     rb->sound_set(SOUND_VOLUME, value);
 179 }
 180
 181 static const char *format_volume(char *buf, size_t len, int value,
 182                                  const char *unit)
 183 {
 184     (void)unit;
 185     rb->snprintf(buf, len, "%d %s", rb->sound_val2phys(SOUND_VOLUME, value),
 186                  rb->sound_unit(SOUND_VOLUME));
 187     return buf;
 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     while (!exit)
 300     {
 301         int result = rb->do_menu(&menu, &selected, NULL, false);
 302
 303         switch (result)
 304         {
 305 #ifndef HAVE_VOLUME_IN_LIST
 306         case MENU_VOL_SET:
 307             play_tone(true);
 308             break;
 309 #endif /* HAVE_VOLUME_IN_LIST */
 310         case MENU_SAMPR_SET:
 311             play_tone(false);
 312             break;
 313
 314         case MENU_QUIT:
 315             exit = true;
 316             break;
 317         }
 318     }
 319
 320     rb->talk_disable(false);
 321
 322     return PLUGIN_OK;
 323     (void)parameter;
 324 }