apps/gui/pitchscreen.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Björn Stenberg
  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
  22 #include <stdbool.h>
  23 #include <string.h>
  24 #include <stdio.h>
  25 #include <math.h>
  26 #include <stdlib.h> /* for abs() */
  27 #include "config.h"
  28 #include "action.h"
  29 #include "dsp.h"
  30 #include "sound.h"
  31 #include "pcmbuf.h"
  32 #include "lang.h"
  33 #include "icons.h"
  34 #include "screens.h"
  35 #include "viewport.h"
  36 #include "font.h"
  37 #include "system.h"
  38 #include "misc.h"
  39 #include "pitchscreen.h"
  40 #include "settings.h"
  41 #if CONFIG_CODEC == SWCODEC
  42 #include "tdspeed.h"
  43 #endif
  44
  45 #define ICON_BORDER 12 /* icons are currently 7x8, so add ~2 pixels  */
  46                        /*   on both sides when drawing */
  47
  48 #define PITCH_MAX         (200 * PITCH_SPEED_PRECISION)
  49 #define PITCH_MIN         (50 * PITCH_SPEED_PRECISION)
  50 #define PITCH_SMALL_DELTA (PITCH_SPEED_PRECISION / 10)      /* .1% */
  51 #define PITCH_BIG_DELTA   (PITCH_SPEED_PRECISION)           /*  1% */
  52 #define PITCH_NUDGE_DELTA (2 * PITCH_SPEED_PRECISION)       /*  2% */
  53
  54 #define SPEED_SMALL_DELTA (PITCH_SPEED_PRECISION / 10)      /* .1% */
  55 #define SPEED_BIG_DELTA   (PITCH_SPEED_PRECISION)           /*  1% */
  56
  57 #define SEMITONE_SMALL_DELTA (PITCH_SPEED_PRECISION / 10)  /* 10 cents   */
  58 #define SEMITONE_BIG_DELTA   PITCH_SPEED_PRECISION         /* 1 semitone */
  59
  60 enum
  61 {
  62     PITCH_TOP = 0,
  63     PITCH_MID,
  64     PITCH_BOTTOM,
  65     PITCH_ITEM_COUNT,
  66 };
  67
  68
  69 /* This is a table of semitone percentage values of the appropriate
  70    precision (based on PITCH_SPEED_PRECISION).  Note that these are
  71    all constant expressions, which will be evaluated at compile time,
  72    so no need to worry about how complex the expressions look.
  73    That's just to get the precision right.
  74
  75    I calculated these values, starting from 50, as
  76
  77    x(n) = 50 * 2^(n/12)
  78
  79    All that math in each entry simply converts the float constant
  80    to an integer equal to PITCH_SPEED_PRECISION times the float value,
  81    with as little precision loss as possible (i.e. correctly rounding
  82    the last digit).
  83 */
  84 #define TO_INT_WITH_PRECISION(x) \
  85     ( (unsigned short)(((x) * PITCH_SPEED_PRECISION * 10 + 5) / 10) )
  86
  87 static const unsigned short semitone_table[] =
  88 {
  89     TO_INT_WITH_PRECISION(50.00000000), /* Octave lower */
  90     TO_INT_WITH_PRECISION(52.97315472),
  91     TO_INT_WITH_PRECISION(56.12310242),
  92     TO_INT_WITH_PRECISION(59.46035575),
  93     TO_INT_WITH_PRECISION(62.99605249),
  94     TO_INT_WITH_PRECISION(66.74199271),
  95     TO_INT_WITH_PRECISION(70.71067812),
  96     TO_INT_WITH_PRECISION(74.91535384),
  97     TO_INT_WITH_PRECISION(79.37005260),
  98     TO_INT_WITH_PRECISION(84.08964153),
  99     TO_INT_WITH_PRECISION(89.08987181),
 100     TO_INT_WITH_PRECISION(94.38743127),
 101     TO_INT_WITH_PRECISION(100.0000000), /* Normal sound */
 102     TO_INT_WITH_PRECISION(105.9463094),
 103     TO_INT_WITH_PRECISION(112.2462048),
 104     TO_INT_WITH_PRECISION(118.9207115),
 105     TO_INT_WITH_PRECISION(125.9921049),
 106     TO_INT_WITH_PRECISION(133.4839854),
 107     TO_INT_WITH_PRECISION(141.4213562),
 108     TO_INT_WITH_PRECISION(149.8307077),
 109     TO_INT_WITH_PRECISION(158.7401052),
 110     TO_INT_WITH_PRECISION(168.1792831),
 111     TO_INT_WITH_PRECISION(178.1797436),
 112     TO_INT_WITH_PRECISION(188.7748625),
 113     TO_INT_WITH_PRECISION(200.0000000)  /* Octave higher */
 114 };
 115
 116 #define NUM_SEMITONES   ((int)(sizeof(semitone_table)/sizeof(semitone_table[0])))
 117 #define SEMITONE_END    (NUM_SEMITONES/2)
 118 #define SEMITONE_START  (-SEMITONE_END)
 119
 120 /* A table of values for approximating the cent curve with
 121    linear interpolation.  Multipy the next lowest semitone
 122    by this much to find the corresponding cent percentage.
 123
 124    These values were calculated as
 125    x(n) = 100 * 2^(n * 20/1200)
 126 */
 127
 128 static const unsigned short cent_interp[] =
 129 {
 130     TO_INT_WITH_PRECISION(100.0000000),
 131     TO_INT_WITH_PRECISION(101.1619440),
 132     TO_INT_WITH_PRECISION(102.3373892),
 133     TO_INT_WITH_PRECISION(103.5264924),
 134     TO_INT_WITH_PRECISION(104.7294123),
 135     /* this one's the next semitone but we have it here for convenience */
 136     TO_INT_WITH_PRECISION(105.9463094),
 137 };
 138
 139 /* Number of cents between entries in the cent_interp table */
 140 #define CENT_INTERP_INTERVAL 20
 141 #define CENT_INTERP_NUM      ((int)(sizeof(cent_interp)/sizeof(cent_interp[0])))
 142
 143 /* This stores whether the pitch and speed are at their own limits */
 144 /* or that of the timestretching algorithm                         */
 145 static bool at_limit = false;
 146
 147 /*
 148  *
 149  * The pitchscreen is divided into 3 viewports (each row is a viewport)
 150  * Then each viewport is again divided into 3 colums, each showsing some infos
 151  * Additionally, on touchscreen, each cell represents a button
 152  *
 153  * Below a sketch describing what each cell will show (what's drawn on it)
 154  * --------------------------
 155  * |      |        |        | <-- pitch up in the middle (text and button)
 156  * |      |        |        | <-- arrows for mode toggling on the sides for touchscreen
 157  * |------------------------|
 158  * |      |        |        | <-- semitone/speed up/down on the sides
 159  * |      |        |        | <-- reset pitch&speed in the middle
 160  * |------------------------|
 161  * |      |        |        | <-- pitch down in the middle
 162  * |      |        |        | <-- Two "OK" for exit on the sides for touchscreen
 163  * |------------------------|
 164  *
 165  *
 166  */
 167
 168 /*
 169  * Fixes the viewports so they represent the 3 rows, and adds a little margin
 170  * on all sides for the icons (which are drawn outside of the grid
 171  *
 172  * The modified viewports need to be passed to the touchscreen handling function
 173  **/
 174 static void pitchscreen_fix_viewports(struct viewport *parent,
 175         struct viewport pitch_viewports[PITCH_ITEM_COUNT])
 176 {
 177     int i, font_height;
 178     font_height = font_get(parent->font)->height;
 179     for (i = 0; i < PITCH_ITEM_COUNT; i++)
 180     {
 181         pitch_viewports[i] = *parent;
 182         pitch_viewports[i].height = parent->height / PITCH_ITEM_COUNT;
 183         pitch_viewports[i].x += ICON_BORDER;
 184         pitch_viewports[i].width -= 2*ICON_BORDER;
 185     }
 186     pitch_viewports[PITCH_TOP].y      += ICON_BORDER;
 187     pitch_viewports[PITCH_TOP].height -= ICON_BORDER;
 188
 189     if(pitch_viewports[PITCH_MID].height < font_height * 2)
 190         pitch_viewports[PITCH_MID].height = font_height * 2;
 191
 192     pitch_viewports[PITCH_MID].y = pitch_viewports[PITCH_TOP].y
 193                                  + pitch_viewports[PITCH_TOP].height;
 194
 195     pitch_viewports[PITCH_BOTTOM].y = pitch_viewports[PITCH_MID].y
 196                                     + pitch_viewports[PITCH_MID].height;
 197
 198     pitch_viewports[PITCH_BOTTOM].height -= ICON_BORDER;
 199 }
 200
 201 /* must be called before pitchscreen_draw, or within
 202  * since it neither clears nor updates the display */
 203 static void pitchscreen_draw_icons(struct screen *display,
 204                                    struct viewport *parent)
 205 {
 206     display->set_viewport(parent);
 207     display->mono_bitmap(bitmap_icons_7x8[Icon_UpArrow],
 208             parent->width/2 - 3,
 209             2, 7, 8);
 210     display->mono_bitmap(bitmap_icons_7x8[Icon_DownArrow],
 211             parent->width /2 - 3,
 212             parent->height - 10, 7, 8);
 213     display->mono_bitmap(bitmap_icons_7x8[Icon_FastForward],
 214             parent->width - 10,
 215             parent->height /2 - 4, 7, 8);
 216     display->mono_bitmap(bitmap_icons_7x8[Icon_FastBackward],
 217             2,
 218             parent->height /2 - 4, 7, 8);
 219     display->update_viewport();
 220 }
 221
 222 static void pitchscreen_draw(struct screen *display, int max_lines,
 223                              struct viewport pitch_viewports[PITCH_ITEM_COUNT],
 224                              int32_t pitch, int32_t semitone
 225 #if CONFIG_CODEC == SWCODEC
 226                              ,int32_t speed
 227 #endif
 228                              )
 229 {
 230     const char* ptr;
 231     char buf[32];
 232     int w, h;
 233     bool show_lang_pitch;
 234
 235      /* "Pitch up/Pitch down" - hide for a small screen,
 236       * the text is drawn centered automatically
 237       *
 238       * note: this assumes 5 lines always fit on a touchscreen (should be
 239       * reasonable) */
 240     if (max_lines >= 5)
 241     {
 242         int w, h;
 243         struct viewport *vp = &pitch_viewports[PITCH_TOP];
 244         display->set_viewport(vp);
 245         display->clear_viewport();
 246 #ifdef HAVE_TOUCHSCREEN
 247         /* two arrows in the top row, left and right column */
 248         char *arrows[] = { "<", ">"};
 249         display->getstringsize(arrows[0], &w, &h);
 250         display->putsxy(0, vp->height/2 - h/2, arrows[0]);
 251         display->putsxy(vp->width - w, vp->height/2 - h/2, arrows[1]);
 252 #endif
 253         /* UP: Pitch Up */
 254         if (global_settings.pitch_mode_semitone)
 255             ptr = str(LANG_PITCH_UP_SEMITONE);
 256         else
 257             ptr = str(LANG_PITCH_UP);
 258
 259         display->getstringsize(ptr, &w, NULL);
 260         /* draw text */
 261         display->putsxy(vp->width/2 - w/2, 0, ptr);
 262         display->update_viewport();
 263
 264         /* DOWN: Pitch Down */
 265         vp = &pitch_viewports[PITCH_BOTTOM];
 266         display->set_viewport(vp);
 267         display->clear_viewport();
 268
 269 #ifdef HAVE_TOUCHSCREEN
 270         ptr = str(LANG_KBD_OK);
 271         display->getstringsize(ptr, &w, &h);
 272         /* one OK in the middle first column of the vp (at half height) */
 273         display->putsxy(vp->width/6 - w/2, vp->height/2 - h/2, ptr);
 274         /* one OK in the middle of the last column of the vp (at half height) */
 275         display->putsxy(5*vp->width/6 - w/2, vp->height/2 - h/2, ptr);
 276 #endif
 277         if (global_settings.pitch_mode_semitone)
 278             ptr = str(LANG_PITCH_DOWN_SEMITONE);
 279         else
 280             ptr = str(LANG_PITCH_DOWN);
 281         display->getstringsize(ptr, &w, &h);
 282         /* draw text */
 283         display->putsxy(vp->width/2 - w/2, vp->height - h, ptr);
 284         display->update_viewport();
 285     }
 286
 287     /* Middle section */
 288     display->set_viewport(&pitch_viewports[PITCH_MID]);
 289     display->clear_viewport();
 290     int width_used = 0;
 291
 292     /* Middle section upper line - hide for a small screen */
 293     if ((show_lang_pitch = (max_lines >= 3)))
 294     {
 295 #if CONFIG_CODEC == SWCODEC
 296         if(global_settings.pitch_mode_timestretch)
 297         {
 298             /* Pitch:XXX.X% */
 299             if(global_settings.pitch_mode_semitone)
 300             {
 301                 snprintf(buf, sizeof(buf), "%s: %s%d.%02d", str(LANG_PITCH),
 302                          semitone >= 0 ? "+" : "-",
 303                          abs(semitone / PITCH_SPEED_PRECISION),
 304                          abs((semitone % PITCH_SPEED_PRECISION) /
 305                                          (PITCH_SPEED_PRECISION / 100))
 306                         );
 307             }
 308             else
 309             {
 310                 snprintf(buf, sizeof(buf), "%s: %ld.%ld%%", str(LANG_PITCH),
 311                          pitch / PITCH_SPEED_PRECISION,
 312                          (pitch % PITCH_SPEED_PRECISION) /
 313                          (PITCH_SPEED_PRECISION / 10));
 314             }
 315         }
 316         else
 317 #endif
 318         {
 319             /* Rate */
 320             snprintf(buf, sizeof(buf), "%s:", str(LANG_PLAYBACK_RATE));
 321         }
 322         display->getstringsize(buf, &w, &h);
 323         display->putsxy((pitch_viewports[PITCH_MID].width  / 2) - (w / 2),
 324                         (pitch_viewports[PITCH_MID].height / 2) - h, buf);
 325         if (w > width_used)
 326             width_used = w;
 327     }
 328
 329     /* Middle section lower line */
 330     /* "Speed:XXX%" */
 331 #if CONFIG_CODEC == SWCODEC
 332     if(global_settings.pitch_mode_timestretch)
 333     {
 334         snprintf(buf, sizeof(buf), "%s: %ld.%ld%%", str(LANG_SPEED),
 335                  speed / PITCH_SPEED_PRECISION,
 336                  (speed % PITCH_SPEED_PRECISION) / (PITCH_SPEED_PRECISION / 10));
 337     }
 338     else
 339 #endif
 340     {
 341         if(global_settings.pitch_mode_semitone)
 342         {
 343             snprintf(buf, sizeof(buf), "%s%d.%02d",
 344                      semitone >= 0 ? "+" : "-",
 345                      abs(semitone / PITCH_SPEED_PRECISION),
 346                      abs((semitone % PITCH_SPEED_PRECISION) /
 347                                      (PITCH_SPEED_PRECISION / 100))
 348                     );
 349         }
 350         else
 351         {
 352             snprintf(buf, sizeof(buf), "%ld.%ld%%",
 353                      pitch / PITCH_SPEED_PRECISION,
 354                      (pitch  % PITCH_SPEED_PRECISION) / (PITCH_SPEED_PRECISION / 10));
 355         }
 356     }
 357
 358     display->getstringsize(buf, &w, &h);
 359     display->putsxy((pitch_viewports[PITCH_MID].width / 2) - (w / 2),
 360         show_lang_pitch ? (pitch_viewports[PITCH_MID].height / 2) :
 361                           (pitch_viewports[PITCH_MID].height / 2) - (h / 2),
 362         buf);
 363     if (w > width_used)
 364         width_used = w;
 365
 366     /* "limit" and "timestretch" labels */
 367     if (max_lines >= 7)
 368     {
 369         if(at_limit)
 370         {
 371             const char * const p = str(LANG_STRETCH_LIMIT);
 372             display->getstringsize(p, &w, &h);
 373             display->putsxy((pitch_viewports[PITCH_MID].width / 2) - (w / 2),
 374                             (pitch_viewports[PITCH_MID].height / 2) + h, p);
 375             if (w > width_used)
 376                 width_used = w;
 377         }
 378     }
 379
 380     /* Middle section left/right labels */
 381     const char *leftlabel = "-2%";
 382     const char *rightlabel = "+2%";
 383 #if CONFIG_CODEC == SWCODEC
 384     if (global_settings.pitch_mode_timestretch)
 385     {
 386         leftlabel = "<<";
 387         rightlabel = ">>";
 388     }
 389 #endif
 390
 391     /* Only display if they fit */
 392     display->getstringsize(leftlabel, &w, &h);
 393     width_used += w;
 394     display->getstringsize(rightlabel, &w, &h);
 395     width_used += w;
 396
 397     if (width_used <= pitch_viewports[PITCH_MID].width)
 398     {
 399         display->putsxy(0, (pitch_viewports[PITCH_MID].height / 2) - (h / 2),
 400                         leftlabel);
 401         display->putsxy((pitch_viewports[PITCH_MID].width - w),
 402                         (pitch_viewports[PITCH_MID].height / 2) - (h / 2),
 403                         rightlabel);
 404     }
 405     display->update_viewport();
 406     display->set_viewport(NULL);
 407 }
 408
 409 static int32_t pitch_increase(int32_t pitch, int32_t pitch_delta, bool allow_cutoff
 410 #if CONFIG_CODEC == SWCODEC
 411                           /* need this to maintain correct pitch/speed caps */
 412                           , int32_t speed
 413 #endif
 414                           )
 415 {
 416     int32_t new_pitch;
 417 #if CONFIG_CODEC == SWCODEC
 418     int32_t new_stretch;
 419 #endif
 420     at_limit = false;
 421
 422     if (pitch_delta < 0)
 423     {
 424         /* for large jumps, snap up to whole numbers */
 425         if(allow_cutoff && pitch_delta <= -PITCH_SPEED_PRECISION &&
 426            (pitch + pitch_delta) % PITCH_SPEED_PRECISION != 0)
 427         {
 428             pitch_delta += PITCH_SPEED_PRECISION - ((pitch + pitch_delta) % PITCH_SPEED_PRECISION);
 429         }
 430
 431         new_pitch = pitch + pitch_delta;
 432
 433         if (new_pitch < PITCH_MIN)
 434         {
 435             if (!allow_cutoff)
 436             {
 437                 return pitch;
 438             }
 439             new_pitch = PITCH_MIN;
 440             at_limit = true;
 441         }
 442     }
 443     else if (pitch_delta > 0)
 444     {
 445         /* for large jumps, snap down to whole numbers */
 446         if(allow_cutoff && pitch_delta >= PITCH_SPEED_PRECISION &&
 447            (pitch + pitch_delta) % PITCH_SPEED_PRECISION != 0)
 448         {
 449             pitch_delta -= (pitch + pitch_delta) % PITCH_SPEED_PRECISION;
 450         }
 451
 452         new_pitch = pitch + pitch_delta;
 453
 454         if (new_pitch > PITCH_MAX)
 455         {
 456             if (!allow_cutoff)
 457                 return pitch;
 458             new_pitch = PITCH_MAX;
 459             at_limit = true;
 460         }
 461     }
 462     else
 463     {
 464         /* pitch_delta == 0 -> no real change */
 465         return pitch;
 466     }
 467 #if CONFIG_CODEC == SWCODEC
 468     if (dsp_timestretch_available())
 469     {
 470         /* increase the multiple to increase precision of this calculation */
 471         new_stretch = GET_STRETCH(new_pitch, speed);
 472         if(new_stretch < STRETCH_MIN)
 473         {
 474             /* we have to ignore allow_cutoff, because we can't have the */
 475             /* stretch go higher than STRETCH_MAX                        */
 476             new_pitch = GET_PITCH(speed, STRETCH_MIN);
 477         }
 478         else if(new_stretch > STRETCH_MAX)
 479         {
 480             /* we have to ignore allow_cutoff, because we can't have the */
 481             /* stretch go higher than STRETCH_MAX                        */
 482             new_pitch = GET_PITCH(speed, STRETCH_MAX);
 483         }
 484
 485         if(new_stretch >= STRETCH_MAX ||
 486            new_stretch <= STRETCH_MIN)
 487         {
 488             at_limit = true;
 489         }
 490     }
 491 #endif
 492
 493     sound_set_pitch(new_pitch);
 494
 495     return new_pitch;
 496 }
 497
 498 static int32_t get_semitone_from_pitch(int32_t pitch)
 499 {
 500     int semitone = 0;
 501     int32_t fractional_index = 0;
 502
 503     while(semitone < NUM_SEMITONES - 1 &&
 504           pitch >= semitone_table[semitone + 1])
 505     {
 506         semitone++;
 507     }
 508
 509
 510     /* now find the fractional part */
 511     while(pitch > (cent_interp[fractional_index + 1] *
 512                    semitone_table[semitone] / PITCH_SPEED_100))
 513     {
 514         /* Check to make sure fractional_index isn't too big */
 515         /* This should never happen. */
 516         if(fractional_index >= CENT_INTERP_NUM - 1)
 517         {
 518             break;
 519         }
 520         fractional_index++;
 521     }
 522
 523     int32_t semitone_pitch_a = cent_interp[fractional_index] *
 524                                semitone_table[semitone] /
 525                                PITCH_SPEED_100;
 526     int32_t semitone_pitch_b = cent_interp[fractional_index + 1] *
 527                                semitone_table[semitone] /
 528                                PITCH_SPEED_100;
 529     /* this will be the integer offset from the cent_interp entry */
 530     int32_t semitone_frac_ofs = (pitch - semitone_pitch_a) * CENT_INTERP_INTERVAL /
 531                             (semitone_pitch_b - semitone_pitch_a);
 532     semitone = (semitone + SEMITONE_START) * PITCH_SPEED_PRECISION +
 533                      fractional_index * CENT_INTERP_INTERVAL +
 534                      semitone_frac_ofs;
 535
 536     return semitone;
 537 }
 538
 539 static int32_t get_pitch_from_semitone(int32_t semitone)
 540 {
 541     int32_t adjusted_semitone = semitone - SEMITONE_START * PITCH_SPEED_PRECISION;
 542
 543     /* Find the index into the semitone table */
 544     int32_t semitone_index = (adjusted_semitone / PITCH_SPEED_PRECISION);
 545
 546     /* set pitch to the semitone's integer part value */
 547     int32_t pitch = semitone_table[semitone_index];
 548     /* get the range of the cent modification for future calculation */
 549     int32_t pitch_mod_a =
 550         cent_interp[(adjusted_semitone % PITCH_SPEED_PRECISION) /
 551                     CENT_INTERP_INTERVAL];
 552     int32_t pitch_mod_b =
 553         cent_interp[(adjusted_semitone % PITCH_SPEED_PRECISION) /
 554                     CENT_INTERP_INTERVAL + 1];
 555     /* figure out the cent mod amount based on the semitone fractional value */
 556     int32_t pitch_mod = pitch_mod_a + (pitch_mod_b - pitch_mod_a) *
 557                    (adjusted_semitone % CENT_INTERP_INTERVAL) / CENT_INTERP_INTERVAL;
 558
 559     /* modify pitch based on the mod amount we just calculated */
 560     return (pitch * pitch_mod  + PITCH_SPEED_100 / 2) / PITCH_SPEED_100;
 561 }
 562
 563 static int32_t pitch_increase_semitone(int32_t pitch,
 564                                        int32_t current_semitone,
 565                                        int32_t semitone_delta
 566 #if CONFIG_CODEC == SWCODEC
 567                                        , int32_t speed
 568 #endif
 569                                       )
 570 {
 571     int32_t new_semitone = current_semitone;
 572
 573     /* snap to the delta interval */
 574     if(current_semitone % semitone_delta != 0)
 575     {
 576         if(current_semitone > 0 && semitone_delta > 0)
 577             new_semitone += semitone_delta;
 578         else if(current_semitone < 0 && semitone_delta < 0)
 579             new_semitone += semitone_delta;
 580
 581         new_semitone -= new_semitone % semitone_delta;
 582     }
 583     else
 584         new_semitone += semitone_delta;
 585
 586     /* clamp the pitch so it doesn't go beyond the pitch limits */
 587     if(new_semitone < (SEMITONE_START * PITCH_SPEED_PRECISION))
 588     {
 589         new_semitone = SEMITONE_START * PITCH_SPEED_PRECISION;
 590         at_limit = true;
 591     }
 592     else if(new_semitone > (SEMITONE_END * PITCH_SPEED_PRECISION))
 593     {
 594         new_semitone = SEMITONE_END * PITCH_SPEED_PRECISION;
 595         at_limit = true;
 596     }
 597
 598     int32_t new_pitch = get_pitch_from_semitone(new_semitone);
 599
 600 #if CONFIG_CODEC == SWCODEC
 601     int32_t new_stretch = GET_STRETCH(new_pitch, speed);
 602
 603     /* clamp the pitch so it doesn't go beyond the stretch limits */
 604     if( new_stretch > STRETCH_MAX)
 605     {
 606         new_pitch = GET_PITCH(speed, STRETCH_MAX);
 607         new_semitone = get_semitone_from_pitch(new_pitch);
 608         at_limit = true;
 609     }
 610     else if (new_stretch < STRETCH_MIN)
 611     {
 612         new_pitch = GET_PITCH(speed, STRETCH_MIN);
 613         new_semitone = get_semitone_from_pitch(new_pitch);
 614         at_limit = true;
 615     }
 616 #endif
 617
 618     pitch_increase(pitch, new_pitch - pitch, false
 619 #if CONFIG_CODEC == SWCODEC
 620                    , speed
 621 #endif
 622                    );
 623
 624     return new_semitone;
 625 }
 626
 627 #ifdef HAVE_TOUCHSCREEN
 628 /*
 629  * Check for touchscreen presses as per sketch above in this file
 630  *
 631  * goes through each row of the, checks whether the touchscreen
 632  * was pressed in it. Then it looks the columns of each row for specific actions
 633  */
 634 static int pitchscreen_do_touchscreen(struct viewport vps[])
 635 {
 636     short x, y;
 637     struct viewport *this_vp = &vps[PITCH_TOP];
 638     int ret;
 639     static bool wait_for_release = false;
 640     ret = action_get_touchscreen_press_in_vp(&x, &y, this_vp);
 641
 642     /* top row */
 643     if (ret > ACTION_UNKNOWN)
 644     {   /* press on top row, left or right column
 645          * only toggle mode if released */
 646         int column = this_vp->width / 3;
 647         if ((x < column || x > (2*column)) && (ret == BUTTON_REL))
 648             return ACTION_PS_TOGGLE_MODE;
 649
 650
 651         else if (x >= column && x <= (2*column))
 652         {   /* center column pressed */
 653             if (ret == BUTTON_REPEAT)
 654                 return ACTION_PS_INC_BIG;
 655             else if (ret & BUTTON_REL)
 656                 return ACTION_PS_INC_SMALL;
 657         }
 658         return ACTION_NONE;
 659     }
 660
 661     /* now the center row */
 662     this_vp = &vps[PITCH_MID];
 663     ret = action_get_touchscreen_press_in_vp(&x, &y, this_vp);
 664
 665     if (ret > ACTION_UNKNOWN)
 666     {
 667         int column = this_vp->width / 3;
 668
 669         if (x < column)
 670         {   /* left column */
 671             if (ret & BUTTON_REL)
 672             {
 673                 wait_for_release = false;
 674                 return ACTION_PS_NUDGE_LEFTOFF;
 675             }
 676             else if (ret & BUTTON_REPEAT)
 677                 return ACTION_PS_SLOWER;
 678             if (!wait_for_release)
 679             {
 680                 wait_for_release = true;
 681                 return ACTION_PS_NUDGE_LEFT;
 682             }
 683         }
 684         else if (x > (2*column))
 685         {   /* right column */
 686             debugf("%s(): %8x", __func__, ret);
 687             if (ret & BUTTON_REL)
 688             {
 689                 wait_for_release = false;
 690                 return ACTION_PS_NUDGE_LEFTOFF;
 691             }
 692             else if (ret & BUTTON_REPEAT)
 693                 return ACTION_PS_FASTER;
 694             if (!wait_for_release)
 695             {
 696                 wait_for_release = true;
 697                 return ACTION_PS_NUDGE_LEFT;
 698             }
 699         }
 700         else
 701             /* center column was pressed */
 702             return ACTION_PS_RESET;
 703     }
 704
 705     /* now the bottom row */
 706     this_vp = &vps[PITCH_BOTTOM];
 707     ret = action_get_touchscreen_press_in_vp(&x, &y, this_vp);
 708
 709     if (ret > ACTION_UNKNOWN)
 710     {
 711         int column = this_vp->width / 3;
 712
 713         /* left or right column is exit */
 714         if ((x < column || x > (2*column)) && (ret == BUTTON_REL))
 715             return ACTION_PS_EXIT;
 716         else if (x >= column && x <= (2*column))
 717         {   /* center column was pressed */
 718             if (ret & BUTTON_REPEAT)
 719                 return ACTION_PS_DEC_BIG;
 720             else if (ret & BUTTON_REL)
 721                 return ACTION_PS_DEC_SMALL;
 722         }
 723         return ACTION_NONE;
 724     }
 725     return ACTION_NONE;
 726 }
 727
 728 #endif
 729 /*
 730     returns:
 731     0 on exit
 732     1 if USB was connected
 733 */
 734
 735 int gui_syncpitchscreen_run(void)
 736 {
 737     int button, i;
 738     int32_t pitch = sound_get_pitch();
 739     int32_t semitone;
 740
 741     int32_t new_pitch;
 742     int32_t pitch_delta;
 743     bool nudged = false;
 744     bool exit = false;
 745     /* should maybe be passed per parameter later, not needed for now */
 746     struct viewport parent[NB_SCREENS];
 747     struct viewport pitch_viewports[NB_SCREENS][PITCH_ITEM_COUNT];
 748     int max_lines[NB_SCREENS];
 749
 750 #if CONFIG_CODEC == SWCODEC
 751     int32_t new_speed = 0, new_stretch;
 752
 753     /* the speed variable holds the apparent speed of the playback */
 754     int32_t speed;
 755     if (dsp_timestretch_available())
 756     {
 757         speed = GET_SPEED(pitch, dsp_get_timestretch());
 758     }
 759     else
 760     {
 761         speed = pitch;
 762     }
 763
 764     /* Figure out whether to be in timestretch mode */
 765     if (global_settings.pitch_mode_timestretch && !dsp_timestretch_available())
 766     {
 767         global_settings.pitch_mode_timestretch = false;
 768         settings_save();
 769     }
 770 #endif
 771
 772     /* set the semitone index based on the current pitch */
 773     semitone = get_semitone_from_pitch(pitch);
 774
 775     /* initialize pitchscreen vps */
 776     FOR_NB_SCREENS(i)
 777     {
 778         viewport_set_defaults(&parent[i], i);
 779         max_lines[i] = viewport_get_nb_lines(&parent[i]);
 780         pitchscreen_fix_viewports(&parent[i], pitch_viewports[i]);
 781         screens[i].set_viewport(&parent[i]);
 782         screens[i].clear_viewport();
 783
 784         /* also, draw the icons now, it's only needed once */
 785         pitchscreen_draw_icons(&screens[i], &parent[i]);
 786     }
 787 #if CONFIG_CODEC == SWCODEC
 788     pcmbuf_set_low_latency(true);
 789 #endif
 790
 791     while (!exit)
 792     {
 793         FOR_NB_SCREENS(i)
 794             pitchscreen_draw(&screens[i], max_lines[i],
 795                               pitch_viewports[i], pitch, semitone
 796 #if CONFIG_CODEC == SWCODEC
 797                               , speed
 798 #endif
 799                               );
 800         pitch_delta = 0;
 801 #if CONFIG_CODEC == SWCODEC
 802         new_speed = 0;
 803 #endif
 804         button = get_action(CONTEXT_PITCHSCREEN, HZ);
 805
 806 #ifdef HAVE_TOUCHSCREEN
 807         if (button == ACTION_TOUCHSCREEN)
 808         {
 809             FOR_NB_SCREENS(i)
 810                 button = pitchscreen_do_touchscreen(pitch_viewports[i]);
 811         }
 812 #endif
 813         switch (button)
 814         {
 815             case ACTION_PS_INC_SMALL:
 816                 if(global_settings.pitch_mode_semitone)
 817                     pitch_delta = SEMITONE_SMALL_DELTA;
 818                 else
 819                     pitch_delta = PITCH_SMALL_DELTA;
 820                 break;
 821
 822             case ACTION_PS_INC_BIG:
 823                 if(global_settings.pitch_mode_semitone)
 824                     pitch_delta = SEMITONE_BIG_DELTA;
 825                 else
 826                     pitch_delta = PITCH_BIG_DELTA;
 827                 break;
 828
 829             case ACTION_PS_DEC_SMALL:
 830                 if(global_settings.pitch_mode_semitone)
 831                     pitch_delta = -SEMITONE_SMALL_DELTA;
 832                 else
 833                     pitch_delta = -PITCH_SMALL_DELTA;
 834                 break;
 835
 836             case ACTION_PS_DEC_BIG:
 837                 if(global_settings.pitch_mode_semitone)
 838                     pitch_delta = -SEMITONE_BIG_DELTA;
 839                 else
 840                     pitch_delta = -PITCH_BIG_DELTA;
 841                 break;
 842
 843             case ACTION_PS_NUDGE_RIGHT:
 844 #if CONFIG_CODEC == SWCODEC
 845                 if (!global_settings.pitch_mode_timestretch)
 846                 {
 847 #endif
 848                     new_pitch = pitch_increase(pitch, PITCH_NUDGE_DELTA, false
 849 #if CONFIG_CODEC == SWCODEC
 850                                                , speed
 851 #endif
 852                         );
 853                     nudged = (new_pitch != pitch);
 854                     pitch = new_pitch;
 855                     semitone = get_semitone_from_pitch(pitch);
 856 #if CONFIG_CODEC == SWCODEC
 857                     speed = pitch;
 858 #endif
 859                     break;
 860 #if CONFIG_CODEC == SWCODEC
 861                 }
 862                 else
 863                 {
 864                     new_speed = speed + SPEED_SMALL_DELTA;
 865                     at_limit = false;
 866                 }
 867                 break;
 868
 869             case ACTION_PS_FASTER:
 870                 if (global_settings.pitch_mode_timestretch)
 871                 {
 872                     new_speed = speed + SPEED_BIG_DELTA;
 873                     /* snap to whole numbers */
 874                     if(new_speed % PITCH_SPEED_PRECISION != 0)
 875                         new_speed -= new_speed % PITCH_SPEED_PRECISION;
 876                     at_limit = false;
 877                 }
 878                 break;
 879 #endif
 880
 881             case ACTION_PS_NUDGE_RIGHTOFF:
 882                 if (nudged)
 883                 {
 884                     pitch = pitch_increase(pitch, -PITCH_NUDGE_DELTA, false
 885 #if CONFIG_CODEC == SWCODEC
 886                                            , speed
 887 #endif
 888                         );
 889 #if CONFIG_CODEC == SWCODEC
 890                     speed = pitch;
 891 #endif
 892                     semitone = get_semitone_from_pitch(pitch);
 893                     nudged = false;
 894                 }
 895                 break;
 896
 897             case ACTION_PS_NUDGE_LEFT:
 898 #if CONFIG_CODEC == SWCODEC
 899                 if (!global_settings.pitch_mode_timestretch)
 900                 {
 901 #endif
 902                     new_pitch = pitch_increase(pitch, -PITCH_NUDGE_DELTA, false
 903 #if CONFIG_CODEC == SWCODEC
 904                                                , speed
 905 #endif
 906                         );
 907                     nudged = (new_pitch != pitch);
 908                     pitch = new_pitch;
 909                     semitone = get_semitone_from_pitch(pitch);
 910 #if CONFIG_CODEC == SWCODEC
 911                     speed = pitch;
 912 #endif
 913                     break;
 914 #if CONFIG_CODEC == SWCODEC
 915                 }
 916                 else
 917                 {
 918                     new_speed = speed - SPEED_SMALL_DELTA;
 919                     at_limit = false;
 920                 }
 921                 break;
 922
 923             case ACTION_PS_SLOWER:
 924                 if (global_settings.pitch_mode_timestretch)
 925                 {
 926                     new_speed = speed - SPEED_BIG_DELTA;
 927                     /* snap to whole numbers */
 928                     if(new_speed % PITCH_SPEED_PRECISION != 0)
 929                         new_speed += PITCH_SPEED_PRECISION - speed % PITCH_SPEED_PRECISION;
 930                     at_limit = false;
 931                 }
 932                 break;
 933 #endif
 934
 935             case ACTION_PS_NUDGE_LEFTOFF:
 936                 if (nudged)
 937                 {
 938                     pitch = pitch_increase(pitch, PITCH_NUDGE_DELTA, false
 939 #if CONFIG_CODEC == SWCODEC
 940                                            , speed
 941 #endif
 942                         );
 943 #if CONFIG_CODEC == SWCODEC
 944                     speed = pitch;
 945 #endif
 946                     semitone = get_semitone_from_pitch(pitch);
 947                     nudged = false;
 948                 }
 949                 break;
 950
 951             case ACTION_PS_RESET:
 952                 pitch = PITCH_SPEED_100;
 953                 sound_set_pitch(pitch);
 954 #if CONFIG_CODEC == SWCODEC
 955                 speed = PITCH_SPEED_100;
 956                 if (dsp_timestretch_available())
 957                 {
 958                     dsp_set_timestretch(PITCH_SPEED_100);
 959                     at_limit = false;
 960                 }
 961 #endif
 962                 semitone = get_semitone_from_pitch(pitch);
 963                 break;
 964
 965             case ACTION_PS_TOGGLE_MODE:
 966                 global_settings.pitch_mode_semitone = !global_settings.pitch_mode_semitone;
 967 #if CONFIG_CODEC == SWCODEC
 968
 969                 if (dsp_timestretch_available() && !global_settings.pitch_mode_semitone)
 970                 {
 971                     global_settings.pitch_mode_timestretch = !global_settings.pitch_mode_timestretch;
 972                     if(!global_settings.pitch_mode_timestretch)
 973                     {
 974                         /* no longer in timestretch mode.  Reset speed */
 975                         speed = pitch;
 976                         dsp_set_timestretch(PITCH_SPEED_100);
 977                     }
 978                 }
 979                 settings_save();
 980 #endif
 981                 break;
 982
 983             case ACTION_PS_EXIT:
 984                 exit = true;
 985                 break;
 986
 987             default:
 988                 if (default_event_handler(button) == SYS_USB_CONNECTED)
 989                     return 1;
 990                 break;
 991         }
 992         if (pitch_delta)
 993         {
 994             if (global_settings.pitch_mode_semitone)
 995             {
 996                 semitone = pitch_increase_semitone(pitch, semitone, pitch_delta
 997 #if CONFIG_CODEC == SWCODEC
 998                                                 , speed
 999 #endif
1000                 );
1001                 pitch = get_pitch_from_semitone(semitone);
1002             }
1003             else
1004             {
1005                 pitch = pitch_increase(pitch, pitch_delta, true
1006 #if CONFIG_CODEC == SWCODEC
1007                                        , speed
1008 #endif
1009                 );
1010                 semitone = get_semitone_from_pitch(pitch);
1011             }
1012 #if CONFIG_CODEC == SWCODEC
1013             if (global_settings.pitch_mode_timestretch)
1014             {
1015                 /* do this to make sure we properly obey the stretch limits */
1016                 new_speed = speed;
1017             }
1018             else
1019             {
1020                 speed = pitch;
1021             }
1022 #endif
1023         }
1024
1025 #if CONFIG_CODEC == SWCODEC
1026         if(new_speed)
1027         {
1028             new_stretch = GET_STRETCH(pitch, new_speed);
1029
1030             /* limit the amount of stretch */
1031             if(new_stretch > STRETCH_MAX)
1032             {
1033                 new_stretch = STRETCH_MAX;
1034                 new_speed = GET_SPEED(pitch, new_stretch);
1035             }
1036             else if(new_stretch < STRETCH_MIN)
1037             {
1038                 new_stretch = STRETCH_MIN;
1039                 new_speed = GET_SPEED(pitch, new_stretch);
1040             }
1041
1042             new_stretch = GET_STRETCH(pitch, new_speed);
1043             if(new_stretch >= STRETCH_MAX ||
1044                new_stretch <= STRETCH_MIN)
1045             {
1046                 at_limit = true;
1047             }
1048
1049             /* set the amount of stretch */
1050             dsp_set_timestretch(new_stretch);
1051
1052             /* update the speed variable with the new speed */
1053             speed = new_speed;
1054
1055             /* Reset new_speed so we only call dsp_set_timestretch */
1056             /* when needed                                         */
1057             new_speed = 0;
1058         }
1059 #endif
1060     }
1061 #if CONFIG_CODEC == SWCODEC
1062     pcmbuf_set_low_latency(false);
1063 #endif
1064     return 0;
1065 }