void CddaImpl::read_toc()
{
_cdtext = cdio_get_cdtext(_cdio);
track_t tracks = cdda_tracks(_cdrom);
for (int i = 1; i <= tracks; i++)
{
if (not cdda_track_audiop(_cdrom, i))
continue;
CddaTrackImpl* cd_track = new CddaTrackImpl(this, i);
_tracks.push_back(cd_track);
_audio_length += cd_track->offset();
}
}
/* this function gets called by the gui to update mplayer */
static void guiSetEvent(int event)
{
if(guiInfo.mpcontext)
mixer = mpctx_get_mixer(guiInfo.mpcontext);
switch(event)
{
case evPlay:
case evPlaySwitchToPause:
case evPauseSwitchToPlay:
uiPlay();
break;
case evPause:
uiPause();
break;
#ifdef CONFIG_DVDREAD
case evPlayDVD:
{
static char dvdname[MAX_PATH];
guiInfo.Track = 1;
guiInfo.Chapter = 1;
guiInfo.Angle = 1;
guiInfo.NewPlay = GUI_FILE_SAME;
#ifdef __WINE__
// dvd_device is in the Windows style (D:\), which needs to be
// converted for MPlayer, so that it will find the device in the
// Linux filesystem.
dvd_device = unix_device(dvd_device);
#endif
uiSetFileName(NULL, dvd_device, STREAMTYPE_DVD);
dvdname[0] = 0;
strcat(dvdname, "DVD Movie");
GetVolumeInformation(dvd_device, dvdname, MAX_PATH, NULL, NULL, NULL, NULL, 0);
capitalize(dvdname);
mp_msg(MSGT_GPLAYER, MSGL_V, "Opening DVD %s -> %s\n", dvd_device, dvdname);
mygui->playlist->clear_playlist(mygui->playlist);
mygui->playlist->add_track(mygui->playlist, filename, NULL, dvdname, 0);
uiPlay();
break;
}
#endif
#ifdef CONFIG_CDDA
case evPlayCD:
{
int i;
char track[10];
char trackname[10];
#ifdef CONFIG_LIBCDIO
cdrom_drive_t *cd;
#else
cdrom_drive *cd;
#endif
int i_tracks;
#ifdef __WINE__
// cdrom_device is in the Windows style (D:\), which needs to be
// converted for MPlayer, so that it will find the device in the
// Linux filesystem.
cdrom_device = unix_device(cdrom_device);
#endif
cd = cdda_identify(cdrom_device, 0, NULL);
if (cd)
{
if (cdda_open(cd) != 0)
{
cdda_close(cd);
cd = NULL;
}
}
if(!cd)
{
printf("Couldn't find a driver.\n");
break;
}
i_tracks = cdda_tracks(cd);
mygui->playlist->clear_playlist(mygui->playlist);
for(i=0;i<i_tracks;i++)
{
sprintf(track, "cdda://%d", i+1);
sprintf(trackname, "Track %d", i+1);
mygui->playlist->add_track(mygui->playlist, track, NULL, trackname, 0);
}
cdda_close(cd);
mygui->startplay(mygui);
break;
}
#endif
case evFullScreen:
mp_input_queue_cmd(mp_input_parse_cmd("vo_fullscreen"));
break;
case evExit:
{
/* We are asking mplayer to exit, later it will ask us after uninit is made
this should be the only safe way to quit */
mygui->activewidget = NULL;
mp_input_queue_cmd(mp_input_parse_cmd("quit"));
break;
}
case evStop:
if(guiInfo.Playing)
gui(GUI_SET_STATE, (void *) GUI_STOP);
break;
case evSetMoviePosition:
{
rel_seek_secs = guiInfo.Position / 100.0f;
abs_seek_pos = 3;
break;
}
case evForward10sec:
{
rel_seek_secs = 10.0f;
abs_seek_pos = 0;
break;
}
case evBackward10sec:
{
rel_seek_secs = -10.0f;
abs_seek_pos = 0;
break;
}
case evSetBalance:
case evSetVolume:
{
float l,r;
if (guiInfo.Playing == GUI_STOP)
break;
if (guiInfo.Balance == 50.0f)
mixer_setvolume(mixer, guiInfo.Volume, guiInfo.Volume);
l = guiInfo.Volume * ((100.0f - guiInfo.Balance) / 50.0f);
r = guiInfo.Volume * ((guiInfo.Balance) / 50.0f);
if (l > guiInfo.Volume) l=guiInfo.Volume;
if (r > guiInfo.Volume) r=guiInfo.Volume;
mixer_setvolume(mixer, l, r);
/* Check for balance support on mixer - there is a better way ?? */
if (r != l)
{
mixer_getvolume(mixer, &l, &r);
if (r == l)
{
mp_msg(MSGT_GPLAYER, MSGL_V, "[GUI] Mixer doesn't support balanced audio\n");
mixer_setvolume(mixer, guiInfo.Volume, guiInfo.Volume);
guiInfo.Balance = 50.0f;
}
}
break;
}
case evMute:
{
mp_cmd_t * cmd = calloc(1, sizeof(*cmd));
cmd->id=MP_CMD_MUTE;
cmd->name=strdup("mute");
mp_input_queue_cmd(cmd);
break;
}
case evLoadPlay:
{
switch(guiInfo.StreamType)
{
case STREAMTYPE_DVD:
{
guiInfo.NewPlay = GUI_FILE_SAME;
gui(GUI_SET_STATE, (void *) GUI_PLAY);
break;
}
default:
{
guiInfo.NewPlay = GUI_FILE_NEW;
update_playlistwindow();
uiGotoTheNext = guiInfo.Playing? 0 : 1;
gui(GUI_SET_STATE, (void *) GUI_STOP);
gui(GUI_SET_STATE, (void *) GUI_PLAY);
break;
}
}
break;
}
case evNext:
uiNext();
break;
case evPrev:
uiPrev();
break;
}
}
static int open_cdda(stream_t *st, int m)
{
cdda_priv *priv = st->priv;
cdda_priv *p = priv;
int mode = p->paranoia_mode;
int offset = p->toc_offset;
cdrom_drive_t *cdd = NULL;
int last_track;
if (m != STREAM_READ) {
return STREAM_UNSUPPORTED;
}
if (!p->device) {
if (cdrom_device)
p->device = talloc_strdup(NULL, cdrom_device);
else
p->device = talloc_strdup(NULL, DEFAULT_CDROM_DEVICE);
}
#if defined(__NetBSD__)
cdd = cdda_identify_scsi(p->device, p->device, 0, NULL);
#else
cdd = cdda_identify(p->device, 0, NULL);
#endif
if (!cdd) {
MP_ERR(st, "Can't open CDDA device.\n");
return STREAM_ERROR;
}
cdda_verbose_set(cdd, CDDA_MESSAGE_FORGETIT, CDDA_MESSAGE_FORGETIT);
if (p->sector_size)
cdd->nsectors = p->sector_size;
if (cdda_open(cdd) != 0) {
MP_ERR(st, "Can't open disc.\n");
cdda_close(cdd);
return STREAM_ERROR;
}
priv = malloc(sizeof(cdda_priv));
memset(priv, 0, sizeof(cdda_priv));
priv->cd = cdd;
if (p->toc_bias)
offset -= cdda_track_firstsector(cdd, 1);
if (offset) {
for (int n = 0; n < cdd->tracks + 1; n++)
cdd->disc_toc[n].dwStartSector += offset;
}
if (p->speed > 0)
cdda_speed_set(cdd, p->speed);
last_track = cdda_tracks(cdd);
if (p->span[0] > last_track)
p->span[0] = last_track;
if (p->span[1] < p->span[0])
p->span[1] = p->span[0];
if (p->span[1] > last_track)
p->span[1] = last_track;
if (p->span[0])
priv->start_sector = cdda_track_firstsector(cdd, p->span[0]);
else
priv->start_sector = cdda_disc_firstsector(cdd);
if (p->span[1])
priv->end_sector = cdda_track_lastsector(cdd, p->span[1]);
else
priv->end_sector = cdda_disc_lastsector(cdd);
priv->cdp = paranoia_init(cdd);
if (priv->cdp == NULL) {
cdda_close(cdd);
free(priv);
return STREAM_ERROR;
}
if (mode == 0)
mode = PARANOIA_MODE_DISABLE;
else if (mode == 1)
mode = PARANOIA_MODE_OVERLAP;
else
mode = PARANOIA_MODE_FULL;
if (p->no_skip)
mode |= PARANOIA_MODE_NEVERSKIP;
else
mode &= ~PARANOIA_MODE_NEVERSKIP;
if (p->search_overlap > 0)
mode |= PARANOIA_MODE_OVERLAP;
else if (p->search_overlap == 0)
mode &= ~PARANOIA_MODE_OVERLAP;
paranoia_modeset(priv->cdp, mode);
if (p->search_overlap > 0)
paranoia_overlapset(priv->cdp, p->search_overlap);
paranoia_seek(priv->cdp, priv->start_sector, SEEK_SET);
priv->sector = priv->start_sector;
st->priv = priv;
st->start_pos = priv->start_sector * CDIO_CD_FRAMESIZE_RAW;
st->end_pos = (priv->end_sector + 1) * CDIO_CD_FRAMESIZE_RAW;
st->sector_size = CDIO_CD_FRAMESIZE_RAW;
st->fill_buffer = fill_buffer;
st->seek = seek;
st->control = control;
st->close = close_cdda;
st->demuxer = "rawaudio";
print_cdtext(st, 0);
return STREAM_OK;
}
static int open_cdda(stream_t *st,int m, void* opts, int* file_format) {
struct cdda_params* p = (struct cdda_params*)opts;
int mode = p->paranoia_mode;
int offset = p->toc_offset;
#ifndef HAVE_LIBCDIO
cdrom_drive* cdd = NULL;
#else
cdrom_drive_t* cdd = NULL;
#endif
cdda_priv* priv;
cd_info_t *cd_info,*cddb_info = NULL;
unsigned int audiolen=0;
int last_track;
int i;
char *xmcd_file = NULL;
if(m != STREAM_READ) {
m_struct_free(&stream_opts,opts);
return STREAM_UNSUPORTED;
}
if(!p->device) {
if (cdrom_device)
p->device = strdup(cdrom_device);
else
p->device = strdup(DEFAULT_CDROM_DEVICE);
}
#ifdef HAVE_CDDB
// cdd_identify returns -1 if it cannot read the TOC,
// in which case there is no point in calling cddb_resolve
if(cdd_identify(p->device) >= 0 && strncmp(st->url,"cddb",4) == 0) {
i = cddb_resolve(p->device, &xmcd_file);
if(i == 0) {
cddb_info = cddb_parse_xmcd(xmcd_file);
free(xmcd_file);
}
}
#endif
#ifndef HAVE_LIBCDIO
if(p->generic_dev)
cdd = cdda_identify_scsi(p->generic_dev,p->device,0,NULL);
else
#endif
#if defined(__NetBSD__)
cdd = cdda_identify_scsi(p->device,p->device,0,NULL);
#else
cdd = cdda_identify(p->device,0,NULL);
#endif
if(!cdd) {
mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_MPDEMUX_CDDA_CantOpenCDDADevice);
m_struct_free(&stream_opts,opts);
free(cddb_info);
return STREAM_ERROR;
}
cdda_verbose_set(cdd, CDDA_MESSAGE_FORGETIT, CDDA_MESSAGE_FORGETIT);
if(p->sector_size) {
cdd->nsectors = p->sector_size;
#ifndef HAVE_LIBCDIO
cdd->bigbuff = p->sector_size * CD_FRAMESIZE_RAW;
#endif
}
if(cdda_open(cdd) != 0) {
mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_MPDEMUX_CDDA_CantOpenDisc);
cdda_close(cdd);
m_struct_free(&stream_opts,opts);
free(cddb_info);
return STREAM_ERROR;
}
cd_info = cd_info_new();
mp_msg(MSGT_OPEN,MSGL_INFO,MSGTR_MPDEMUX_CDDA_AudioCDFoundWithNTracks,cdda_tracks(cdd));
for(i=0;i<cdd->tracks;i++) {
char track_name[80];
long sec=cdda_track_firstsector(cdd,i+1);
long off=cdda_track_lastsector(cdd,i+1)-sec+1;
sprintf(track_name, "Track %d", i+1);
cd_info_add_track(cd_info, track_name, i+1, (unsigned int)(off/(60*75)), (unsigned int)((off/75)%60), (unsigned int)(off%75), sec, off );
audiolen += off;
}
cd_info->min = (unsigned int)(audiolen/(60*75));
cd_info->sec = (unsigned int)((audiolen/75)%60);
cd_info->msec = (unsigned int)(audiolen%75);
priv = malloc(sizeof(cdda_priv));
memset(priv, 0, sizeof(cdda_priv));
priv->cd = cdd;
priv->cd_info = cd_info;
if(p->toc_bias)
offset -= cdda_track_firstsector(cdd,1);
if(offset) {
int i;
for(i = 0 ; i < cdd->tracks + 1 ; i++)
cdd->disc_toc[i].dwStartSector += offset;
}
if(p->speed)
cdda_speed_set(cdd,p->speed);
last_track = cdda_tracks(cdd);
if (p->span.start > last_track) p->span.start = last_track;
if (p->span.end < p->span.start) p->span.end = p->span.start;
if (p->span.end > last_track) p->span.end = last_track;
if(p->span.start)
priv->start_sector = cdda_track_firstsector(cdd,p->span.start);
else
priv->start_sector = cdda_disc_firstsector(cdd);
if(p->span.end) {
priv->end_sector = cdda_track_lastsector(cdd,p->span.end);
} else
priv->end_sector = cdda_disc_lastsector(cdd);
priv->cdp = paranoia_init(cdd);
if(priv->cdp == NULL) {
cdda_close(cdd);
free(priv);
cd_info_free(cd_info);
m_struct_free(&stream_opts,opts);
free(cddb_info);
return STREAM_ERROR;
}
if(mode == 0)
mode = PARANOIA_MODE_DISABLE;
else if(mode == 1)
mode = PARANOIA_MODE_OVERLAP;
else
mode = PARANOIA_MODE_FULL;
if(p->no_skip)
mode |= PARANOIA_MODE_NEVERSKIP;
#ifndef HAVE_LIBCDIO
paranoia_modeset(cdd, mode);
if(p->search_overlap >= 0)
paranoia_overlapset(cdd,p->search_overlap);
#else
paranoia_modeset(priv->cdp, mode);
if(p->search_overlap >= 0)
paranoia_overlapset(priv->cdp,p->search_overlap);
#endif
paranoia_seek(priv->cdp,priv->start_sector,SEEK_SET);
priv->sector = priv->start_sector;
#ifdef HAVE_CDDB
if(cddb_info) {
cd_info_free(cd_info);
priv->cd_info = cddb_info;
cd_info_debug( cddb_info );
}
#endif
st->priv = priv;
st->start_pos = priv->start_sector*CD_FRAMESIZE_RAW;
st->end_pos = priv->end_sector*CD_FRAMESIZE_RAW;
st->type = STREAMTYPE_CDDA;
st->sector_size = CD_FRAMESIZE_RAW;
st->fill_buffer = fill_buffer;
st->seek = seek;
st->close = close_cdda;
*file_format = DEMUXER_TYPE_RAWAUDIO;
m_struct_free(&stream_opts,opts);
return STREAM_OK;
}
unsigned LocalAudioCD::Create(const std::string& device, AudioCDPtr *pcd)
{
*pcd = AudioCDPtr(NULL);
TRACE << "Calling identify\n";
cdrom_drive *cdt = cdda_identify(device.c_str(), CDDA_MESSAGE_FORGETIT,
NULL);
if (!cdt)
{
TRACE << "Can't identify CD drive\n";
return EINVAL;
}
TRACE << "Identified\n";
int rc = cdda_open(cdt);
if (rc<0)
{
TRACE << "Can't open CD drive\n";
return (unsigned)errno;
}
TRACE << "Opened\n";
unsigned int total = (unsigned int)cdda_tracks(cdt);
TRACE << "Got tracks\n";
if (total == (track_t)-1)
{
cdda_close(cdt);
TRACE << "No audio tracks\n";
return ENOENT;
}
toc_t toc;
unsigned total_sectors = 0;
for (track_t i=1; i<=total; ++i) // Peculiar 1-based numbering
{
if (cdda_track_audiop(cdt, i))
{
TocEntry te;
te.first_sector = (int)cdda_track_firstsector(cdt, i);
te.last_sector = (int)cdda_track_lastsector(cdt, i);
TRACE << "Track " << i << " " << te.first_sector
<< ".." << te.last_sector << "\n";
toc.push_back(te);
total_sectors += (unsigned)(te.last_sector - te.first_sector + 1);
}
else
{
// TRACE << "Track " << i+1 << " not audio\n";
}
}
if (toc.empty())
{
cdda_close(cdt);
TRACE << "No audio tracks\n";
return ENOENT;
}
TRACE << "Opened with " << toc.size() << " tracks\n";
LocalAudioCD *cd = new LocalAudioCD();
cd->m_toc = toc;
cd->m_cdt = cdt;
cd->m_total_sectors = total_sectors;
*pcd = AudioCDPtr(cd);
return 0;
}
/*
* Class: org_tritonus_lowlevel_cdda_cdparanoia_Cdparanoia
* Method: readTOC
* Signature: ([I[I[I[I[Z[Z[Z[I)I
*/
JNIEXPORT jint JNICALL
Java_org_tritonus_lowlevel_cdda_cdparanoia_Cdparanoia_readTOC
(JNIEnv* env, jobject obj,
jintArray anValues,
jintArray anStartFrame,
jintArray anLength,
jintArray anType,
jbooleanArray abAudio,
jbooleanArray abCopy,
jbooleanArray abPre,
jintArray anChannels)
{
handle_t* handle;
cdrom_drive* cdrom;
int nFirstTrack;
int nLastTrack;
jint* pnValues;
jint* pnStartFrame;
jint* pnLength;
jint* pnType;
jboolean* pbAudio;
jboolean* pbCopy;
jboolean* pbPre;
jint* pnChannels;
int nTrack;
if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_cdda_cdparanoia_Cdparanoia_readTOC(): begin\n"); }
handle = getHandle(env, obj);
cdrom = handle->drive;
checkArrayLength(env, anValues, 2);
pnValues = (*env)->GetIntArrayElements(env, anValues, NULL);
if (pnValues == NULL)
{
throwRuntimeException(env, "GetIntArrayElements failed");
}
// TODO: check if first track is guaranteed to be 1
pnValues[0] = 1;
pnValues[1] = cdda_tracks(cdrom);
nFirstTrack = 1;
nLastTrack = cdda_tracks(cdrom);
(*env)->ReleaseIntArrayElements(env, anValues, pnValues, 0);
checkArrayLength(env, anStartFrame, 100);
pnStartFrame = (*env)->GetIntArrayElements(env, anStartFrame, NULL);
if (pnStartFrame == NULL)
{
throwRuntimeException(env, "GetIntArrayElements failed");
}
checkArrayLength(env, anLength, 100);
pnLength = (*env)->GetIntArrayElements(env, anLength, NULL);
if (pnLength == NULL)
{
throwRuntimeException(env, "GetIntArrayElements failed");
}
checkArrayLength(env, anType, 100);
pnType = (*env)->GetIntArrayElements(env, anType, NULL);
if (pnType == NULL)
{
throwRuntimeException(env, "GetIntArrayElements failed");
}
checkArrayLength(env, abAudio, 100);
pbAudio = (*env)->GetBooleanArrayElements(env, abAudio, NULL);
if (pbAudio == NULL)
{
throwRuntimeException(env, "GetBooleanArrayElements failed");
}
checkArrayLength(env, abCopy, 100);
pbCopy = (*env)->GetBooleanArrayElements(env, abCopy, NULL);
if (pbCopy == NULL)
{
throwRuntimeException(env, "GetBooleanArrayElements failed");
}
checkArrayLength(env, abPre, 100);
pbPre = (*env)->GetBooleanArrayElements(env, abPre, NULL);
if (pbPre == NULL)
{
throwRuntimeException(env, "GetBooleanArrayElements failed");
}
checkArrayLength(env, anChannels, 100);
pnChannels = (*env)->GetIntArrayElements(env, anChannels, NULL);
if (pnChannels == NULL)
{
throwRuntimeException(env, "GetIntArrayElements failed");
}
for (nTrack = nFirstTrack; nTrack <= nLastTrack; nTrack++)
{
pnStartFrame[nTrack - nFirstTrack] = cdda_track_firstsector(cdrom, nTrack);
pnLength[nTrack - nFirstTrack] = cdda_track_lastsector(cdrom, nTrack) - cdda_track_firstsector(cdrom, nTrack) + 1;
pnType[nTrack - nFirstTrack] = 0; // TODO: toc_entry.cdte_ctrl & CDROM_DATA_TRACK;
pbAudio[nTrack - nFirstTrack] = cdda_track_audiop(cdrom, nTrack);
pbCopy[nTrack - nFirstTrack] = cdda_track_copyp(cdrom, nTrack);
pbPre[nTrack - nFirstTrack] = cdda_track_preemp(cdrom, nTrack);
pnChannels[nTrack - nFirstTrack] = cdda_track_channels(cdrom, nTrack);
if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_cdda_cdparanoia_Cdparanoia_readTOC(): %d: %d %ld %ld\n", nTrack - nFirstTrack, nTrack, (long) pnStartFrame[nTrack - nFirstTrack], (long) pnLength[nTrack - nFirstTrack]); }
}
(*env)->ReleaseIntArrayElements(env, anStartFrame, pnStartFrame, 0);
(*env)->ReleaseIntArrayElements(env, anLength, pnLength, 0);
(*env)->ReleaseIntArrayElements(env, anType, pnType, 0);
(*env)->ReleaseBooleanArrayElements(env, abAudio, pbAudio, 0);
(*env)->ReleaseBooleanArrayElements(env, abCopy, pbCopy, 0);
(*env)->ReleaseBooleanArrayElements(env, abPre, pbPre, 0);
(*env)->ReleaseIntArrayElements(env, anChannels, pnChannels, 0);
if (debug_flag) { fprintf(debug_file, "Java_org_tritonus_lowlevel_cdda_cdparanoia_Cdparanoia_readTOC(): end\n"); }
return 0;
}
