1 /**************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2008 Lechner Michael / smoking gnu
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
18 * ----------------------------------------------------------------------------
21 * OK, this is an attempt to write an instrument tuner for rockbox.
22 * It uses a Schmitt trigger algorithm, which I copied from
23 * tuneit [ (c) 2004 Mario Lang <mlang@delysid.org> ], for detecting the
24 * fundamental freqency of a sound. A FFT algorithm would be more accurate
25 * but also much slower.
28 * - Adapt the Yin FFT algorithm, which would reduce complexity from O(n^2)
29 * to O(nlogn), theoretically reducing latency by a factor of ~10. -David
32 * 08.03.2008 Started coding
33 * 21.03.2008 Pitch detection works more or less
34 * Button definitions for most targets added
35 * 02.04.2008 Proper GUI added
36 * Todo, Major Changes and Current Limitations added
37 * 08.19.2009 Brought the code up to date with current plugin standards
38 * Made it work more nicely with color, BW and grayscale
39 * Changed pitch detection to use the Yin algorithm (better
40 * detection, but slower -- would be ~4x faster with
41 * fixed point math, I think). Code was poached from the
42 * Aubio sound processing library (aubio.org). -David
43 * 08.31.2009 Lots of changes:
44 * Added a menu to tweak settings
45 * Converted everything to fixed point (greatly improving
47 * Improved the display
48 * Improved efficiency with judicious use of cpu_boost, the
49 * backlight, and volume detection to limit unneeded
51 * Fixed a problem that caused an octave-off error
53 * 05.14.2010 Multibuffer continuous recording with two buffers
56 * CURRENT LIMITATIONS:
57 * - No gapless recording. Strictly speaking true gappless isn't possible,
58 * since the algorithm takes longer to calculate than the length of the
59 * sample, but latency could be improved a bit with proper use of the DMA
60 * recording functions.
61 * - Due to how the Yin algorithm works, latency is higher for lower
66 #include "lib/pluginlib_actions.h"
67 #include "lib/picture.h"
68 #include "lib/helper.h"
69 #include "pluginbitmaps/pitch_notes.h"
73 /* Some fixed point calculation stuff */
74 typedef int32_t fixed_data
;
79 typedef struct _fixed fixed
;
80 #define FIXED_PRECISION 18
81 #define FP_MAX ((fixed) {0x7fffffff})
82 #define FP_MIN ((fixed) {-0x80000000})
83 #define int2fixed(x) ((fixed){(x) << FIXED_PRECISION})
84 #define int2mantissa(x) ((fixed){x})
85 #define fixed2int(x) ((int)((x).a >> FIXED_PRECISION))
86 #define fixed2float(x) (((float)(x).a) / ((float)(1 << FIXED_PRECISION)))
87 #define float2fixed(x) \
88 ((fixed){(fixed_data)(x * (float)(1 << FIXED_PRECISION))})
89 /* I adapted these ones from the Rockbox fixed point library */
90 #define fp_mul(x, y) \
91 ((fixed){(((int64_t)((x).a)) * ((int64_t)((y).a))) >> (FIXED_PRECISION)})
92 #define fp_div(x, y) \
93 ((fixed){(((int64_t)((x).a)) << (FIXED_PRECISION)) / ((int64_t)((y).a))})
94 /* Operators for fixed point */
95 #define fp_add(x, y) ((fixed){(x).a + (y).a})
96 #define fp_sub(x, y) ((fixed){(x).a - (y).a})
97 #define fp_shl(x, y) ((fixed){(x).a << y})
98 #define fp_shr(x, y) ((fixed){(x).a >> y})
99 #define fp_neg(x) ((fixed){-(x).a})
100 #define fp_gt(x, y) ((x).a > (y).a)
101 #define fp_gte(x, y) ((x).a >= (y).a)
102 #define fp_lt(x, y) ((x).a < (y).a)
103 #define fp_lte(x, y) ((x).a <= (y).a)
104 #define fp_sqr(x) fp_mul((x), (x))
105 #define fp_equal(x, y) ((x).a == (y).a)
106 #define fp_round(x) (fixed2int(fp_add((x), float2fixed(0.5))))
107 #define fp_data(x) ((x).a)
108 #define fp_frac(x) (fp_sub((x), int2fixed(fixed2int(x))))
109 #define FP_ZERO ((fixed){0})
110 #define FP_LOW ((fixed){2})
112 /* Some defines for converting between period and frequency */
114 /* I introduce some divisors in this because the fixed point */
115 /* variables aren't big enough to hold higher than a certain */
116 /* value. This loses a bit of precision but it means we */
117 /* don't have to use 32.32 variables (yikes). */
118 /* With an 18-bit decimal precision, the max value in the */
119 /* integer part is 8192. Divide 44100 by 7 and it'll fit in */
121 #define fp_period2freq(x) fp_div(int2fixed(sample_rate / 7), \
122 fp_div((x),int2fixed(7)))
123 #define fp_freq2period(x) fp_period2freq(x)
124 #define period2freq(x) (sample_rate / (x))
125 #define freq2period(x) period2freq(x)
127 #define sqr(x) ((x)*(x))
129 /* Some constants for tuning */
130 #define A_FREQ float2fixed(440.0f)
131 #define D_NOTE float2fixed(1.059463094359f)
132 #define LOG_D_NOTE float2fixed(1.0f/12.0f)
133 #define D_NOTE_SQRT float2fixed(1.029302236643f)
134 #define LOG_2 float2fixed(1.0f)
136 /* The recording buffer size */
137 /* This is how much is sampled at a time. */
138 /* It also determines latency -- if BUFFER_SIZE == sample_rate then */
139 /* there'll be one sample per second, or a latency of one second. */
140 /* Furthermore, the lowest detectable frequency will be about twice */
141 /* the number of reads per second */
142 /* If we ever switch to Yin FFT algorithm then this needs to be
144 #define BUFFER_SIZE 4096
145 #define SAMPLE_SIZE 4096
146 #define SAMPLE_SIZE_MIN 1024
147 #define YIN_BUFFER_SIZE (BUFFER_SIZE / 4)
149 #define LCD_FACTOR (fp_div(int2fixed(LCD_WIDTH), int2fixed(100)))
150 /* The threshold for the YIN algorithm */
151 #define DEFAULT_YIN_THRESHOLD 5 /* 0.10 */
152 const fixed yin_threshold_table
[] =
170 /* Structure for the reference frequency (frequency of A)
171 * It's used for scaling the frequency before finding out
172 * the note. The frequency is scaled in a way that the main
173 * algorithm can assume the frequency of A to be 440 Hz.
177 const int frequency
; /* Frequency in Hz */
178 const fixed ratio
; /* 440/frequency */
179 const fixed logratio
; /* log2(factor) */
182 const struct freq_A_entry freq_A
[] =
184 {435, float2fixed(1.011363636), float2fixed( 0.016301812)},
185 {436, float2fixed(1.009090909), float2fixed( 0.013056153)},
186 {437, float2fixed(1.006818182), float2fixed( 0.009803175)},
187 {438, float2fixed(1.004545455), float2fixed( 0.006542846)},
188 {439, float2fixed(1.002272727), float2fixed( 0.003275132)},
189 {440, float2fixed(1.000000000), float2fixed( 0.000000000)},
190 {441, float2fixed(0.997727273), float2fixed(-0.003282584)},
191 {442, float2fixed(0.995454545), float2fixed(-0.006572654)},
192 {443, float2fixed(0.993181818), float2fixed(-0.009870244)},
193 {444, float2fixed(0.990909091), float2fixed(-0.013175389)},
194 {445, float2fixed(0.988636364), float2fixed(-0.016488123)},
197 /* Index of the entry for 440 Hz in the table (default frequency for A) */
198 #define DEFAULT_FREQ_A 5
199 #define NUM_FREQ_A (sizeof(freq_A)/sizeof(freq_A[0]))
201 /* How loud the audio has to be to start displaying pitch */
202 /* Must be between 0 and 100 */
203 #define VOLUME_THRESHOLD (50)
205 /* Change to AUDIO_SRC_LINEIN if you want to record from line-in */
207 #define INPUT_TYPE AUDIO_SRC_MIC
209 #define INPUT_TYPE AUDIO_SRC_LINEIN
212 /* How many decimal places to display for the Hz value */
213 #define DISPLAY_HZ_PRECISION 100
215 /* Where to put the various GUI elements */
218 #define LCD_RES_MIN (LCD_HEIGHT < LCD_WIDTH ? LCD_HEIGHT : LCD_WIDTH)
219 #define BAR_PADDING (LCD_RES_MIN / 32)
220 #define BAR_Y (LCD_HEIGHT * 3 / 4)
221 #define BAR_HEIGHT (LCD_RES_MIN / 4 - BAR_PADDING)
222 #define BAR_HLINE_Y (BAR_Y - BAR_PADDING)
223 #define BAR_HLINE_Y2 (BAR_Y + BAR_HEIGHT + BAR_PADDING - 1)
225 #define GRADUATION 10 /* Subdivisions of the whole 100-cent scale */
227 /* Bitmaps for drawing the note names. These need to have height
228 <= (bar_grad_y - note_y), or 15/32 * LCD_HEIGHT
230 #define NUM_NOTE_IMAGES 9
231 #define NOTE_INDEX_A 0
232 #define NOTE_INDEX_B 1
233 #define NOTE_INDEX_C 2
234 #define NOTE_INDEX_D 3
235 #define NOTE_INDEX_E 4
236 #define NOTE_INDEX_F 5
237 #define NOTE_INDEX_G 6
238 #define NOTE_INDEX_SHARP 7
239 #define NOTE_INDEX_FLAT 8
240 const struct picture note_bitmaps
=
243 BMPWIDTH_pitch_notes
,
244 BMPHEIGHT_pitch_notes
,
245 BMPHEIGHT_pitch_notes
/NUM_NOTE_IMAGES
249 static unsigned int sample_rate
;
250 static int audio_head
= 0; /* which of the two buffers to use? */
251 static volatile int audio_tail
= 0; /* which of the two buffers to record? */
252 /* It's stereo, so make the buffer twice as big */
253 static int16_t audio_data
[2][BUFFER_SIZE
];
254 static fixed yin_buffer
[YIN_BUFFER_SIZE
];
256 /* Description of a note of scale */
259 const char *name
; /* Name of the note, e.g. "A#" */
260 const fixed freq
; /* Note frequency, Hz */
261 const fixed logfreq
; /* log2(frequency) */
264 /* Notes within one (reference) scale */
265 static const struct note_entry notes
[] =
267 {"A" , float2fixed(440.0000000f
), float2fixed(8.781359714f
)},
268 {"A#", float2fixed(466.1637615f
), float2fixed(8.864693047f
)},
269 {"B" , float2fixed(493.8833013f
), float2fixed(8.948026380f
)},
270 {"C" , float2fixed(523.2511306f
), float2fixed(9.031359714f
)},
271 {"C#", float2fixed(554.3652620f
), float2fixed(9.114693047f
)},
272 {"D" , float2fixed(587.3295358f
), float2fixed(9.198026380f
)},
273 {"D#", float2fixed(622.2539674f
), float2fixed(9.281359714f
)},
274 {"E" , float2fixed(659.2551138f
), float2fixed(9.364693047f
)},
275 {"F" , float2fixed(698.4564629f
), float2fixed(9.448026380f
)},
276 {"F#", float2fixed(739.9888454f
), float2fixed(9.531359714f
)},
277 {"G" , float2fixed(783.9908720f
), float2fixed(9.614693047f
)},
278 {"G#", float2fixed(830.6093952f
), float2fixed(9.698026380f
)},
283 static unsigned front_color
;
285 static int font_w
,font_h
;
287 static int lbl_x_minus_50
, lbl_x_minus_20
, lbl_x_0
, lbl_x_20
, lbl_x_50
;
289 /* Settings for the plugin */
290 struct tuner_settings
292 unsigned volume_threshold
;
293 unsigned record_gain
;
294 unsigned sample_size
;
295 unsigned lowest_freq
;
296 unsigned yin_threshold
;
297 int freq_A
; /* Index of the frequency of A */
302 /*=================================================================*/
303 /* Settings loading and saving(adapted from the clock plugin) */
304 /*=================================================================*/
306 #define SETTINGS_FILENAME PLUGIN_APPS_DIR "/.pitch_settings"
318 enum settings_file_status
324 /* The settings as they exist on the hard disk, so that
325 * we can know at saving time if changes have been made */
326 struct tuner_settings hdd_tuner_settings
;
328 /*---------------------------------------------------------------------*/
330 bool settings_needs_saving(struct tuner_settings
* settings
)
332 return(rb
->memcmp(settings
, &hdd_tuner_settings
, sizeof(*settings
)));
335 /*---------------------------------------------------------------------*/
337 void tuner_settings_reset(struct tuner_settings
* settings
)
339 settings
->volume_threshold
= VOLUME_THRESHOLD
;
340 settings
->record_gain
= rb
->global_settings
->rec_mic_gain
;
341 settings
->sample_size
= BUFFER_SIZE
;
342 settings
->lowest_freq
= period2freq(BUFFER_SIZE
/ 4);
343 settings
->yin_threshold
= DEFAULT_YIN_THRESHOLD
;
344 settings
->freq_A
= DEFAULT_FREQ_A
;
345 settings
->use_sharps
= true;
346 settings
->display_hz
= false;
349 /*---------------------------------------------------------------------*/
351 enum settings_file_status
tuner_settings_load(struct tuner_settings
* settings
,
354 int fd
= rb
->open(filename
, O_RDONLY
);
355 if(fd
>= 0){ /* does file exist? */
356 /* basic consistency check */
357 if(rb
->filesize(fd
) == sizeof(*settings
)){
358 rb
->read(fd
, settings
, sizeof(*settings
));
360 rb
->memcpy(&hdd_tuner_settings
, settings
, sizeof(*settings
));
364 /* Initializes the settings with default values at least */
365 tuner_settings_reset(settings
);
369 /*---------------------------------------------------------------------*/
371 enum settings_file_status
tuner_settings_save(struct tuner_settings
* settings
,
374 int fd
= rb
->creat(filename
, 0666);
375 if(fd
>= 0){ /* does file exist? */
376 rb
->write (fd
, settings
, sizeof(*settings
));
383 /*---------------------------------------------------------------------*/
385 void load_settings(void)
387 tuner_settings_load(&tuner_settings
, SETTINGS_FILENAME
);
392 /*---------------------------------------------------------------------*/
394 void save_settings(void)
396 if(!settings_needs_saving(&tuner_settings
))
399 tuner_settings_save(&tuner_settings
, SETTINGS_FILENAME
);
402 /*=================================================================*/
404 /*=================================================================*/
407 const struct button_mapping
* plugin_contexts
[]={
409 generic_increase_decrease
,
415 #define PLA_ARRAY_COUNT sizeof(plugin_contexts)/sizeof(plugin_contexts[0])
419 /* This has to match yin_threshold_table */
420 static const struct opt_items yin_threshold_text
[] =
438 static const struct opt_items accidental_text
[] =
444 void set_min_freq(int new_freq
)
446 tuner_settings
.sample_size
= freq2period(new_freq
) * 4;
448 /* clamp the sample size between min and max */
449 if(tuner_settings
.sample_size
<= SAMPLE_SIZE_MIN
)
450 tuner_settings
.sample_size
= SAMPLE_SIZE_MIN
;
451 else if(tuner_settings
.sample_size
>= BUFFER_SIZE
)
452 tuner_settings
.sample_size
= BUFFER_SIZE
;
454 /* sample size must be divisible by 4 - round up */
455 tuner_settings
.sample_size
= (tuner_settings
.sample_size
+ 3) & ~3;
462 bool exit_tuner
= false;
467 backlight_use_settings();
468 #ifdef HAVE_SCHEDULER_BOOSTCTRL
469 rb
->cancel_cpu_boost();
472 MENUITEM_STRINGLIST(menu
,"Tuner Settings",NULL
,
477 "Algorithm Pickiness",
479 "Display Frequency (Hz)",
480 "Frequency of A (Hz)",
486 choice
= rb
->do_menu(&menu
, &selection
, NULL
, false);
490 rb
->set_int("Volume Threshold", "%", UNIT_INT
,
491 &tuner_settings
.volume_threshold
,
492 NULL
, 5, 5, 95, NULL
);
495 rb
->set_int("Listening Volume", "%", UNIT_INT
,
496 &tuner_settings
.record_gain
,
497 NULL
, 1, rb
->sound_min(SOUND_MIC_GAIN
),
498 rb
->sound_max(SOUND_MIC_GAIN
), NULL
);
501 rb
->set_int("Lowest Frequency", "Hz", UNIT_INT
,
502 &tuner_settings
.lowest_freq
, set_min_freq
, 1,
503 /* Range depends on the size of the buffer */
504 sample_rate
/ (BUFFER_SIZE
/ 4),
505 sample_rate
/ (SAMPLE_SIZE_MIN
/ 4), NULL
);
509 "Algorithm Pickiness (Lower -> more discriminating)",
510 &tuner_settings
.yin_threshold
,
511 INT
, yin_threshold_text
,
512 sizeof(yin_threshold_text
) / sizeof(yin_threshold_text
[0]),
516 rb
->set_option("Display Accidentals As",
517 &tuner_settings
.use_sharps
,
518 BOOL
, accidental_text
, 2, NULL
);
521 rb
->set_bool("Display Frequency (Hz)",
522 &tuner_settings
.display_hz
);
525 freq_val
= freq_A
[tuner_settings
.freq_A
].frequency
;
526 rb
->set_int("Frequency of A (Hz)",
527 "Hz", UNIT_INT
, &freq_val
, NULL
,
528 1, freq_A
[0].frequency
, freq_A
[NUM_FREQ_A
-1].frequency
,
530 tuner_settings
.freq_A
= freq_val
- freq_A
[0].frequency
;
534 rb
->set_bool("Reset Tuner Settings?", &reset
);
536 tuner_settings_reset(&tuner_settings
);
544 /* Return to the tuner */
550 backlight_force_on();
554 /*=================================================================*/
556 /*=================================================================*/
558 /* Fixed-point log base 2*/
559 /* Adapted from python code at
560 http://en.wikipedia.org/wiki/Binary_logarithm#Algorithm
565 fixed fp
= int2fixed(1);
566 fixed res
= int2fixed(0);
568 if(fp_lte(x
, FP_ZERO
))
575 while(fp_lt(x
, int2fixed(1)))
577 res
= fp_sub(res
, int2fixed(1));
581 while(fp_gte(x
, int2fixed(2)))
583 res
= fp_add(res
, int2fixed(1));
587 /* Fractional part */
589 while(fp_gt(fp
, FP_ZERO
))
594 if(fp_gte(x
, int2fixed(2)))
597 res
= fp_add(res
, fp
);
604 /*=================================================================*/
606 /*=================================================================*/
608 /* The function name is pretty self-explaining ;) */
609 void print_int_xy(int x
, int y
, int v
)
613 rb
->lcd_set_foreground(front_color
);
615 rb
->snprintf(temp
,20,"%d",v
);
616 rb
->lcd_putsxy(x
,y
,temp
);
619 /* Print out the frequency etc */
620 void print_str(char* s
)
623 rb
->lcd_set_foreground(front_color
);
625 rb
->lcd_putsxy(0, HZ_Y
, s
);
628 /* What can I say? Read the function name... */
629 void print_char_xy(int x
, int y
, char c
)
636 rb
->lcd_set_foreground(front_color
);
639 rb
->lcd_putsxy(x
, y
, temp
);
642 /* Draw the note bitmap */
643 void draw_note(const char *note
)
646 int note_x
= (LCD_WIDTH
- BMPWIDTH_pitch_notes
) / 2;
647 int accidental_index
= NOTE_INDEX_SHARP
;
653 if(!(tuner_settings
.use_sharps
))
656 accidental_index
= NOTE_INDEX_FLAT
;
659 vertical_picture_draw_sprite(rb
->screens
[0],
664 note_x
= LCD_WIDTH
/ 2 - BMPWIDTH_pitch_notes
;
667 vertical_picture_draw_sprite(rb
->screens
[0], ¬e_bitmaps
, i
,
671 /* Draw the red bar and the white lines */
672 void draw_bar(fixed wrong_by_cents
)
677 #ifdef HAVE_LCD_COLOR
678 rb
->lcd_set_foreground(LCD_RGBPACK(255,255,255)); /* Color screens */
680 rb
->lcd_set_foreground(LCD_BLACK
); /* Greyscale screens */
683 rb
->lcd_hline(0,LCD_WIDTH
-1, BAR_HLINE_Y
);
684 rb
->lcd_hline(0,LCD_WIDTH
-1, BAR_HLINE_Y2
);
686 /* Draw graduation lines on the off-by readout */
687 for(n
= 0; n
<= GRADUATION
; n
++)
689 x
= (LCD_WIDTH
* n
+ GRADUATION
/ 2) / GRADUATION
;
692 rb
->lcd_vline(x
, BAR_HLINE_Y
, BAR_HLINE_Y2
);
695 print_int_xy(lbl_x_minus_50
,bar_grad_y
, -50);
696 print_int_xy(lbl_x_minus_20
,bar_grad_y
, -20);
697 print_int_xy(lbl_x_0
,bar_grad_y
, 0);
698 print_int_xy(lbl_x_20
,bar_grad_y
, 20);
699 print_int_xy(lbl_x_50
,bar_grad_y
, 50);
701 #ifdef HAVE_LCD_COLOR
702 rb
->lcd_set_foreground(LCD_RGBPACK(255,0,0)); /* Color screens */
704 rb
->lcd_set_foreground(LCD_DARKGRAY
); /* Greyscale screens */
707 if (fp_gt(wrong_by_cents
, FP_ZERO
))
709 rb
->lcd_fillrect(bar_x_0
, BAR_Y
,
710 fixed2int(fp_mul(wrong_by_cents
, LCD_FACTOR
)), BAR_HEIGHT
);
714 rb
->lcd_fillrect(bar_x_0
+ fixed2int(fp_mul(wrong_by_cents
,LCD_FACTOR
)),
716 fixed2int(fp_mul(wrong_by_cents
, LCD_FACTOR
)) * -1,
721 /* Calculate how wrong the note is and draw the GUI */
722 void display_frequency (fixed freq
)
730 if (fp_lt(freq
, FP_LOW
))
733 /* We calculate the frequency and its log as if */
734 /* the reference frequency of A were 440 Hz. */
736 lfreq
= fp_add(log(freq
), freq_A
[tuner_settings
.freq_A
].logratio
);
737 freq
= fp_mul(freq
, freq_A
[tuner_settings
.freq_A
].ratio
);
739 /* This calculates a log freq offset for note A */
740 /* Get the frequency to within the range of our reference table, */
741 /* i.e. into the right octave. */
742 while (fp_lt(lfreq
, fp_sub(notes
[0].logfreq
, fp_shr(LOG_D_NOTE
, 1))))
743 lfreq
= fp_add(lfreq
, LOG_2
);
744 while (fp_gte(lfreq
, fp_sub(fp_add(notes
[0].logfreq
, LOG_2
),
745 fp_shr(LOG_D_NOTE
, 1))))
746 lfreq
= fp_sub(lfreq
, LOG_2
);
750 ldf
= fp_gt(fp_sub(lfreq
,notes
[i
].logfreq
), FP_ZERO
) ?
751 fp_sub(lfreq
,notes
[i
].logfreq
) : fp_neg(fp_sub(lfreq
,notes
[i
].logfreq
));
752 if (fp_lt(ldf
, mldf
))
758 nfreq
= notes
[note
].freq
;
759 while (fp_gt(fp_div(nfreq
, freq
), D_NOTE_SQRT
))
760 nfreq
= fp_shr(nfreq
, 1);
762 while (fp_gt(fp_div(freq
, nfreq
), D_NOTE_SQRT
))
763 nfreq
= fp_shl(nfreq
, 1);
765 ldf
= fp_mul(int2fixed(1200), log(fp_div(freq
,nfreq
)));
767 rb
->lcd_clear_display();
768 draw_bar(ldf
); /* The red bar */
769 if(fp_round(freq
) != 0)
771 draw_note(notes
[note
].name
);
772 if(tuner_settings
.display_hz
)
774 rb
->snprintf(str_buf
,30, "%s : %d cents (%d.%02dHz)",
775 notes
[note
].name
, fp_round(ldf
) ,fixed2int(orig_freq
),
776 fp_round(fp_mul(fp_frac(orig_freq
),
777 int2fixed(DISPLAY_HZ_PRECISION
))));
784 /*-----------------------------------------------------------------------
785 * Functions for the Yin algorithm
787 * These were all adapted from the versions in Aubio v0.3.2
788 * Here's what the Aubio documentation has to say:
790 * This algorithm was developped by A. de Cheveigne and H. Kawahara and
793 * de Cheveign?, A., Kawahara, H. (2002) "YIN, a fundamental frequency
794 * estimator for speech and music", J. Acoust. Soc. Am. 111, 1917-1930.
796 * see http://recherche.ircam.fr/equipes/pcm/pub/people/cheveign.html
797 -------------------------------------------------------------------------*/
799 /* Find the index of the minimum element of an array of floats */
800 unsigned vec_min_elem(fixed
*s
, unsigned buflen
)
802 unsigned j
, pos
=0.0f
;
804 for (j
=0; j
< buflen
; j
++)
816 fixed
aubio_quadfrac(fixed s0
, fixed s1
, fixed s2
, fixed pf
)
818 /* Original floating point version: */
819 /* tmp = s0 + (pf/2.0f) * (pf * ( s0 - 2.0f*s1 + s2 ) -
820 3.0f*s0 + 4.0f*s1 - s2);*/
821 /* Converted to explicit operator precedence: */
822 /* tmp = s0 + ((pf/2.0f) * ((((pf * ((s0 - (2*s1)) + s2)) -
823 (3*s0)) + (4*s1)) - s2)); */
825 /* I made it look like this so I could easily track the precedence and */
826 /* make sure it matched the original expression */
827 /* Oy, this is when I really wish I could do C++ operator overloading */
868 #define QUADINT_STEP float2fixed(1.0f/200.0f)
870 fixed
vec_quadint_min(fixed
*x
, unsigned bufsize
, unsigned pos
, unsigned span
)
872 fixed res
, frac
, s0
, s1
, s2
;
873 fixed exactpos
= int2fixed(pos
);
874 /* init resold to something big (in case x[pos+-span]<0)) */
875 fixed resold
= FP_MAX
;
877 if ((pos
> span
) && (pos
< bufsize
-span
))
883 for (frac
= float2fixed(0.0f
);
884 fp_lt(frac
, float2fixed(2.0f
));
885 frac
= fp_add(frac
, QUADINT_STEP
))
887 res
= aubio_quadfrac(s0
, s1
, s2
, frac
);
888 if (fp_lt(res
, resold
))
894 /* exactpos += (frac-QUADINT_STEP)*span - span/2.0f; */
895 exactpos
= fp_add(exactpos
,
898 fp_sub(frac
, QUADINT_STEP
),
912 /* Calculate the period of the note in the
913 buffer using the YIN algorithm */
914 /* The yin pointer is just a buffer that the algorithm uses as a work
915 space. It needs to be half the length of the input buffer. */
917 fixed
pitchyin(int16_t *input
, fixed
*yin
)
922 unsigned yin_size
= tuner_settings
.sample_size
/ 4;
924 fixed tmp
= FP_ZERO
, tmp2
= FP_ZERO
;
925 yin
[0] = int2fixed(1);
926 for (tau
= 1; tau
< yin_size
; tau
++)
929 for (j
= 0; j
< yin_size
; j
++)
931 tmp
= fp_sub(int2mantissa(input
[2 * j
]),
932 int2mantissa(input
[2 * (j
+ tau
)]));
933 yin
[tau
] = fp_add(yin
[tau
], fp_mul(tmp
, tmp
));
935 tmp2
= fp_add(tmp2
, yin
[tau
]);
936 if(!fp_equal(tmp2
, FP_ZERO
))
938 yin
[tau
] = fp_mul(yin
[tau
], fp_div(int2fixed(tau
), tmp2
));
941 if(tau
> 4 && fp_lt(yin
[period
],
942 yin_threshold_table
[tuner_settings
.yin_threshold
])
943 && fp_lt(yin
[period
], yin
[period
+1]))
945 retval
= vec_quadint_min(yin
, yin_size
, period
, 1);
949 retval
= vec_quadint_min(yin
, yin_size
,
950 vec_min_elem(yin
, yin_size
), 1);
955 /*-----------------------------------------------------------------*/
957 uint32_t buffer_magnitude(int16_t *input
)
962 /* Operate on only one channel of the stereo signal */
963 for(n
= 0; n
< tuner_settings
.sample_size
; n
+=2)
969 tally
/= tuner_settings
.sample_size
/ 2;
971 /* now tally holds the average of the squares of all the samples */
972 /* It must be between 0 and 0x7fff^2, so it fits in 32 bits */
973 return (uint32_t)tally
;
976 /* Stop the recording when the buffer is full */
978 int recording_callback(int status
)
980 int tail
= audio_tail
^ 1;
982 /* Do not overrun the reader. Reuse current buffer if full. */
983 if (tail
!= audio_head
)
986 /* Always record full buffer, even if not required */
987 rb
->pcm_record_more(audio_data
[tail
],
988 BUFFER_SIZE
* sizeof (int16_t));
995 /* Start recording */
996 static void record_data(void)
999 /* Always record full buffer, even if not required */
1000 rb
->pcm_record_data(recording_callback
, audio_data
[audio_tail
],
1001 BUFFER_SIZE
* sizeof (int16_t));
1005 /* The main program loop */
1006 void record_and_get_pitch(void)
1010 /* For tracking the latency */
1013 char debug_string[20];
1017 bool waiting
= false;
1020 backlight_force_on();
1026 while (audio_head
== audio_tail
&& !quit
) /* wait for the buffer to be filled */
1028 button
=pluginlib_getaction(HZ
/100, plugin_contexts
, PLA_ARRAY_COUNT
);
1037 rb
->pcm_stop_recording();
1038 quit
= main_menu() != 0;
1053 /* Only do the heavy lifting if the volume is high enough */
1054 if(buffer_magnitude(audio_data
[audio_head
]) >
1055 sqr(tuner_settings
.volume_threshold
*
1056 rb
->sound_max(SOUND_MIC_GAIN
)))
1061 #ifdef HAVE_SCHEDULER_BOOSTCTRL
1062 rb
->trigger_cpu_boost();
1065 /* This returns the period of the detected pitch in samples */
1066 period
= pitchyin(audio_data
[audio_head
], yin_buffer
);
1067 /* Hz = sample rate / period */
1068 if(fp_gt(period
, FP_ZERO
))
1070 display_frequency(fp_period2freq(period
));
1074 display_frequency(FP_ZERO
);
1077 else if(redraw
|| !waiting
)
1081 display_frequency(FP_ZERO
);
1082 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1083 rb
->cancel_cpu_boost();
1086 #else /* SIMULATOR */
1087 /* Display a preselected frequency */
1088 display_frequency(int2fixed(445));
1090 /* Move to next buffer if not empty (but empty *shouldn't* happen
1092 if (audio_head
!= audio_tail
)
1096 rb
->pcm_close_recording();
1097 #ifdef HAVE_SCHEDULER_BOOSTCTRL
1098 rb
->cancel_cpu_boost();
1101 backlight_use_settings();
1104 /* Init recording, tuning, and GUI */
1105 void init_everything(void)
1109 /* Stop all playback */
1110 rb
->plugin_get_audio_buffer(NULL
);
1112 /* --------- Init the audio recording ----------------- */
1113 rb
->audio_set_output_source(AUDIO_SRC_PLAYBACK
);
1114 rb
->audio_set_input_source(INPUT_TYPE
, SRCF_RECORDING
);
1116 /* set to maximum gain */
1117 rb
->audio_set_recording_gain(tuner_settings
.record_gain
,
1118 tuner_settings
.record_gain
,
1121 /* Highest C on piano is approx 4.186 kHz, so we need just over
1122 * 8.372 kHz to pass it. */
1123 sample_rate
= rb
->round_value_to_list32(9000, rb
->rec_freq_sampr
,
1124 REC_NUM_FREQ
, false);
1125 sample_rate
= rb
->rec_freq_sampr
[sample_rate
];
1126 rb
->pcm_set_frequency(sample_rate
);
1127 rb
->pcm_init_recording();
1131 front_color
= rb
->lcd_get_foreground();
1133 rb
->lcd_getstringsize("X", &font_w
, &font_h
);
1135 bar_x_0
= LCD_WIDTH
/ 2;
1137 lbl_x_minus_20
= (LCD_WIDTH
/ 2) -
1138 fixed2int(fp_mul(LCD_FACTOR
, int2fixed(20))) - font_w
;
1139 lbl_x_0
= (LCD_WIDTH
- font_w
) / 2;
1140 lbl_x_20
= (LCD_WIDTH
/ 2) +
1141 fixed2int(fp_mul(LCD_FACTOR
, int2fixed(20))) - font_w
;
1142 lbl_x_50
= LCD_WIDTH
- 2 * font_w
;
1144 bar_grad_y
= BAR_Y
- BAR_PADDING
- font_h
;
1145 /* Put the note right between the top and bottom text elements */
1146 note_y
= ((font_h
+ bar_grad_y
- note_bitmaps
.slide_height
) / 2);
1150 enum plugin_status
plugin_start(const void* parameter
) NO_PROF_ATTR
1155 record_and_get_pitch();