?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
FFT plugin: remove redundant NUM_CORES checks.
[kugel-rb.git] / apps / plugins / fft / fft.c
blobb6b1e2fead2f11cf061286302a47169d9fbb4bec
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2009 Delyan Kratunov
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 #include "lib/helper.h"
24 #include "lib/xlcd.h"
25 #include "math.h"
26 #include "fracmul.h"
27 #ifndef HAVE_LCD_COLOR
28 #include "lib/grey.h"
29 #endif
30 #include "lib/mylcd.h"
31
32
33
34 #ifndef HAVE_LCD_COLOR
35 GREY_INFO_STRUCT
36 #endif
37
38 #if CONFIG_KEYPAD == ARCHOS_AV300_PAD
39 # define FFT_PREV_GRAPH BUTTON_LEFT
40 # define FFT_NEXT_GRAPH BUTTON_RIGHT
41 # define FFT_ORIENTATION BUTTON_F3
42 # define FFT_WINDOW BUTTON_F1
43 # define FFT_AMP_SCALE BUTTON_UP
44 # define FFT_QUIT BUTTON_OFF
45
46 #elif (CONFIG_KEYPAD == IRIVER_H100_PAD) || \
47 (CONFIG_KEYPAD == IRIVER_H300_PAD)
48 # define FFT_PREV_GRAPH BUTTON_LEFT
49 # define FFT_NEXT_GRAPH BUTTON_RIGHT
50 # define FFT_ORIENTATION BUTTON_REC
51 # define FFT_WINDOW BUTTON_SELECT
52 # define FFT_AMP_SCALE BUTTON_UP
53 # define FFT_FREQ_SCALE BUTTON_DOWN
54 # define FFT_QUIT BUTTON_OFF
55
56 #elif (CONFIG_KEYPAD == IPOD_4G_PAD) || \
57 (CONFIG_KEYPAD == IPOD_3G_PAD) || \
58 (CONFIG_KEYPAD == IPOD_1G2G_PAD)
59 # define MINESWP_SCROLLWHEEL
60 # define FFT_PREV_GRAPH BUTTON_LEFT
61 # define FFT_NEXT_GRAPH BUTTON_RIGHT
62 # define FFT_ORIENTATION (BUTTON_SELECT | BUTTON_LEFT)
63 # define FFT_WINDOW (BUTTON_SELECT | BUTTON_RIGHT)
64 # define FFT_AMP_SCALE BUTTON_MENU
65 # define FFT_FREQ_SCALE BUTTON_PLAY
66 # define FFT_QUIT (BUTTON_SELECT | BUTTON_MENU)
67
68 #elif (CONFIG_KEYPAD == IAUDIO_X5M5_PAD)
69 # define FFT_PREV_GRAPH BUTTON_LEFT
70 # define FFT_NEXT_GRAPH BUTTON_RIGHT
71 # define FFT_ORIENTATION BUTTON_SELECT
72 # define FFT_WINDOW BUTTON_PLAY
73 # define FFT_AMP_SCALE BUTTON_UP
74 # define FFT_FREQ_SCALE BUTTON_DOWN
75 # define FFT_QUIT BUTTON_POWER
76
77 #elif (CONFIG_KEYPAD == GIGABEAT_PAD)
78 # define FFT_PREV_GRAPH BUTTON_LEFT
79 # define FFT_NEXT_GRAPH BUTTON_RIGHT
80 # define FFT_AMP_SCALE BUTTON_UP
81 # define FFT_FREQ_SCALE BUTTON_DOWN
82 # define FFT_ORIENTATION BUTTON_SELECT
83 # define FFT_WINDOW BUTTON_A
84 # define FFT_QUIT BUTTON_POWER
85
86 #elif (CONFIG_KEYPAD == SANSA_E200_PAD)
87 # define FFT_PREV_GRAPH BUTTON_LEFT
88 # define FFT_NEXT_GRAPH BUTTON_RIGHT
89 # define FFT_ORIENTATION BUTTON_SELECT
90 # define FFT_WINDOW BUTTON_REC
91 # define FFT_AMP_SCALE BUTTON_UP
92 # define FFT_FREQ_SCALE BUTTON_DOWN
93 # define FFT_QUIT BUTTON_POWER
94
95 #elif (CONFIG_KEYPAD == SANSA_FUZE_PAD)
96 # define FFT_PREV_GRAPH BUTTON_LEFT
97 # define FFT_NEXT_GRAPH BUTTON_RIGHT
98 # define FFT_ORIENTATION (BUTTON_SELECT | BUTTON_LEFT)
99 # define FFT_WINDOW (BUTTON_SELECT | BUTTON_RIGHT)
100 # define FFT_AMP_SCALE BUTTON_UP
101 # define FFT_FREQ_SCALE BUTTON_DOWN
102 # define FFT_QUIT (BUTTON_HOME|BUTTON_REPEAT)
103
104 #elif (CONFIG_KEYPAD == SANSA_C200_PAD)
105 # define FFT_PREV_GRAPH BUTTON_LEFT
106 # define FFT_NEXT_GRAPH BUTTON_RIGHT
107 # define FFT_ORIENTATION BUTTON_UP
108 # define FFT_WINDOW BUTTON_REC
109 # define FFT_AMP_SCALE BUTTON_SELECT
110 # define FFT_QUIT BUTTON_POWER
111 #elif (CONFIG_KEYPAD == SANSA_M200_PAD)
112 # define FFT_PREV_GRAPH BUTTON_LEFT
113 # define FFT_NEXT_GRAPH BUTTON_RIGHT
114 # define FFT_ORIENTATION BUTTON_UP
115 # define FFT_WINDOW BUTTON_DOWN
116 # define FFT_AMP_SCALE BUTTON_SELECT
117 # define FFT_QUIT BUTTON_POWER
118 #elif (CONFIG_KEYPAD == SANSA_CLIP_PAD)
119 # define FFT_PREV_GRAPH BUTTON_LEFT
120 # define FFT_NEXT_GRAPH BUTTON_RIGHT
121 # define FFT_ORIENTATION BUTTON_UP
122 # define FFT_WINDOW BUTTON_HOME
123 # define FFT_AMP_SCALE BUTTON_SELECT
124 # define FFT_QUIT BUTTON_POWER
125
126 #elif (CONFIG_KEYPAD == IRIVER_H10_PAD)
127 # define FFT_PREV_GRAPH BUTTON_LEFT
128 # define FFT_NEXT_GRAPH BUTTON_RIGHT
129 # define FFT_ORIENTATION BUTTON_FF
130 # define FFT_WINDOW BUTTON_SCROLL_UP
131 # define FFT_AMP_SCALE BUTTON_REW
132 # define FFT_FREQ_SCALE BUTTON_PLAY
133 # define FFT_QUIT BUTTON_POWER
134
135 #elif (CONFIG_KEYPAD == GIGABEAT_S_PAD)
136 # define FFT_PREV_GRAPH BUTTON_LEFT
137 # define FFT_NEXT_GRAPH BUTTON_RIGHT
138 # define FFT_ORIENTATION BUTTON_MENU
139 # define FFT_WINDOW BUTTON_PREV
140 # define FFT_AMP_SCALE BUTTON_UP
141 # define FFT_FREQ_SCALE BUTTON_DOWN
142 # define FFT_QUIT BUTTON_BACK
143
144 #elif (CONFIG_KEYPAD == MROBE100_PAD)
145 # define FFT_PREV_GRAPH BUTTON_LEFT
146 # define FFT_NEXT_GRAPH BUTTON_RIGHT
147 # define FFT_ORIENTATION BUTTON_PLAY
148 # define FFT_WINDOW BUTTON_SELECT
149 # define FFT_AMP_SCALE BUTTON_UP
150 # define FFT_FREQ_SCALE BUTTON_DOWN
151 # define FFT_QUIT BUTTON_POWER
152
153 #elif CONFIG_KEYPAD == IAUDIO_M3_PAD
154 # define FFT_PREV_GRAPH BUTTON_RC_REW
155 # define FFT_NEXT_GRAPH BUTTON_RC_FF
156 # define FFT_ORIENTATION BUTTON_RC_MODE
157 # define FFT_WINDOW BUTTON_RC_PLAY
158 # define FFT_AMP_SCALE BUTTON_RC_VOL_UP
159 # define FFT_QUIT BUTTON_RC_REC
160
161 #elif (CONFIG_KEYPAD == COWON_D2_PAD)
162 # define FFT_QUIT BUTTON_POWER
163 # define FFT_PREV_GRAPH BUTTON_PLUS
164 # define FFT_NEXT_GRAPH BUTTON_MINUS
165
166 #elif CONFIG_KEYPAD == CREATIVEZVM_PAD
167 # define FFT_PREV_GRAPH BUTTON_LEFT
168 # define FFT_NEXT_GRAPH BUTTON_RIGHT
169 # define FFT_ORIENTATION BUTTON_MENU
170 # define FFT_WINDOW BUTTON_SELECT
171 # define FFT_AMP_SCALE BUTTON_UP
172 # define FFT_FREQ_SCALE BUTTON_DOWN
173 # define FFT_QUIT BUTTON_BACK
174
175 #elif CONFIG_KEYPAD == PHILIPS_HDD1630_PAD
176 # define FFT_PREV_GRAPH BUTTON_LEFT
177 # define FFT_NEXT_GRAPH BUTTON_RIGHT
178 # define FFT_ORIENTATION BUTTON_SELECT
179 # define FFT_WINDOW BUTTON_MENU
180 # define FFT_AMP_SCALE BUTTON_UP
181 # define FFT_FREQ_SCALE BUTTON_DOWN
182 # define FFT_QUIT BUTTON_POWER
183
184 #elif CONFIG_KEYPAD == PHILIPS_HDD6330_PAD
185 # define FFT_PREV_GRAPH BUTTON_PREV
186 # define FFT_NEXT_GRAPH BUTTON_NEXT
187 # define FFT_ORIENTATION BUTTON_PLAY
188 # define FFT_WINDOW BUTTON_MENU
189 # define FFT_AMP_SCALE BUTTON_UP
190 # define FFT_FREQ_SCALE BUTTON_DOWN
191 # define FFT_QUIT BUTTON_POWER
192
193 #elif CONFIG_KEYPAD == PHILIPS_SA9200_PAD
194 # define FFT_PREV_GRAPH BUTTON_PREV
195 # define FFT_NEXT_GRAPH BUTTON_NEXT
196 # define FFT_ORIENTATION BUTTON_PLAY
197 # define FFT_WINDOW BUTTON_MENU
198 # define FFT_AMP_SCALE BUTTON_UP
199 # define FFT_FREQ_SCALE BUTTON_DOWN
200 # define FFT_QUIT BUTTON_POWER
201
202 #elif (CONFIG_KEYPAD == SAMSUNG_YH_PAD)
203 # define FFT_PREV_GRAPH BUTTON_LEFT
204 # define FFT_NEXT_GRAPH BUTTON_RIGHT
205 # define FFT_ORIENTATION BUTTON_UP
206 # define FFT_WINDOW BUTTON_DOWN
207 # define FFT_AMP_SCALE BUTTON_FFWD
208 # define FFT_QUIT BUTTON_PLAY
209
210 #elif (CONFIG_KEYPAD == MROBE500_PAD)
211 # define FFT_QUIT BUTTON_POWER
212
213 #elif (CONFIG_KEYPAD == ONDAVX747_PAD)
214 # define FFT_QUIT BUTTON_POWER
215
216 #elif (CONFIG_KEYPAD == ONDAVX777_PAD)
217 # define FFT_QUIT BUTTON_POWER
218
219 #elif (CONFIG_KEYPAD == PBELL_VIBE500_PAD)
220 # define FFT_PREV_GRAPH BUTTON_PREV
221 # define FFT_NEXT_GRAPH BUTTON_NEXT
222 # define FFT_ORIENTATION BUTTON_MENU
223 # define FFT_WINDOW BUTTON_OK
224 # define FFT_AMP_SCALE BUTTON_PLAY
225 # define FFT_QUIT BUTTON_REC
226
227 #elif CONFIG_KEYPAD == MPIO_HD200_PAD
228 # define FFT_PREV_GRAPH BUTTON_REW
229 # define FFT_NEXT_GRAPH BUTTON_FF
230 # define FFT_ORIENTATION BUTTON_REC
231 # define FFT_WINDOW BUTTON_FUNC
232 # define FFT_AMP_SCALE BUTTON_PLAY
233 # define FFT_QUIT (BUTTON_REC | BUTTON_PLAY)
234
235 #elif CONFIG_KEYPAD == MPIO_HD300_PAD
236 # define FFT_PREV_GRAPH BUTTON_REW
237 # define FFT_NEXT_GRAPH BUTTON_FF
238 # define FFT_ORIENTATION BUTTON_REC
239 # define FFT_WINDOW BUTTON_ENTER
240 # define FFT_AMP_SCALE BUTTON_PLAY
241 # define FFT_QUIT (BUTTON_REC | BUTTON_REPEAT)
242
243 #else
244 #error No keymap defined!
245 #endif
246
247 #ifdef HAVE_TOUCHSCREEN
248 #ifndef FFT_PREV_GRAPH
249 # define FFT_PREV_GRAPH BUTTON_MIDLEFT
250 #endif
251 #ifndef FFT_NEXT_GRAPH
252 # define FFT_NEXT_GRAPH BUTTON_MIDRIGHT
253 #endif
254 #ifndef FFT_ORIENTATION
255 # define FFT_ORIENTATION BUTTON_CENTER
256 #endif
257 #ifndef FFT_WINDOW
258 # define FFT_WINDOW BUTTON_TOPLEFT
259 #endif
260 #ifndef FFT_AMP_SCALE
261 # define FFT_AMP_SCALE BUTTON_TOPRIGHT
262 #endif
263 #ifndef FFT_QUIT
264 # define FFT_QUIT BUTTON_BOTTOMLEFT
265 #endif
266 #endif /* HAVE_TOUCHSCREEN */
267
268 #ifdef HAVE_LCD_COLOR
269 #include "pluginbitmaps/fft_colors.h"
270 #endif
271
272 #include "kiss_fftr.h"
273 #include "_kiss_fft_guts.h" /* sizeof(struct kiss_fft_state) */
274 #include "const.h"
275
276 #define LCD_SIZE MAX(LCD_WIDTH, LCD_HEIGHT)
277
278 #if (LCD_SIZE <= 511)
279 #define FFT_SIZE 1024 /* 512*2 */
280 #elif (LCD_SIZE <= 1023)
281 #define FFT_SIZE 2048 /* 1024*2 */
282 #else
283 #define FFT_SIZE 4096 /* 2048*2 */
284 #endif
285
286 #define ARRAYLEN_IN (FFT_SIZE)
287 #define ARRAYLEN_OUT (FFT_SIZE)
288 #define ARRAYLEN_PLOT (FFT_SIZE/2-1) /* FFT is symmetric, ignore DC */
289 #define BUFSIZE_FFT (sizeof(struct kiss_fft_state)+sizeof(kiss_fft_cpx)*(FFT_SIZE-1))
290
291 #define __COEFF(type,size) type##_##size
292 #define _COEFF(x, y) __COEFF(x,y) /* force the preprocessor to evaluate FFT_SIZE) */
293 #define HANN_COEFF _COEFF(hann, FFT_SIZE)
294 #define HAMMING_COEFF _COEFF(hamming, FFT_SIZE)
295
296 /****************************** Globals ****************************/
297 /* cacheline-aligned buffers with COP, otherwise word-aligned */
298 /* CPU/COP only applies when compiled for more than one core */
299
300 #define CACHEALIGN_UP_SIZE(type, len) \
301 (CACHEALIGN_UP((len)*sizeof(type) + (sizeof(type)-1)) / sizeof(type))
302 /* Shared */
303 /* COP + CPU PCM */
304 static kiss_fft_cpx input[CACHEALIGN_UP_SIZE(kiss_fft_scalar, ARRAYLEN_IN)]
305 CACHEALIGN_AT_LEAST_ATTR(4);
306 /* CPU+COP */
307 #if NUM_CORES > 1
308 /* Output queue indexes */
309 static volatile int output_head SHAREDBSS_ATTR = 0;
310 static volatile int output_tail SHAREDBSS_ATTR = 0;
311 /* The result is nfft/2 complex frequency bins from DC to Nyquist. */
312 static kiss_fft_cpx output[2][CACHEALIGN_UP_SIZE(kiss_fft_cpx, ARRAYLEN_OUT)]
313 SHAREDBSS_ATTR;
314 #else
315 /* Only one output buffer */
316 #define output_head 0
317 #define output_tail 0
318 /* The result is nfft/2 complex frequency bins from DC to Nyquist. */
319 static kiss_fft_cpx output[1][ARRAYLEN_OUT];
320 #endif
321
322 /* Unshared */
323 /* COP */
324 static kiss_fft_cfg fft_state SHAREDBSS_ATTR;
325 static char fft_buffer[CACHEALIGN_UP_SIZE(char, BUFSIZE_FFT)]
326 CACHEALIGN_AT_LEAST_ATTR(4);
327 /* CPU */
328 static int32_t plot_history[ARRAYLEN_PLOT];
329 static int32_t plot[ARRAYLEN_PLOT];
330 static struct
331 {
332 int16_t bin; /* integer bin number */
333 uint16_t frac; /* interpolation fraction */
334 } binlog[ARRAYLEN_PLOT] __attribute__((aligned(4)));
335
336 enum fft_window_func
337 {
338 FFT_WF_FIRST = 0,
339 FFT_WF_HAMMING = 0,
340 FFT_WF_HANN,
341 };
342 #define FFT_WF_COUNT (FFT_WF_HANN+1)
343
344 enum fft_display_mode
345 {
346 FFT_DM_FIRST = 0,
347 FFT_DM_LINES = 0,
348 FFT_DM_BARS,
349 FFT_DM_SPECTROGRAPH,
350 };
351 #define FFT_DM_COUNT (FFT_DM_SPECTROGRAPH+1)
352
353 static const unsigned char* const modes_text[FFT_DM_COUNT] =
354 { "Lines", "Bars", "Spectrogram" };
355
356 static const unsigned char* const amp_scales_text[2] =
357 { "Linear amplitude", "Logarithmic amplitude" };
358
359 static const unsigned char* const freq_scales_text[2] =
360 { "Linear frequency", "Logarithmic frequency" };
361
362 static const unsigned char* const window_text[FFT_WF_COUNT] =
363 { "Hamming window", "Hann window" };
364
365 static struct {
366 bool orientation_vertical;
367 enum fft_display_mode mode;
368 bool logarithmic_amp;
369 bool logarithmic_freq;
370 enum fft_window_func window_func;
371 int spectrogram_pos; /* row or column - only used by one at a time */
372 union
373 {
374 struct
375 {
376 bool orientation : 1;
377 bool mode : 1;
378 bool amp_scale : 1;
379 bool freq_scale : 1;
380 bool window_func : 1;
381 bool do_clear : 1;
382 };
383 bool clear_all; /* Write 'false' to clear all above */
384 } changed;
385 } graph_settings SHAREDDATA_ATTR =
386 {
387 /* Defaults */
388 .orientation_vertical = true,
389 .mode = FFT_DM_LINES,
390 .logarithmic_amp = true,
391 .logarithmic_freq = true,
392 .window_func = FFT_WF_HAMMING,
393 .spectrogram_pos = 0,
394 .changed = { .clear_all = false },
395 };
396
397 #ifdef HAVE_LCD_COLOR
398 #define SHADES BMPWIDTH_fft_colors
399 #define SPECTROGRAPH_PALETTE(index) (fft_colors[index])
400 #else
401 #define SHADES 256
402 #define SPECTROGRAPH_PALETTE(index) (255 - (index))
403 #endif
404
405 /************************* End of globals *************************/
406
407 /************************* Math functions *************************/
408
409 /* Based on feeding-in a 0db sinewave at FS/4 */
410 #define QLOG_MAX 0x0009154B
411 /* fudge it a little or it's not very visbile */
412 #define QLIN_MAX (0x00002266 >> 1)
413
414 /* Apply window function to input */
415 static void apply_window_func(enum fft_window_func mode)
416 {
417 int i;
418
419 switch(mode)
420 {
421 case FFT_WF_HAMMING:
422 for(i = 0; i < ARRAYLEN_IN; ++i)
423 {
424 input[i].r = (input[i].r * HAMMING_COEFF[i] + 16384) >> 15;
425 }
426 break;
427
428 case FFT_WF_HANN:
429 for(i = 0; i < ARRAYLEN_IN; ++i)
430 {
431 input[i].r = (input[i].r * HANN_COEFF[i] + 16384) >> 15;
432 }
433 break;
434 }
435 }
436
437 /* Calculates the magnitudes from complex numbers and returns the maximum */
438 static int32_t calc_magnitudes(bool logarithmic_amp)
439 {
440 /* A major assumption made when calculating the Q*MAX constants
441 * is that the maximum magnitude is 29 bits long. */
442 uint32_t max = 0;
443 kiss_fft_cpx *this_output = output[output_head] + 1; /* skip DC */
444 int i;
445
446 /* Calculate the magnitude, discarding the phase. */
447 for(i = 0; i < ARRAYLEN_PLOT; ++i)
448 {
449 int32_t re = this_output[i].r;
450 int32_t im = this_output[i].i;
451
452 uint32_t tmp = re*re + im*im;
453
454 if(tmp > 0)
455 {
456 if(tmp > 0x7FFFFFFF) /* clip */
457 {
458 tmp = 0x7FFFFFFF; /* if our assumptions are correct,
459 this should never happen. It's just
460 a safeguard. */
461 }
462
463 if(logarithmic_amp)
464 {
465 if(tmp < 0x8000) /* be more precise */
466 {
467 /* ln(x ^ .5) = .5*ln(x) */
468 tmp = fp16_log(tmp << 16) >> 1;
469 }
470 else
471 {
472 tmp = isqrt(tmp); /* linear scaling, nothing
473 bad should happen */
474 tmp = fp16_log(tmp << 16); /* the log function
475 expects s15.16 values */
476 }
477 }
478 else
479 {
480 tmp = isqrt(tmp); /* linear scaling, nothing
481 bad should happen */
482 }
483 }
484
485 /* Length 2 moving average - last transform and this one */
486 tmp = (plot_history[i] + tmp) >> 1;
487 plot[i] = tmp;
488 plot_history[i] = tmp;
489
490 if(tmp > max)
491 max = tmp;
492 }
493
494 return max;
495 }
496
497 /* Move plot bins into a logarithmic scale by sliding them towards the
498 * Nyquist bin according to the translation in the binlog array. */
499 static void logarithmic_plot_translate(void)
500 {
501 int i;
502
503 for(i = ARRAYLEN_PLOT-1; i > 0; --i)
504 {
505 int bin;
506 int s = binlog[i].bin;
507 int e = binlog[i-1].bin;
508 int frac = binlog[i].frac;
509
510 bin = plot[s];
511
512 if(frac)
513 {
514 /* slope < 1, Interpolate stretched bins (linear for now) */
515 int diff = plot[s+1] - bin;
516
517 do
518 {
519 plot[i] = bin + FRACMUL(frac << 15, diff);
520 frac = binlog[--i].frac;
521 }
522 while(frac);
523 }
524 else
525 {
526 /* slope > 1, Find peak of two or more bins */
527 while(--s > e)
528 {
529 int val = plot[s];
530
531 if (val > bin)
532 bin = val;
533 }
534 }
535
536 plot[i] = bin;
537 }
538 }
539
540 /* Calculates the translation for logarithmic plot bins */
541 static void logarithmic_plot_init(void)
542 {
543 int i, j;
544 /*
545 * log: y = round(n * ln(x) / ln(n))
546 * anti: y = round(exp(x * ln(n) / n))
547 */
548 j = fp16_log((ARRAYLEN_PLOT - 1) << 16);
549 for(i = 0; i < ARRAYLEN_PLOT; ++i)
550 {
551 binlog[i].bin = (fp16_exp(i * j / (ARRAYLEN_PLOT - 1)) + 32768) >> 16;
552 }
553
554 /* setup fractions for interpolation of stretched bins */
555 for(i = 0; i < ARRAYLEN_PLOT-1; i = j)
556 {
557 j = i + 1;
558
559 /* stop when we have two different values */
560 while(binlog[j].bin == binlog[i].bin)
561 j++; /* if here, local slope of curve is < 1 */
562
563 if(j > i + 1)
564 {
565 /* distribute pieces evenly over stretched interval */
566 int diff = j - i;
567 int x = 0;
568 do
569 {
570 binlog[i].frac = (x++ << 16) / diff;
571 }
572 while(++i < j);
573 }
574 }
575 }
576
577 /************************ End of math functions ***********************/
578
579 /********************* Plotting functions (modes) *********************/
580 static void draw_lines_vertical(void);
581 static void draw_lines_horizontal(void);
582 static void draw_bars_vertical(void);
583 static void draw_bars_horizontal(void);
584 static void draw_spectrogram_vertical(void);
585 static void draw_spectrogram_horizontal(void);
586
587 #define COLOR_DEFAULT_FG MYLCD_DEFAULT_FG
588 #define COLOR_DEFAULT_BG MYLCD_DEFAULT_BG
589
590 #ifdef HAVE_LCD_COLOR
591 #define COLOR_MESSAGE_FRAME LCD_RGBPACK(0xc6, 0x00, 0x00)
592 #define COLOR_MESSAGE_BG LCD_BLACK
593 #define COLOR_MESSAGE_FG LCD_WHITE
594 #else
595 #define COLOR_MESSAGE_FRAME GREY_DARKGRAY
596 #define COLOR_MESSAGE_BG GREY_WHITE
597 #define COLOR_MESSAGE_FG GREY_BLACK
598 #endif
599
600 #define POPUP_HPADDING 3 /* 3 px of horizontal padding and */
601 #define POPUP_VPADDING 2 /* 2 px of vertical padding */
602
603 static void draw_message_string(const unsigned char *message, bool active)
604 {
605 int x, y;
606 mylcd_getstringsize(message, &x, &y);
607
608 /* x and y give the size of the box for the popup */
609 x += POPUP_HPADDING*2;
610 y += POPUP_VPADDING*2;
611
612 /* In vertical spectrogram mode, leave space for the popup
613 * before actually drawing it (if space is needed) */
614 if(active &&
615 graph_settings.mode == FFT_DM_SPECTROGRAPH &&
616 graph_settings.orientation_vertical &&
617 graph_settings.spectrogram_pos >= LCD_WIDTH - x)
618 {
619 mylcd_scroll_left(graph_settings.spectrogram_pos -
620 LCD_WIDTH + x);
621 graph_settings.spectrogram_pos = LCD_WIDTH - x - 1;
622 }
623
624 mylcd_set_foreground(COLOR_MESSAGE_FRAME);
625 mylcd_fillrect(LCD_WIDTH - x, 0, LCD_WIDTH - 1, y);
626
627 mylcd_set_foreground(COLOR_MESSAGE_FG);
628 mylcd_set_background(COLOR_MESSAGE_BG);
629 mylcd_putsxy(LCD_WIDTH - x + POPUP_HPADDING,
630 POPUP_VPADDING, message);
631 mylcd_set_foreground(COLOR_DEFAULT_FG);
632 mylcd_set_background(COLOR_DEFAULT_BG);
633 }
634
635 static void draw(const unsigned char* message)
636 {
637 static long show_message_tick = 0;
638 static const unsigned char* last_message = 0;
639
640 if(message != NULL)
641 {
642 last_message = message;
643 show_message_tick = (*rb->current_tick + HZ) | 1;
644 }
645
646 /* maybe take additional actions depending upon the changed setting */
647 if(graph_settings.changed.orientation)
648 {
649 graph_settings.changed.amp_scale = true;
650 graph_settings.changed.do_clear = true;
651 }
652
653 if(graph_settings.changed.mode)
654 {
655 graph_settings.changed.amp_scale = true;
656 graph_settings.changed.do_clear = true;
657 }
658
659 if(graph_settings.changed.amp_scale)
660 memset(plot_history, 0, sizeof (plot_history));
661
662 if(graph_settings.changed.freq_scale)
663 graph_settings.changed.freq_scale = true;
664
665 mylcd_set_foreground(COLOR_DEFAULT_FG);
666 mylcd_set_background(COLOR_DEFAULT_BG);
667
668 switch (graph_settings.mode)
669 {
670 default:
671 case FFT_DM_LINES: {
672
673 mylcd_clear_display();
674
675 if (graph_settings.orientation_vertical)
676 draw_lines_vertical();
677 else
678 draw_lines_horizontal();
679 break;
680 }
681 case FFT_DM_BARS: {
682
683 mylcd_clear_display();
684
685 if(graph_settings.orientation_vertical)
686 draw_bars_vertical();
687 else
688 draw_bars_horizontal();
689
690 break;
691 }
692 case FFT_DM_SPECTROGRAPH: {
693
694 if(graph_settings.changed.do_clear)
695 {
696 graph_settings.spectrogram_pos = 0;
697 mylcd_clear_display();
698 }
699
700 if(graph_settings.orientation_vertical)
701 draw_spectrogram_vertical();
702 else
703 draw_spectrogram_horizontal();
704 break;
705 }
706 }
707
708 if(show_message_tick != 0)
709 {
710 if(TIME_BEFORE(*rb->current_tick, show_message_tick))
711 {
712 /* We have a message to show */
713 draw_message_string(last_message, true);
714 }
715 else
716 {
717 /* Stop drawing message */
718 show_message_tick = 0;
719 }
720 }
721 else if(last_message != NULL)
722 {
723 if(graph_settings.mode == FFT_DM_SPECTROGRAPH)
724 {
725 /* Spectrogram mode - need to erase the popup */
726 int x, y;
727 mylcd_getstringsize(last_message, &x, &y);
728 /* Recalculate the size */
729 x += POPUP_HPADDING*2;
730 y += POPUP_VPADDING*2;
731
732 if(!graph_settings.orientation_vertical)
733 {
734 /* In horizontal spectrogram mode, just scroll up by Y lines */
735 mylcd_scroll_up(y);
736 graph_settings.spectrogram_pos -= y;
737 if(graph_settings.spectrogram_pos < 0)
738 graph_settings.spectrogram_pos = 0;
739 }
740 else
741 {
742 /* In vertical spectrogram mode, erase the popup */
743 mylcd_set_foreground(COLOR_DEFAULT_BG);
744 mylcd_fillrect(graph_settings.spectrogram_pos + 1, 0,
745 LCD_WIDTH, y);
746 mylcd_set_foreground(COLOR_DEFAULT_FG);
747 }
748 }
749 /* else These modes clear the screen themselves */
750
751 last_message = NULL;
752 }
753
754 mylcd_update();
755
756 graph_settings.changed.clear_all = false;
757 }
758
759 static void draw_lines_vertical(void)
760 {
761 static int max = 0;
762
763 #if LCD_WIDTH < ARRAYLEN_PLOT /* graph compression */
764 const int offset = 0;
765 const int plotwidth = LCD_WIDTH;
766 #else
767 const int offset = (LCD_HEIGHT - ARRAYLEN_PLOT) / 2;
768 const int plotwidth = ARRAYLEN_PLOT;
769 #endif
770
771 int this_max;
772 int i, x;
773
774 if(graph_settings.changed.amp_scale)
775 max = 0; /* reset the graph on scaling mode change */
776
777 this_max = calc_magnitudes(graph_settings.logarithmic_amp);
778
779 if(this_max == 0)
780 {
781 mylcd_hline(0, LCD_WIDTH - 1, LCD_HEIGHT - 1); /* Draw all "zero" */
782 return;
783 }
784
785 if(graph_settings.logarithmic_freq)
786 logarithmic_plot_translate();
787
788 /* take the maximum of neighboring bins if we have to scale the graph
789 * horizontally */
790 if(LCD_WIDTH < ARRAYLEN_PLOT) /* graph compression */
791 {
792 int bins_acc = LCD_WIDTH / 2;
793 int bins_max = 0;
794
795 i = 0, x = 0;
796
797 for(;;)
798 {
799 int bin = plot[i++];
800
801 if(bin > bins_max)
802 bins_max = bin;
803
804 bins_acc += LCD_WIDTH;
805
806 if(bins_acc >= ARRAYLEN_PLOT)
807 {
808 plot[x] = bins_max;
809
810 if(bins_max > max)
811 max = bins_max;
812
813 if(++x >= LCD_WIDTH)
814 break;
815
816 bins_acc -= ARRAYLEN_PLOT;
817 bins_max = 0;
818 }
819 }
820 }
821 else
822 {
823 if(this_max > max)
824 max = this_max;
825 }
826
827 for(x = 0; x < plotwidth; ++x)
828 {
829 int h = LCD_HEIGHT*plot[x] / max;
830 mylcd_vline(x + offset, LCD_HEIGHT - h, LCD_HEIGHT-1);
831 }
832 }
833
834 static void draw_lines_horizontal(void)
835 {
836 static int max = 0;
837
838 #if LCD_WIDTH < ARRAYLEN_PLOT /* graph compression */
839 const int offset = 0;
840 const int plotwidth = LCD_HEIGHT;
841 #else
842 const int offset = (LCD_HEIGHT - ARRAYLEN_PLOT) / 2;
843 const int plotwidth = ARRAYLEN_PLOT;
844 #endif
845
846 int this_max;
847 int y;
848
849 if(graph_settings.changed.amp_scale)
850 max = 0; /* reset the graph on scaling mode change */
851
852 this_max = calc_magnitudes(graph_settings.logarithmic_amp);
853
854 if(this_max == 0)
855 {
856 mylcd_vline(0, 0, LCD_HEIGHT-1); /* Draw all "zero" */
857 return;
858 }
859
860 if(graph_settings.logarithmic_freq)
861 logarithmic_plot_translate();
862
863 /* take the maximum of neighboring bins if we have to scale the graph
864 * horizontally */
865 if(LCD_HEIGHT < ARRAYLEN_PLOT) /* graph compression */
866 {
867 int bins_acc = LCD_HEIGHT / 2;
868 int bins_max = 0;
869 int i = 0;
870
871 y = 0;
872
873 for(;;)
874 {
875 int bin = plot[i++];
876
877 if (bin > bins_max)
878 bins_max = bin;
879
880 bins_acc += LCD_HEIGHT;
881
882 if(bins_acc >= ARRAYLEN_PLOT)
883 {
884 plot[y] = bins_max;
885
886 if(bins_max > max)
887 max = bins_max;
888
889 if(++y >= LCD_HEIGHT)
890 break;
891
892 bins_acc -= ARRAYLEN_PLOT;
893 bins_max = 0;
894 }
895 }
896 }
897 else
898 {
899 if(this_max > max)
900 max = this_max;
901 }
902
903 for(y = 0; y < plotwidth; ++y)
904 {
905 int w = LCD_WIDTH*plot[y] / max;
906 mylcd_hline(0, w - 1, y + offset);
907 }
908 }
909
910 static void draw_bars_vertical(void)
911 {
912 static int max = 0;
913
914 #if LCD_WIDTH < LCD_HEIGHT
915 const int bars = 15;
916 #else
917 const int bars = 20;
918 #endif
919 const int border = 2;
920 const int barwidth = LCD_WIDTH / (bars + border);
921 const int width = barwidth - border;
922 const int offset = (LCD_WIDTH - bars*barwidth) / 2;
923
924 if(graph_settings.changed.amp_scale)
925 max = 0; /* reset the graph on scaling mode change */
926
927 mylcd_hline(0, LCD_WIDTH-1, LCD_HEIGHT-1); /* Draw baseline */
928
929 if(calc_magnitudes(graph_settings.logarithmic_amp) == 0)
930 return; /* nothing more to draw */
931
932 if(graph_settings.logarithmic_freq)
933 logarithmic_plot_translate();
934
935 int bins_acc = bars / 2;
936 int bins_max = 0;
937 int x = 0, i = 0;
938
939 for(;;)
940 {
941 int bin = plot[i++];
942
943 if(bin > bins_max)
944 bins_max = bin;
945
946 bins_acc += bars;
947
948 if(bins_acc >= ARRAYLEN_PLOT)
949 {
950 plot[x] = bins_max;
951
952 if(bins_max > max)
953 max = bins_max;
954
955 if(++x >= bars)
956 break;
957
958 bins_acc -= ARRAYLEN_PLOT;
959 bins_max = 0;
960 }
961 }
962
963 for(i = 0, x = offset; i < bars; ++i, x += barwidth)
964 {
965 int h = LCD_HEIGHT * plot[i] / max;
966 mylcd_fillrect(x, LCD_HEIGHT - h, width, h - 1);
967 }
968 }
969
970 static void draw_bars_horizontal(void)
971 {
972 static int max = 0;
973
974 #if LCD_WIDTH < LCD_HEIGHT
975 const int bars = 20;
976 #else
977 const int bars = 15;
978 #endif
979 const int border = 2;
980 const int barwidth = LCD_HEIGHT / (bars + border);
981 const int height = barwidth - border;
982 const int offset = (LCD_HEIGHT - bars*barwidth) / 2;
983
984 if(graph_settings.changed.amp_scale)
985 max = 0; /* reset the graph on scaling mode change */
986
987 mylcd_vline(0, 0, LCD_HEIGHT-1); /* Draw baseline */
988
989 if(calc_magnitudes(graph_settings.logarithmic_amp) == 0)
990 return; /* nothing more to draw */
991
992 if(graph_settings.logarithmic_freq)
993 logarithmic_plot_translate();
994
995 int bins_acc = bars / 2;
996 int bins_max = 0;
997 int y = 0, i = 0;
998
999 for(;;)
1000 {
1001 int bin = plot[i++];
1002
1003 if (bin > bins_max)
1004 bins_max = bin;
1005
1006 bins_acc += bars;
1007
1008 if(bins_acc >= ARRAYLEN_PLOT)
1009 {
1010 plot[y] = bins_max;
1011
1012 if(bins_max > max)
1013 max = bins_max;
1014
1015 if(++y >= bars)
1016 break;
1017
1018 bins_acc -= ARRAYLEN_PLOT;
1019 bins_max = 0;
1020 }
1021 }
1022
1023 for(i = 0, y = offset; i < bars; ++i, y += barwidth)
1024 {
1025 int w = LCD_WIDTH * plot[i] / max;
1026 mylcd_fillrect(1, y, w, height);
1027 }
1028 }
1029
1030 static void draw_spectrogram_vertical(void)
1031 {
1032 const int32_t scale_factor = MIN(LCD_HEIGHT, ARRAYLEN_PLOT);
1033
1034 calc_magnitudes(graph_settings.logarithmic_amp);
1035
1036 if(graph_settings.logarithmic_freq)
1037 logarithmic_plot_translate();
1038
1039 int bins_acc = scale_factor / 2;
1040 int bins_max = 0;
1041 int y = 0, i = 0;
1042
1043 for(;;)
1044 {
1045 int bin = plot[i++];
1046
1047 if(bin > bins_max)
1048 bins_max = bin;
1049
1050 bins_acc += scale_factor;
1051
1052 if(bins_acc >= ARRAYLEN_PLOT)
1053 {
1054 unsigned index;
1055
1056 if(graph_settings.logarithmic_amp)
1057 index = (SHADES-1)*bins_max / QLOG_MAX;
1058 else
1059 index = (SHADES-1)*bins_max / QLIN_MAX;
1060
1061 /* These happen because we exaggerate the graph a little for
1062 * linear mode */
1063 if(index >= SHADES)
1064 index = SHADES-1;
1065
1066 mylcd_set_foreground(SPECTROGRAPH_PALETTE(index));
1067 mylcd_drawpixel(graph_settings.spectrogram_pos,
1068 scale_factor-1 - y);
1069
1070 if(++y >= scale_factor)
1071 break;
1072
1073 bins_acc -= ARRAYLEN_PLOT;
1074 bins_max = 0;
1075 }
1076 }
1077
1078 if(graph_settings.spectrogram_pos < LCD_WIDTH-1)
1079 graph_settings.spectrogram_pos++;
1080 else
1081 mylcd_scroll_left(1);
1082 }
1083
1084 static void draw_spectrogram_horizontal(void)
1085 {
1086 const int32_t scale_factor = MIN(LCD_WIDTH, ARRAYLEN_PLOT);
1087
1088 calc_magnitudes(graph_settings.logarithmic_amp);
1089
1090 if(graph_settings.logarithmic_freq)
1091 logarithmic_plot_translate();
1092
1093 int bins_acc = scale_factor / 2;
1094 int bins_max = 0;
1095 int x = 0, i = 0;
1096
1097 for(;;)
1098 {
1099 int bin = plot[i++];
1100
1101 if(bin > bins_max)
1102 bins_max = bin;
1103
1104 bins_acc += scale_factor;
1105
1106 if(bins_acc >= ARRAYLEN_PLOT)
1107 {
1108 unsigned index;
1109
1110 if(graph_settings.logarithmic_amp)
1111 index = (SHADES-1)*bins_max / QLOG_MAX;
1112 else
1113 index = (SHADES-1)*bins_max / QLIN_MAX;
1114
1115 /* These happen because we exaggerate the graph a little for
1116 * linear mode */
1117 if(index >= SHADES)
1118 index = SHADES-1;
1119
1120 mylcd_set_foreground(SPECTROGRAPH_PALETTE(index));
1121 mylcd_drawpixel(x, graph_settings.spectrogram_pos);
1122
1123 if(++x >= scale_factor)
1124 break;
1125
1126 bins_acc -= ARRAYLEN_PLOT;
1127 bins_max = 0;
1128 }
1129 }
1130
1131 if(graph_settings.spectrogram_pos < LCD_HEIGHT-1)
1132 graph_settings.spectrogram_pos++;
1133 else
1134 mylcd_scroll_up(1);
1135 }
1136
1137 /********************* End of plotting functions (modes) *********************/
1138
1139 /****************************** FFT functions ********************************/
1140
1141 /** functions use in single/multi configuration **/
1142 static inline bool fft_init_fft_lib(void)
1143 {
1144 size_t size = sizeof(fft_buffer);
1145 fft_state = kiss_fft_alloc(FFT_SIZE, 0, fft_buffer, &size);
1146
1147 if(fft_state == NULL)
1148 {
1149 DEBUGF("needed data: %i", (int) size);
1150 return false;
1151 }
1152
1153 return true;
1154 }
1155
1156 static inline bool fft_get_fft(void)
1157 {
1158 int count;
1159 int16_t *value = (int16_t *) rb->pcm_get_peak_buffer(&count);
1160 /* This block can introduce discontinuities in our data. Meaning, the
1161 * FFT will not be done a continuous segment of the signal. Which can
1162 * be bad. Or not.
1163 *
1164 * Anyway, this is a demo, not a scientific tool. If you want accuracy,
1165 * do a proper spectrum analysis.*/
1166
1167 /* there are cases when we don't have enough data to fill the buffer */
1168 if(count != ARRAYLEN_IN)
1169 {
1170 if(count < ARRAYLEN_IN)
1171 return false;
1172
1173 count = ARRAYLEN_IN; /* too much - limit */
1174 }
1175
1176 int fft_idx = 0; /* offset in 'input' */
1177
1178 do
1179 {
1180 kiss_fft_scalar left = *value++;
1181 kiss_fft_scalar right = *value++;
1182 input[fft_idx].r = (left + right) >> 1; /* to mono */
1183 } while (fft_idx++, --count > 0);
1184
1185 apply_window_func(graph_settings.window_func);
1186
1187 rb->yield();
1188
1189 kiss_fft(fft_state, input, output[output_tail]);
1190
1191 rb->yield();
1192
1193 return true;
1194 }
1195
1196 #if NUM_CORES > 1
1197 /* use a worker thread if there is another processor core */
1198 static volatile bool fft_thread_run SHAREDDATA_ATTR = false;
1199 static unsigned long fft_thread;
1200
1201 static long fft_thread_stack[CACHEALIGN_UP(DEFAULT_STACK_SIZE*4/sizeof(long))]
1202 CACHEALIGN_AT_LEAST_ATTR(4);
1203
1204 static void fft_thread_entry(void)
1205 {
1206 if (!fft_init_fft_lib())
1207 {
1208 output_tail = -1; /* tell that we bailed */
1209 fft_thread_run = true;
1210 return;
1211 }
1212
1213 fft_thread_run = true;
1214
1215 while(fft_thread_run)
1216 {
1217 if (!rb->pcm_is_playing())
1218 {
1219 rb->sleep(HZ/5);
1220 continue;
1221 }
1222
1223 if (!fft_get_fft())
1224 {
1225 rb->sleep(0); /* not enough - ease up */
1226 continue;
1227 }
1228
1229 /* write back output for other processor and invalidate for next frame read */
1230 rb->cpucache_invalidate();
1231
1232 int new_tail = output_tail ^ 1;
1233
1234 /* if full, block waiting until reader has freed a slot */
1235 while(fft_thread_run)
1236 {
1237 if(new_tail != output_head)
1238 {
1239 output_tail = new_tail;
1240 break;
1241 }
1242
1243 rb->sleep(0);
1244 }
1245 }
1246 }
1247
1248 static bool fft_have_fft(void)
1249 {
1250 return output_head != output_tail;
1251 }
1252
1253 /* Call only after fft_have_fft() has returned true */
1254 static inline void fft_free_fft_output(void)
1255 {
1256 output_head ^= 1; /* finished with this */
1257 }
1258
1259 static bool fft_init_fft(void)
1260 {
1261 /* create worker thread - on the COP for dual-core targets */
1262 fft_thread = rb->create_thread(fft_thread_entry,
1263 fft_thread_stack, sizeof(fft_thread_stack), 0, "fft output thread"
1264 IF_PRIO(, PRIORITY_USER_INTERFACE+1) IF_COP(, COP));
1265
1266 if(fft_thread == 0)
1267 {
1268 rb->splash(HZ, "FFT thread failed create");
1269 return false;
1270 }
1271
1272 /* wait for it to indicate 'ready' */
1273 while(fft_thread_run == false)
1274 rb->sleep(0);
1275
1276 if(output_tail == -1)
1277 {
1278 /* FFT thread bailed-out like The Fed */
1279 rb->thread_wait(fft_thread);
1280 rb->splash(HZ, "FFT thread failed to init");
1281 return false;
1282 }
1283
1284 return true;
1285 }
1286
1287 static void fft_close_fft(void)
1288 {
1289 /* Handle our FFT thread. */
1290 fft_thread_run = false;
1291 rb->thread_wait(fft_thread);
1292 rb->cpucache_invalidate();
1293 }
1294 #else /* NUM_CORES == 1 */
1295 /* everything serialize on single-core and FFT gets to use IRAM main stack if
1296 * target uses IRAM */
1297 static bool fft_have_fft(void)
1298 {
1299 return rb->pcm_is_playing() && fft_get_fft();
1300 }
1301
1302 static inline void fft_free_fft_output(void)
1303 {
1304 /* nothing to do */
1305 }
1306
1307 static bool fft_init_fft(void)
1308 {
1309 return fft_init_fft_lib();
1310 }
1311
1312 static inline void fft_close_fft(void)
1313 {
1314 /* nothing to do */
1315 }
1316 #endif /* NUM_CORES */
1317 /*************************** End of FFT functions ****************************/
1318
1319 enum plugin_status plugin_start(const void* parameter)
1320 {
1321 /* Defaults */
1322 bool run = true;
1323 bool showing_warning = false;
1324
1325 if (!fft_init_fft())
1326 return PLUGIN_ERROR;
1327
1328 #ifndef HAVE_LCD_COLOR
1329 unsigned char *gbuf;
1330 size_t gbuf_size = 0;
1331 /* get the remainder of the plugin buffer */
1332 gbuf = (unsigned char *) rb->plugin_get_buffer(&gbuf_size);
1333
1334 /* initialize the greyscale buffer.*/
1335 if (!grey_init(gbuf, gbuf_size, GREY_ON_COP | GREY_BUFFERED,
1336 LCD_WIDTH, LCD_HEIGHT, NULL))
1337 {
1338 rb->splash(HZ, "Couldn't init greyscale display");
1339 fft_close_fft();
1340 return PLUGIN_ERROR;
1341 }
1342 grey_show(true);
1343 #endif
1344
1345 logarithmic_plot_init();
1346
1347 #if LCD_DEPTH > 1
1348 rb->lcd_set_backdrop(NULL);
1349 mylcd_clear_display();
1350 mylcd_update();
1351 #endif
1352 backlight_ignore_timeout();
1353
1354 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1355 rb->cpu_boost(true);
1356 #endif
1357
1358 while (run)
1359 {
1360 /* Unless otherwise specified, HZ/50 is around the window length
1361 * and quite fast. We want to be done with drawing by this time. */
1362 long next_frame_tick = *rb->current_tick + HZ/50;
1363 int button;
1364
1365 while (!fft_have_fft())
1366 {
1367 int timeout;
1368
1369 if(!rb->pcm_is_playing())
1370 {
1371 showing_warning = true;
1372 mylcd_clear_display();
1373 draw_message_string("No audio playing", false);
1374 mylcd_update();
1375 timeout = HZ/5;
1376 }
1377 else
1378 {
1379 if(showing_warning)
1380 {
1381 showing_warning = false;
1382 mylcd_clear_display();
1383 mylcd_update();
1384 }
1385
1386 timeout = HZ/100; /* 'till end of curent tick, don't use 100% CPU */
1387 }
1388
1389 /* Make sure the FFT has produced something before doing anything
1390 * but watching for buttons. Music might not be playing or things
1391 * just aren't going well for picking up buffers so keys are
1392 * scanned to avoid lockup. */
1393 button = rb->button_get_w_tmo(timeout);
1394 if (button != BUTTON_NONE)
1395 goto read_button;
1396 }
1397
1398 draw(NULL);
1399
1400 fft_free_fft_output(); /* COP only */
1401
1402 long tick = *rb->current_tick;
1403 if(TIME_BEFORE(tick, next_frame_tick))
1404 {
1405 tick = next_frame_tick - tick;
1406 }
1407 else
1408 {
1409 rb->yield(); /* tmo = 0 won't yield */
1410 tick = 0;
1411 }
1412
1413 button = rb->button_get_w_tmo(tick);
1414 read_button:
1415 switch (button)
1416 {
1417 case FFT_QUIT:
1418 run = false;
1419 break;
1420 case FFT_PREV_GRAPH: {
1421 if (graph_settings.mode-- <= FFT_DM_FIRST)
1422 graph_settings.mode = FFT_DM_COUNT-1;
1423 graph_settings.changed.mode = true;
1424 draw(modes_text[graph_settings.mode]);
1425 break;
1426 }
1427 case FFT_NEXT_GRAPH: {
1428 if (++graph_settings.mode >= FFT_DM_COUNT)
1429 graph_settings.mode = FFT_DM_FIRST;
1430 graph_settings.changed.mode = true;
1431 draw(modes_text[graph_settings.mode]);
1432 break;
1433 }
1434 case FFT_WINDOW: {
1435 if(++graph_settings.window_func >= FFT_WF_COUNT)
1436 graph_settings.window_func = FFT_WF_FIRST;
1437 graph_settings.changed.window_func = true;
1438 draw(window_text[graph_settings.window_func]);
1439 break;
1440 }
1441 case FFT_AMP_SCALE: {
1442 graph_settings.logarithmic_amp = !graph_settings.logarithmic_amp;
1443 graph_settings.changed.amp_scale = true;
1444 draw(amp_scales_text[graph_settings.logarithmic_amp ? 1 : 0]);
1445 break;
1446 }
1447 #ifdef FFT_FREQ_SCALE /* 'Till all keymaps are defined */
1448 case FFT_FREQ_SCALE: {
1449 graph_settings.logarithmic_freq = !graph_settings.logarithmic_freq;
1450 graph_settings.changed.freq_scale = true;
1451 draw(freq_scales_text[graph_settings.logarithmic_freq ? 1 : 0]);
1452 break;
1453 }
1454 #endif
1455 case FFT_ORIENTATION: {
1456 graph_settings.orientation_vertical =
1457 !graph_settings.orientation_vertical;
1458 graph_settings.changed.orientation = true;
1459 draw(NULL);
1460 break;
1461 }
1462 default: {
1463 if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
1464 return PLUGIN_USB_CONNECTED;
1465 }
1466
1467 }
1468 }
1469
1470 fft_close_fft();
1471
1472 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1473 rb->cpu_boost(false);
1474 #endif
1475 #ifndef HAVE_LCD_COLOR
1476 grey_release();
1477 #endif
1478 backlight_use_settings();
1479 return PLUGIN_OK;
1480 (void)parameter;
1481 }
My public Rockbox git repo