/*! Close CD tray */
static bool
cd_close(const char *psz_device)
{
bool b_ok = true;
if (!b_cd) {
b_ok = DRIVER_OP_SUCCESS == cdio_close_tray(psz_device, &driver_id);
if (!b_ok)
xperror("close");
}
return b_ok;
}
int main(int argc, char ** argv)
{
driver_return_code_t err;
int close_tray = 0;
const char * device = NULL;
if(argc < 2 || argc > 3)
{
usage(argv[0]);
return -1;
}
if((argc == 3) && strcmp(argv[1], "-t"))
{
usage(argv[0]);
return -1;
}
if(argc == 2)
device = argv[1];
else if(argc == 3)
{
close_tray = 1;
device = argv[2];
}
if(close_tray)
{
err = cdio_close_tray(device, NULL);
if(err)
{
fprintf(stderr, "Closing tray failed for device %s: %s\n",
device, cdio_driver_errmsg(err));
return -1;
}
}
else
{
err = cdio_eject_media_drive(device);
if(err)
{
fprintf(stderr, "Ejecting failed for device %s: %s\n",
device, cdio_driver_errmsg(err));
return -1;
}
}
return 0;
}
static int
cda_action_add_cd (DB_plugin_action_t *act, int ctx)
{
/* Get all devices containg CD audio media */
cdio_close_tray(NULL, NULL);
char **device_list = cdio_get_devices_with_cap(NULL, CDIO_FS_AUDIO, false);
if (!device_list) {
return 0;
}
char *drive_device = NULL;
if (device_list[0] && device_list[1]) {
/* Multiple devices, ask the user to pick one */
size_t device_count;
size_t device_combo_length = sizeof(DRIVE_COMBO_SCRIPT);
for (device_count = 0; device_list[device_count]; device_count++) {
device_combo_length += strlen(device_list[device_count]) + 1;
}
char *layout = malloc(device_combo_length);
if (layout) {
sprintf(layout, DRIVE_COMBO_SCRIPT, device_count);
for (char **device = device_list; *device; device++) {
strcat(layout, " ");
strcat(layout, *device);
}
strcat(layout, ";");
ddb_dialog_t conf = {
.title = "Audio CD Drive",
.layout = layout,
.set_param = set_param,
.get_param = get_param,
.parent = NULL
};
struct DB_plugin_s **plugin_list;
for (plugin_list = deadbeef->plug_get_list(); *plugin_list && (*plugin_list)->type != DB_PLUGIN_GUI; plugin_list++);
if (*plugin_list) {
DB_gui_t *gui_plugin = (DB_gui_t *)*plugin_list;
if (gui_plugin->run_dialog(&conf, 1<<ddb_button_ok|1<<ddb_button_cancel, NULL, NULL) == ddb_button_ok) {
drive_device = device_list[dialog_combo_index];
}
}
free(layout);
}
}
else if (device_list[0]) {
QList< Playlist::Entry > AudioCDDemux::getTracks( const QString &_device )
{
QList< Playlist::Entry > tracks;
Playlist::Entry entry;
device = _device;
cdio_close_tray( device.toLocal8Bit(), NULL );
if ( ( cdio = cdio_open( device.toLocal8Bit(), DRIVER_UNKNOWN ) ) )
{
numTracks = cdio_get_num_tracks( cdio );
if ( cdio_get_discmode( cdio ) != CDIO_DISC_MODE_ERROR && numTracks > 0 && numTracks != CDIO_INVALID_TRACK )
{
cddb_disc_t *cddb_disc = NULL;
bool cddb_ok = useCDDB;
for ( trackNo = 1 ; trackNo <= numTracks ; ++trackNo )
{
chn = cdio_get_track_channels( cdio, trackNo );
if ( chn != 2 && chn != 4 )
continue;
if ( useCDTEXT )
readCDText( trackNo );
isData = cdio_get_track_format( cdio, trackNo ) != TRACK_FORMAT_AUDIO;
duration = CD_BLOCKSIZE / chn / ( double )srate;
numSectors = cdio_get_track_last_lsn( cdio, trackNo ) - cdio_get_track_lsn( cdio, trackNo );
if ( cddb_ok && ( cddb_disc || ( Title.isEmpty() && ( cddb_ok = freedb_query( cddb_disc ) ) ) ) )
freedb_get_track_info( cddb_disc );
entry.name = title();
entry.url = AudioCDName"://" + QString::number( trackNo ) + "?device=" + device;
entry.length = length();
tracks += entry;
}
cddb_disc_destroy( cddb_disc );
}
}
return tracks;
}
int
main(int argc, const char *argv[])
{
driver_return_code_t ret;
driver_id_t driver_id = DRIVER_DEVICE;
char *psz_drive = NULL;
if (argc > 1)
psz_drive = strdup(argv[1]);
if (!psz_drive) {
psz_drive = cdio_get_default_device_driver(&driver_id);
if (!psz_drive) {
printf("Can't find a CD-ROM to eject\n");
exit(1);
}
}
ret = cdio_eject_media_drive(psz_drive);
switch(ret) {
case DRIVER_OP_UNSUPPORTED:
printf("Eject not supported for %s.\n", psz_drive);
break;
case DRIVER_OP_SUCCESS:
printf("CD-ROM drive %s ejected.\n", psz_drive);
break;
default:
printf("Eject of CD-ROM drive %s failed.\n", psz_drive);
break;
}
if (DRIVER_OP_SUCCESS == cdio_close_tray(psz_drive, &driver_id)) {
printf("Closed tray of CD-ROM drive %s.\n", psz_drive);
} else {
printf("Closing tray of CD-ROM drive %s failed.\n", psz_drive);
}
free(psz_drive);
ret = cdio_eject_media_drive(NULL);
switch(ret) {
case DRIVER_OP_UNSUPPORTED:
printf("Eject not supported for default device.\n");
break;
case DRIVER_OP_SUCCESS:
printf("CD-ROM drive ejected for default device.\n");
break;
default:
printf("Eject of CD-ROM drive failed for default device.\n");
break;
}
driver_id = DRIVER_DEVICE;
if (DRIVER_OP_SUCCESS == cdio_close_tray(NULL, &driver_id)) {
printf("Closed tray of CD-ROM drive for default disc driver:\n\t%s\n",
cdio_driver_describe(driver_id));
} else {
printf("Closing tray of CD-ROM drive failed for default "
"disc driver:\n\t%s\n", cdio_driver_describe(driver_id));
}
return 0;
}
static DB_playItem_t *
cda_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *path)
{
trace("CDA insert: %s\n", path);
cdio_close_tray(NULL, NULL);
/* Deal with any NRG files and get them out of the way */
const char *ext = strrchr(path, '.');
if (ext && !strcasecmp(ext, ".nrg")) {
if (!deadbeef->conf_get_int("cdda.enable_nrg", 0)) {
trace("cda: NRG found but disabled in preferences\n");
return NULL;
}
CdIo_t* cdio = cdio_open(path, DRIVER_NRG);
if (!cdio) {
trace("not an NRG image, or file not found (%s)\n", path);
return NULL;
}
DB_playItem_t *inserted = insert_disc(plt, after, path, 0, cdio);
cdio_destroy(cdio);
return inserted;
}
/* Get a list of all devices containing CD audio */
driver_id_t driver_id;
char **device_list = cdio_get_devices_with_cap_ret(NULL, CDIO_FS_AUDIO, false, &driver_id);
if (!device_list) {
trace("cda: no audio drives found\n");
return NULL;
}
/* Match the device name for the requested insert (invalid devices may crash cdio) */
const char *sep = strrchr(path, '/');
char *drive_device = NULL;
if (sep) {
char *real_path = realpath(path, NULL);
if (!real_path) {
const size_t device_length = sep - path;
char device_path[device_length+1];
strncpy(device_path, path, device_length);
device_path[device_length] = '\0';
real_path = realpath(device_path, NULL);
}
if (real_path) {
for (size_t i = 0; device_list[i] && !drive_device; i++) {
char *real_device = realpath(device_list[i], NULL);
if (real_device) {
if (!strcmp(real_device, real_path)) {
drive_device = device_list[i];
}
free(real_device);
}
}
free(real_path);
}
}
else {
drive_device = device_list[0];
}
/* Open the device and insert the requested track(s) */
DB_playItem_t *inserted = NULL;
if (drive_device) {
trace("cda: try to open device %s\n", drive_device);
CdIo_t* cdio = cdio_open(drive_device, driver_id);
if (cdio) {
char *track_end;
const unsigned long track_nr = strtoul(sep ? sep + 1 : path, &track_end, 10);
const track_t single_track = strcmp(track_end, ".cda") || track_nr > CDIO_CD_MAX_TRACKS ? 0 : track_nr;
inserted = insert_disc(plt, after, drive_device, single_track, cdio);
cdio_destroy(cdio);
}
}
cdio_free_device_list(device_list);
return inserted;
}
static int open_vcd(bgav_input_context_t * ctx, const char * url, char ** r)
{
driver_return_code_t err;
int i;
vcd_priv * priv;
const char * pos;
// bgav_find_devices_vcd();
priv = calloc(1, sizeof(*priv));
ctx->priv = priv;
#ifndef SECTOR_ACCESS
priv->buffer = priv->sector + 8;
priv->buffer_ptr = priv->buffer + SECTOR_SIZE;
#endif
pos = strrchr(url, '.');
if(pos && !strcasecmp(pos, ".cue"))
priv->cdio = cdio_open (url, DRIVER_BINCUE);
else
{
if((err = cdio_close_tray(url, NULL)))
#if LIBCDIO_VERSION_NUM >= 77
bgav_log(ctx->opt, BGAV_LOG_ERROR, LOG_DOMAIN,
"cdio_close_tray failed: %s",
cdio_driver_errmsg(err));
#else
bgav_log(ctx->opt, BGAV_LOG_ERROR, LOG_DOMAIN,
"cdio_close_tray failed");
#endif
priv->cdio = cdio_open (url, DRIVER_DEVICE);
/* Close tray, hope this won't be harmful if the
tray is already closed */
}
if(!priv->cdio)
{
bgav_log(ctx->opt, BGAV_LOG_ERROR, LOG_DOMAIN,
"cdio_open failed for %s", url);
return 0;
}
/* Get some infos */
// dump_cdrom(priv->fd);
/* Read TOC */
if(!read_toc(priv, &ctx->disc_name))
{
bgav_log(ctx->opt, BGAV_LOG_ERROR, LOG_DOMAIN,
"read_toc failed for %s", url);
return 0;
}
toc_2_tt(ctx);
/* Set up sector stuff */
#ifdef SECTOR_ACCESS
ctx->sector_size = 2324;
ctx->sector_size_raw = 2352;
ctx->sector_header_size = 8;
#endif
/* Create demuxer */
ctx->demuxer = bgav_demuxer_create(ctx->opt, &bgav_demuxer_mpegps, ctx);
ctx->demuxer->tt = ctx->tt;
/* Now, loop through all tracks and let the demuxer find the durations */
for(i = 0; i < ctx->tt->num_tracks; i++)
{
select_track_vcd(ctx, i);
bgav_track_table_select_track(ctx->tt, i);
bgav_demuxer_start(ctx->demuxer, NULL);
bgav_demuxer_stop(ctx->demuxer);
}
ctx->can_pause = 1;
return 1;
}
/*!
Close media tray in CD drive if there is a routine to do so.
@param psz_drive the name of CD-ROM to be closed.
@param driver_id is the driver to be used or that got used if
it was DRIVER_UNKNOWN or DRIVER_DEVICE; If this is NULL, we won't
report back the driver used.
*/
void closeTray (const char *psz_drive, /*in/out*/ driver_id_t &driver_id)
{
driver_return_code_t drc = cdio_close_tray (psz_drive, &driver_id);
possible_throw_device_exception(drc);
}
int
main(int argc, char *argv[])
{
int c;
char *h;
int i_rc = 0;
int i_volume_level = -1;
cd_operation_t todo = NO_OP; /* operation to do in non-interactive mode */
psz_program = strrchr(argv[0],'/');
psz_program = psz_program ? psz_program+1 : argv[0];
/* parse options */
while ( 1 ) {
if (-1 == (c = getopt(argc, argv, "aCdehkpL:sSt:vx")))
break;
switch (c) {
case 'v':
b_verbose = true;
break;
case 'd':
debug = 1;
break;
case 'a':
auto_mode = 1;
break;
case 'L':
if (NULL != strchr(optarg,'-')) {
i_volume_level = atoi(optarg);
todo = SET_VOLUME;
}
break;
case 't':
if (NULL != (h = strchr(optarg,'-'))) {
*h = 0;
start_track = atoi(optarg);
stop_track = atoi(h+1)+1;
if (0 == start_track) start_track = 1;
if (1 == stop_track) stop_track = CDIO_CDROM_LEADOUT_TRACK;
} else {
start_track = atoi(optarg);
stop_track = start_track+1;
one_track = 1;
}
todo = PLAY_TRACK;
break;
case 'p':
todo = PLAY_CD;
break;
case 'C':
todo = CLOSE_CD;
break;
break;
case 's':
todo = STOP_PLAYING;
break;
case 'S':
todo = LIST_SUBCHANNEL;
break;
case 'e':
todo = EJECT_CD;
break;
case 'h':
usage(psz_program);
exit(1);
default:
usage(psz_program);
exit(1);
}
}
if (argc > optind) {
psz_device = strdup(argv[optind]);
} else {
char **ppsz_cdda_drives=NULL;
char **ppsz_all_cd_drives = cdio_get_devices_ret(&driver_id);
if (!ppsz_all_cd_drives) {
fprintf(stderr, "Can't find a CD-ROM drive\n");
exit(2);
}
ppsz_cdda_drives = cdio_get_devices_with_cap(ppsz_all_cd_drives,
CDIO_FS_AUDIO, false);
if (!ppsz_cdda_drives || !ppsz_cdda_drives[0]) {
fprintf(stderr, "Can't find a CD-ROM drive with a CD-DA in it\n");
exit(3);
}
psz_device = strdup(ppsz_cdda_drives[0]);
cdio_free_device_list(ppsz_all_cd_drives);
cdio_free_device_list(ppsz_cdda_drives);
}
if (!b_cd && todo != EJECT_CD) {
cd_close(psz_device);
}
/* open device */
if (b_verbose)
fprintf(stderr,"open %s... ", psz_device);
p_cdio = cdio_open (psz_device, driver_id);
if (!p_cdio) {
if (b_verbose)
fprintf(stderr, "error: %s\n", strerror(errno));
else
fprintf(stderr, "open %s: %s\n", psz_device, strerror(errno));
exit(1);
} else
if (b_verbose) fprintf(stderr,"ok\n");
if (EJECT_CD == todo) {
i_rc = cd_eject() ? 0 : 1;
} else {
read_toc(p_cdio);
if (!b_cd) {
cd_close(psz_device);
read_toc(p_cdio);
}
if (b_cd)
switch (todo) {
case NO_OP:
break;
case STOP_PLAYING:
i_rc = cd_stop(p_cdio) ? 0 : 1;
break;
case EJECT_CD:
/* Should have been handled above before case statement. gcc
warns if we don't include this. And with this Coverty
complains when we do - we can't win, so go with gcc. */
cd_eject();
break;
case PLAY_TRACK:
/* play just this one track */
play_track(start_track, stop_track);
break;
case PLAY_CD:
play_track(1,CDIO_CDROM_LEADOUT_TRACK);
break;
case CLOSE_CD:
i_rc = cdio_close_tray(psz_device, NULL) ? 0 : 1;
break;
case SET_VOLUME:
{
cdio_audio_volume_t volume;
volume.level[0] = i_volume_level;
i_rc = (DRIVER_OP_SUCCESS == cdio_audio_set_volume(p_cdio,
&volume))
? 0 : 1;
break;
}
case LIST_SUBCHANNEL:
if (read_subchannel(p_cdio)) {
if (sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY) {
{
printf("track %2d - %02x:%02x (%02x:%02x abs) ",
sub.track, sub.rel_addr.m, sub.rel_addr.s,
sub.abs_addr.m, sub.abs_addr.s);
}
}
printf("drive state: %s\n",
mmc_audio_state2str(sub.audio_status));
} else {
i_rc = 1;
}
break;
}
else {
fprintf(stderr,"no CD in drive (%s)\n", psz_device);
}
}
oops("bye", i_rc);
return 0; /* keep compiler happy */
}
int
main(int argc, char *argv[])
{
int c, nostop=0;
char *h;
int i_rc = 0;
cd_operation_t cd_op = NO_OP; /* operation to do in non-interactive mode */
psz_program = strrchr(argv[0],'/');
psz_program = psz_program ? psz_program+1 : argv[0];
memset(&cddb_opts, 0, sizeof(cddb_opts));
cdio_loglevel_default = CDIO_LOG_WARN;
/* parse options */
while ( 1 ) {
if (-1 == (c = getopt(argc, argv, "acCdehkplL:sSt:vx")))
break;
switch (c) {
case 'v':
b_verbose = true;
if (cdio_loglevel_default > CDIO_LOG_INFO)
cdio_loglevel_default = CDIO_LOG_INFO;
break;
case 'd':
debug = 1;
if (cdio_loglevel_default > CDIO_LOG_DEBUG)
cdio_loglevel_default = CDIO_LOG_DEBUG;
break;
case 'a':
auto_mode = 1;
break;
case 'L':
i_volume_level = atoi(optarg);
cd_op = SET_VOLUME;
b_interactive = false;
break;
case 't':
if (NULL != (h = strchr(optarg,'-'))) {
*h = 0;
start_track = atoi(optarg);
stop_track = atoi(h+1)+1;
if (0 == start_track) start_track = 1;
if (1 == stop_track) stop_track = CDIO_CDROM_LEADOUT_TRACK;
} else {
start_track = atoi(optarg);
stop_track = start_track+1;
one_track = 1;
}
b_interactive = false;
cd_op = PLAY_TRACK;
break;
case 'p':
b_interactive = false;
cd_op = PLAY_CD;
break;
case 'l':
b_interactive = false;
cd_op = LIST_TRACKS;
break;
case 'C':
b_interactive = false;
cd_op = CLOSE_CD;
break;
case 'c':
b_interactive = false;
cd_op = PS_LIST_TRACKS;
break;
case 's':
b_interactive = false;
cd_op = STOP_PLAYING;
break;
case 'S':
b_interactive = false;
cd_op = LIST_SUBCHANNEL;
break;
case 'e':
b_interactive = false;
cd_op = EJECT_CD;
break;
case 'k':
print_keys();
exit(1);
case 'h':
usage(psz_program);
exit(1);
default:
usage(psz_program);
exit(1);
}
}
if (argc > optind) {
psz_device = strdup(argv[optind]);
} else {
char **ppsz_cdda_drives=NULL;
char **ppsz_all_cd_drives = cdio_get_devices_ret(&driver_id);
if (!ppsz_all_cd_drives) {
fprintf(stderr, "Can't find a CD-ROM drive\n");
exit(2);
}
ppsz_cdda_drives = cdio_get_devices_with_cap(ppsz_all_cd_drives,
CDIO_FS_AUDIO, false);
if (!ppsz_cdda_drives || !ppsz_cdda_drives[0]) {
fprintf(stderr, "Can't find a CD-ROM drive with a CD-DA in it\n");
exit(3);
}
psz_device = strdup(ppsz_cdda_drives[0]);
cdio_free_device_list(ppsz_all_cd_drives);
cdio_free_device_list(ppsz_cdda_drives);
}
if (!b_interactive) {
b_sig = true;
nostop=1;
}
tty_raw();
signal(SIGINT,ctrlc);
signal(SIGQUIT,ctrlc);
signal(SIGTERM,ctrlc);
signal(SIGHUP,ctrlc);
signal(SIGWINCH, sigwinch);
if (CLOSE_CD != cd_op) {
/* open device */
if (b_verbose)
fprintf(stderr, "open %s... ", psz_device);
p_cdio = cdio_open (psz_device, driver_id);
if (!p_cdio && cd_op != EJECT_CD) {
cd_close(psz_device);
p_cdio = cdio_open (psz_device, driver_id);
}
if (p_cdio && b_verbose)
fprintf(stderr,"ok\n");
}
if (b_interactive) {
#ifdef HAVE_CDDB
cddb_log_set_handler (cddb_log_handler);
#else
;
#endif
} else {
b_sig = true;
nostop=1;
if (EJECT_CD == cd_op) {
i_rc = cd_eject() ? 0 : 1;
} else {
switch (cd_op) {
case PS_LIST_TRACKS:
case LIST_TRACKS:
case PLAY_TRACK:
read_toc(p_cdio);
default:
break;
}
if (p_cdio)
switch (cd_op) {
case STOP_PLAYING:
b_cd = true;
i_rc = cd_stop(p_cdio) ? 0 : 1;
break;
case EJECT_CD:
/* Should have been handled above. */
cd_eject();
break;
case LIST_TRACKS:
list_tracks();
break;
case PS_LIST_TRACKS:
ps_list_tracks();
break;
case PLAY_TRACK:
/* play just this one track */
if (b_record) {
printf("%s / %s\n", artist, title);
if (one_track)
printf("%s\n", cd_info[start_track].title);
}
i_rc = play_track(start_track, stop_track) ? 0 : 1;
break;
case PLAY_CD:
if (b_record)
printf("%s / %s\n", artist, title);
play_track(1,CDIO_CDROM_LEADOUT_TRACK);
break;
case SET_VOLUME:
i_rc = set_volume_level(p_cdio, i_volume_level);
break;
case LIST_SUBCHANNEL:
if (read_subchannel(p_cdio)) {
if (sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY) {
{
printf("track %2d - %02x:%02x (%02x:%02x abs) ",
sub.track, sub.rel_addr.m, sub.rel_addr.s,
sub.abs_addr.m, sub.abs_addr.s);
}
}
printf("drive state: %s\n",
mmc_audio_state2str(sub.audio_status));
} else {
i_rc = 1;
}
break;
case CLOSE_CD: /* Handled below */
case LIST_KEYS:
case TOGGLE_PAUSE:
case EXIT_PROGRAM:
case NO_OP:
break;
}
else if (CLOSE_CD == cd_op) {
i_rc = (DRIVER_OP_SUCCESS == cdio_close_tray(psz_device, NULL))
? 0 : 1;
} else {
fprintf(stderr,"no CD in drive (%s)\n", psz_device);
}
}
}
/* Play all tracks *unless* we have a play or paused status
already. */
read_subchannel(p_cdio);
if (sub.audio_status != CDIO_MMC_READ_SUB_ST_PAUSED &&
sub.audio_status != CDIO_MMC_READ_SUB_ST_PLAY)
play_track(1, CDIO_CDROM_LEADOUT_TRACK);
while ( !b_sig ) {
int key;
if (!b_cd) read_toc(p_cdio);
read_subchannel(p_cdio);
display_status(false);
if (1 == select_wait(b_cd ? 1 : 5)) {
switch (key = getch()) {
case '-':
decrease_volume_level(p_cdio);
break;
case '+':
increase_volume_level(p_cdio);
break;
case 'A':
case 'a':
auto_mode = !auto_mode;
break;
case 'X':
case 'x':
nostop=1;
/* fall through */
case 'Q':
case 'q':
b_sig = true;
break;
case 'E':
case 'e':
cd_eject();
break;
case 's':
cd_stop(p_cdio);
break;
case 'C':
case 'c':
cd_close(psz_device);
break;
case 'L':
case 'l':
b_all_tracks = !b_all_tracks;
if (b_all_tracks)
display_tracks();
else {
i_last_display_track = CDIO_INVALID_TRACK;
display_cdinfo(p_cdio, i_tracks, i_first_track);
}
break;
case 'K':
case 'k':
case 'h':
case 'H':
case '?':
list_keys();
break;
case ' ':
case 'P':
case 'p':
toggle_pause();
break;
case KEY_RIGHT:
if (b_cd &&
(sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY))
play_track(sub.track+1, CDIO_CDROM_LEADOUT_TRACK);
else
play_track(1,CDIO_CDROM_LEADOUT_TRACK);
break;
case KEY_LEFT:
if (b_cd &&
(sub.audio_status == CDIO_MMC_READ_SUB_ST_PAUSED ||
sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY))
play_track(sub.track-1,CDIO_CDROM_LEADOUT_TRACK);
break;
case KEY_UP:
if (b_cd && sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY)
skip(10);
break;
case KEY_DOWN:
if (b_cd && sub.audio_status == CDIO_MMC_READ_SUB_ST_PLAY)
skip(-10);
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
play_track(key - '0', CDIO_CDROM_LEADOUT_TRACK);
break;
case '0':
play_track(10, CDIO_CDROM_LEADOUT_TRACK);
break;
case KEY_F(1):
case KEY_F(2):
case KEY_F(3):
case KEY_F(4):
case KEY_F(5):
case KEY_F(6):
case KEY_F(7):
case KEY_F(8):
case KEY_F(9):
case KEY_F(10):
case KEY_F(11):
case KEY_F(12):
case KEY_F(13):
case KEY_F(14):
case KEY_F(15):
case KEY_F(16):
case KEY_F(17):
case KEY_F(18):
case KEY_F(19):
case KEY_F(20):
play_track(key - KEY_F(1) + 11, CDIO_CDROM_LEADOUT_TRACK);
break;
}
}
}
if (!nostop) cd_stop(p_cdio);
tty_restore();
finish("bye", i_rc);
return 0; /* keep compiler happy */
}
