void CddaLister::Init() {
cdio_init();
#ifdef Q_OS_DARWIN
if (!cdio_have_driver(DRIVER_OSX)) {
qLog(Error) << "libcdio was compiled without support for OS X!";
}
#endif
char **devices = cdio_get_devices(DRIVER_DEVICE);
if (!devices) {
qLog(Debug) << "No CD devices found";
return;
}
for (; *devices != NULL; ++devices) {
QString device(*devices);
QFileInfo device_info(device);
if (device_info.isSymLink()) {
device = device_info.symLinkTarget();
}
#ifdef Q_OS_DARWIN
// Every track is detected as a separate device on Darwin. The raw disk looks
// like /dev/rdisk1
if (!device.contains(QRegExp("^/dev/rdisk[0-9]$"))) {
continue;
}
#endif
if (!devices_list_.contains(device)) {
devices_list_ << device;
emit DeviceAdded(device);
}
}
}
int
main(int argc, const char *argv[])
{
char **ppsz_cd_drives=NULL, **c;
cdio_log_set_handler (log_handler);
/* Print out a list of CD-drives */
ppsz_cd_drives = cdio_get_devices(DRIVER_DEVICE);
if (NULL != ppsz_cd_drives)
for( c = ppsz_cd_drives; *c != NULL; c++ ) {
printf("Drive %s\n", *c);
}
cdio_free_device_list(ppsz_cd_drives);
ppsz_cd_drives = NULL;
printf("-----\n");
/* Print out a list of CD-drives the harder way. */
ppsz_cd_drives = cdio_get_devices_with_cap(NULL, CDIO_FS_MATCH_ALL, false);
if (NULL != ppsz_cd_drives) {
for( c = ppsz_cd_drives; *c != NULL; c++ ) {
printf("Drive %s\n", *c);
}
}
cdio_free_device_list(ppsz_cd_drives);
printf("-----\n");
printf("CD-DA drives...\n");
ppsz_cd_drives = NULL;
/* Print out a list of CD-drives with CD-DA's in them. */
ppsz_cd_drives = cdio_get_devices_with_cap(NULL, CDIO_FS_AUDIO, false);
if (NULL != ppsz_cd_drives) {
for( c = ppsz_cd_drives; *c != NULL; c++ ) {
printf("drive: %s\n", *c);
}
}
cdio_free_device_list(ppsz_cd_drives);
printf("-----\n");
ppsz_cd_drives = NULL;
printf("VCD drives...\n");
/* Print out a list of CD-drives with VCD's in them. */
ppsz_cd_drives = cdio_get_devices_with_cap(NULL,
(CDIO_FS_ANAL_SVCD|CDIO_FS_ANAL_CVD|CDIO_FS_ANAL_VIDEOCD|CDIO_FS_UNKNOWN),
true);
if (NULL != ppsz_cd_drives) {
for( c = ppsz_cd_drives; *c != NULL; c++ ) {
printf("drive: %s\n", *c);
}
}
cdio_free_device_list(ppsz_cd_drives);
return 0;
}
// Returns true if device is a cdrom/dvd drive
bool cdio_is_cdrom(std::string device)
{
#ifdef __linux__
// Resolve symbolic links. This allows symbolic links to valid
// drives to be passed from the command line with the -e flag.
char *devname = realpath(device.c_str(), NULL);
if (!devname)
return false;
#endif
std::vector<std::string> devices = cdio_get_devices();
bool res = false;
for (unsigned int i = 0; i < devices.size(); i++)
{
#ifdef __linux__
if (strncmp(devices[i].c_str(), devname, MAX_PATH) == 0)
#else
if (strncmp(devices[i].c_str(), device.c_str(), MAX_PATH) == 0)
#endif
{
res = true;
break;
}
}
#ifdef __linux__
if (devname)
free(devname);
#endif
devices.clear();
return res;
}
int
main(int argc, const char *argv[])
{
char **ppsz_cd_drives=NULL, **c;
cdio_log_set_handler (log_handler);
/* Print out a list of CD-drives */
ppsz_cd_drives = cdio_get_devices(DRIVER_DEVICE);
if (NULL != ppsz_cd_drives)
for( c = ppsz_cd_drives; *c != NULL; c++ ) {
printf("-- Drive %s\n", *c);
}
cdio_free_device_list(ppsz_cd_drives);
ppsz_cd_drives = NULL;
printf("-----\n");
/* Print out a list of CD-drives the harder way. */
print_drive_class("-- All CD-ROM drives (again)", CDIO_FS_MATCH_ALL, false);
print_drive_class("-- CD-ROM drives with a CD-DA loaded...",
CDIO_FS_AUDIO, false);
print_drive_class("-- CD-ROM drives with some sort of ISO 9660 filesystem...",
CDIO_FS_ANAL_ISO9660_ANY, true);
print_drive_class("-- (S)VCD drives...", CDIO_FS_ANAL_VCD_ANY, true);
return 0;
}
bgav_device_info_t * bgav_find_devices_vcd()
{
int i;
char * device_name;
char ** devices;
bgav_device_info_t * ret = NULL;
devices = cdio_get_devices(DRIVER_DEVICE);
if(!devices)
return 0;
i = 0;
while(devices[i])
{
device_name = NULL;
if(bgav_check_device_vcd(devices[i], &device_name))
{
ret = bgav_device_info_append(ret,
devices[i],
device_name);
if(device_name)
free(device_name);
}
i++;
}
cdio_free_device_list(devices);
return ret;
}
int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio;
char **ppsz_drives=NULL;
int n=0;
cdio_loglevel_default = (argc > 1) ? CDIO_LOG_DEBUG : CDIO_LOG_INFO;
/* snprintf(psz_nrgfile, sizeof(psz_nrgfile)-1,
"%s/%s", TEST_DIR, cue_file[i]);
*/
if (!cdio_have_driver(DRIVER_OSX)) return(77);
ppsz_drives = cdio_get_devices(DRIVER_DEVICE);
if (!ppsz_drives) {
printf("Can't find a CD-ROM drive. Skipping test.\n");
exit(77);
}
do {
p_cdio = cdio_open_osx(ppsz_drives[n]);
if (p_cdio) {
const char *psz_source = cdio_get_arg(p_cdio, "source");
const char *psz_access_mode = cdio_get_arg(p_cdio, "access-mode");
discmode_t discmode = cdio_get_discmode(p_cdio);
if (0 != strncmp(psz_source, ppsz_drives[0],
strlen(ppsz_drives[0]))) {
fprintf(stderr,
"Got %s; should get back %s, the name we opened.\n",
psz_source, ppsz_drives[0]);
exit(1);
}
if (0 != strncmp(psz_access_mode, "OS X", strlen("OS X"))) {
fprintf(stderr,
"Got %s; Should get back %s, the access mode requested.\n",
psz_access_mode, "OS X");
exit(2);
}
if (CDIO_DISC_MODE_ERROR == discmode) {
fprintf(stderr,
"Error getting disc mode for device %s.\n",
ppsz_drives[n]);
exit(3);
}
}
cdio_destroy(p_cdio);
}
while (ppsz_drives[++n] != NULL);
cdio_free_device_list(ppsz_drives);
return 0;
}
int
main(int argc, const char *argv[])
{
CdIo_t *p_cdio;
char **ppsz_drives=NULL;
cdio_loglevel_default = (argc > 1) ? CDIO_LOG_DEBUG : CDIO_LOG_INFO;
/* snprintf(psz_nrgfile, sizeof(psz_nrgfile)-1,
"%s/%s", TEST_DIR, cue_file[i]);
*/
if (!cdio_have_driver(DRIVER_SOLARIS)) return(77);
ppsz_drives = cdio_get_devices(DRIVER_DEVICE);
if (!ppsz_drives) {
printf("Can't find a CD-ROM drive. Skipping test.\n");
exit(77);
}
p_cdio = cdio_open_linux(ppsz_drives[0]);
if (p_cdio) {
const char *psz_source = cdio_get_arg(p_cdio, "source");
if (0 != strncmp(psz_source, ppsz_drives[0],
strlen(ppsz_drives[0]))) {
fprintf(stderr,
"Got %s; should get back %s, the name we opened.\n",
psz_source, ppsz_drives[0]);
exit(1);
}
}
cdio_destroy(p_cdio);
p_cdio = cdio_open_am_linux(ppsz_drives[0], "SCSI");
if (p_cdio) {
const char *psz_access_mode = cdio_get_arg(p_cdio, "access-mode");
if (0 != strncmp(psz_access_mode, "SCSI", strlen("SCSI"))) {
fprintf(stderr,
"Got %s; Should get back %s, the access mode requested.\n",
psz_access_mode, "SCSI");
exit(2);
}
}
cdio_destroy(p_cdio);
cdio_free_device_list(ppsz_drives);
return 0;
}
QStringList AudioCDDemux::getDevices()
{
QStringList devicesList;
if ( char **devices = cdio_get_devices( DRIVER_DEVICE ) )
{
for ( size_t i = 0 ; char *device = devices[ i ] ; ++i )
{
devicesList += device;
#ifdef Q_OS_WIN
devicesList.last().remove( 0, 4 );
#endif
}
cdio_free_device_list( devices );
}
return devicesList;
}
// Returns true if device is a cdrom/dvd drive
bool cdio_is_cdrom(std::string device)
{
#ifndef _WIN32
// Resolve symbolic links. This allows symbolic links to valid
// drives to be passed from the command line with the -e flag.
char resolved_path[MAX_PATH];
char *devname = realpath(device.c_str(), resolved_path);
if (!devname)
return false;
device = devname;
#endif
std::vector<std::string> devices = cdio_get_devices();
for (const std::string& d : devices)
{
if (d == device)
return true;
}
return false;
}
wxMenu* MainMenuBar::CreateFileMenu() const
{
auto* const external_drive_menu = new wxMenu;
const std::vector<std::string> drives = cdio_get_devices();
// Windows Limitation of 24 character drives
for (size_t i = 0; i < drives.size() && i < 24; i++)
{
const int drive_id = static_cast<int>(IDM_DRIVE1 + i);
external_drive_menu->Append(drive_id, StrToWxStr(drives[i]));
}
auto* const file_menu = new wxMenu;
file_menu->Append(wxID_OPEN, _("&Open..."));
file_menu->Append(IDM_CHANGE_DISC, _("Change &Disc..."));
file_menu->Append(IDM_DRIVES, _("&Boot from DVD Backup"), external_drive_menu);
file_menu->AppendSeparator();
file_menu->Append(wxID_REFRESH, _("&Refresh List"));
file_menu->AppendSeparator();
file_menu->Append(wxID_EXIT, _("E&xit") + "\tAlt+F4");
return file_menu;
}
void CGameListCtrl::ScanForISOs()
{
ClearIsoFiles();
CFileSearch::XStringVector Directories(SConfig::GetInstance().m_ISOFolder);
if (SConfig::GetInstance().m_RecursiveISOFolder)
{
for (u32 i = 0; i < Directories.size(); i++)
{
File::FSTEntry FST_Temp;
File::ScanDirectoryTree(Directories[i], FST_Temp);
for (u32 j = 0; j < FST_Temp.children.size(); j++)
{
if (FST_Temp.children[j].isDirectory)
{
bool duplicate = false;
for (u32 k = 0; k < Directories.size(); k++)
{
if (strcmp(Directories[k].c_str(),
FST_Temp.children[j].physicalName.c_str()) == 0)
{
duplicate = true;
break;
}
}
if (!duplicate)
Directories.push_back(
FST_Temp.children[j].physicalName.c_str());
}
}
}
}
CFileSearch::XStringVector Extensions;
if (SConfig::GetInstance().m_ListGC)
Extensions.push_back("*.gcm");
if (SConfig::GetInstance().m_ListWii || SConfig::GetInstance().m_ListGC)
{
Extensions.push_back("*.iso");
Extensions.push_back("*.ciso");
Extensions.push_back("*.gcz");
Extensions.push_back("*.wbfs");
}
if (SConfig::GetInstance().m_ListWad)
Extensions.push_back("*.wad");
CFileSearch FileSearch(Extensions, Directories);
const CFileSearch::XStringVector& rFilenames = FileSearch.GetFileNames();
if (rFilenames.size() > 0)
{
wxProgressDialog dialog(
_("Scanning for ISOs"),
_("Scanning..."),
(int)rFilenames.size() - 1,
this,
wxPD_APP_MODAL |
wxPD_AUTO_HIDE |
wxPD_CAN_ABORT |
wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME | wxPD_REMAINING_TIME |
wxPD_SMOOTH // - makes updates as small as possible (down to 1px)
);
for (u32 i = 0; i < rFilenames.size(); i++)
{
std::string FileName;
SplitPath(rFilenames[i], NULL, &FileName, NULL);
// Update with the progress (i) and the message
dialog.Update(i, wxString::Format(_("Scanning %s"),
wxString(FileName.c_str(), *wxConvCurrent).c_str()));
if (dialog.WasCancelled())
break;
std::auto_ptr<GameListItem> iso_file(new GameListItem(rFilenames[i]));
const GameListItem& ISOFile = *iso_file;
if (ISOFile.IsValid())
{
bool list = true;
switch(ISOFile.GetPlatform())
{
case GameListItem::WII_DISC:
if (!SConfig::GetInstance().m_ListWii)
list = false;
break;
case GameListItem::WII_WAD:
if (!SConfig::GetInstance().m_ListWad)
list = false;
break;
default:
if (!SConfig::GetInstance().m_ListGC)
list = false;
break;
}
switch(ISOFile.GetCountry())
{
case DiscIO::IVolume::COUNTRY_TAIWAN:
if (!SConfig::GetInstance().m_ListTaiwan)
list = false;
case DiscIO::IVolume::COUNTRY_KOREA:
if (!SConfig::GetInstance().m_ListKorea)
list = false;
break;
case DiscIO::IVolume::COUNTRY_JAPAN:
if (!SConfig::GetInstance().m_ListJap)
list = false;
break;
case DiscIO::IVolume::COUNTRY_USA:
if (!SConfig::GetInstance().m_ListUsa)
list = false;
break;
case DiscIO::IVolume::COUNTRY_FRANCE:
if (!SConfig::GetInstance().m_ListFrance)
list = false;
break;
case DiscIO::IVolume::COUNTRY_ITALY:
if (!SConfig::GetInstance().m_ListItaly)
list = false;
break;
default:
if (!SConfig::GetInstance().m_ListPal)
list = false;
break;
}
if (list)
m_ISOFiles.push_back(iso_file.release());
}
}
}
if (SConfig::GetInstance().m_ListDrives)
{
const std::vector<std::string> drives = cdio_get_devices();
for (std::vector<std::string>::const_iterator iter = drives.begin(); iter != drives.end(); ++iter)
{
#ifdef __APPLE__
std::auto_ptr<GameListItem> gli(new GameListItem(*iter));
#else
std::unique_ptr<GameListItem> gli(new GameListItem(*iter));
#endif
if (gli->IsValid())
m_ISOFiles.push_back(gli.release());
}
}
std::sort(m_ISOFiles.begin(), m_ISOFiles.end());
}
int
main(int argc, const char *argv[])
{
char **nrg_images=NULL;
char **bincue_images=NULL;
char **imgs;
char **c;
unsigned int i;
int ret=0;
const char *cue_files[2] = {"cdda.cue", "isofs-m1.cue"};
const char *nrg_files[1] = {"videocd.nrg"};
cdio_log_set_handler (log_handler);
if (cdio_have_driver(-1) != false)
{
printf("Bogus driver number -1 should be regexted\n");
return 5;
}
if (! (cdio_have_driver(DRIVER_NRG) && cdio_have_driver(DRIVER_BINCUE)) ) {
printf("You don't have enough drivers for this test\n");
exit(77);
}
nrg_images = cdio_get_devices(DRIVER_NRG);
for (imgs=nrg_images; *imgs != NULL; imgs++) {
printf("NRG image %s\n", *imgs);
}
if (!is_in(nrg_images, nrg_files[0])) {
cdio_free_device_list(nrg_images);
return 10;
}
bincue_images = cdio_get_devices(DRIVER_BINCUE);
for (imgs=bincue_images; *imgs != NULL; imgs++) {
printf("bincue image %s\n", *imgs);
}
for (i=0; i<2; i++) {
if (is_in(bincue_images, cue_files[i])) {
printf("%s parses as a CDRWIN BIN/CUE csheet.\n", cue_files[i]);
} else {
printf("%s doesn't parse as a CDRWIN BIN/CUE csheet.\n", cue_files[i]);
ret = i+1;
}
}
if (ret != 0) return ret;
printf("-----\n");
printf("ISO 9660 images...\n");
imgs = NULL;
/* Print out a list of CDDA-drives. */
imgs = cdio_get_devices_with_cap(bincue_images, CDIO_FS_ISO_9660, false);
if (NULL == imgs || *imgs == NULL) {
printf("Failed to find an ISO 9660 image\n");
return 11;
}
for( c = imgs; *c != NULL; c++ ) {
printf("%s\n", *c);
}
cdio_free_device_list(imgs);
free(imgs);
printf("-----\n");
printf("CD-DA images...\n");
imgs = NULL;
/* Print out a list of CDDA-drives. */
imgs = cdio_get_devices_with_cap(bincue_images, CDIO_FS_AUDIO, false);
if (NULL == imgs || *imgs == NULL) {
printf("Failed to find CDDA image\n");
return 12;
}
for( c = imgs; *c != NULL; c++ ) {
printf("%s\n", *c);
}
cdio_free_device_list(imgs);
free(imgs);
printf("-----\n");
imgs = NULL;
printf("VCD images...\n");
/* Print out a list of CD-drives with VCD's in them. */
imgs = cdio_get_devices_with_cap(nrg_images,
(CDIO_FS_ANAL_SVCD|CDIO_FS_ANAL_CVD|CDIO_FS_ANAL_VIDEOCD|CDIO_FS_UNKNOWN),
true);
if (NULL == imgs || *imgs == NULL) {
printf("Failed to find VCD image\n");
return 13;
}
for( c = imgs; *c != NULL; c++ ) {
printf("image: %s\n", *c);
}
cdio_free_device_list(imgs);
free(imgs);
imgs = NULL;
/* Print out a list of CDDA-drives. */
imgs = cdio_get_devices_with_cap(bincue_images, CDIO_FS_HIGH_SIERRA, false);
if (NULL != imgs && *imgs != NULL) {
printf("Found erroneous High Sierra image\n");
return 14;
}
imgs = NULL;
/* Print out a list of CDDA-drives. */
imgs = cdio_get_devices_with_cap(bincue_images, CDIO_FS_UFS, true);
if (NULL != imgs && *imgs != NULL) {
printf("Found erroneous UFS image\n");
return 15;
}
cdio_free_device_list(nrg_images);
cdio_free_device_list(bincue_images);
cdio_free_device_list(imgs);
return 0;
}
int
main(int argc, const char *argv[])
{
cdio_log_set_handler (log_handler);
#if defined(__MINGW32__)
printf("testgetdevices test skipped until drive recording testing issues resolved\n");
return 77;
#else
char **nrg_images=NULL;
char **bincue_images=NULL;
char **imgs;
unsigned int i;
int ret=0;
const char *cue_files[2] = {"cdda.cue", "isofs-m1.cue"};
const char *nrg_files[1] = {"videocd.nrg"};
if (cdio_have_driver(-1) != false)
{
fprintf(stderr, "Bogus driver number -1 should be rejected\n");
return 5;
}
#ifdef HAVE_SYS_UTSNAME_H
{
struct utsname utsname;
if (0 == uname(&utsname))
{
if (0 == strncmp("Linux", utsname.sysname, sizeof("Linux")))
{
if (!cdio_have_driver(DRIVER_LINUX))
{
fprintf(stderr,
"You should have been able to get GNU/Linux driver\n");
return 6;
} else {
printf("-- Good! You have the GNU/Linux driver installed.\n");
}
}
else if (0 == strncmp("CYGWIN", utsname.sysname, sizeof("CYGWIN")))
{
if (!cdio_have_driver(DRIVER_WIN32))
{
fprintf(stderr,
"You should have been able to get Win32 driver\n");
return 6;
} else {
printf("-- Good! You have the Win32 driver installed.\n");
}
}
else if (0 == strncmp("Darwin", utsname.sysname, sizeof("Darwin")))
{
if (!cdio_have_driver(DRIVER_OSX))
{
fprintf(stderr,
"You should have been able to get OS/X driver\n");
return 6;
} else {
printf("-- Good! You have the OS/X driver installed.\n");
}
}
else if (0 == strncmp("NetBSD", utsname.sysname, sizeof("NetBSD")))
{
if (!cdio_have_driver(DRIVER_NETBSD))
{
fprintf(stderr,
"You should have been able to get NetBSD driver\n");
return 6;
} else {
printf("-- Good! You have the OS/X driver installed.\n");
}
}
}
}
#endif
if (! (cdio_have_driver(DRIVER_NRG) && cdio_have_driver(DRIVER_BINCUE)) ) {
printf("You don't have enough drivers for this test\n");
exit(77);
}
bincue_images = cdio_get_devices(DRIVER_BINCUE);
for (imgs=bincue_images; *imgs != NULL; imgs++) {
printf("-- bincue image %s\n", *imgs);
}
if (ret != 0) return ret;
if (0 == chdir(DATA_DIR)) {
nrg_images = cdio_get_devices(DRIVER_NRG);
for (imgs=nrg_images; *imgs != NULL; imgs++) {
printf("-- NRG image %s\n", *imgs);
}
if (!is_in(nrg_images, nrg_files[0])) {
cdio_free_device_list(nrg_images);
return 10;
}
for (i=0; i<2; i++) {
if (is_in(bincue_images, cue_files[i])) {
printf("-- %s parses as a CDRWIN BIN/CUE csheet.\n",
cue_files[i]);
} else {
printf("-- %s doesn't parse as a CDRWIN BIN/CUE csheet.\n",
cue_files[i]);
ret = i+1;
}
}
}
cdio_free_device_list(nrg_images);
cdio_free_device_list(bincue_images);
return 0;
#endif
}
void CGameListCtrl::ScanForISOs()
{
ClearIsoFiles();
CFileSearch::XStringVector Directories(SConfig::GetInstance().m_ISOFolder);
if (SConfig::GetInstance().m_RecursiveISOFolder)
{
for (u32 i = 0; i < Directories.size(); i++)
{
File::FSTEntry FST_Temp;
File::ScanDirectoryTree(Directories[i], FST_Temp);
for (auto& Entry : FST_Temp.children)
{
if (Entry.isDirectory)
{
bool duplicate = false;
for (auto& Directory : Directories)
{
if (Directory == Entry.physicalName)
{
duplicate = true;
break;
}
}
if (!duplicate)
Directories.push_back(Entry.physicalName);
}
}
}
}
CFileSearch::XStringVector Extensions;
if (SConfig::GetInstance().m_ListGC)
Extensions.push_back("*.gcm");
if (SConfig::GetInstance().m_ListWii || SConfig::GetInstance().m_ListGC)
{
Extensions.push_back("*.iso");
Extensions.push_back("*.ciso");
Extensions.push_back("*.gcz");
Extensions.push_back("*.wbfs");
}
if (SConfig::GetInstance().m_ListWad)
Extensions.push_back("*.wad");
CFileSearch FileSearch(Extensions, Directories);
const CFileSearch::XStringVector& rFilenames = FileSearch.GetFileNames();
if (rFilenames.size() > 0)
{
wxProgressDialog dialog(
_("Scanning for ISOs"),
_("Scanning..."),
(int)rFilenames.size() - 1,
this,
wxPD_APP_MODAL |
wxPD_AUTO_HIDE |
wxPD_CAN_ABORT |
wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME | wxPD_REMAINING_TIME |
wxPD_SMOOTH // - makes updates as small as possible (down to 1px)
);
for (u32 i = 0; i < rFilenames.size(); i++)
{
std::string FileName;
SplitPath(rFilenames[i], nullptr, &FileName, nullptr);
// Update with the progress (i) and the message
dialog.Update(i, wxString::Format(_("Scanning %s"),
StrToWxStr(FileName)));
if (dialog.WasCancelled())
break;
auto iso_file = std::make_unique<GameListItem>(rFilenames[i]);
if (iso_file->IsValid())
{
bool list = true;
switch(iso_file->GetPlatform())
{
case GameListItem::WII_DISC:
if (!SConfig::GetInstance().m_ListWii)
list = false;
break;
case GameListItem::WII_WAD:
if (!SConfig::GetInstance().m_ListWad)
list = false;
break;
default:
if (!SConfig::GetInstance().m_ListGC)
list = false;
break;
}
switch(iso_file->GetCountry())
{
case DiscIO::IVolume::COUNTRY_AUSTRALIA:
if (!SConfig::GetInstance().m_ListAustralia)
list = false;
break;
case DiscIO::IVolume::COUNTRY_GERMANY:
if (!SConfig::GetInstance().m_ListGermany)
list = false;
break;
case DiscIO::IVolume::COUNTRY_RUSSIA:
if (!SConfig::GetInstance().m_ListRussia)
list = false;
break;
case DiscIO::IVolume::COUNTRY_UNKNOWN:
if (!SConfig::GetInstance().m_ListUnknown)
list = false;
break;
case DiscIO::IVolume::COUNTRY_TAIWAN:
if (!SConfig::GetInstance().m_ListTaiwan)
list = false;
break;
case DiscIO::IVolume::COUNTRY_KOREA:
if (!SConfig::GetInstance().m_ListKorea)
list = false;
break;
case DiscIO::IVolume::COUNTRY_JAPAN:
if (!SConfig::GetInstance().m_ListJap)
list = false;
break;
case DiscIO::IVolume::COUNTRY_USA:
if (!SConfig::GetInstance().m_ListUsa)
list = false;
break;
case DiscIO::IVolume::COUNTRY_FRANCE:
if (!SConfig::GetInstance().m_ListFrance)
list = false;
break;
case DiscIO::IVolume::COUNTRY_ITALY:
if (!SConfig::GetInstance().m_ListItaly)
list = false;
break;
case DiscIO::IVolume::COUNTRY_SPAIN:
if (!SConfig::GetInstance().m_ListSpain)
list = false;
break;
case DiscIO::IVolume::COUNTRY_NETHERLANDS:
if (!SConfig::GetInstance().m_ListNetherlands)
list = false;
break;
default:
if (!SConfig::GetInstance().m_ListPal)
list = false;
break;
}
if (list)
m_ISOFiles.push_back(iso_file.release());
}
}
}
if (SConfig::GetInstance().m_ListDrives)
{
const std::vector<std::string> drives = cdio_get_devices();
for (const auto& drive : drives)
{
auto gli = std::make_unique<GameListItem>(drive);
if (gli->IsValid())
m_ISOFiles.push_back(gli.release());
}
}
std::sort(m_ISOFiles.begin(), m_ISOFiles.end());
}
void CGameListCtrl::ScanForISOs()
{
ClearIsoFiles();
// Load custom game titles from titles.txt
// http://www.gametdb.com/Wii/Downloads
std::unordered_map<std::string, std::string> custom_title_map;
std::ifstream titlestxt;
OpenFStream(titlestxt, File::GetUserPath(D_LOAD_IDX) + "titles.txt", std::ios::in);
if (!titlestxt.is_open())
OpenFStream(titlestxt, File::GetUserPath(D_LOAD_IDX) + "wiitdb.txt", std::ios::in);
if (titlestxt.is_open())
{
std::string line;
while (!titlestxt.eof() && std::getline(titlestxt, line))
{
const size_t equals_index = line.find('=');
if (equals_index != std::string::npos)
custom_title_map.emplace(StripSpaces(line.substr(0, equals_index)),
StripSpaces(line.substr(equals_index + 1)));
}
titlestxt.close();
}
std::vector<std::string> Extensions;
if (SConfig::GetInstance().m_ListGC)
Extensions.push_back(".gcm");
if (SConfig::GetInstance().m_ListWii || SConfig::GetInstance().m_ListGC)
{
Extensions.push_back(".iso");
Extensions.push_back(".ciso");
Extensions.push_back(".gcz");
Extensions.push_back(".wbfs");
}
if (SConfig::GetInstance().m_ListWad)
Extensions.push_back(".wad");
if (SConfig::GetInstance().m_ListElfDol)
{
Extensions.push_back(".dol");
Extensions.push_back(".elf");
}
auto rFilenames = DoFileSearch(Extensions, SConfig::GetInstance().m_ISOFolder, SConfig::GetInstance().m_RecursiveISOFolder);
if (rFilenames.size() > 0)
{
wxProgressDialog dialog(
_("Scanning for ISOs"),
_("Scanning..."),
(int)rFilenames.size() - 1,
this,
wxPD_APP_MODAL |
wxPD_AUTO_HIDE |
wxPD_CAN_ABORT |
wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME | wxPD_REMAINING_TIME |
wxPD_SMOOTH // - makes updates as small as possible (down to 1px)
);
for (u32 i = 0; i < rFilenames.size(); i++)
{
std::string FileName;
SplitPath(rFilenames[i], nullptr, &FileName, nullptr);
// Update with the progress (i) and the message
dialog.Update(i, wxString::Format(_("Scanning %s"),
StrToWxStr(FileName)));
if (dialog.WasCancelled())
break;
auto iso_file = std::make_unique<GameListItem>(rFilenames[i], custom_title_map);
if (iso_file->IsValid())
{
bool list = true;
switch(iso_file->GetPlatform())
{
case DiscIO::IVolume::WII_DISC:
if (!SConfig::GetInstance().m_ListWii)
list = false;
break;
case DiscIO::IVolume::WII_WAD:
if (!SConfig::GetInstance().m_ListWad)
list = false;
break;
case DiscIO::IVolume::ELF_DOL:
if (!SConfig::GetInstance().m_ListElfDol)
list = false;
break;
default:
if (!SConfig::GetInstance().m_ListGC)
list = false;
break;
}
switch(iso_file->GetCountry())
{
case DiscIO::IVolume::COUNTRY_AUSTRALIA:
if (!SConfig::GetInstance().m_ListAustralia)
list = false;
break;
case DiscIO::IVolume::COUNTRY_EUROPE:
if (!SConfig::GetInstance().m_ListPal)
list = false;
break;
case DiscIO::IVolume::COUNTRY_FRANCE:
if (!SConfig::GetInstance().m_ListFrance)
list = false;
break;
case DiscIO::IVolume::COUNTRY_GERMANY:
if (!SConfig::GetInstance().m_ListGermany)
list = false;
break;
case DiscIO::IVolume::COUNTRY_ITALY:
if (!SConfig::GetInstance().m_ListItaly)
list = false;
break;
case DiscIO::IVolume::COUNTRY_JAPAN:
if (!SConfig::GetInstance().m_ListJap)
list = false;
break;
case DiscIO::IVolume::COUNTRY_KOREA:
if (!SConfig::GetInstance().m_ListKorea)
list = false;
break;
case DiscIO::IVolume::COUNTRY_NETHERLANDS:
if (!SConfig::GetInstance().m_ListNetherlands)
list = false;
break;
case DiscIO::IVolume::COUNTRY_RUSSIA:
if (!SConfig::GetInstance().m_ListRussia)
list = false;
break;
case DiscIO::IVolume::COUNTRY_SPAIN:
if (!SConfig::GetInstance().m_ListSpain)
list = false;
break;
case DiscIO::IVolume::COUNTRY_TAIWAN:
if (!SConfig::GetInstance().m_ListTaiwan)
list = false;
break;
case DiscIO::IVolume::COUNTRY_USA:
if (!SConfig::GetInstance().m_ListUsa)
list = false;
break;
case DiscIO::IVolume::COUNTRY_WORLD:
if (!SConfig::GetInstance().m_ListWorld)
list = false;
break;
case DiscIO::IVolume::COUNTRY_UNKNOWN:
default:
if (!SConfig::GetInstance().m_ListUnknown)
list = false;
break;
}
if (list)
m_ISOFiles.push_back(iso_file.release());
}
}
}
if (SConfig::GetInstance().m_ListDrives)
{
const std::vector<std::string> drives = cdio_get_devices();
for (const auto& drive : drives)
{
auto gli = std::make_unique<GameListItem>(drive, custom_title_map);
if (gli->IsValid())
m_ISOFiles.push_back(gli.release());
}
}
std::sort(m_ISOFiles.begin(), m_ISOFiles.end());
}
CDRFile *cdrfile_open(const char *path)
{
CDRFile *ret = (CDRFile *)calloc(1, sizeof(CDRFile));
struct stat stat_buf;
if(path == NULL || stat(path, &stat_buf) || !S_ISREG(stat_buf.st_mode))
{
CdIo *p_cdio;
char **devices;
char **parseit;
cdio_init();
GetFileBase("cdrom");
devices = cdio_get_devices(DRIVER_DEVICE);
parseit = devices;
if(parseit)
{
MDFN_printf(_("Connected physical devices:\n"));
MDFN_indent(1);
while(*parseit)
{
MDFN_printf("%s\n", *parseit);
parseit++;
}
MDFN_indent(-1);
}
if(!parseit || parseit == devices)
{
MDFN_PrintError(_("No CDROM drives detected(or no disc present)."));
if(devices)
cdio_free_device_list(devices);
free(ret);
return(NULL);
}
if(devices)
cdio_free_device_list(devices);
p_cdio = cdio_open_cd(path); //, DRIVER_UNKNOWN); //NULL, DRIVER_UNKNOWN);
if(!p_cdio)
{
free(ret);
return(NULL);
}
ret->p_cdio = p_cdio;
ret->FirstTrack = cdio_get_first_track_num(ret->p_cdio);
ret->NumTracks = cdio_get_num_tracks(ret->p_cdio);
ret->total_sectors = cdio_stat_size(ret->p_cdio);
if(ret->FirstTrack > 99)
{
MDFN_PrintError(_("Invalid first track: %d\n"), ret->FirstTrack);
free(ret);
cdio_destroy(p_cdio);
return(NULL);
}
if(ret->NumTracks > 100)
{
MDFN_PrintError(_("Invalid track count: %d\n"), ret->NumTracks);
free(ret);
cdio_destroy(p_cdio);
return(NULL);
}
for(track_t track = ret->FirstTrack; track < (ret->FirstTrack + ret->NumTracks); track++)
{
memset(&ret->Tracks[track], 0, sizeof(CDRFILE_TRACK_INFO));
ret->Tracks[track].sectors = cdio_get_track_sec_count(ret->p_cdio, track);
ret->Tracks[track].LSN = cdio_get_track_lsn(ret->p_cdio, track);
ret->Tracks[track].Format = cdio_get_track_format(ret->p_cdio, track);
}
return(ret);
}
FILE *fp = fopen(path, "rb");
bool IsTOC = FALSE;
// Assign opposite maximum values so our tests will work!
int FirstTrack = 99;
int LastTrack = 0;
if(!fp)
{
MDFN_PrintError(_("Error opening CUE sheet/TOC \"%s\": %m\n"), path, errno);
free(ret);
return(NULL);
}
GetFileBase(path);
char linebuf[512];
int32 active_track = -1;
int32 AutoTrackInc = 1; // For TOC
CDRFILE_TRACK_INFO TmpTrack;
memset(&TmpTrack, 0, sizeof(TmpTrack));
while(fgets(linebuf, 512, fp) > 0)
{
char cmdbuf[512], raw_args[512], args[4][512];
int argcount = 0;
raw_args[0] = 0;
cmdbuf[0] = 0;
args[0][0] = args[1][0] = args[2][0] = args[3][0] = 0;
if(!strncasecmp(linebuf, "CD_ROM", 6) || !strncasecmp(linebuf, "CD_DA", 5) || !strncasecmp(linebuf, "CD_ROM_XA", 9))
{
IsTOC = TRUE;
puts("TOC file detected.");
}
if(IsTOC)
{
char *ss_loc = strstr(linebuf, "//");
if(ss_loc)
{
ss_loc[0] = '\n'; // For consistency!
ss_loc[1] = 0;
}
}
trio_sscanf(linebuf, "%s %[^\r\n]", cmdbuf, raw_args);
if(!strcasecmp(cmdbuf, "CD_ROM") || !strcasecmp(cmdbuf, "CD_DA"))
IsTOC = TRUE;
UnQuotify(UnQuotify(UnQuotify(UnQuotify(raw_args, args[0]), args[1]), args[2]), args[3]);
if(args[0][0])
{
argcount++;
if(args[1][0])
{
argcount++;
if(args[2][0])
{
argcount++;
if(args[3][0])
{
argcount++;
}
}
}
}
if(IsTOC)
{
if(!strcasecmp(cmdbuf, "TRACK"))
{
if(active_track >= 0)
{
memcpy(&ret->Tracks[active_track], &TmpTrack, sizeof(TmpTrack));
memset(&TmpTrack, 0, sizeof(TmpTrack));
active_track = -1;
}
if(AutoTrackInc > 99)
{
MDFN_printf(_("Invalid track number: %d\n"), AutoTrackInc);
free(ret);
return(NULL);
}
active_track = AutoTrackInc++;
if(active_track < FirstTrack)
FirstTrack = active_track;
if(active_track > LastTrack)
LastTrack = active_track;
if(!strcasecmp(args[0], "AUDIO"))
{
TmpTrack.Format = TRACK_FORMAT_AUDIO;
TmpTrack.RawAudioMSBFirst = TRUE; // Silly cdrdao...
}
else if(!strcasecmp(args[0], "MODE1"))
{
TmpTrack.Format = TRACK_FORMAT_DATA;
TmpTrack.IsData2352 = 0;
}
else if(!strcasecmp(args[0], "MODE1_RAW"))
{
TmpTrack.Format = TRACK_FORMAT_DATA;
TmpTrack.IsData2352 = 1;
}
if(!strcasecmp(args[1], "RW"))
{
TmpTrack.SubchannelMode = CDRF_SUBM_RW;
MDFN_printf(_("\"RW\" format subchannel data not supported, only \"RW_RAW\" is!\n"));
free(ret);
return(0);
}
else if(!strcasecmp(args[1], "RW_RAW"))
TmpTrack.SubchannelMode = CDRF_SUBM_RW_RAW;
} // end to TRACK
else if(!strcasecmp(cmdbuf, "SILENCE"))
{
}
else if(!strcasecmp(cmdbuf, "ZERO"))
{
}
else if(!strcasecmp(cmdbuf, "FILE") || !strcasecmp(cmdbuf, "AUDIOFILE"))
{
const char *binoffset = NULL;
const char *msfoffset = NULL;
const char *length = NULL;
if(args[1][0] == '#')
{
binoffset = args[1] + 1;
msfoffset = args[2];
length = args[3];
}
else
{
msfoffset = args[1];
length = args[2];
}
//printf("%s, %s, %s, %s\n", args[0], binoffset, msfoffset, length);
if(!ParseTOCFileLineInfo(&TmpTrack, active_track, args[0], binoffset, msfoffset, length))
{
free(ret);
return(0);
}
}
else if(!strcasecmp(cmdbuf, "DATAFILE"))
{
const char *binoffset = NULL;
const char *length = NULL;
if(args[1][0] == '#')
{
binoffset = args[1] + 1;
length = args[2];
}
else
length = args[1];
if(!ParseTOCFileLineInfo(&TmpTrack, active_track, args[0], binoffset, NULL, length))
{
free(ret);
return(0);
}
}
else if(!strcasecmp(cmdbuf, "INDEX"))
{
}
else if(!strcasecmp(cmdbuf, "PREGAP"))
{
if(active_track < 0)
{
MDFN_printf(_("Command %s is outside of a TRACK definition!\n"), cmdbuf);
free(ret);
return(NULL);
}
int m,s,f;
trio_sscanf(args[0], "%d:%d:%d", &m, &s, &f);
TmpTrack.pregap = (m * 60 + s) * 75 + f;
} // end to PREGAP
else if(!strcasecmp(cmdbuf, "START"))
{
if(active_track < 0)
{
MDFN_printf(_("Command %s is outside of a TRACK definition!\n"), cmdbuf);
free(ret);
return(NULL);
}
int m,s,f;
trio_sscanf(args[0], "%d:%d:%d", &m, &s, &f);
TmpTrack.pregap = (m * 60 + s) * 75 + f;
}
} /*********** END TOC HANDLING ************/
else // now for CUE sheet handling
{
if(!strcasecmp(cmdbuf, "FILE"))
{
if(active_track >= 0)
{
memcpy(&ret->Tracks[active_track], &TmpTrack, sizeof(TmpTrack));
memset(&TmpTrack, 0, sizeof(TmpTrack));
active_track = -1;
}
std::string efn = MDFN_MakeFName(MDFNMKF_AUX, 0, args[0]);
if(NULL == (TmpTrack.fp = fopen(efn.c_str(), "rb")))
{
MDFN_printf(_("Could not open referenced file \"%s\": %m\n"), efn.c_str(), errno);
free(ret);
return(0);
}
TmpTrack.FirstFileInstance = 1;
if(!strcasecmp(args[1], "BINARY"))
{
//TmpTrack.Format = TRACK_FORMAT_DATA;
//struct stat stat_buf;
//fstat(fileno(TmpTrack.fp), &stat_buf);
//TmpTrack.sectors = stat_buf.st_size; // / 2048;
}
else if(!strcasecmp(args[1], "OGG") || !strcasecmp(args[1], "VORBIS") || !strcasecmp(args[1], "WAVE") || !strcasecmp(args[1], "WAV") || !strcasecmp(args[1], "PCM")
|| !strcasecmp(args[1], "MPC") || !strcasecmp(args[1], "MP+"))
{
TmpTrack.ovfile = (OggVorbis_File *) calloc(1, sizeof(OggVorbis_File));
if((TmpTrack.sf = sf_open_fd(fileno(TmpTrack.fp), SFM_READ, &TmpTrack.sfinfo, 0)))
{
free(TmpTrack.ovfile);
TmpTrack.ovfile = NULL;
}
else if(!lseek(fileno(TmpTrack.fp), 0, SEEK_SET) && !ov_open(TmpTrack.fp, TmpTrack.ovfile, NULL, 0))
{
//TmpTrack.Format = TRACK_FORMAT_AUDIO;
//TmpTrack.sectors = ov_pcm_total(&TmpTrack.ovfile, -1) / 588;
}
else
{
free(TmpTrack.ovfile);
TmpTrack.ovfile = NULL;
fseek(TmpTrack.fp, 0, SEEK_SET);
TmpTrack.MPCReaderFile = (mpc_reader_file *)calloc(1, sizeof(mpc_reader_file));
TmpTrack.MPCStreamInfo = (mpc_streaminfo *)calloc(1, sizeof(mpc_streaminfo));
TmpTrack.MPCDecoder = (mpc_decoder *)calloc(1, sizeof(mpc_decoder));
TmpTrack.MPCBuffer = (MPC_SAMPLE_FORMAT *)calloc(MPC_DECODER_BUFFER_LENGTH, sizeof(MPC_SAMPLE_FORMAT));
mpc_streaminfo_init(TmpTrack.MPCStreamInfo);
mpc_reader_setup_file_reader(TmpTrack.MPCReaderFile, TmpTrack.fp);
if(mpc_streaminfo_read(TmpTrack.MPCStreamInfo, &TmpTrack.MPCReaderFile->reader) != ERROR_CODE_OK)
{
MDFN_printf(_("Unsupported audio track file format: %s\n"), args[0]);
free(TmpTrack.MPCReaderFile);
free(TmpTrack.MPCStreamInfo);
free(TmpTrack.MPCDecoder);
free(TmpTrack.MPCBuffer);
free(ret);
return(0);
}
mpc_decoder_setup(TmpTrack.MPCDecoder, &TmpTrack.MPCReaderFile->reader);
if(!mpc_decoder_initialize(TmpTrack.MPCDecoder, TmpTrack.MPCStreamInfo))
{
MDFN_printf(_("Error initializing MusePack decoder: %s!\n"), args[0]);
free(TmpTrack.MPCReaderFile);
free(TmpTrack.MPCStreamInfo);
free(TmpTrack.MPCDecoder);
free(TmpTrack.MPCBuffer);
free(ret);
return(0);
}
}
}
else
{
MDFN_printf(_("Unsupported track format: %s\n"), args[1]);
free(ret);
return(0);
}
}
else if(!strcasecmp(cmdbuf, "TRACK"))
{
if(active_track >= 0)
{
memcpy(&ret->Tracks[active_track], &TmpTrack, sizeof(TmpTrack));
TmpTrack.FirstFileInstance = 0;
TmpTrack.pregap = 0;
}
active_track = atoi(args[0]);
if(active_track < FirstTrack)
FirstTrack = active_track;
if(active_track > LastTrack)
LastTrack = active_track;
if(!strcasecmp(args[1], "AUDIO"))
TmpTrack.Format = TRACK_FORMAT_AUDIO;
else if(!strcasecmp(args[1], "MODE1/2048"))
{
TmpTrack.Format = TRACK_FORMAT_DATA;
TmpTrack.IsData2352 = 0;
}
else if(!strcasecmp(args[1], "MODE1/2352"))
{
TmpTrack.Format = TRACK_FORMAT_DATA;
TmpTrack.IsData2352 = 1;
}
TmpTrack.sectors = GetSectorCount(&TmpTrack);
if(active_track < 0 || active_track > 99)
{
MDFN_printf(_("Invalid track number: %d\n"), active_track);
return(0);
}
}
else if(!strcasecmp(cmdbuf, "INDEX"))
{
if(active_track >= 0 && (!strcasecmp(args[0], "01") || !strcasecmp(args[0], "1")))
{
int m,s,f;
trio_sscanf(args[1], "%d:%d:%d", &m, &s, &f);
TmpTrack.index = (m * 60 + s) * 75 + f;
}
}
else if(!strcasecmp(cmdbuf, "PREGAP"))
{
if(active_track >= 0)
{
int m,s,f;
trio_sscanf(args[0], "%d:%d:%d", &m, &s, &f);
TmpTrack.pregap = (m * 60 + s) * 75 + f;
}
}
} // end of CUE sheet handling
} // end of fgets() loop
if(ferror(fp))
{
if(IsTOC)
MDFN_printf(_("Error reading TOC file: %m\n"), errno);
else
MDFN_printf(_("Error reading CUE sheet: %m\n"), errno);
return(0);
}
if(active_track >= 0)
memcpy(&ret->Tracks[active_track], &TmpTrack, sizeof(TmpTrack));
if(FirstTrack > LastTrack)
{
MDFN_printf(_("No tracks found!\n"));
return(0);
}
ret->FirstTrack = FirstTrack;
ret->NumTracks = 1 + LastTrack - FirstTrack;
lsn_t RunningLSN = 0;
lsn_t LastIndex = 0;
long FileOffset = 0;
for(int x = ret->FirstTrack; x < (ret->FirstTrack + ret->NumTracks); x++)
{
if(IsTOC)
{
RunningLSN += ret->Tracks[x].pregap;
ret->Tracks[x].LSN = RunningLSN;
RunningLSN += ret->Tracks[x].sectors;
}
else // else handle CUE sheet...
{
if(ret->Tracks[x].FirstFileInstance)
{
LastIndex = 0;
FileOffset = 0;
}
RunningLSN += ret->Tracks[x].pregap;
ret->Tracks[x].LSN = RunningLSN;
// Make sure this is set before the call to GetSectorCount() for the last track sector count fix.
ret->Tracks[x].FileOffset = FileOffset;
if((x + 1) >= (ret->FirstTrack + ret->NumTracks))
{
if(!(ret->Tracks[x].FirstFileInstance))
{
// This will fix the last sector count for CUE+BIN
ret->Tracks[x].sectors = GetSectorCount(&ret->Tracks[x]);
}
}
else if(ret->Tracks[x+1].FirstFileInstance)
{
//RunningLSN += ret->Tracks[x].sectors;
}
else
{
// Fix the sector count if we're CUE+BIN
ret->Tracks[x].sectors = ret->Tracks[x + 1].index - ret->Tracks[x].index;
}
//printf("Poo: %d %d\n", x, ret->Tracks[x].sectors);
RunningLSN += ret->Tracks[x].sectors;
//printf("%d, %ld %d %d %d %d\n", x, FileOffset, ret->Tracks[x].index, ret->Tracks[x].pregap, ret->Tracks[x].sectors, ret->Tracks[x].LSN);
if(ret->Tracks[x].Format == TRACK_FORMAT_AUDIO || TmpTrack.IsData2352)
FileOffset += ret->Tracks[x].sectors * 2352;
else
FileOffset += ret->Tracks[x].sectors * 2048;
} // end to cue sheet handling
} // end to track loop
LEC_Eval = MDFN_GetSettingB("cdrom.lec_eval");
if(LEC_Eval)
{
Init_LEC_Correct();
}
MDFN_printf(_("Raw rip data correction using L-EC: %s\n\n"), LEC_Eval ? _("Enabled") : _("Disabled"));
ret->total_sectors = RunningLSN; // Running LBA? Running LSN? arghafsdf...LSNBAN!#!$ -_-
return(ret);
}
void
cdda_scan_all_drives(void) {
char ** drives = NULL;
char touched[CDDA_DRIVES_MAX];
int i;
for (i = 0; i < CDDA_DRIVES_MAX; i++) {
if (cdda_drives[i].cdio != NULL) {
cdda_drives[i].media_changed = options.cdda_force_drive_rescan ?
1 : cdio_get_media_changed(cdda_drives[i].cdio);
if (cdda_drives[i].media_changed) {
cdio_destroy(cdda_drives[i].cdio);
cdda_drives[i].cdio = NULL;
}
}
}
drives = cdio_get_devices(DRIVER_DEVICE);
if (!drives)
return;
for (i = 0; i < CDDA_DRIVES_MAX; i++)
touched[i] = 0;
for (i = 0; (drives[i] != NULL) && (i < CDDA_DRIVES_MAX); i++) {
int n;
/* see if drives[i] is already known to us... */
cdda_drive_t * d = cdda_get_drive_by_device_path(drives[i]);
if (d != NULL) { /* yes */
n = cdda_get_n(drives[i]);
touched[n] = 1;
if (cdda_drives[n].media_changed) {
cdda_scan_drive(drives[i], cdda_get_drive(n));
if ((cdda_drives[n].disc.hash == 0L) ||
(cdda_drives[n].disc.hash != cdda_drives[n].disc.hash_prev)) {
/* EVENT refresh disc data */
cdda_send_event(CDDA_EVENT_CHANGED_DRIVE, drives[i]);
}
}
} else { /* no, scan the drive */
if (cdda_skip_extra_symlink(drives, i))
continue;
if (cdda_get_first_free_slot(&n) < 0) {
printf("cdda.c: error: too many CD drives\n");
return;
}
if (cdda_scan_drive(drives[i], cdda_get_drive(n)) >= 0) {
touched[n] = 1;
/* EVENT newly discovered drive */
cdda_send_event(CDDA_EVENT_NEW_DRIVE, drives[i]);
}
}
}
cdio_free_device_list(drives);
/* remove all drives that were not touched (those that disappeared) */
for (i = 0; i < CDDA_DRIVES_MAX; i++) {
if ((cdda_drives[i].device_path[0] != '\0') && (touched[i] == 0)) {
/* EVENT removed drive */
cdda_send_event(CDDA_EVENT_REMOVED_DRIVE, cdda_drives[i].device_path);
cdio_destroy(cdda_drives[i].cdio);
memset(cdda_drives + i, 0, sizeof(cdda_drive_t));
}
}
}
