xbmc/storage/cdioSupport.cpp

   1 /*
   2  *  Copyright (C) 2005-2018 Team Kodi
   3  *  This file is part of Kodi - https://kodi.tv
   4  *
   5  *  SPDX-License-Identifier: GPL-2.0-or-later
   6  *  See LICENSES/README.md for more information.
   7  */
   8
   9 #include "cdioSupport.h"
  10
  11 #include "platform/Environment.h"
  12 #include "utils/log.h"
  13
  14 #include <mutex>
  15
  16 #include <cdio/cd_types.h>
  17 #include <cdio/cdio.h>
  18 #include <cdio/logging.h>
  19 #include <cdio/mmc.h>
  20 #include <cdio/util.h>
  21
  22 namespace
  23 {
  24 /* Helper constexpr to hide the 0 return code for tray closed. */
  25 constexpr int CDIO_TRAY_STATUS_CLOSED = 0;
  26 /* Helper constexpr to hide the 1 return code for tray open */
  27 constexpr int CDIO_TRAY_STATUS_OPEN = 1;
  28 /* Helper constexpr to hide the -2 driver code for unsupported tray status get operation */
  29 constexpr int CDIO_TRAY_STATUS_OP_UNSUPPORTED = -2;
  30 } // namespace
  31
  32 using namespace MEDIA_DETECT;
  33
  34 std::shared_ptr<CLibcdio> CLibcdio::m_pInstance;
  35
  36 /* Some interesting sector numbers stored in the above buffer. */
  37 #define ISO_SUPERBLOCK_SECTOR  16  /* buffer[0] */
  38 #define UFS_SUPERBLOCK_SECTOR   4  /* buffer[2] */
  39 #define BOOT_SECTOR            17  /* buffer[3] */
  40 #define VCD_INFO_SECTOR       150  /* buffer[4] */
  41 #define UDF_ANCHOR_SECTOR     256  /* buffer[5] */
  42
  43
  44 signature_t CCdIoSupport::sigs[] = {
  45     /*buffer[x] off look for     description */
  46     {0, 1, "CD001\0", "ISO 9660\0"},
  47     {0, 1, "CD-I", "CD-I"},
  48     {0, 8, "CDTV", "CDTV"},
  49     {0, 8, "CD-RTOS", "CD-RTOS"},
  50     {0, 9, "CDROM", "HIGH SIERRA"},
  51     {0, 16, "CD-BRIDGE", "BRIDGE"},
  52     {0, 1024, "CD-XA001", "XA"},
  53     {1, 64, "PPPPHHHHOOOOTTTTOOOO____CCCCDDDD", "PHOTO CD"},
  54     {1, 0x438, "\x53\xef", "EXT2 FS"},
  55     {2, 1372, "\x54\x19\x01\x0", "UFS"},
  56     {3, 7, "EL TORITO", "BOOTABLE"},
  57     {4, 0, "VIDEO_CD", "VIDEO CD"},
  58     {4, 0, "SUPERVCD", "Chaoji VCD"},
  59     {0, 1, "BEA01", "UDF"},
  60     {}};
  61
  62 #undef DEBUG_CDIO
  63
  64 static void
  65 cdio_log_handler (cdio_log_level_t level, const char message[])
  66 {
  67 #ifdef DEBUG_CDIO
  68   switch (level)
  69   {
  70   case CDIO_LOG_ERROR:
  71     CLog::Log(LOGDEBUG, "**ERROR: {}", message);
  72     break;
  73   case CDIO_LOG_DEBUG:
  74     CLog::Log(LOGDEBUG, "--DEBUG: {}", message);
  75     break;
  76   case CDIO_LOG_WARN:
  77     CLog::Log(LOGDEBUG, "++ WARN: {}", message);
  78     break;
  79   case CDIO_LOG_INFO:
  80     CLog::Log(LOGDEBUG, "   INFO: {}", message);
  81     break;
  82   case CDIO_LOG_ASSERT:
  83     CLog::Log(LOGDEBUG, "!ASSERT: {}", message);
  84     break;
  85   default:
  86     //cdio_assert_not_reached ();
  87     break;
  88   }
  89 #endif
  90 }
  91
  92 //////////////////////////////////////////////////////////////////////
  93 // Construction/Destruction
  94 //////////////////////////////////////////////////////////////////////
  95 CLibcdio::CLibcdio(): s_defaultDevice(NULL)
  96 {
  97   cdio_log_set_handler( cdio_log_handler );
  98 }
  99
 100 CLibcdio::~CLibcdio()
 101 {
 102   free(s_defaultDevice);
 103   s_defaultDevice = NULL;
 104 }
 105
 106 void CLibcdio::ReleaseInstance()
 107 {
 108   m_pInstance.reset();
 109 }
 110
 111 std::shared_ptr<CLibcdio> CLibcdio::GetInstance()
 112 {
 113   if (!m_pInstance)
 114   {
 115     m_pInstance = std::shared_ptr<CLibcdio>(new CLibcdio());
 116   }
 117   return m_pInstance;
 118 }
 119
 120 CdIo_t* CLibcdio::cdio_open(const char *psz_source, driver_id_t driver_id)
 121 {
 122   std::unique_lock<CCriticalSection> lock(*this);
 123
 124   return( ::cdio_open(psz_source, driver_id) );
 125 }
 126
 127 CdIo_t* CLibcdio::cdio_open_win32(const char *psz_source)
 128 {
 129   std::unique_lock<CCriticalSection> lock(*this);
 130
 131   return( ::cdio_open_win32(psz_source) );
 132 }
 133
 134 void CLibcdio::cdio_destroy(CdIo_t *p_cdio)
 135 {
 136   std::unique_lock<CCriticalSection> lock(*this);
 137
 138   ::cdio_destroy(p_cdio);
 139 }
 140
 141 discmode_t CLibcdio::cdio_get_discmode(CdIo_t *p_cdio)
 142 {
 143   std::unique_lock<CCriticalSection> lock(*this);
 144
 145   return( ::cdio_get_discmode(p_cdio) );
 146 }
 147
 148 CdioTrayStatus CLibcdio::mmc_get_tray_status(const CdIo_t* p_cdio)
 149 {
 150   std::unique_lock<CCriticalSection> lock(*this);
 151
 152   int status = ::mmc_get_tray_status(p_cdio);
 153   switch (status)
 154   {
 155     case CDIO_TRAY_STATUS_CLOSED:
 156       return CdioTrayStatus::CLOSED;
 157     case CDIO_TRAY_STATUS_OPEN:
 158       return CdioTrayStatus::OPEN;
 159     case CDIO_TRAY_STATUS_OP_UNSUPPORTED:
 160       return CdioTrayStatus::UNKNOWN;
 161     default:
 162       break;
 163   }
 164   return CdioTrayStatus::DRIVER_ERROR;
 165 }
 166
 167 driver_return_code_t CLibcdio::cdio_eject_media(CdIo_t** p_cdio)
 168 {
 169   std::unique_lock<CCriticalSection> lock(*this);
 170
 171   return( ::cdio_eject_media(p_cdio) );
 172 }
 173
 174 track_t CLibcdio::cdio_get_last_track_num(const CdIo_t *p_cdio)
 175 {
 176   std::unique_lock<CCriticalSection> lock(*this);
 177
 178   return( ::cdio_get_last_track_num(p_cdio) );
 179 }
 180
 181 lsn_t CLibcdio::cdio_get_track_lsn(const CdIo_t *p_cdio, track_t i_track)
 182 {
 183   std::unique_lock<CCriticalSection> lock(*this);
 184
 185   return( ::cdio_get_track_lsn(p_cdio, i_track) );
 186 }
 187
 188 lsn_t CLibcdio::cdio_get_track_last_lsn(const CdIo_t *p_cdio, track_t i_track)
 189 {
 190   std::unique_lock<CCriticalSection> lock(*this);
 191
 192   return( ::cdio_get_track_last_lsn(p_cdio, i_track) );
 193 }
 194
 195 driver_return_code_t CLibcdio::cdio_read_audio_sectors(
 196     const CdIo_t *p_cdio, void *p_buf, lsn_t i_lsn, uint32_t i_blocks)
 197 {
 198   std::unique_lock<CCriticalSection> lock(*this);
 199
 200   return( ::cdio_read_audio_sectors(p_cdio, p_buf, i_lsn, i_blocks) );
 201 }
 202
 203 driver_return_code_t CLibcdio::cdio_close_tray(const char* psz_source, driver_id_t* driver_id)
 204 {
 205   std::unique_lock<CCriticalSection> lock(*this);
 206   return (::cdio_close_tray(psz_source, driver_id));
 207 }
 208
 209 const char* CLibcdio::cdio_driver_errmsg(driver_return_code_t drc)
 210 {
 211   return (::cdio_driver_errmsg(drc));
 212 }
 213
 214 char* CLibcdio::GetDeviceFileName()
 215 {
 216   std::unique_lock<CCriticalSection> lock(*this);
 217
 218   // If We don't have a DVD device initially present (Darwin or a USB DVD drive),
 219   // We have to keep checking in case one appears.
 220   if (s_defaultDevice && strlen(s_defaultDevice) == 0)
 221   {
 222     free(s_defaultDevice);
 223     s_defaultDevice = NULL;
 224   }
 225
 226   if (s_defaultDevice == NULL)
 227   {
 228     std::string strEnvDvd = CEnvironment::getenv("KODI_DVD_DEVICE");
 229     if (!strEnvDvd.empty())
 230       s_defaultDevice = strdup(strEnvDvd.c_str());
 231     else
 232     {
 233       CdIo_t *p_cdio = ::cdio_open(NULL, DRIVER_UNKNOWN);
 234       if (p_cdio != NULL)
 235       {
 236         s_defaultDevice = strdup(::cdio_get_arg(p_cdio, "source"));
 237         ::cdio_destroy(p_cdio);
 238       }
 239       else
 240         s_defaultDevice = strdup("");
 241     }
 242   }
 243   return s_defaultDevice;
 244 }
 245
 246
 247 //////////////////////////////////////////////////////////////////////
 248 // Construction/Destruction
 249 //////////////////////////////////////////////////////////////////////
 250 CCdIoSupport::CCdIoSupport() : cdio(nullptr), m_cdio(CLibcdio::GetInstance())
 251 {
 252   m_nFirstData = -1;        /* # of first data track */
 253   m_nNumData = 0;                /* # of data tracks */
 254   m_nFirstAudio = -1;      /* # of first audio track */
 255   m_nNumAudio = 0;              /* # of audio tracks */
 256   m_nIsofsSize = 0;               /* size of session */
 257   m_nJolietLevel = 0;
 258   m_nFs = 0;
 259   m_nUDFVerMinor = 0;
 260   m_nUDFVerMajor = 0;
 261   m_nDataStart = 0;
 262   m_nMsOffset = 0;
 263   m_nStartTrack = 0;
 264 }
 265
 266 CCdIoSupport::~CCdIoSupport() = default;
 267
 268 bool CCdIoSupport::EjectTray()
 269 {
 270   return false;
 271 }
 272
 273 bool CCdIoSupport::CloseTray()
 274 {
 275   return false;
 276 }
 277
 278 HANDLE CCdIoSupport::OpenCDROM()
 279 {
 280   std::unique_lock<CCriticalSection> lock(*m_cdio);
 281
 282   char* source_name = m_cdio->GetDeviceFileName();
 283   CdIo* cdio = ::cdio_open(source_name, DRIVER_UNKNOWN);
 284
 285   return reinterpret_cast<HANDLE>(cdio);
 286 }
 287
 288 HANDLE CCdIoSupport::OpenIMAGE( std::string& strFilename )
 289 {
 290   std::unique_lock<CCriticalSection> lock(*m_cdio);
 291
 292   CdIo* cdio = ::cdio_open(strFilename.c_str(), DRIVER_UNKNOWN);
 293
 294   return reinterpret_cast<HANDLE>(cdio);
 295 }
 296
 297 int CCdIoSupport::ReadSector(HANDLE hDevice, DWORD dwSector, char* lpczBuffer)
 298 {
 299   std::unique_lock<CCriticalSection> lock(*m_cdio);
 300
 301   CdIo* cdio = (CdIo*) hDevice;
 302   if ( cdio == NULL )
 303     return -1;
 304
 305   if ( ::cdio_read_mode1_sector( cdio, lpczBuffer, dwSector, false ) == 0 )
 306     return dwSector;
 307
 308   return -1;
 309 }
 310
 311 int CCdIoSupport::ReadSectorMode2(HANDLE hDevice, DWORD dwSector, char* lpczBuffer)
 312 {
 313   std::unique_lock<CCriticalSection> lock(*m_cdio);
 314
 315   CdIo* cdio = (CdIo*) hDevice;
 316   if ( cdio == NULL )
 317     return -1;
 318
 319   if ( ::cdio_read_mode2_sector( cdio, lpczBuffer, dwSector, false ) == 0 )
 320     return dwSector;
 321
 322   return -1;
 323 }
 324
 325 int CCdIoSupport::ReadSectorCDDA(HANDLE hDevice, DWORD dwSector, char* lpczBuffer)
 326 {
 327   std::unique_lock<CCriticalSection> lock(*m_cdio);
 328
 329   CdIo* cdio = (CdIo*) hDevice;
 330   if ( cdio == NULL )
 331     return -1;
 332
 333   if ( ::cdio_read_audio_sector( cdio, lpczBuffer, dwSector ) == 0 )
 334     return dwSector;
 335
 336   return -1;
 337 }
 338
 339 void CCdIoSupport::CloseCDROM(HANDLE hDevice)
 340 {
 341   std::unique_lock<CCriticalSection> lock(*m_cdio);
 342
 343   CdIo* cdio = (CdIo*) hDevice;
 344
 345   if ( cdio == NULL )
 346     return ;
 347
 348   ::cdio_destroy( cdio );
 349 }
 350
 351 void CCdIoSupport::PrintAnalysis(int fs, int num_audio)
 352 {
 353   switch (fs & FS_MASK)
 354   {
 355   case FS_UDF:
 356     CLog::Log(LOGINFO, "CD-ROM with UDF filesystem");
 357     break;
 358   case FS_NO_DATA:
 359     CLog::Log(LOGINFO, "CD-ROM with audio tracks");
 360     break;
 361   case FS_ISO_9660:
 362     CLog::Log(LOGINFO, "CD-ROM with ISO 9660 filesystem");
 363     if (fs & JOLIET)
 364     {
 365       CLog::Log(LOGINFO, " with joliet extension level {}", m_nJolietLevel);
 366     }
 367     if (fs & ROCKRIDGE)
 368     {
 369       CLog::Log(LOGINFO, " and rockridge extensions");
 370     }
 371     break;
 372   case FS_ISO_9660_INTERACTIVE:
 373     CLog::Log(LOGINFO, "CD-ROM with CD-RTOS and ISO 9660 filesystem");
 374     break;
 375   case FS_HIGH_SIERRA:
 376     CLog::Log(LOGINFO, "CD-ROM with High Sierra filesystem");
 377     break;
 378   case FS_INTERACTIVE:
 379     CLog::Log(LOGINFO, "CD-Interactive{}", num_audio > 0 ? "/Ready" : "");
 380     break;
 381   case FS_HFS:
 382     CLog::Log(LOGINFO, "CD-ROM with Macintosh HFS");
 383     break;
 384   case FS_ISO_HFS:
 385     CLog::Log(LOGINFO, "CD-ROM with both Macintosh HFS and ISO 9660 filesystem");
 386     break;
 387   case FS_ISO_UDF:
 388     CLog::Log(LOGINFO, "CD-ROM with both UDF and ISO 9660 filesystem");
 389     break;
 390   case FS_UFS:
 391     CLog::Log(LOGINFO, "CD-ROM with Unix UFS");
 392     break;
 393   case FS_EXT2:
 394     CLog::Log(LOGINFO, "CD-ROM with Linux second extended filesystem");
 395     break;
 396   case FS_3DO:
 397     CLog::Log(LOGINFO, "CD-ROM with Panasonic 3DO filesystem");
 398     break;
 399   case FS_UNKNOWN:
 400     CLog::Log(LOGINFO, "CD-ROM with unknown filesystem");
 401     break;
 402   }
 403
 404   switch (fs & FS_MASK)
 405   {
 406   case FS_ISO_9660:
 407   case FS_ISO_9660_INTERACTIVE:
 408   case FS_ISO_HFS:
 409   case FS_ISO_UDF:
 410     CLog::Log(LOGINFO, "ISO 9660: {} blocks, label {}", m_nIsofsSize, m_strDiscLabel);
 411     break;
 412   }
 413
 414   switch (fs & FS_MASK)
 415   {
 416   case FS_UDF:
 417   case FS_ISO_UDF:
 418     CLog::Log(LOGINFO, "UDF: version {:x}.{:02x}", m_nUDFVerMajor, m_nUDFVerMinor);
 419     break;
 420   }
 421
 422   if (m_nFirstData == 1 && num_audio > 0)
 423   {
 424     CLog::Log(LOGINFO, "mixed mode CD   ");
 425   }
 426   if (fs & XA)
 427   {
 428     CLog::Log(LOGINFO, "XA sectors   ");
 429   }
 430   if (fs & MULTISESSION)
 431   {
 432     CLog::Log(LOGINFO, "Multisession, offset = {}   ", m_nMsOffset);
 433   }
 434   if (fs & HIDDEN_TRACK)
 435   {
 436     CLog::Log(LOGINFO, "Hidden Track   ");
 437   }
 438   if (fs & PHOTO_CD)
 439   {
 440     CLog::Log(LOGINFO, "{}Photo CD   ", num_audio > 0 ? " Portfolio " : "");
 441   }
 442   if (fs & CDTV)
 443   {
 444     CLog::Log(LOGINFO, "Commodore CDTV   ");
 445   }
 446   if (m_nFirstData > 1)
 447   {
 448     CLog::Log(LOGINFO, "CD-Plus/Extra   ");
 449   }
 450   if (fs & BOOTABLE)
 451   {
 452     CLog::Log(LOGINFO, "bootable CD   ");
 453   }
 454   if (fs & VIDEOCDI && num_audio == 0)
 455   {
 456     CLog::Log(LOGINFO, "Video CD   ");
 457 #if defined(HAVE_VCDINFO) && defined(DEBUG)
 458     if (!opts.no_vcd)
 459     {
 460       printf("\n");
 461       print_vcd_info();
 462     }
 463 #endif
 464
 465   }
 466   if (fs & CVD)
 467   {
 468     CLog::Log(LOGINFO, "Chaoji Video CD");
 469   }
 470 }
 471
 472 int CCdIoSupport::ReadBlock(int superblock, uint32_t offset, uint8_t bufnum, track_t track_num)
 473 {
 474   std::unique_lock<CCriticalSection> lock(*m_cdio);
 475
 476   unsigned int track_sec_count = ::cdio_get_track_sec_count(cdio, track_num);
 477   memset(buffer[bufnum], 0, CDIO_CD_FRAMESIZE);
 478
 479   if ( track_sec_count < static_cast<unsigned int>(superblock))
 480   {
 481     ::cdio_debug("reading block %u skipped track %d has only %u sectors\n",
 482                superblock, track_num, track_sec_count);
 483     return -1;
 484   }
 485
 486   ::cdio_debug("about to read sector %lu\n",
 487              (long unsigned int) offset + superblock);
 488
 489   if (::cdio_get_track_green(cdio, track_num))
 490   {
 491     if (0 < ::cdio_read_mode2_sector(cdio, buffer[bufnum],
 492                                    offset + superblock, false))
 493       return -1;
 494   }
 495   else
 496   {
 497     if (0 < ::cdio_read_mode1_sector(cdio, buffer[bufnum],
 498                                    offset + superblock, false))
 499       return -1;
 500   }
 501
 502   return 0;
 503 }
 504
 505 bool CCdIoSupport::IsIt(int num)
 506 {
 507   signature_t *sigp = &sigs[num];
 508   int len = strlen(sigp->sig_str);
 509
 510   //! @todo check that num < largest sig.
 511   return 0 == memcmp(&buffer[sigp->buf_num][sigp->offset], sigp->sig_str, len);
 512 }
 513
 514 int CCdIoSupport::IsHFS(void)
 515 {
 516   return (0 == memcmp(&buffer[1][512], "PM", 2)) ||
 517          (0 == memcmp(&buffer[1][512], "TS", 2)) ||
 518          (0 == memcmp(&buffer[1][1024], "BD", 2));
 519 }
 520
 521 int CCdIoSupport::Is3DO(void)
 522 {
 523   return (0 == memcmp(&buffer[1][0], "\x01\x5a\x5a\x5a\x5a\x5a\x01", 7)) &&
 524          (0 == memcmp(&buffer[1][40], "CD-ROM", 6));
 525 }
 526
 527 int CCdIoSupport::IsJoliet(void)
 528 {
 529   return 2 == buffer[3][0] && buffer[3][88] == 0x25 && buffer[3][89] == 0x2f;
 530 }
 531
 532 int CCdIoSupport::IsUDF(void)
 533 {
 534   return 2 == ((uint16_t)buffer[5][0] | ((uint16_t)buffer[5][1] << 8));
 535 }
 536
 537 /* ISO 9660 volume space in M2F1_SECTOR_SIZE byte units */
 538 int CCdIoSupport::GetSize(void)
 539 {
 540   return ((buffer[0][80] & 0xff) |
 541           ((buffer[0][81] & 0xff) << 8) |
 542           ((buffer[0][82] & 0xff) << 16) |
 543           ((buffer[0][83] & 0xff) << 24));
 544 }
 545
 546 int CCdIoSupport::GetJolietLevel( void )
 547 {
 548   switch (buffer[3][90])
 549   {
 550   case 0x40:
 551     return 1;
 552   case 0x43:
 553     return 2;
 554   case 0x45:
 555     return 3;
 556   }
 557   return 0;
 558 }
 559
 560 #define is_it_dbg(sig) /*\
 561     if (is_it(sig)) printf("%s, ", sigs[sig].description)*/
 562
 563 int CCdIoSupport::GuessFilesystem(int start_session, track_t track_num)
 564 {
 565   std::unique_lock<CCriticalSection> lock(*m_cdio);
 566
 567   int ret = FS_UNKNOWN;
 568   cdio_iso_analysis_t anal;
 569   cdio_fs_anal_t fs;
 570   bool udf = false;
 571
 572   memset(&anal, 0, sizeof(anal));
 573   discmode_t mode = ::cdio_get_discmode(cdio);
 574   if (::cdio_is_discmode_dvd(mode))
 575   {
 576     m_strDiscLabel = "";
 577     m_nIsofsSize = ::cdio_get_disc_last_lsn(cdio);
 578     m_nJolietLevel = ::cdio_get_joliet_level(cdio);
 579
 580     return FS_ISO_9660;
 581   }
 582
 583   fs = ::cdio_guess_cd_type(cdio, start_session, track_num, &anal);
 584
 585   switch(CDIO_FSTYPE(fs))
 586     {
 587     case CDIO_FS_AUDIO:
 588       ret = FS_NO_DATA;
 589       break;
 590
 591     case CDIO_FS_HIGH_SIERRA:
 592       ret = FS_HIGH_SIERRA;
 593       break;
 594
 595     case CDIO_FS_ISO_9660:
 596       ret = FS_ISO_9660;
 597       break;
 598
 599     case CDIO_FS_INTERACTIVE:
 600       ret = FS_ISO_9660_INTERACTIVE;
 601       break;
 602
 603     case CDIO_FS_HFS:
 604       ret = FS_HFS;
 605       break;
 606
 607     case CDIO_FS_UFS:
 608       ret = FS_UFS;
 609       break;
 610
 611     case CDIO_FS_EXT2:
 612       ret = FS_EXT2;
 613       break;
 614
 615     case CDIO_FS_UDF:
 616       ret = FS_UDF;
 617       udf = true;
 618       break;
 619
 620     case CDIO_FS_ISO_UDF:
 621       ret = FS_ISO_UDF;
 622       udf = true;
 623       break;
 624
 625     default:
 626       break;
 627     }
 628
 629   if (udf)
 630   {
 631     m_nUDFVerMinor = anal.UDFVerMinor;
 632     m_nUDFVerMajor = anal.UDFVerMajor;
 633   }
 634
 635   m_strDiscLabel = anal.iso_label;
 636   m_nIsofsSize = anal.isofs_size;
 637   m_nJolietLevel = anal.joliet_level;
 638
 639   return ret;
 640 }
 641
 642 void CCdIoSupport::GetCdTextInfo(xbmc_cdtext_t &xcdt, int trackNum)
 643 {
 644   // cdtext disabled for windows as some setup doesn't like mmc commands
 645   // and stall for over a minute in cdio_get_cdtext 83
 646 #if !defined(TARGET_WINDOWS)
 647   std::unique_lock<CCriticalSection> lock(*m_cdio);
 648
 649   // Get the CD-Text , if any
 650 #if defined(LIBCDIO_VERSION_NUM) && (LIBCDIO_VERSION_NUM >= 84)
 651   cdtext_t *pcdtext = static_cast<cdtext_t*>( cdio_get_cdtext(cdio) );
 652 #else
 653   //! @todo - remove after Ubuntu 16.04 (Xenial) is EOL
 654   cdtext_t *pcdtext = (cdtext_t *)::cdio_get_cdtext(cdio, trackNum);
 655 #endif
 656
 657   if (pcdtext == NULL)
 658     return ;
 659
 660 #if defined(LIBCDIO_VERSION_NUM) && (LIBCDIO_VERSION_NUM >= 84)
 661   for (int i=0; i < MAX_CDTEXT_FIELDS; i++)
 662     if (cdtext_get_const(pcdtext, (cdtext_field_t)i, trackNum))
 663       xcdt[(cdtext_field_t)i] = cdtext_field2str((cdtext_field_t)i);
 664 #else
 665   //! @todo - remove after Ubuntu 16.04 (Xenial) is EOL
 666   // Same ids used in libcdio and for our structure + the ids are consecutive make this copy loop safe.
 667   for (int i = 0; i < MAX_CDTEXT_FIELDS; i++)
 668     if (pcdtext->field[i])
 669       xcdt[(cdtext_field_t)i] = pcdtext->field[(cdtext_field_t)i];
 670 #endif
 671 #endif // TARGET_WINDOWS
 672 }
 673
 674 CCdInfo* CCdIoSupport::GetCdInfo(char* cDeviceFileName)
 675 {
 676   std::unique_lock<CCriticalSection> lock(*m_cdio);
 677
 678   char* source_name;
 679   if(cDeviceFileName == NULL)
 680     source_name = m_cdio->GetDeviceFileName();
 681   else
 682     source_name = cDeviceFileName;
 683
 684   cdio = ::cdio_open(source_name, DRIVER_UNKNOWN);
 685   if (cdio == NULL)
 686   {
 687     CLog::Log(LOGERROR, "{}: Error in automatically selecting driver with input", __FUNCTION__);
 688     return NULL;
 689   }
 690
 691   bool bIsCDRom = true;
 692
 693   m_nFirstTrackNum = ::cdio_get_first_track_num(cdio);
 694   if (m_nFirstTrackNum == CDIO_INVALID_TRACK)
 695   {
 696 #if !defined(TARGET_DARWIN)
 697     ::cdio_destroy(cdio);
 698     return NULL;
 699 #else
 700     m_nFirstTrackNum = 1;
 701     bIsCDRom = false;
 702 #endif
 703   }
 704
 705   m_nNumTracks = ::cdio_get_num_tracks(cdio);
 706   if (m_nNumTracks == CDIO_INVALID_TRACK)
 707   {
 708 #if !defined(TARGET_DARWIN)
 709     ::cdio_destroy(cdio);
 710     return NULL;
 711 #else
 712     m_nNumTracks = 1;
 713     bIsCDRom = false;
 714 #endif
 715   }
 716
 717   CCdInfo* info = new CCdInfo;
 718   info->SetFirstTrack( m_nFirstTrackNum );
 719   info->SetTrackCount( m_nNumTracks );
 720
 721   for (i = m_nFirstTrackNum; i <= CDIO_CDROM_LEADOUT_TRACK; i++)
 722   {
 723     msf_t msf;
 724     if (bIsCDRom && !::cdio_get_track_msf(cdio, i, &msf))
 725     {
 726       trackinfo ti;
 727       ti.nfsInfo = FS_UNKNOWN;
 728       ti.ms_offset = 0;
 729       ti.isofs_size = 0;
 730       ti.nJolietLevel = 0;
 731       ti.nFrames = 0;
 732       ti.nMins = 0;
 733       ti.nSecs = 0;
 734       info->SetTrackInformation( i, ti );
 735       CLog::Log(LOGDEBUG, "cdio_track_msf for track {} failed, I give up.", i);
 736       delete info;
 737       ::cdio_destroy(cdio);
 738       return NULL;
 739     }
 740
 741     trackinfo ti;
 742     if (bIsCDRom && TRACK_FORMAT_AUDIO == ::cdio_get_track_format(cdio, i))
 743     {
 744       m_nNumAudio++;
 745       ti.nfsInfo = FS_NO_DATA;
 746       m_nFs = FS_NO_DATA;
 747       int temp1 = ::cdio_get_track_lba(cdio, i) - CDIO_PREGAP_SECTORS;
 748       int temp2 = ::cdio_get_track_lba(cdio, i + 1) - CDIO_PREGAP_SECTORS;
 749       // The length is the address of the second track minus the address of the first track
 750       temp2 -= temp1;                  // temp2 now has length of track1 in frames
 751       ti.nMins = temp2 / (60 * 75);    // calculate the number of minutes
 752       temp2 %= 60 * 75;                // calculate the left-over frames
 753       ti.nSecs = temp2 / 75;           // calculate the number of seconds
 754       if ( -1 == m_nFirstAudio)
 755         m_nFirstAudio = i;
 756
 757       // Make sure that we have the Disc related info available
 758       if (i == 1)
 759       {
 760         xbmc_cdtext_t xcdt;
 761         GetCdTextInfo(xcdt, 0);
 762         info->SetDiscCDTextInformation( xcdt );
 763       }
 764
 765       // Get this tracks info
 766       GetCdTextInfo(ti.cdtext, i);
 767     }
 768     else
 769     {
 770       m_nNumData++;
 771       if ( -1 == m_nFirstData)
 772         m_nFirstData = i;
 773     }
 774     ti.nfsInfo = FS_NO_DATA;
 775     ti.ms_offset = 0;
 776     ti.isofs_size = 0;
 777     ti.nJolietLevel = 0;
 778     ti.nFrames = ::cdio_get_track_lba(cdio, i);
 779     ti.nMins = 0;
 780     ti.nSecs = 0;
 781
 782     info->SetTrackInformation( i, ti );
 783     /* skip to leadout? */
 784     if (i == m_nNumTracks)
 785       i = CDIO_CDROM_LEADOUT_TRACK;
 786   }
 787
 788   info->SetCddbDiscId( CddbDiscId() );
 789   info->SetDiscLength( ::cdio_get_track_lba(cdio, CDIO_CDROM_LEADOUT_TRACK) / CDIO_CD_FRAMES_PER_SEC );
 790
 791   info->SetAudioTrackCount( m_nNumAudio );
 792   info->SetDataTrackCount( m_nNumData );
 793   info->SetFirstAudioTrack( m_nFirstAudio );
 794   info->SetFirstDataTrack( m_nFirstData );
 795
 796   CLog::Log(LOGINFO, "CD Analysis Report");
 797   CLog::Log(LOGINFO, STRONG);
 798
 799   /* Try to find out what sort of CD we have */
 800   if (0 == m_nNumData)
 801   {
 802     /* no data track, may be a "real" audio CD or hidden track CD */
 803
 804     msf_t msf;
 805     ::cdio_get_track_msf(cdio, 1, &msf);
 806     m_nStartTrack = ::cdio_msf_to_lsn(&msf);
 807
 808     /* CD-I/Ready says start_track <= 30*75 then CDDA */
 809     if (m_nStartTrack > 100 /* 100 is just a guess */)
 810     {
 811       m_nFs = GuessFilesystem(0, 1);
 812       if ((m_nFs & FS_MASK) != FS_UNKNOWN)
 813         m_nFs |= HIDDEN_TRACK;
 814       else
 815       {
 816         m_nFs &= ~FS_MASK; /* del filesystem info */
 817         CLog::Log(LOGDEBUG, "Oops: {} unused sectors at start, but hidden track check failed.",
 818                   m_nStartTrack);
 819       }
 820     }
 821     PrintAnalysis(m_nFs, m_nNumAudio);
 822   }
 823   else
 824   {
 825     /* We have data track(s) */
 826     for (j = 2, i = m_nFirstData; i <= m_nNumTracks; i++)
 827     {
 828       msf_t msf;
 829       track_format_t track_format = ::cdio_get_track_format(cdio, i);
 830
 831       ::cdio_get_track_msf(cdio, i, &msf);
 832
 833       switch ( track_format )
 834       {
 835       case TRACK_FORMAT_AUDIO:
 836         {
 837           trackinfo ti;
 838           ti.nfsInfo = FS_NO_DATA;
 839           m_nFs = FS_NO_DATA;
 840           ti.ms_offset = 0;
 841           ti.isofs_size = 0;
 842           ti.nJolietLevel = 0;
 843           ti.nFrames = ::cdio_get_track_lba(cdio, i);
 844           ti.nMins = 0;
 845           ti.nSecs = 0;
 846           info->SetTrackInformation( i + 1, ti );
 847         }
 848       case TRACK_FORMAT_ERROR:
 849         break;
 850       case TRACK_FORMAT_CDI:
 851       case TRACK_FORMAT_XA:
 852       case TRACK_FORMAT_DATA:
 853       case TRACK_FORMAT_PSX:
 854         break;
 855       }
 856
 857       m_nStartTrack = (i == 1) ? 0 : ::cdio_msf_to_lsn(&msf);
 858
 859       /* Save the start of the data area */
 860       if (i == m_nFirstData)
 861         m_nDataStart = m_nStartTrack;
 862
 863       /* Skip tracks which belong to the current walked session */
 864       if (m_nStartTrack < m_nDataStart + m_nIsofsSize)
 865         continue;
 866
 867       m_nFs = GuessFilesystem(m_nStartTrack, i);
 868       trackinfo ti;
 869       ti.nfsInfo = m_nFs;
 870       ti.ms_offset = m_nMsOffset;
 871       ti.isofs_size = m_nIsofsSize;
 872       ti.nJolietLevel = m_nJolietLevel;
 873       ti.nFrames = ::cdio_get_track_lba(cdio, i);
 874       ti.nMins = 0;
 875       ti.nSecs = 0;
 876       info->SetDiscLabel(m_strDiscLabel);
 877
 878
 879       if (i > 1)
 880       {
 881         /* Track is beyond last session -> new session found */
 882         m_nMsOffset = m_nStartTrack;
 883
 884         CLog::Log(LOGINFO,
 885                   "Session #{} starts at track {:2}, LSN: {:6},"
 886                   " ISO 9660 blocks: {:6}",
 887                   j++, i, m_nStartTrack, m_nIsofsSize);
 888
 889         CLog::Log(LOGINFO, "ISO 9660: {} blocks, label {}", m_nIsofsSize, m_strDiscLabel);
 890         m_nFs |= MULTISESSION;
 891         ti.nfsInfo = m_nFs;
 892       }
 893       else
 894       {
 895         PrintAnalysis(m_nFs, m_nNumAudio);
 896       }
 897
 898       info->SetTrackInformation( i, ti );
 899
 900     }
 901   }
 902   ::cdio_destroy( cdio );
 903   return info;
 904 }
 905
 906
 907 // Returns the sum of the decimal digits in a number. Eg. 1955 = 20
 908 int CCdIoSupport::CddbDecDigitSum(int n)
 909 {
 910   int ret = 0;
 911
 912   for (;;)
 913   {
 914     ret += n % 10;
 915     n = n / 10;
 916     if (!n)
 917       return ret;
 918   }
 919 }
 920
 921 // Return the number of seconds (discarding frame portion) of an MSF
 922 unsigned int CCdIoSupport::MsfSeconds(msf_t *msf)
 923 {
 924   std::unique_lock<CCriticalSection> lock(*m_cdio);
 925
 926   return ::cdio_from_bcd8(msf->m)*60 + ::cdio_from_bcd8(msf->s);
 927 }
 928
 929
 930 // Compute the CDDB disk ID for an Audio disk.
 931 // This is a funny checksum consisting of the concatenation of 3 things:
 932 //    The sum of the decimal digits of sizes of all tracks,
 933 //    The total length of the disk, and
 934 //    The number of tracks.
 935
 936 uint32_t CCdIoSupport::CddbDiscId()
 937 {
 938   std::unique_lock<CCriticalSection> lock(*m_cdio);
 939
 940   int i, t, n = 0;
 941   msf_t start_msf;
 942   msf_t msf;
 943
 944   for (i = 1; i <= m_nNumTracks; i++)
 945   {
 946     ::cdio_get_track_msf(cdio, i, &msf);
 947     n += CddbDecDigitSum(MsfSeconds(&msf));
 948   }
 949
 950   ::cdio_get_track_msf(cdio, 1, &start_msf);
 951   ::cdio_get_track_msf(cdio, CDIO_CDROM_LEADOUT_TRACK, &msf);
 952
 953   t = MsfSeconds(&msf) - MsfSeconds(&start_msf);
 954
 955   return ((n % 0xff) << 24 | t << 8 | m_nNumTracks);
 956 }