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     ret = action_get_touchscreen_press_in_vp(&x, &y, this_vp);
 640
 641     /* top row */
 642     if (ret > ACTION_UNKNOWN)
 643     {   /* press on top row, left or right column
 644          * only toggle mode if released */
 645         int column = this_vp->width / 3;
 646         if ((x < column || x > (2*column)) && (ret == BUTTON_REL))
 647             return ACTION_PS_TOGGLE_MODE;
 648
 649
 650         else if (x >= column && x <= (2*column))
 651         {   /* center column pressed */
 652             if (ret == BUTTON_REPEAT)
 653                 return ACTION_PS_INC_BIG;
 654             else if (ret == BUTTON_TOUCHSCREEN)
 655                 return ACTION_PS_INC_SMALL;
 656         }
 657         return ACTION_NONE;
 658     }
 659
 660     /* now the center row */
 661     this_vp = &vps[PITCH_MID];
 662     ret = action_get_touchscreen_press_in_vp(&x, &y, this_vp);
 663
 664     if (ret > ACTION_UNKNOWN)
 665     {
 666         int column = this_vp->width / 3;
 667
 668         if (x < column)
 669         {   /* left column */
 670             if (ret & BUTTON_REL)
 671                 return ACTION_PS_NUDGE_LEFTOFF;
 672             else if (ret & BUTTON_REPEAT)
 673                 return ACTION_PS_SLOWER;
 674             return ACTION_PS_NUDGE_LEFT;
 675         }
 676         else if (x > (2*column))
 677         {   /* right column */
 678             if (ret & BUTTON_REL)
 679                 return ACTION_PS_NUDGE_LEFTOFF;
 680             else if (ret & BUTTON_REPEAT)
 681                 return ACTION_PS_FASTER;
 682             return ACTION_PS_NUDGE_LEFT;
 683         }
 684         /* center column was pressed */
 685         return ACTION_PS_RESET;
 686     }
 687
 688     /* now the bottom row */
 689     this_vp = &vps[PITCH_BOTTOM];
 690     ret = action_get_touchscreen_press_in_vp(&x, &y, this_vp);
 691
 692     if (ret > ACTION_UNKNOWN)
 693     {
 694         int column = this_vp->width / 3;
 695
 696         /* left or right column is exit */
 697         if ((x < column || x > (2*column)) && (ret == BUTTON_REL))
 698             return ACTION_PS_EXIT;
 699         else if (x >= column && x <= (2*column))
 700         {   /* center column was pressed */
 701             if (ret == BUTTON_REPEAT)
 702                 return ACTION_PS_DEC_BIG;
 703             else if (ret == BUTTON_TOUCHSCREEN)
 704                 return ACTION_PS_DEC_SMALL;
 705         }
 706         return ACTION_NONE;
 707     }
 708     return ACTION_NONE;
 709 }
 710
 711 #endif
 712 /*
 713     returns:
 714     0 on exit
 715     1 if USB was connected
 716 */
 717
 718 int gui_syncpitchscreen_run(void)
 719 {
 720     int button, i;
 721     int32_t pitch = sound_get_pitch();
 722     int32_t semitone;
 723
 724     int32_t new_pitch;
 725     int32_t pitch_delta;
 726     bool nudged = false;
 727     bool exit = false;
 728     /* should maybe be passed per parameter later, not needed for now */
 729     struct viewport parent[NB_SCREENS];
 730     struct viewport pitch_viewports[NB_SCREENS][PITCH_ITEM_COUNT];
 731     int max_lines[NB_SCREENS];
 732
 733 #if CONFIG_CODEC == SWCODEC
 734     int32_t new_speed = 0, new_stretch;
 735
 736     /* the speed variable holds the apparent speed of the playback */
 737     int32_t speed;
 738     if (dsp_timestretch_available())
 739     {
 740         speed = GET_SPEED(pitch, dsp_get_timestretch());
 741     }
 742     else
 743     {
 744         speed = pitch;
 745     }
 746
 747     /* Figure out whether to be in timestretch mode */
 748     if (global_settings.pitch_mode_timestretch && !dsp_timestretch_available())
 749     {
 750         global_settings.pitch_mode_timestretch = false;
 751         settings_save();
 752     }
 753 #endif
 754
 755     /* set the semitone index based on the current pitch */
 756     semitone = get_semitone_from_pitch(pitch);
 757
 758     /* initialize pitchscreen vps */
 759     FOR_NB_SCREENS(i)
 760     {
 761         viewport_set_defaults(&parent[i], i);
 762         max_lines[i] = viewport_get_nb_lines(&parent[i]);
 763         pitchscreen_fix_viewports(&parent[i], pitch_viewports[i]);
 764         screens[i].set_viewport(&parent[i]);
 765         screens[i].clear_viewport();
 766
 767         /* also, draw the icons now, it's only needed once */
 768         pitchscreen_draw_icons(&screens[i], &parent[i]);
 769     }
 770 #if CONFIG_CODEC == SWCODEC
 771     pcmbuf_set_low_latency(true);
 772 #endif
 773
 774     while (!exit)
 775     {
 776         FOR_NB_SCREENS(i)
 777             pitchscreen_draw(&screens[i], max_lines[i],
 778                               pitch_viewports[i], pitch, semitone
 779 #if CONFIG_CODEC == SWCODEC
 780                               , speed
 781 #endif
 782                               );
 783         pitch_delta = 0;
 784 #if CONFIG_CODEC == SWCODEC
 785         new_speed = 0;
 786 #endif
 787         button = get_action(CONTEXT_PITCHSCREEN, HZ);
 788
 789 #ifdef HAVE_TOUCHSCREEN
 790         if (button == ACTION_TOUCHSCREEN)
 791         {
 792             FOR_NB_SCREENS(i)
 793                 button = pitchscreen_do_touchscreen(pitch_viewports[i]);
 794         }
 795 #endif
 796         switch (button)
 797         {
 798             case ACTION_PS_INC_SMALL:
 799                 if(global_settings.pitch_mode_semitone)
 800                     pitch_delta = SEMITONE_SMALL_DELTA;
 801                 else
 802                     pitch_delta = PITCH_SMALL_DELTA;
 803                 break;
 804
 805             case ACTION_PS_INC_BIG:
 806                 if(global_settings.pitch_mode_semitone)
 807                     pitch_delta = SEMITONE_BIG_DELTA;
 808                 else
 809                     pitch_delta = PITCH_BIG_DELTA;
 810                 break;
 811
 812             case ACTION_PS_DEC_SMALL:
 813                 if(global_settings.pitch_mode_semitone)
 814                     pitch_delta = -SEMITONE_SMALL_DELTA;
 815                 else
 816                     pitch_delta = -PITCH_SMALL_DELTA;
 817                 break;
 818
 819             case ACTION_PS_DEC_BIG:
 820                 if(global_settings.pitch_mode_semitone)
 821                     pitch_delta = -SEMITONE_BIG_DELTA;
 822                 else
 823                     pitch_delta = -PITCH_BIG_DELTA;
 824                 break;
 825
 826             case ACTION_PS_NUDGE_RIGHT:
 827 #if CONFIG_CODEC == SWCODEC
 828                 if (!global_settings.pitch_mode_timestretch)
 829                 {
 830 #endif
 831                     new_pitch = pitch_increase(pitch, PITCH_NUDGE_DELTA, false
 832 #if CONFIG_CODEC == SWCODEC
 833                                                , speed
 834 #endif
 835                         );
 836                     nudged = (new_pitch != pitch);
 837                     pitch = new_pitch;
 838                     semitone = get_semitone_from_pitch(pitch);
 839 #if CONFIG_CODEC == SWCODEC
 840                     speed = pitch;
 841 #endif
 842                     break;
 843 #if CONFIG_CODEC == SWCODEC
 844                 }
 845                 else
 846                 {
 847                     new_speed = speed + SPEED_SMALL_DELTA;
 848                     at_limit = false;
 849                 }
 850                 break;
 851
 852             case ACTION_PS_FASTER:
 853                 if (global_settings.pitch_mode_timestretch)
 854                 {
 855                     new_speed = speed + SPEED_BIG_DELTA;
 856                     /* snap to whole numbers */
 857                     if(new_speed % PITCH_SPEED_PRECISION != 0)
 858                         new_speed -= new_speed % PITCH_SPEED_PRECISION;
 859                     at_limit = false;
 860                 }
 861                 break;
 862 #endif
 863
 864             case ACTION_PS_NUDGE_RIGHTOFF:
 865                 if (nudged)
 866                 {
 867                     pitch = pitch_increase(pitch, -PITCH_NUDGE_DELTA, false
 868 #if CONFIG_CODEC == SWCODEC
 869                                            , speed
 870 #endif
 871                         );
 872 #if CONFIG_CODEC == SWCODEC
 873                     speed = pitch;
 874 #endif
 875                     semitone = get_semitone_from_pitch(pitch);
 876                     nudged = false;
 877                 }
 878                 break;
 879
 880             case ACTION_PS_NUDGE_LEFT:
 881 #if CONFIG_CODEC == SWCODEC
 882                 if (!global_settings.pitch_mode_timestretch)
 883                 {
 884 #endif
 885                     new_pitch = pitch_increase(pitch, -PITCH_NUDGE_DELTA, false
 886 #if CONFIG_CODEC == SWCODEC
 887                                                , speed
 888 #endif
 889                         );
 890                     nudged = (new_pitch != pitch);
 891                     pitch = new_pitch;
 892                     semitone = get_semitone_from_pitch(pitch);
 893 #if CONFIG_CODEC == SWCODEC
 894                     speed = pitch;
 895 #endif
 896                     break;
 897 #if CONFIG_CODEC == SWCODEC
 898                 }
 899                 else
 900                 {
 901                     new_speed = speed - SPEED_SMALL_DELTA;
 902                     at_limit = false;
 903                 }
 904                 break;
 905
 906             case ACTION_PS_SLOWER:
 907                 if (global_settings.pitch_mode_timestretch)
 908                 {
 909                     new_speed = speed - SPEED_BIG_DELTA;
 910                     /* snap to whole numbers */
 911                     if(new_speed % PITCH_SPEED_PRECISION != 0)
 912                         new_speed += PITCH_SPEED_PRECISION - speed % PITCH_SPEED_PRECISION;
 913                     at_limit = false;
 914                 }
 915                 break;
 916 #endif
 917
 918             case ACTION_PS_NUDGE_LEFTOFF:
 919                 if (nudged)
 920                 {
 921                     pitch = pitch_increase(pitch, PITCH_NUDGE_DELTA, false
 922 #if CONFIG_CODEC == SWCODEC
 923                                            , speed
 924 #endif
 925                         );
 926 #if CONFIG_CODEC == SWCODEC
 927                     speed = pitch;
 928 #endif
 929                     semitone = get_semitone_from_pitch(pitch);
 930                     nudged = false;
 931                 }
 932                 break;
 933
 934             case ACTION_PS_RESET:
 935                 pitch = PITCH_SPEED_100;
 936                 sound_set_pitch(pitch);
 937 #if CONFIG_CODEC == SWCODEC
 938                 speed = PITCH_SPEED_100;
 939                 if (dsp_timestretch_available())
 940                 {
 941                     dsp_set_timestretch(PITCH_SPEED_100);
 942                     at_limit = false;
 943                 }
 944 #endif
 945                 semitone = get_semitone_from_pitch(pitch);
 946                 break;
 947
 948             case ACTION_PS_TOGGLE_MODE:
 949                 global_settings.pitch_mode_semitone = !global_settings.pitch_mode_semitone;
 950 #if CONFIG_CODEC == SWCODEC
 951
 952                 if (dsp_timestretch_available() && !global_settings.pitch_mode_semitone)
 953                 {
 954                     global_settings.pitch_mode_timestretch = !global_settings.pitch_mode_timestretch;
 955                     if(!global_settings.pitch_mode_timestretch)
 956                     {
 957                         /* no longer in timestretch mode.  Reset speed */
 958                         speed = pitch;
 959                         dsp_set_timestretch(PITCH_SPEED_100);
 960                     }
 961                 }
 962                 settings_save();
 963 #endif
 964                 break;
 965
 966             case ACTION_PS_EXIT:
 967                 exit = true;
 968                 break;
 969
 970             default:
 971                 if (default_event_handler(button) == SYS_USB_CONNECTED)
 972                     return 1;
 973                 break;
 974         }
 975         if (pitch_delta)
 976         {
 977             if (global_settings.pitch_mode_semitone)
 978             {
 979                 semitone = pitch_increase_semitone(pitch, semitone, pitch_delta
 980 #if CONFIG_CODEC == SWCODEC
 981                                                 , speed
 982 #endif
 983                 );
 984                 pitch = get_pitch_from_semitone(semitone);
 985             }
 986             else
 987             {
 988                 pitch = pitch_increase(pitch, pitch_delta, true
 989 #if CONFIG_CODEC == SWCODEC
 990                                        , speed
 991 #endif
 992                 );
 993                 semitone = get_semitone_from_pitch(pitch);
 994             }
 995 #if CONFIG_CODEC == SWCODEC
 996             if (global_settings.pitch_mode_timestretch)
 997             {
 998                 /* do this to make sure we properly obey the stretch limits */
 999                 new_speed = speed;
1000             }
1001             else
1002             {
1003                 speed = pitch;
1004             }
1005 #endif
1006         }
1007
1008 #if CONFIG_CODEC == SWCODEC
1009         if(new_speed)
1010         {
1011             new_stretch = GET_STRETCH(pitch, new_speed);
1012
1013             /* limit the amount of stretch */
1014             if(new_stretch > STRETCH_MAX)
1015             {
1016                 new_stretch = STRETCH_MAX;
1017                 new_speed = GET_SPEED(pitch, new_stretch);
1018             }
1019             else if(new_stretch < STRETCH_MIN)
1020             {
1021                 new_stretch = STRETCH_MIN;
1022                 new_speed = GET_SPEED(pitch, new_stretch);
1023             }
1024
1025             new_stretch = GET_STRETCH(pitch, new_speed);
1026             if(new_stretch >= STRETCH_MAX ||
1027                new_stretch <= STRETCH_MIN)
1028             {
1029                 at_limit = true;
1030             }
1031
1032             /* set the amount of stretch */
1033             dsp_set_timestretch(new_stretch);
1034
1035             /* update the speed variable with the new speed */
1036             speed = new_speed;
1037
1038             /* Reset new_speed so we only call dsp_set_timestretch */
1039             /* when needed                                         */
1040             new_speed = 0;
1041         }
1042 #endif
1043     }
1044 #if CONFIG_CODEC == SWCODEC
1045     pcmbuf_set_low_latency(false);
1046 #endif
1047     return 0;
1048 }