Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
rockbox/apps/wps.c
Markus Braun 6110c98234 Consolidated display restore code. 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@1836 a1c6a512-1295-4272-9138-f99709370657
2002-08-21 06:40:06 +00:00

981 lines
29 KiB
C
Raw Blame History

/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 Jerome Kuptz
*
* All files in this archive are subject to the GNU General Public License.
* See the file COPYING in the source tree root for full license agreement.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "file.h"
#include "lcd.h"
#include "button.h"
#include "kernel.h"
#include "tree.h"
#include "debug.h"
#include "sprintf.h"
#include "settings.h"
#include "wps.h"
#include "mpeg.h"
#include "usb.h"
#include "powermgmt.h"
#include "status.h"
#include "main_menu.h"
#include "ata.h"
#ifdef HAVE_LCD_BITMAP
#include "icons.h"
#include "widgets.h"
#endif
#ifdef LOADABLE_FONTS
#include "ajf.h"
#endif
#ifdef HAVE_LCD_BITMAP
#define PLAY_DISPLAY_2LINEID3 0
#define PLAY_DISPLAY_FILENAME_SCROLL 1
#define PLAY_DISPLAY_TRACK_TITLE 2
#else
#define PLAY_DISPLAY_1LINEID3 0
#define PLAY_DISPLAY_2LINEID3 1
#define PLAY_DISPLAY_FILENAME_SCROLL 2
#define PLAY_DISPLAY_TRACK_TITLE 3
#endif
#ifdef HAVE_RECORDER_KEYPAD
#define RELEASE_MASK (BUTTON_F1 | BUTTON_DOWN | BUTTON_LEFT | BUTTON_RIGHT | BUTTON_UP)
#else
#define RELEASE_MASK (BUTTON_MENU | BUTTON_STOP | BUTTON_LEFT | BUTTON_RIGHT | BUTTON_PLAY)
#endif
bool keys_locked = false;
bool device_muted = false;
static bool ff_rewind = false;
static bool paused = false;
static void draw_screen(struct mp3entry* id3)
{
int font_height;
#ifdef LOADABLE_FONTS
unsigned char *font = lcd_getcurrentldfont();
font_height = ajf_get_fontheight(font);
#else
font_height = 8;
#endif
lcd_clear_display();
if(!id3)
{
#ifdef HAVE_LCD_CHARCELLS
lcd_puts(0, 0, "End of list");
lcd_puts(0, 1, "<Press ON>");
#else
lcd_puts(0, 2, "<End of song list>");
lcd_puts(5, 4, "Press ON");
#endif
}
else
{
switch ( global_settings.wps_display ) {
case PLAY_DISPLAY_TRACK_TITLE:
{
char ch = '/';
char* end;
char* szTok;
char* szDelimit;
char* szPeriod;
char szArtist[26];
char szBuff[257];
szBuff[sizeof(szBuff)-1] = 0;
strncpy(szBuff, id3->path, sizeof(szBuff));
szTok = strtok_r(szBuff, "/", &end);
szTok = strtok_r(NULL, "/", &end);
// Assume path format of: Genre/Artist/Album/Mp3_file
strncpy(szArtist,szTok,sizeof(szArtist));
szArtist[sizeof(szArtist)-1] = 0;
szDelimit = strrchr(id3->path, ch);
lcd_puts(0, 0, szArtist?szArtist:"<nothing>");
// removes the .mp3 from the end of the display buffer
szPeriod = strrchr(szDelimit, '.');
if (szPeriod != NULL)
*szPeriod = 0;
lcd_puts_scroll(0, 1, (++szDelimit));
break;
}
case PLAY_DISPLAY_FILENAME_SCROLL:
{
char buffer[64];
char ch = '/';
char* szLast = strrchr(id3->path, ch);
if (szLast)
{
snprintf(buffer, sizeof(buffer), "%d/%d: %s",
id3->index + 1,
playlist.amount,
++szLast);
}
else
{
snprintf(buffer, sizeof(buffer), "%d/%d: %s",
id3->index + 1,
playlist.amount,
id3->path);
}
lcd_puts_scroll(0, 0, buffer);
break;
}
case PLAY_DISPLAY_2LINEID3:
{
int l = 0;
#ifdef HAVE_LCD_BITMAP
char buffer[64];
lcd_puts_scroll(0, l++, id3->path);
lcd_puts(0, l++, id3->title?id3->title:"");
lcd_puts(0, l++, id3->album?id3->album:"");
lcd_puts(0, l++, id3->artist?id3->artist:"");
if(!global_settings.statusbar && font_height <= 8) {
if(id3->vbr)
snprintf(buffer, sizeof(buffer), "%d kbit (avg)",
id3->bitrate);
else
snprintf(buffer, sizeof(buffer), "%d kbit", id3->bitrate);
lcd_puts(0, l++, buffer);
snprintf(buffer,sizeof(buffer), "%d Hz", id3->frequency);
lcd_puts(0, l++, buffer);
}
else {
if(id3->vbr)
snprintf(buffer, sizeof(buffer), "%dkbit(a) %dHz",
id3->bitrate, id3->frequency);
else
snprintf(buffer, sizeof(buffer), "%dkbit %dHz",
id3->bitrate, id3->frequency);
lcd_puts(0, l++, buffer);
}
#else
lcd_puts(0, l++, id3->artist?id3->artist:"<no artist>");
lcd_puts_scroll(0, l++, id3->title?id3->title:"<no title>");
#endif
break;
}
#ifdef HAVE_LCD_CHARCELLS
case PLAY_DISPLAY_1LINEID3:
{
char buffer[64];
char ch = '/';
char* szLast = strrchr(id3->path, ch);
if(id3->artist && id3->title)
{
snprintf(buffer, sizeof(buffer), "%d/%d: %s - %s",
id3->index + 1,
playlist.amount,
id3->artist?id3->artist:"<no artist>",
id3->title?id3->title:"<no title>");
}
else
{
snprintf(buffer, sizeof(buffer), "%d/%d: %s",
id3->index + 1,
playlist.amount,
szLast?++szLast:id3->path);
}
lcd_puts_scroll(0, 0, buffer);
break;
}
#endif
}
}
status_draw();
lcd_update();
}
int player_id3_show(void)
{
#ifdef HAVE_PLAYER_KEYPAD
int button;
int menu_pos = 0;
int menu_max = 6;
bool menu_changed = true;
char scroll_text[MAX_PATH];
struct mp3entry* id3 = NULL;
lcd_stop_scroll();
lcd_clear_display();
lcd_puts(0, 0, "-ID3 Info- ");
lcd_puts(0, 1, "--Screen-- ");
sleep(HZ*1.5);
while(1)
{
id3 = mpeg_current_track();
button = button_get(false);
switch(button)
{
case BUTTON_LEFT:
menu_changed = true;
if(menu_pos > 0)
menu_pos--;
else
menu_pos = menu_max;
break;
case BUTTON_RIGHT:
menu_changed = true;
if(menu_pos < menu_max)
menu_pos++;
else
menu_pos = 0;
break;
case BUTTON_REPEAT:
break;
case BUTTON_STOP:
case BUTTON_PLAY:
lcd_stop_scroll();
return(0);
break;
#ifndef SIMULATOR
case SYS_USB_CONNECTED:
/* Tell the USB thread that we are safe */
DEBUGF("wps got SYS_USB_CONNECTED\n");
usb_acknowledge(SYS_USB_CONNECTED_ACK);
/* Wait until the USB cable is extracted again */
usb_wait_for_disconnect(&button_queue);
/* Signal to our caller that we have been in USB mode */
return SYS_USB_CONNECTED;
break;
#endif
}
switch(menu_pos)
{
case 0:
lcd_puts(0, 0, "Title");
snprintf(scroll_text,sizeof(scroll_text), "%s",
id3->title);
break;
case 1:
lcd_puts(0, 0, "Artist");
snprintf(scroll_text,sizeof(scroll_text), "%s",
id3->artist);
break;
case 2:
lcd_puts(0, 0, "Album");
snprintf(scroll_text,sizeof(scroll_text), "%s",
id3->album);
break;
case 3:
lcd_puts(0, 0, "Length");
snprintf(scroll_text,sizeof(scroll_text), "%d:%02d",
id3->length / 60000,
id3->length % 60000 / 1000 );
break;
case 4:
lcd_puts(0, 0, "Bitrate");
snprintf(scroll_text,sizeof(scroll_text), "%d kbps",
id3->bitrate);
break;
case 5:
lcd_puts(0, 0, "Frequency");
snprintf(scroll_text,sizeof(scroll_text), "%d kHz",
id3->frequency);
break;
case 6:
lcd_puts(0, 0, "Path");
snprintf(scroll_text,sizeof(scroll_text), "%s",
id3->path);
break;
}
if(menu_changed == true)
{
menu_changed = false;
lcd_stop_scroll();
lcd_clear_display();
lcd_puts_scroll(0, 1, scroll_text);
}
status_draw();
lcd_update();
yield();
}
#endif
return(0);
}
static void display_file_time(unsigned int elapsed, unsigned int length)
{
char buffer[32];
#ifdef HAVE_LCD_BITMAP
int line;
if(global_settings.statusbar)
line = 5;
else
line = 6;
snprintf(buffer,sizeof(buffer),
"Time:%3d:%02d/%d:%02d",
elapsed / 60000,
elapsed % 60000 / 1000,
length / 60000,
length % 60000 / 1000 );
lcd_puts(0, line, buffer);
slidebar(0, LCD_HEIGHT-6, LCD_WIDTH, 6, elapsed*100/length, Grow_Right);
lcd_update();
#else
/* Display time with the filename scroll only because
the screen has room. */
if ((global_settings.wps_display == PLAY_DISPLAY_FILENAME_SCROLL) ||
global_settings.wps_display == PLAY_DISPLAY_1LINEID3 ||
ff_rewind)
{
snprintf(buffer,sizeof(buffer), "%d:%02d/%d:%02d ",
elapsed / 60000,
elapsed % 60000 / 1000,
length / 60000,
length % 60000 / 1000 );
lcd_puts(0, 1, buffer);
lcd_update();
}
#endif
}
void display_volume_level(int vol_level)
{
char buffer[32];
lcd_stop_scroll();
snprintf(buffer,sizeof(buffer),"Vol: %d %s ", vol_level * 2, "%");
#ifdef HAVE_LCD_CHARCELLS
lcd_puts(0, 0, buffer);
#else
lcd_puts(2, 3, buffer);
lcd_update();
#endif
sleep(HZ/6);
}
void display_keylock_text(bool locked)
{
lcd_stop_scroll();
lcd_clear_display();
#ifdef HAVE_LCD_CHARCELLS
if(locked)
lcd_puts(0, 0, "Keylock ON");
else
lcd_puts(0, 0, "Keylock OFF");
#else
if(locked)
{
lcd_puts(2, 3, "Key lock is ON");
}
else
{
lcd_puts(2, 3, "Key lock is OFF");
}
status_draw();
lcd_update();
#endif
sleep(HZ);
}
void display_mute_text(bool muted)
{
lcd_stop_scroll();
lcd_clear_display();
#ifdef HAVE_LCD_CHARCELLS
if(muted)
lcd_puts(0, 0, "Mute ON");
else
lcd_puts(0, 0, "Mute OFF");
#else
if(muted)
{
lcd_puts(2, 3, "Mute is ON");
}
else
{
lcd_puts(2, 3, "Mute is OFF");
}
status_draw();
lcd_update();
#endif
sleep(HZ);
}
/* demonstrates showing different formats from playtune */
int wps_show(void)
{
struct mp3entry* id3 = NULL;
#ifdef HAVE_PLAYER_KEYPAD
int retval;
#endif
bool dont_go_to_menu = false;
bool menu_button_is_down = false;
bool pending_keylock = true; /* Keylock will go ON next time */
bool pending_mute = true; /* Mute will go ON next time */
int old_release_mask;
int button;
int ff_rewind_count = 0;
bool ignore_keyup = true;
old_release_mask = button_set_release(RELEASE_MASK);
#ifdef HAVE_LCD_CHARCELLS
lcd_icon(ICON_AUDIO, true);
lcd_icon(ICON_PARAM, false);
#else
if(global_settings.statusbar)
lcd_setmargins(0, STATUSBAR_HEIGHT);
else
lcd_setmargins(0, 0);
#endif
ff_rewind = false;
if(mpeg_is_playing())
{
id3 = mpeg_current_track();
draw_screen(id3);
}
while ( 1 )
{
bool restore = false;
button = button_get_w_tmo(HZ/5);
/* discard first event if it's a button release */
if (button && ignore_keyup)
{
ignore_keyup = false;
if (button & BUTTON_REL)
continue;
}
if(mpeg_has_changed_track())
{
lcd_stop_scroll();
id3 = mpeg_current_track();
draw_screen(id3);
}
switch(button)
{
case BUTTON_ON:
if (keys_locked)
{
display_keylock_text(keys_locked);
restore = true;
break;
}
#ifdef HAVE_LCD_CHARCELLS
lcd_icon(ICON_RECORD, false);
lcd_icon(ICON_AUDIO, false);
#endif
button_set_release(old_release_mask);
return 0;
case BUTTON_PLAY:
if (keys_locked)
{
display_keylock_text(keys_locked);
restore = true;
break;
}
if ( !paused )
{
mpeg_pause();
paused = true;
status_set_playmode(STATUS_PAUSE);
status_draw();
if (global_settings.resume) {
settings_save();
#ifndef HAVE_RTC
ata_flush();
#endif
}
}
else
{
mpeg_resume();
paused = false;
status_set_playmode(STATUS_PLAY);
status_draw();
}
break;
#ifdef HAVE_RECORDER_KEYPAD
case BUTTON_UP:
case BUTTON_UP | BUTTON_REPEAT:
#endif
case BUTTON_VOL_UP:
if (keys_locked)
{
display_keylock_text(keys_locked);
restore = true;
break;
}
global_settings.volume++;
if(global_settings.volume > mpeg_sound_max(SOUND_VOLUME))
global_settings.volume = mpeg_sound_max(SOUND_VOLUME);
mpeg_sound_set(SOUND_VOLUME, global_settings.volume);
status_draw();
settings_save();
break;
#ifdef HAVE_RECORDER_KEYPAD
case BUTTON_DOWN:
case BUTTON_DOWN | BUTTON_REPEAT:
#endif
case BUTTON_VOL_DOWN:
if (keys_locked)
{
display_keylock_text(keys_locked);
restore = true;
break;
}
global_settings.volume--;
if(global_settings.volume < mpeg_sound_min(SOUND_VOLUME))
global_settings.volume = mpeg_sound_min(SOUND_VOLUME);
mpeg_sound_set(SOUND_VOLUME, global_settings.volume);
status_draw();
settings_save();
break;
case BUTTON_LEFT | BUTTON_REPEAT:
if (!keys_locked)
{
if (ff_rewind)
{
ff_rewind_count -= global_settings.ff_rewind*1000;
}
else
{
if ( mpeg_is_playing() && id3 && id3->length )
{
mpeg_pause();
#ifdef HAVE_PLAYER_KEYPAD
lcd_stop_scroll();
#endif
status_set_playmode(STATUS_FASTBACKWARD);
status_draw();
ff_rewind = true;
ff_rewind_count = -global_settings.ff_rewind*1000;
}
else
break;
}
if ((int)(id3->elapsed + ff_rewind_count) < 0)
ff_rewind_count = -id3->elapsed;
display_file_time(id3->elapsed + ff_rewind_count,
id3->length);
}
break;
case BUTTON_RIGHT | BUTTON_REPEAT:
if (!keys_locked)
{
if (ff_rewind)
{
ff_rewind_count += global_settings.ff_rewind*1000;
}
else
{
if ( mpeg_is_playing() && id3 && id3->length )
{
mpeg_pause();
#ifdef HAVE_PLAYER_KEYPAD
lcd_stop_scroll();
#endif
status_set_playmode(STATUS_FASTFORWARD);
status_draw();
ff_rewind = true;
ff_rewind_count = global_settings.ff_rewind*1000;
}
else
break;
}
if ((id3->elapsed + ff_rewind_count) > id3->length)
ff_rewind_count = id3->length - id3->elapsed;
display_file_time(id3->elapsed + ff_rewind_count,
id3->length);
}
break;
case BUTTON_LEFT | BUTTON_REL:
if (menu_button_is_down && keys_locked)
{
sleep(HZ/6);
draw_screen(id3);
}
if (!keys_locked)
{
if (ff_rewind)
{
/* rewind */
mpeg_ff_rewind(ff_rewind_count);
ff_rewind_count = 0;
ff_rewind = false;
mpeg_resume();
status_set_playmode(STATUS_PLAY);
#ifdef HAVE_LCD_CHARCELLS
draw_screen(id3);
#endif
}
#ifdef HAVE_PLAYER_KEYPAD
else if(!menu_button_is_down)
#else
else
#endif
{
mpeg_prev();
}
}
#ifdef HAVE_PLAYER_KEYPAD
else if(!menu_button_is_down)
#else
else
#endif
{
display_keylock_text(keys_locked);
restore = true;
}
break;
case BUTTON_RIGHT | BUTTON_REL:
if (menu_button_is_down && keys_locked)
{
sleep(HZ/6);
draw_screen(id3);
}
if (!keys_locked)
{
if (ff_rewind)
{
/* fast forward */
mpeg_ff_rewind(ff_rewind_count);
ff_rewind_count = 0;
ff_rewind = false;
mpeg_resume();
status_set_playmode(STATUS_PLAY);
#ifdef HAVE_LCD_CHARCELLS
draw_screen(id3);
#endif
}
#ifdef HAVE_PLAYER_KEYPAD
else if(!menu_button_is_down)
#else
else
#endif
{
mpeg_next();
}
}
#ifdef HAVE_PLAYER_KEYPAD
else if(!menu_button_is_down)
#else
else
#endif
{
display_keylock_text(keys_locked);
restore = true;
break;
}
break;
#ifdef HAVE_PLAYER_KEYPAD
case BUTTON_MENU | BUTTON_LEFT:
case BUTTON_MENU | BUTTON_LEFT | BUTTON_REPEAT:
dont_go_to_menu = true;
global_settings.volume--;
if(global_settings.volume < mpeg_sound_min(SOUND_VOLUME))
global_settings.volume = mpeg_sound_min(SOUND_VOLUME);
mpeg_sound_set(SOUND_VOLUME, global_settings.volume);
display_volume_level(global_settings.volume);
draw_screen(id3);
status_draw();
settings_save();
break;
case BUTTON_MENU | BUTTON_RIGHT:
case BUTTON_MENU | BUTTON_RIGHT | BUTTON_REPEAT:
dont_go_to_menu = true;
global_settings.volume++;
if(global_settings.volume > mpeg_sound_max(SOUND_VOLUME))
global_settings.volume = mpeg_sound_max(SOUND_VOLUME);
mpeg_sound_set(SOUND_VOLUME, global_settings.volume);
display_volume_level(global_settings.volume);
draw_screen(id3);
status_draw();
settings_save();
break;
case BUTTON_MENU | BUTTON_ON:
if (keys_locked)
{
display_keylock_text(keys_locked);
restore = true;
break;
}
lcd_stop_scroll();
dont_go_to_menu = true;
menu_button_is_down = false;
lcd_icon(ICON_PARAM, true);
lcd_icon(ICON_AUDIO, true);
retval = player_id3_show();
if(retval == SYS_USB_CONNECTED)
return SYS_USB_CONNECTED;
lcd_icon(ICON_PARAM, false);
lcd_icon(ICON_AUDIO, true);
draw_screen(id3);
break;
case BUTTON_MENU:
lcd_icon(ICON_PARAM, true);
lcd_icon(ICON_AUDIO, false);
menu_button_is_down = true;
break;
case BUTTON_PLAY | BUTTON_REL:
/* The PLAY key has been release while the MENU key
was held */
if(menu_button_is_down)
pending_mute = !pending_mute;
break;
case BUTTON_STOP | BUTTON_REL:
/* The STOP key has been release while the MENU key
was held */
if(menu_button_is_down)
pending_keylock = !pending_keylock;
break;
#else
case BUTTON_F1:
menu_button_is_down = true;
break;
case BUTTON_UP | BUTTON_REL:
/* The UP key has been release while the F1 key
was held */
if(menu_button_is_down)
{
pending_mute = !pending_mute;
debugf("pending: %d\n", pending_mute);
}
break;
case BUTTON_DOWN | BUTTON_REL:
/* The DOWN key has been release while the F1 key
was held */
if(menu_button_is_down)
{
pending_keylock = !pending_keylock;
debugf("pending: %d\n", pending_keylock);
}
break;
#endif
#ifdef HAVE_RECORDER_KEYPAD
case BUTTON_F1 | BUTTON_UP:
#else
case BUTTON_MENU | BUTTON_PLAY:
#endif
if(keys_locked)
{
display_keylock_text(keys_locked);
restore = true;
break;
}
if(device_muted != pending_mute)
{
device_muted = pending_mute;
if(device_muted)
mpeg_sound_set(SOUND_VOLUME, 0);
else
mpeg_sound_set(SOUND_VOLUME, global_settings.volume);
display_mute_text(device_muted);
restore = true;
}
dont_go_to_menu = true;
break;
#ifdef HAVE_RECORDER_KEYPAD
case BUTTON_F1 | BUTTON_DOWN:
#else
case BUTTON_MENU | BUTTON_STOP:
#endif
if(keys_locked != pending_keylock)
{
keys_locked = pending_keylock;
#ifdef HAVE_LCD_CHARCELLS
if(keys_locked)
lcd_icon(ICON_RECORD, true);
else
lcd_icon(ICON_RECORD, false);
#endif
display_keylock_text(keys_locked);
restore = true;
}
dont_go_to_menu = true;
break;
#ifdef HAVE_RECORDER_KEYPAD
case BUTTON_F1 | BUTTON_REL:
#else
case BUTTON_MENU | BUTTON_REL:
#endif
#ifdef HAVE_LCD_CHARCELLS
lcd_icon(ICON_PARAM, false);
#endif
if(!keys_locked && !dont_go_to_menu && menu_button_is_down)
{
lcd_stop_scroll();
button_set_release(old_release_mask);
main_menu();
old_release_mask = button_set_release(RELEASE_MASK);
ignore_keyup = true;
id3 = mpeg_current_track();
restore = true;
}
else
{
dont_go_to_menu = false;
}
#ifdef HAVE_LCD_CHARCELLS
lcd_icon(ICON_AUDIO, true);
#endif
menu_button_is_down = false;
break;
#ifdef HAVE_RECORDER_KEYPAD
case BUTTON_F3:
#ifdef HAVE_LCD_BITMAP
global_settings.statusbar = !global_settings.statusbar;
settings_save();
if(global_settings.statusbar)
lcd_setmargins(0, STATUSBAR_HEIGHT);
else
lcd_setmargins(0, 0);
restore = true;
#endif
break;
#endif
#ifdef HAVE_RECORDER_KEYPAD
case BUTTON_OFF:
#else
case BUTTON_STOP:
#endif
if (keys_locked)
{
display_keylock_text(keys_locked);
restore = true;
break;
}
#ifdef HAVE_LCD_CHARCELLS
lcd_icon(ICON_RECORD, false);
lcd_icon(ICON_AUDIO, false);
#endif
mpeg_stop();
status_set_playmode(STATUS_STOP);
button_set_release(old_release_mask);
return 0;
#ifndef SIMULATOR
case SYS_USB_CONNECTED: {
#ifdef HAVE_LCD_BITMAP
bool laststate=statusbar(false);
#endif
/* Tell the USB thread that we are safe */
DEBUGF("wps got SYS_USB_CONNECTED\n");
usb_acknowledge(SYS_USB_CONNECTED_ACK);
/* Wait until the USB cable is extracted again */
usb_wait_for_disconnect(&button_queue);
#ifdef HAVE_LCD_BITMAP
statusbar(laststate);
#endif
/* Signal to our caller that we have been in USB mode */
return SYS_USB_CONNECTED;
break;
}
#endif
case BUTTON_NONE: /* Timeout */
if (mpeg_is_playing() && id3)
display_file_time(id3->elapsed, id3->length);
/* save resume data */
if ( id3 &&
global_settings.resume &&
global_settings.resume_offset != id3->offset ) {
DEBUGF("R%X,%X (%X)\n",global_settings.resume_offset,id3->offset,id3);
global_settings.resume_index = id3->index;
global_settings.resume_offset = id3->offset;
settings_save();
}
status_draw();
break;
}
if(restore) {
draw_screen(id3);
if (mpeg_is_playing() && id3)
display_file_time(id3->elapsed, id3->length);
}
}
}
Reference in a new issue View git blame Copy permalink