apps/abrepeat.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 Ray Lambert
  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 "config.h"
  23 #include "abrepeat.h"
  24
  25 #ifdef AB_REPEAT_ENABLE
  26
  27 unsigned int ab_A_marker IDATA_ATTR = AB_MARKER_NONE;
  28 unsigned int ab_B_marker IDATA_ATTR = AB_MARKER_NONE;
  29
  30 static inline bool ab_A_marker_set(void)
  31 {
  32     return ab_A_marker != AB_MARKER_NONE;
  33 }
  34
  35 static inline bool ab_B_marker_set(void)
  36 {
  37     return ab_B_marker != AB_MARKER_NONE;
  38 }
  39
  40 #if (CONFIG_CODEC == SWCODEC)
  41 void ab_end_of_track_report(void)
  42 {
  43     if ( ab_A_marker_set() && ! ab_B_marker_set() )
  44     {
  45         ab_jump_to_A_marker();
  46     }
  47 }
  48 #else
  49 static int ab_audio_event_handler(unsigned short event, unsigned long data)
  50 {
  51     int rc = AUDIO_EVENT_RC_IGNORED;
  52     if ( ab_repeat_mode_enabled() )
  53     {
  54         switch(event)
  55         {
  56             case AUDIO_EVENT_POS_REPORT:
  57             {
  58                 if ( ! (audio_status() & AUDIO_STATUS_PAUSE) &&
  59                         ab_reached_B_marker(data) )
  60                 {
  61                     ab_jump_to_A_marker();
  62                     rc = AUDIO_EVENT_RC_HANDLED;
  63                 }
  64                 break;
  65             }
  66             case AUDIO_EVENT_END_OF_TRACK:
  67             {
  68                 if ( ab_A_marker_set() && ! ab_B_marker_set() )
  69                 {
  70                     ab_jump_to_A_marker();
  71                     rc = AUDIO_EVENT_RC_HANDLED;
  72                 }
  73                 break;
  74             }
  75         }
  76     }
  77     return rc;
  78 }
  79 #endif
  80
  81 void ab_repeat_init(void)
  82 {
  83     static bool ab_initialized = false;
  84     if ( ! ab_initialized )
  85     {
  86         ab_initialized = true;
  87 #if (CONFIG_CODEC != SWCODEC)
  88         audio_register_event_handler(ab_audio_event_handler,
  89             AUDIO_EVENT_POS_REPORT | AUDIO_EVENT_END_OF_TRACK );
  90 #endif
  91     }
  92 }
  93
  94 /* determines if the given song position is earlier than the A mark;
  95 intended for use in handling the jump NEXT and PREV commands */
  96 bool ab_before_A_marker(unsigned int song_position)
  97 {
  98     return (ab_A_marker != AB_MARKER_NONE)
  99         && (song_position < ab_A_marker);
 100 }
 101
 102 /* determines if the given song position is later than the A mark;
 103 intended for use in handling the jump PREV command */
 104 bool ab_after_A_marker(unsigned int song_position)
 105 {
 106 /* following is the size of the virtual A marker; we pretend that the A marker
 107 is larger than a single instant in order to give the user time to hit PREV again
 108 to jump back to the start of the song; it should be large enough to allow a
 109 reasonable amount of time for the typical user to react */
 110 #define A_MARKER_VIRTUAL_SIZE 1000
 111     return (ab_A_marker != AB_MARKER_NONE)
 112         && (song_position > (ab_A_marker+A_MARKER_VIRTUAL_SIZE));
 113 }
 114
 115 void ab_jump_to_A_marker(void)
 116 {
 117 #if (CONFIG_CODEC != SWCODEC)
 118     bool paused = (audio_status() & AUDIO_STATUS_PAUSE) != 0;
 119     if ( ! paused )
 120         audio_pause();
 121 #endif
 122     audio_ff_rewind(ab_A_marker);
 123 #if (CONFIG_CODEC != SWCODEC)
 124     if ( ! paused )
 125         audio_resume();
 126 #endif
 127 }
 128
 129 void ab_reset_markers(void)
 130 {
 131     ab_A_marker = AB_MARKER_NONE;
 132     ab_B_marker = AB_MARKER_NONE;
 133 }
 134
 135 /* following is a fudge factor to help overcome the latency between
 136 the time the user hears the passage they want to mark and the time
 137 they actually press the button; the actual song position is adjusted
 138 by this fudge factor when setting a mark */
 139 #define EAR_TO_HAND_LATENCY_FUDGE 200
 140
 141 void ab_set_A_marker(unsigned int song_position)
 142 {
 143     ab_A_marker = song_position;
 144     ab_A_marker = (ab_A_marker >= EAR_TO_HAND_LATENCY_FUDGE)
 145         ? (ab_A_marker - EAR_TO_HAND_LATENCY_FUDGE) : 0;
 146     /* check if markers are out of order */
 147     if ( (ab_B_marker != AB_MARKER_NONE) && (ab_A_marker > ab_B_marker) )
 148         ab_B_marker = AB_MARKER_NONE;
 149 }
 150
 151 void ab_set_B_marker(unsigned int song_position)
 152 {
 153     ab_B_marker = song_position;
 154     ab_B_marker = (ab_B_marker >= EAR_TO_HAND_LATENCY_FUDGE)
 155         ? (ab_B_marker - EAR_TO_HAND_LATENCY_FUDGE) : 0;
 156     /* check if markers are out of order */
 157     if ( (ab_A_marker != AB_MARKER_NONE) && (ab_B_marker < ab_A_marker) )
 158         ab_A_marker = AB_MARKER_NONE;
 159 }
 160
 161 #ifdef HAVE_LCD_BITMAP
 162
 163 static int ab_calc_mark_x_pos(int mark, int capacity,
 164         int offset, int size)
 165 {
 166     return offset + ( (size * mark) / capacity );
 167 }
 168
 169 static void ab_draw_vertical_line_mark(struct screen * screen,
 170                                               int x, int y, int h)
 171 {
 172     screen->set_drawmode(DRMODE_COMPLEMENT);
 173     screen->vline(x, y, y+h-1);
 174 }
 175
 176 #define DIRECTION_RIGHT 1
 177 #define DIRECTION_LEFT -1
 178
 179 static void ab_draw_arrow_mark(struct screen * screen,
 180                                       int x, int y, int h, int direction)
 181 {
 182     /* draw lines in decreasing size until a height of zero is reached */
 183     screen->set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
 184     while( h > 0 )
 185     {
 186         screen->vline(x, y, y+h-1);
 187         h -= 2;
 188         y++;
 189         x += direction;
 190         screen->set_drawmode(DRMODE_COMPLEMENT);
 191     }
 192 }
 193
 194 void ab_draw_markers(struct screen * screen, int capacity,
 195                      int x, int y, int w, int h)
 196 {
 197     int xa = ab_calc_mark_x_pos(ab_A_marker, capacity, x, w);
 198     int xb = ab_calc_mark_x_pos(ab_B_marker, capacity, x, w);
 199     /* if both markers are set, determine if they're far enough apart
 200     to draw arrows */
 201     if ( ab_A_marker_set() && ab_B_marker_set() )
 202     {
 203         int arrow_width = (h+1) / 2;
 204         if ( (xb-xa) < (arrow_width*2) )
 205         {
 206             ab_draw_vertical_line_mark(screen, xa, y, h);
 207             ab_draw_vertical_line_mark(screen, xb, y, h);
 208             return;
 209         }
 210     }
 211
 212     if (ab_A_marker_set())
 213     {
 214         ab_draw_arrow_mark(screen, xa, y, h, DIRECTION_RIGHT);
 215     }
 216     if (ab_B_marker_set())
 217     {
 218         ab_draw_arrow_mark(screen, xb, y, h, DIRECTION_LEFT);
 219     }
 220 }
 221
 222 #endif /* HAVE_LCD_BITMAP */
 223
 224 #endif /* AB_REPEAT_ENABLE */