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