int main(int argc, const char *argv[]) { track_t i_first_track; track_t i_tracks; CdIo_t *p_cdio = cdio_open ("../test/cdda.cue", DRIVER_BINCUE); if (NULL == p_cdio) { printf("Couldn't open ../test/cdda.cue with BIN/CUE driver.\n"); } else { i_first_track = cdio_get_first_track_num(p_cdio); i_tracks = cdio_get_num_tracks(p_cdio); print_disc_info(p_cdio, i_tracks, i_first_track); cdio_destroy(p_cdio); } p_cdio = cdio_open (NULL, DRIVER_DEVICE); i_first_track = cdio_get_first_track_num(p_cdio); i_tracks = cdio_get_num_tracks(p_cdio); if (NULL == p_cdio) { printf("Couldn't find CD\n"); return 1; } else { print_disc_info(p_cdio, i_tracks, i_first_track); } cdio_destroy(p_cdio); return 0; }
/*! reads TOC via libcdio and returns the number of tracks in the disc. 0 is returned if there was an error. */ static int cddap_readtoc (cdrom_drive_t *d) { int i; track_t i_track; /* Save TOC Entries */ d->tracks = cdio_get_num_tracks(d->p_cdio) ; if (CDIO_INVALID_TRACK == d->tracks) return 0; i_track = cdio_get_first_track_num(d->p_cdio); for ( i=0; i < d->tracks; i++) { d->disc_toc[i].bTrack = i_track; d->disc_toc[i].dwStartSector = cdio_get_track_lsn(d->p_cdio, i_track); i_track++; } d->disc_toc[i].bTrack = i_track; d->disc_toc[i].dwStartSector = cdio_get_track_lsn(d->p_cdio, CDIO_CDROM_LEADOUT_TRACK); d->cd_extra=FixupTOC(d, d->tracks+1); /* fixup includes lead-out */ return --i_track; /* number of tracks returned does not include lead-out */ }
/***************************************************************************** * ioctl_GetTracksMap: Read the Table of Contents, fill in the pp_sectors map * if pp_sectors is not null and return the number of * tracks available. * We allocate and fill one more track than are on * the CD. The last "track" is leadout track information. * This makes finding the end of the last track uniform * how it is done for other tracks. *****************************************************************************/ track_t ioctl_GetTracksMap( vlc_object_t *p_this, const CdIo *cdio, lsn_t **pp_sectors ) { track_t i_tracks = cdio_get_num_tracks(cdio); track_t first_track = cdio_get_first_track_num(cdio); track_t i; *pp_sectors = malloc( (i_tracks + 1) * sizeof(lsn_t) ); if( *pp_sectors == NULL ) { msg_Err( p_this, "out of memory" ); return 0; } /* Fill the p_sectors structure with the track/sector matches. Note cdio_get_track_lsn when given num_tracks + 1 will return the leadout LSN. */ for( i = 0 ; i <= i_tracks ; i++ ) { (*pp_sectors)[ i ] = cdio_get_track_lsn(cdio, first_track+i); } return i_tracks; }
int main(int argc, const char *argv[]) { CdIo_t *p_cdio = cdio_open (NULL, DRIVER_UNKNOWN); track_t i_first_track; track_t i_tracks; int j, i; if (NULL == p_cdio) { printf("Couldn't find a driver.. leaving.\n"); return 1; } printf("Disc last LSN: %d\n", cdio_get_disc_last_lsn(p_cdio)); i_tracks = cdio_get_num_tracks(p_cdio); i_first_track = i = cdio_get_first_track_num(p_cdio); printf("CD-ROM Track List (%i - %i)\n", i_first_track, i_first_track+i_tracks-1); printf(" #: LSN\n"); for (j = 0; j < i_tracks; i++, j++) { lsn_t lsn = cdio_get_track_lsn(p_cdio, i); if (CDIO_INVALID_LSN != lsn) printf("%3d: %06lu\n", (int) i, (long unsigned int) lsn); } printf("%3X: %06lu leadout\n", CDIO_CDROM_LEADOUT_TRACK, (long unsigned int) cdio_get_track_lsn(p_cdio, CDIO_CDROM_LEADOUT_TRACK)); cdio_destroy(p_cdio); return 0; }
static cddb_disc_t * create_disc(CdIo_t *cdio) { cddb_disc_t *disc = cddb_disc_new(); if (disc) { const lba_t leadout_lba = cdio_get_track_lba(cdio, CDIO_CDROM_LEADOUT_TRACK); cddb_disc_set_length(disc, leadout_lba / CDIO_CD_FRAMES_PER_SEC); const track_t first_track = cdio_get_first_track_num(cdio); const track_t num_tracks = cdio_get_num_tracks(cdio); if (leadout_lba == CDIO_INVALID_LBA || first_track == CDIO_INVALID_TRACK || num_tracks == CDIO_INVALID_TRACK) { trace("cda: create_disc failed, invalid CD disc format\n"); cddb_disc_destroy(disc); return NULL; } const track_t last_track = first_track + num_tracks; for (track_t i = first_track; i < last_track; i++) { cddb_track_t *track = cddb_track_new(); if (!track) { cddb_disc_destroy(disc); return NULL; } const lba_t offset = cdio_get_track_lba(cdio, i); cddb_track_set_frame_offset(track, offset); cddb_disc_add_track(disc, track); } cddb_disc_calc_discid(disc); } return disc; }
/*! reads TOC via libcdio and returns the number of tracks in the disc. 0 is returned if there was an error. */ static int cooked_readtoc (cdrom_drive_t *d) { int i; track_t i_track; /* Save TOC Entries */ d->tracks = cdio_get_num_tracks(d->p_cdio) ; if (CDIO_INVALID_TRACK == d->tracks) return 0; i_track = cdio_get_first_track_num(d->p_cdio); for ( i=0; i < d->tracks; i++) { d->disc_toc[i].bTrack = i_track; d->disc_toc[i].dwStartSector = cdio_get_track_lsn(d->p_cdio, i_track); i_track++; } d->disc_toc[i].bTrack = i_track; d->disc_toc[i].dwStartSector = cdio_get_track_lsn(d->p_cdio, CDIO_CDROM_LEADOUT_TRACK); d->cd_extra=FixupTOC(d, i_track); return --i_track; /* without lead-out */ }
/***************************************************************************** VCDEntryPoints: Reads the information about the entry points on the disc and initializes area information with that. Before calling this track information should have been read in. *****************************************************************************/ static bool VCDEntryPoints( access_t * p_access ) { if (!p_access || !p_access->p_sys) return false; vcdplayer_t *p_vcdplayer = (vcdplayer_t *) p_access->p_sys; const unsigned int i_entries = vcdinfo_get_num_entries(p_vcdplayer->vcd); const track_t i_last_track = cdio_get_num_tracks(vcdinfo_get_cd_image(p_vcdplayer->vcd)) + cdio_get_first_track_num(vcdinfo_get_cd_image(p_vcdplayer->vcd)); unsigned int i; if (0 == i_entries) { LOG_ERR ("no entires found -- something is wrong" ); return false; } p_vcdplayer->p_entries = malloc( sizeof( lsn_t ) * i_entries ); if( p_vcdplayer->p_entries == NULL ) { LOG_ERR ("not enough memory for entry points treatment" ); return false; } p_vcdplayer->i_entries = i_entries; for( i = 0 ; i < i_entries ; i++ ) { const track_t i_track = vcdinfo_get_track(p_vcdplayer->vcd, i); if( i_track <= i_last_track ) { seekpoint_t *s = vlc_seekpoint_New(); char psz_entry[100]; snprintf(psz_entry, sizeof(psz_entry), "%s %02d", _("Entry"), i ); p_vcdplayer->p_entries[i] = vcdinfo_get_entry_lsn(p_vcdplayer->vcd, i); s->psz_name = strdup(psz_entry); s->i_byte_offset = (p_vcdplayer->p_entries[i] - vcdinfo_get_track_lsn(p_vcdplayer->vcd,i_track)) * M2F2_SECTOR_SIZE; dbg_print( INPUT_DBG_MRL, "%s, lsn %d, byte_offset %"PRId64"", s->psz_name, p_vcdplayer->p_entries[i], s->i_byte_offset); TAB_APPEND( p_vcdplayer->p_title[i_track-1]->i_seekpoint, p_vcdplayer->p_title[i_track-1]->seekpoint, s ); } else msg_Warn( p_access, "wrong track number found in entry points" ); } p_vcdplayer->b_valid_ep = true; return true; }
/*! Return the number of sectors between this track an the next. This includes any pregap sectors before the start of the next track. Tracks start at 1. 0 is returned if there is an error. */ unsigned int cdio_get_track_sec_count(const CdIo_t *p_cdio, track_t i_track) { const track_t i_tracks = cdio_get_num_tracks(p_cdio); if (i_track >=1 && i_track <= i_tracks) return ( cdio_get_track_lba(p_cdio, i_track+1) - cdio_get_track_lba(p_cdio, i_track) ); return 0; }
/*! Return the number of sectors between this track an the next. This includes any pregap sectors before the start of the next track. Tracks start at 1. 0 is returned if there is an error. */ unsigned int cdio_get_track_sec_count(const CdIo *cdio, track_t track_num) { track_t num_tracks = cdio_get_num_tracks(cdio); if (track_num >=1 && track_num <= num_tracks) return ( cdio_get_track_lba(cdio, track_num+1) - cdio_get_track_lba(cdio, track_num) ); return 0; }
/*! Return the last track number. CDIO_INVALID_TRACK is returned on error. */ track_t cdio_get_last_track_num (const CdIo_t *p_cdio) { if (NULL == p_cdio) return CDIO_INVALID_TRACK; { const track_t i_first_track = cdio_get_first_track_num(p_cdio); if ( CDIO_INVALID_TRACK != i_first_track ) { const track_t i_tracks = cdio_get_num_tracks(p_cdio); if ( CDIO_INVALID_TRACK != i_tracks ) return i_first_track + i_tracks - 1; } return CDIO_INVALID_TRACK; } }
cddb_disc_t* resolve_disc (CdIo_t *cdio) { track_t first_track = cdio_get_first_track_num (cdio); track_t tracks = cdio_get_num_tracks (cdio); track_t i; cddb_track_t *track; cddb_disc_t *disc = cddb_disc_new(); cddb_disc_set_length (disc, cdio_get_track_lba (cdio, CDIO_CDROM_LEADOUT_TRACK) / CDIO_CD_FRAMES_PER_SEC); for (i = 0; i < tracks; i++) { lsn_t offset = cdio_get_track_lba (cdio, i+first_track); track = cddb_track_new(); cddb_track_set_frame_offset (track, offset); cddb_disc_add_track (disc, track); } cddb_conn_t *conn = NULL; conn = cddb_new(); deadbeef->conf_lock (); cddb_set_server_name (conn, deadbeef->conf_get_str_fast ("cdda.freedb.host", DEFAULT_SERVER)); cddb_set_server_port (conn, deadbeef->conf_get_int ("cdda.freedb.port", DEFAULT_PORT)); if (!deadbeef->conf_get_int ("cdda.protocol", DEFAULT_PROTOCOL)) { cddb_http_enable (conn); if (deadbeef->conf_get_int ("network.proxy", 0)) { cddb_set_server_port(conn, deadbeef->conf_get_int ("network.proxy.port", 8080)); cddb_set_server_name(conn, deadbeef->conf_get_str_fast ("network.proxy.address", "")); } } deadbeef->conf_unlock (); int matches = cddb_query (conn, disc); if (matches == -1) { cddb_disc_destroy (disc); cddb_destroy (conn); return NULL; } cddb_read (conn, disc); cddb_destroy (conn); return disc; }
static int read_disc_cdtext (struct cddb_thread_params *params) { DB_playItem_t **items = params->items; cdtext_t *cdtext = cdio_get_cdtext (params->cdio, 0); if (!cdtext) return 0; track_t first_track = cdio_get_first_track_num (params->cdio); track_t tracks = cdio_get_num_tracks (params->cdio); track_t i; for (i = 0; i < tracks; i++) read_track_cdtext (params->cdio, i + first_track, params->items[i]); return 1; }
//public int CdDecoder::getNumTracks() { QMutexLocker lock(&getCdioMutex()); StCdioDevice cdio(m_devicename); if (!cdio) return 0; track_t tracks = cdio_get_num_tracks(cdio); if (CDIO_INVALID_TRACK != tracks) LOG(VB_MEDIA, LOG_DEBUG, QString("getNumTracks = %1").arg(tracks)); else tracks = -1; return tracks; }
/** * Given a CDIO device, calculates the necessary information about the device * and contacts a CDDB server to get disk information. * * @param p_cdio a CDIO device * @param disk the disk structure to store the information in * * @return an error status about whether information was obtained */ enum giles_cddb_err get_cddb_info_for_device(const CdIo_t *p_cdio, cddb_disc_t *disc) { lsn_t last_lsn; msf_t last_msf; unsigned disc_len_in_s, i, matches; track_t num_tracks; cddb_track_t *track; cddb_conn_t *conn; num_tracks = cdio_get_num_tracks(p_cdio); DPRINTF ("Disc contains %d tracks\n", num_tracks); for (i = 1; i <= num_tracks; i++) { track = cddb_track_new(); cddb_track_set_frame_offset(track, cdio_get_track_lba(p_cdio, i)); DPRINTF ("Offset for track %d is %d\n", i, cdio_get_track_lba(p_cdio, i)); cddb_disc_add_track(disc, track); } last_lsn = cdio_get_disc_last_lsn(p_cdio); cdio_lsn_to_msf(last_lsn, &last_msf); disc_len_in_s = cdio_audio_get_msf_seconds(&last_msf); cddb_disc_set_length(disc, disc_len_in_s); conn = cddb_new(); if (conn == NULL) { cddb_error_print(cddb_errno(conn)); return giles_cddb_err_no_conn; } matches = cddb_query(conn, disc); if (matches == -1) { return giles_cddb_err_no_conn; } else if (matches == 0) { return giles_cddb_err_no_match; } cddb_read(conn, disc); cddb_destroy(conn); return giles_cddb_err_none; }
/*! Read CD TOC and set CD information. */ static void read_toc(CdIo_t *p_cdio) { track_t i; i_first_track = cdio_get_first_track_num(p_cdio); i_last_track = cdio_get_last_track_num(p_cdio); i_tracks = cdio_get_num_tracks(p_cdio); i_first_audio_track = i_first_track; i_last_audio_track = i_last_track; if ( CDIO_INVALID_TRACK == i_first_track || CDIO_INVALID_TRACK == i_last_track ) { xperror("read toc header"); b_cd = false; b_record = false; } else { b_cd = true; i_data = 0; for (i = i_first_track; i <= i_last_track+1; i++) { if ( !cdio_get_track_msf(p_cdio, i, &(toc[i])) ) { xperror("read toc entry"); b_cd = false; return; } if ( TRACK_FORMAT_AUDIO != cdio_get_track_format(p_cdio, i) ) { if ((i != i_last_track+1) ) { i_data++; if (i == i_first_track) { if (i == i_last_track) i_first_audio_track = CDIO_CDROM_LEADOUT_TRACK; else i_first_audio_track++; } } } } b_record = true; read_subchannel(p_cdio); if (auto_mode && sub.audio_status != CDIO_MMC_READ_SUB_ST_PLAY) play_track(1, CDIO_CDROM_LEADOUT_TRACK); } }
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; }
static int cdpa_get_tracks(rnc_dev_t *dev, rnc_track_t *buf, size_t size) { cdpa_t *cdpa = dev->data; cdpa_track_t *tracks, *trk; int ntrack, base, naudio; rnc_track_t *t; int id, i; mrp_debug("getting tracks"); base = cdio_get_first_track_num(cdpa->cdio); if (cdpa->ntrack == 0) { ntrack = cdio_get_num_tracks(cdpa->cdio); if (ntrack == 0) return 0; tracks = mrp_allocz_array(typeof(*tracks), ntrack); if (tracks == NULL) return -1; naudio = 0; trk = tracks; for (i = 0; i < ntrack; i++) { id = base + i; if (cdio_get_track_format(cdpa->cdio, id) != TRACK_FORMAT_AUDIO) continue; trk->id = id; trk->idx = i; trk->fblk = cdio_get_track_lsn(cdpa->cdio, id); trk->lblk = cdio_get_track_last_lsn(cdpa->cdio, id); naudio++; trk++; } cdpa->tracks = tracks; cdpa->ntrack = naudio; } else ntrack = cdpa->ntrack; if ((int)size > cdpa->ntrack) size = cdpa->ntrack; for (i = 0, t = buf, trk = cdpa->tracks; i < (int)size; i++, t++, trk++) { t->idx = trk - cdpa->tracks; t->id = base + i; t->fblk = trk->fblk; t->nblk = trk->lblk - trk->fblk + 1; t->length = 1.0 * t->nblk / 75.0; } if (cdpa->ctrack < 0) { cdio_paranoia_modeset(cdpa->cdpa, PARANOIA_MODE_FULL); cdpa->ctrack = 0; seek_track(cdpa, 0, 0); } return ntrack; }
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); }
bool AudioCDDemux::open( const QString &_url ) { #ifdef Q_OS_WIN if ( _url.toLower().contains( QRegExp( "file://\\D:/track\\d\\d.cda" ) ) ) { QString url = _url; url.remove( "file://" ); device = url.mid( 0, url.indexOf( '/' ) ); trackNo = url.mid( url.toLower().indexOf( "track" ) + 5, 2 ).toUInt(); } else #endif { if ( _url.left( 10 ) != "AudioCD://" ) return false; QUrl url( _url.mid( 10 ) ); device = QUrlQuery( url ).queryItemValue( "device" ); trackNo = url.path().toUInt(); } if ( trackNo > 0 && trackNo < CDIO_INVALID_TRACK ) { cdio = destroyTimer.getInstance( device, discID ); if ( cdio || ( cdio = cdio_open( device.toLocal8Bit(), DRIVER_UNKNOWN ) ) ) { cdio_set_speed( cdio, 1 ); numTracks = cdio_get_num_tracks( cdio ); if ( cdio_get_discmode( cdio ) != CDIO_DISC_MODE_ERROR && numTracks > 0 && numTracks != CDIO_INVALID_TRACK ) { chn = cdio_get_track_channels( cdio, trackNo ); if ( numTracks >= trackNo && ( chn == 2 || chn == 4 ) ) { if ( useCDTEXT ) { readCDText( 0 ); readCDText( trackNo ); } isData = cdio_get_track_format( cdio, trackNo ) != TRACK_FORMAT_AUDIO; duration = CD_BLOCKSIZE / chn / ( double )srate; startSector = cdio_get_track_lsn( cdio, trackNo ); numSectors = cdio_get_track_last_lsn( cdio, trackNo ) - startSector; if ( useCDDB && Title.isEmpty() ) { cddb_disc_t *cddb_disc; if ( freedb_query( cddb_disc ) ) { if ( cdTitle.isEmpty() && cdArtist.isEmpty() ) freedb_get_disc_info( cddb_disc ); freedb_get_track_info( cddb_disc ); cddb_disc_destroy( cddb_disc ); } } StreamInfo *streamInfo = new StreamInfo; streamInfo->type = QMPLAY2_TYPE_AUDIO; streamInfo->is_default = true; streamInfo->sample_rate = srate; streamInfo->channels = chn; streams_info += streamInfo; return true; } else QMPlay2Core.log( tr( "Błąd odczytu ścieżki" ) ); } else QMPlay2Core.log( tr( "Brak płyty w napędzie" ) ); } else QMPlay2Core.log( tr( "Nieprawidłowa ścieżka do napędu CD" ) ); } else //dodawanie do listy ścieżek AudioCD { #ifndef Q_OS_WIN device = QUrl( _url ).path(); #else device = _url.mid( strlen( AudioCDName"://" ), 2 ); #endif #ifndef Q_OS_WIN if ( !QFileInfo( device ).isDir() ) #endif if ( !device.isEmpty() ) { emit QMPlay2Core.processParam( "DelPlaylistEntries", _url ); QList< Playlist::Entry > entries = getTracks( device ); if ( !entries.isEmpty() && Playlist::write( entries, "file://" + AudioCDPlaylist ) ) { emit QMPlay2Core.processParam( "open", AudioCDPlaylist ); return true; } } } return false; }
int main(int argc, const char *argv[]) { CdIo_t *p_cdio; cdio_fs_anal_t fs=0; track_t num_tracks; track_t first_track_num; lsn_t start_track; /* first sector of track */ lsn_t data_start =0; /* start of data area */ int first_data = -1; /* # of first data track */ int first_audio = -1; /* # of first audio track */ unsigned int num_data = 0; /* # of data tracks */ unsigned int num_audio = 0; /* # of audio tracks */ unsigned int i; char *cd_image_name = NULL; if (argc > 1) cd_image_name = strdup(argv[1]); cdio_log_set_handler (log_handler); p_cdio = cdio_open (cd_image_name, DRIVER_UNKNOWN); if (NULL == p_cdio) { printf("-- Problem in trying to find a driver.\n\n"); free(cd_image_name); return 77; } first_track_num = cdio_get_first_track_num(p_cdio); num_tracks = cdio_get_num_tracks(p_cdio); /* Count the number of data and audio tracks. */ for (i = first_track_num; i <= num_tracks; i++) { if (TRACK_FORMAT_AUDIO == cdio_get_track_format(p_cdio, i)) { num_audio++; if (-1 == first_audio) first_audio = i; } else { num_data++; if (-1 == first_data) first_data = i; } } /* try to find out what sort of CD we have */ if (0 == num_data) { printf("-- Audio CD\n"); } else { /* we have data track(s) */ cdio_iso_analysis_t cdio_iso_analysis; memset(&cdio_iso_analysis, 0, sizeof(cdio_iso_analysis)); for (i = first_data; i <= num_tracks; i++) { lsn_t lsn; track_format_t track_format = cdio_get_track_format(p_cdio, i); lsn = cdio_get_track_lsn(p_cdio, i); switch ( track_format ) { case TRACK_FORMAT_AUDIO: case TRACK_FORMAT_ERROR: break; case TRACK_FORMAT_CDI: case TRACK_FORMAT_XA: case TRACK_FORMAT_DATA: case TRACK_FORMAT_PSX: ; } start_track = (i == 1) ? 0 : lsn; /* save the start of the data area */ if (i == first_data) data_start = start_track; /* skip tracks which belong to the current walked session */ if (start_track < data_start + cdio_iso_analysis.isofs_size) continue; fs = cdio_guess_cd_type(p_cdio, start_track, i, &cdio_iso_analysis); print_analysis(cdio_iso_analysis, fs, first_data, num_audio); if ( !(CDIO_FSTYPE(fs) == CDIO_FS_ISO_9660 || CDIO_FSTYPE(fs) == CDIO_FS_ISO_HFS || CDIO_FSTYPE(fs) == CDIO_FS_ISO_9660_INTERACTIVE) ) /* no method for non-ISO9660 multisessions */ break; } } free(cd_image_name); cdio_destroy(p_cdio); return 0; }
void cdda_disc_info(cdda_drive_t * drive) { CdIo_t * cdio; track_t itrack; track_t ntracks; track_t track_last; cdtext_field_t i; gchar * text; GtkWidget * dialog; GtkWidget * table; GtkWidget * label; GtkWidget * vbox; GtkWidget * hbox; GtkListStore * list; GtkWidget * view; GtkWidget * viewport; GtkWidget * scrolled_win; GtkCellRenderer * cell; GType types[MAX_CDTEXT_FIELDS + 1]; GtkTreeViewColumn * columns[MAX_CDTEXT_FIELDS + 1]; int visible[MAX_CDTEXT_FIELDS + 1]; int has_some_cdtext = 0; dialog = gtk_dialog_new_with_buttons(_("Disc info"), GTK_WINDOW(browser_window), GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR, GTK_STOCK_CLOSE, GTK_RESPONSE_OK, NULL); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER); gtk_widget_set_size_request(GTK_WIDGET(dialog), 500, 400); vbox = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), vbox, TRUE, TRUE, 4); cdio = cdio_open(drive->device_path, DRIVER_UNKNOWN); table = gtk_table_new(MAX_CDTEXT_FIELDS, 2, FALSE); gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 2); for (i = 0; i < MAX_CDTEXT_FIELDS; i++) { text = cdda_get_cdtext(cdio, i, 0); if (text && *text != '\0') { has_some_cdtext = 1; hbox = gtk_hbox_new(FALSE, 0); label = gtk_label_new(cdtext_field2str(i)); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, i, i + 1, GTK_FILL, GTK_FILL, 4, 1); hbox = gtk_hbox_new(FALSE, 0); label = gtk_label_new(text); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, i, i + 1, GTK_FILL, GTK_FILL, 4, 1); } g_free(text); } types[0] = G_TYPE_INT; for (i = 1; i <= MAX_CDTEXT_FIELDS; i++) { types[i] = G_TYPE_STRING; visible[i] = 0; } list = gtk_list_store_newv(MAX_CDTEXT_FIELDS + 1, types); view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list)); viewport = gtk_viewport_new(NULL, NULL); scrolled_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(vbox), viewport, TRUE, TRUE, 2); gtk_container_add(GTK_CONTAINER(viewport), scrolled_win); gtk_container_add(GTK_CONTAINER(scrolled_win), view); cell = gtk_cell_renderer_text_new(); g_object_set((gpointer)cell, "xalign", 1.0, NULL); columns[0] = gtk_tree_view_column_new_with_attributes(_("No."), cell, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), GTK_TREE_VIEW_COLUMN(columns[0])); for (i = 0; i < MAX_CDTEXT_FIELDS; i++) { cell = gtk_cell_renderer_text_new(); columns[i + 1] = gtk_tree_view_column_new_with_attributes(cdtext_field2str(i), cell, "text", i + 1, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), GTK_TREE_VIEW_COLUMN(columns[i + 1])); } itrack = cdio_get_first_track_num(cdio); ntracks = cdio_get_num_tracks(cdio); track_last = itrack + ntracks; for (; itrack < track_last; itrack++) { GtkTreeIter iter; gtk_list_store_append(list, &iter); gtk_list_store_set(list, &iter, 0, itrack, -1); for (i = 0; i < MAX_CDTEXT_FIELDS; i++) { text = cdda_get_cdtext(cdio, i, itrack); if (text && *text != '\0') { gtk_list_store_set(list, &iter, i + 1, text, -1); visible[i + 1] = 1; has_some_cdtext = 1; } g_free(text); } } for (i = 1; i <= MAX_CDTEXT_FIELDS; i++) { gtk_tree_view_column_set_visible(columns[i], visible[i]); } cdio_destroy(cdio); gtk_widget_show_all(dialog); if (has_some_cdtext) { aqualung_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); } else { gtk_widget_destroy(dialog); message_dialog(_("Disc info"), browser_window, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, NULL, _("This CD does not contain CD-Text information.")); } }
/* return 0 if OK, -1 if drive is apparently not available */ int cdda_scan_drive(char * device_path, cdda_drive_t * cdda_drive) { track_t tracks; track_t first_track; track_t last_track; track_t skipped = 0; int i, n = 0; cdrom_drive_t * d; if (cdda_drive->cdio == NULL) { cdda_drive->cdio = cdio_open(device_path, DRIVER_DEVICE); if (!cdda_drive->cdio) { return -1; } strncpy(cdda_drive->device_path, device_path, CDDA_MAXLEN-1); } cdda_drive->disc.n_tracks = 0; tracks = cdio_get_num_tracks(cdda_drive->cdio); if (tracks < 1 || tracks >= 100) { cdda_drive->disc.hash_prev = cdda_drive->disc.hash; cdda_drive->disc.hash = 0L; return 0; } d = cdio_cddap_identify_cdio(cdda_drive->cdio, 0, NULL); if (d == NULL) { return -1; } first_track = cdio_get_first_track_num(cdda_drive->cdio); last_track = cdio_get_last_track_num(cdda_drive->cdio); for (i = first_track; i <= last_track; i++) { if (!cdio_cddap_track_audiop(d, i)) { skipped = i; last_track = i-1; break; } } cdio_cddap_close_no_free_cdio(d); if (last_track < first_track) { return 0; } cdda_drive->disc.n_tracks = last_track - first_track + 1; for (i = first_track; i <= last_track; i++) { lsn_t lsn = cdio_get_track_lsn(cdda_drive->cdio, i); if (lsn != CDIO_INVALID_LSN) { cdda_drive->disc.toc[n++] = lsn; } } if (skipped == 0) { cdda_drive->disc.toc[n] = cdio_get_track_lsn(cdda_drive->cdio, CDIO_CDROM_LEADOUT_TRACK); } else { cdda_drive->disc.toc[n] = cdio_get_track_lsn(cdda_drive->cdio, skipped); if ((cdda_drive->disc.toc[n] - cdda_drive->disc.toc[n-1]) >= 11400) { /* compensate end of track with multisession offset */ cdda_drive->disc.toc[n] -= 11400; } } cdda_drive->disc.hash_prev = cdda_drive->disc.hash; cdda_drive->disc.hash = calc_cdda_hash(&cdda_drive->disc); if (cdda_drive->disc.hash != cdda_drive->disc.hash_prev) { strncpy(cdda_drive->disc.artist_name, _("Unknown Artist"), MAXLEN-1); strncpy(cdda_drive->disc.record_name, _("Unknown Record"), MAXLEN-1); cdda_drive->swap_bytes = -1; /* unknown */ } return 0; }
RipCD::RipCD(QWidget* parent) : QDialog(parent), transcoder_(new Transcoder(this)), queued_(0), finished_success_(0), finished_failed_(0), ui_(new Ui_RipCD) { // Init ui_->setupUi(this); // Set column widths in the QTableWidget. ui_->tableWidget->horizontalHeader()->setResizeMode( kCheckboxColumn, QHeaderView::ResizeToContents); ui_->tableWidget->horizontalHeader()->setResizeMode( kTrackNumberColumn, QHeaderView::ResizeToContents); ui_->tableWidget->horizontalHeader()->setResizeMode(kTrackTitleColumn, QHeaderView::Stretch); // Add a rip button rip_button_ = ui_->button_box->addButton(tr("Start ripping"), QDialogButtonBox::ActionRole); cancel_button_ = ui_->button_box->button(QDialogButtonBox::Cancel); close_button_ = ui_->button_box->button(QDialogButtonBox::Close); // Hide elements cancel_button_->hide(); ui_->progress_group->hide(); connect(ui_->select_all_button, SIGNAL(clicked()), SLOT(SelectAll())); connect(ui_->select_none_button, SIGNAL(clicked()), SLOT(SelectNone())); connect(ui_->invert_selection_button, SIGNAL(clicked()), SLOT(InvertSelection())); connect(rip_button_, SIGNAL(clicked()), SLOT(ClickedRipButton())); connect(cancel_button_, SIGNAL(clicked()), SLOT(Cancel())); connect(close_button_, SIGNAL(clicked()), SLOT(hide())); connect(transcoder_, SIGNAL(JobComplete(QString, bool)), SLOT(JobComplete(QString, bool))); connect(transcoder_, SIGNAL(AllJobsComplete()), SLOT(AllJobsComplete())); connect(transcoder_, SIGNAL(JobOutputName(QString)), SLOT(AppendOutput(QString))); connect(this, SIGNAL(RippingComplete()), SLOT(ThreadedTranscoding())); connect(this, SIGNAL(SignalUpdateProgress()), SLOT(UpdateProgress())); connect(ui_->options, SIGNAL(clicked()), SLOT(Options())); connect(ui_->select, SIGNAL(clicked()), SLOT(AddDestination())); setWindowTitle(tr("Rip CD")); AddDestinationDirectory(QDir::homePath()); cdio_ = cdio_open(nullptr, DRIVER_UNKNOWN); if (!cdio_) { qLog(Error) << "Failed to read CD drive"; return; } else { i_tracks_ = cdio_get_num_tracks(cdio_); ui_->tableWidget->setRowCount(i_tracks_); for (int i = 1; i <= i_tracks_; i++) { QCheckBox* checkbox_i = new QCheckBox(ui_->tableWidget); checkbox_i->setCheckState(Qt::Checked); checkboxes_.append(checkbox_i); ui_->tableWidget->setCellWidget(i - 1, kCheckboxColumn, checkbox_i); ui_->tableWidget->setCellWidget(i - 1, kTrackNumberColumn, new QLabel(QString::number(i))); QString track_title = QString("Track %1").arg(i); QLineEdit* line_edit_track_title_i = new QLineEdit(track_title, ui_->tableWidget); track_names_.append(line_edit_track_title_i); ui_->tableWidget->setCellWidget(i - 1, kTrackTitleColumn, line_edit_track_title_i); } } // Get presets QList<TranscoderPreset> presets = Transcoder::GetAllPresets(); qSort(presets.begin(), presets.end(), ComparePresetsByName); for (const TranscoderPreset& preset : presets) { ui_->format->addItem( QString("%1 (.%2)").arg(preset.name_, preset.extension_), QVariant::fromValue(preset)); } // Load settings QSettings s; s.beginGroup(kSettingsGroup); last_add_dir_ = s.value("last_add_dir", QDir::homePath()).toString(); QString last_output_format = s.value("last_output_format", "ogg").toString(); for (int i = 0; i < ui_->format->count(); ++i) { if (last_output_format == ui_->format->itemData(i).value<TranscoderPreset>().extension_) { ui_->format->setCurrentIndex(i); break; } } ui_->progress_bar->setValue(0); ui_->progress_bar->setMaximum(100); }
/** Read CD TOC and set CD information. */ static void read_toc(CdIo_t *p_cdio) { track_t i; action("read toc..."); memset(cd_info, 0, sizeof(cd_info)); title[0] = artist[0] = genre[0] = category[0] = year[0] = '\0'; i_first_track = cdio_get_first_track_num(p_cdio); i_last_track = cdio_get_last_track_num(p_cdio); i_tracks = cdio_get_num_tracks(p_cdio); i_first_audio_track = i_first_track; i_last_audio_track = i_last_track; cdio_audio_get_volume(p_cdio, &audio_volume); for (i_vol_port=0; i_vol_port<4; i_vol_port++) { if (audio_volume.level[i_vol_port] > 0) break; } if ( CDIO_INVALID_TRACK == i_first_track || CDIO_INVALID_TRACK == i_last_track ) { xperror("read toc header"); b_cd = false; b_record = false; i_last_display_track = CDIO_INVALID_TRACK; } else { b_cd = true; i_data = 0; get_disc_info(p_cdio); for (i = i_first_track; i <= i_last_track+1; i++) { int s; if ( !cdio_get_track_msf(p_cdio, i, &(toc[i])) ) { xperror("read toc entry"); b_cd = false; return; } if ( TRACK_FORMAT_AUDIO == cdio_get_track_format(p_cdio, i) ) { if (i != i_first_track) { s = cdio_audio_get_msf_seconds(&toc[i]) - cdio_audio_get_msf_seconds(&toc[i-1]); snprintf(cd_info[i-1].length, sizeof(cd_info[0].length), "%02d:%02d", s / CDIO_CD_SECS_PER_MIN, s % CDIO_CD_SECS_PER_MIN); } } else { if ((i != i_last_track+1) ) { i_data++; if (i == i_first_track) { if (i == i_last_track) i_first_audio_track = CDIO_CDROM_LEADOUT_TRACK; else i_first_audio_track++; } } } get_track_info(i); } b_record = true; read_subchannel(p_cdio); if (auto_mode && sub.audio_status != CDIO_MMC_READ_SUB_ST_PLAY) play_track(1, CDIO_CDROM_LEADOUT_TRACK); } action(""); if (!b_all_tracks) display_cdinfo(p_cdio, i_tracks, i_first_track); }
static DB_playItem_t * cda_insert (ddb_playlist_t *plt, DB_playItem_t *after, const char *fname) { trace ("CDA insert: %s\n", fname); CdIo_t* cdio = NULL; int track_nr; DB_playItem_t *res; const char* shortname = strrchr (fname, '/'); if (shortname) { shortname++; } else { shortname = fname; } const char *ext = strrchr (shortname, '.') + 1; int is_image = ext && (0 == strcmp (ext, "nrg")); if (is_image && !deadbeef->conf_get_int ("cdda.enable_nrg", 0)) { return NULL; } if (0 == strcmp (ext, "cda")) { cdio = cdio_open (NULL, DRIVER_UNKNOWN); } else if (is_image) { cdio = cdio_open (fname, DRIVER_NRG); } if (!cdio) { trace ("not an audio disc/image, or file not found (%s)\n", fname); return NULL; } // calculate discid track_t first_track = cdio_get_first_track_num (cdio); if (first_track == 0xff) { trace ("cdda: no medium found\n"); cdio_destroy (cdio); return NULL; } track_t tracks = cdio_get_num_tracks (cdio); track_t i; cddb_track_t *track; cddb_disc_t *disc = cddb_disc_new(); cddb_disc_set_length (disc, cdio_get_track_lba (cdio, CDIO_CDROM_LEADOUT_TRACK) / CDIO_CD_FRAMES_PER_SEC); for (i = 0; i < tracks; i++) { lsn_t offset = cdio_get_track_lba (cdio, i+first_track); track = cddb_track_new(); cddb_track_set_frame_offset (track, offset); cddb_disc_add_track (disc, track); } cddb_disc_calc_discid (disc); int discid = cddb_disc_get_discid (disc); if (0 == strcasecmp (shortname, "all.cda") || is_image) { track_t i; res = after; struct cddb_thread_params *p = malloc (sizeof (struct cddb_thread_params)); memset (p, 0, sizeof (struct cddb_thread_params)); p->cdio = cdio; int enable_cddb = deadbeef->conf_get_int ("cdda.freedb.enable", DEFAULT_USE_CDDB); for (i = 0; i < tracks; i++) { trace ("inserting track %d\n", i); res = insert_single_track (cdio, plt, res, is_image ? fname : NULL, i+first_track, discid); if (res) { p->items[i] = res; } } int got_cdtext = read_disc_cdtext (p); int prefer_cdtext = deadbeef->conf_get_int ("cdda.prefer_cdtext", DEFAULT_PREFER_CDTEXT); if ((!got_cdtext || !prefer_cdtext) && enable_cddb) { trace ("cdda: querying freedb...\n"); intptr_t tid = deadbeef->thread_start (cddb_thread, p); //will destroy cdio deadbeef->thread_detach (tid); } else cleanup_thread_params (p); } else { track_nr = atoi (shortname); res = insert_single_track (cdio, plt, after, NULL, track_nr, discid); if (res) { read_track_cdtext (cdio, track_nr, res); deadbeef->pl_item_unref (res); } cdio_destroy (cdio); } cddb_disc_destroy (disc); return res; }
static int cda_init (DB_fileinfo_t *_info, DB_playItem_t *it) { cdda_info_t *info = (cdda_info_t *)_info; trace ("cdda: init %s\n", deadbeef->pl_find_meta (it, ":URI")); size_t l = strlen (deadbeef->pl_find_meta (it, ":URI")); char location[l+1]; memcpy (location, deadbeef->pl_find_meta (it, ":URI"), l+1); char *nr = strchr (location, '#'); if (nr) { *nr = 0; nr++; } else { trace ("cdda: bad name: %s\n", deadbeef->pl_find_meta (it, ":URI")); return -1; } int track_nr = atoi (nr); char *fname = (*location) ? location : NULL; //NULL if empty string; means pysical CD drive info->cdio = cdio_open (fname, DRIVER_UNKNOWN); if (!info->cdio) { trace ("cdda: Could not open CD\n"); return -1; } track_t first_track = cdio_get_first_track_num (info->cdio); if (first_track == 0xff) { trace ("cdda: no medium found\n"); return -1; } track_t tracks = cdio_get_num_tracks (info->cdio); track_t i; cddb_track_t *track; cddb_disc_t *disc = cddb_disc_new(); cddb_disc_set_length (disc, cdio_get_track_lba (info->cdio, CDIO_CDROM_LEADOUT_TRACK) / CDIO_CD_FRAMES_PER_SEC); for (i = 0; i < tracks; i++) { lsn_t offset = cdio_get_track_lba (info->cdio, i+first_track); track = cddb_track_new(); cddb_track_set_frame_offset (track, offset); cddb_disc_add_track (disc, track); } cddb_disc_calc_discid (disc); int discid = cddb_disc_get_discid (disc); int trk_discid = deadbeef->pl_find_meta_int (it, ":CDIO_DISCID", 0); if (trk_discid != discid) { cddb_disc_destroy (disc); trace ("cdda: the track belongs to another disc, skipped\n"); return -1; } cddb_disc_destroy (disc); if (TRACK_FORMAT_AUDIO != cdio_get_track_format (info->cdio, track_nr)) { trace ("cdda: Not an audio track (%d)\n", track_nr); return -1; } int channels = cdio_get_track_channels (info->cdio, track_nr); trace ("cdio nchannels: %d\n", channels); _info->plugin = &plugin; _info->fmt.bps = 16; _info->fmt.channels = 2; _info->fmt.samplerate = 44100; _info->fmt.channelmask = DDB_SPEAKER_FRONT_LEFT | DDB_SPEAKER_FRONT_RIGHT; _info->readpos = 0; info->first_sector = cdio_get_track_lsn (info->cdio, track_nr); info->sector_count = cdio_get_track_sec_count (info->cdio, track_nr); info->current_sector = info->first_sector; info->tail_len = 0; info->current_sample = 0; return 0; }
static void get_track_info(ripncode_t *r) { rip_track_t *t; int i, base; char file[1024], *msg; int16_t *samples; int fd, n, l, total; base = cdio_get_first_track_num(r->cdio); r->ntrack = cdio_get_num_tracks(r->cdio); r->tracks = mrp_allocz_array(rip_track_t, r->ntrack); if (r->tracks == NULL && r->ntrack > 0) ripncode_fatal(r, "failed to allocate track info"); cdio_paranoia_modeset(r->cdpa, PARANOIA_MODE_FULL); for (i = 0, t = r->tracks; i < r->ntrack; i++, t++) { if (i >= r->last) break; t->id = base + i; t->format = cdio_get_track_format(r->cdio, base + i); t->lsn_beg = cdio_get_track_lsn(r->cdio, base + i); t->lsn_end = cdio_get_track_last_lsn(r->cdio, base + i); t->lba = cdio_get_track_lba(r->cdio, base + i); printf("track #%d (id %d): lsn: %u - %u (lba %u), format: %s\n", i, base + i, t->lsn_beg, t->lsn_end, t->lba, track_format_name(t->format)); if (r->dryrun) continue; snprintf(file, sizeof(file), "track-%d.raw", i); if ((fd = open(file, O_WRONLY|O_CREAT, 0644)) < 0) ripncode_fatal(r, "failed to open '%s' (%d: %s)", file, errno, strerror(errno)); cdio_paranoia_seek(r->cdpa, t->lsn_beg * CDIO_CD_FRAMESIZE_RAW, SEEK_SET); total = t->lsn_end - t->lsn_beg + 1; for (l = 0; l <= total; l++) { printf("\rreading track sector %d/%d (#%d)...", l, total, t->lsn_beg + l); fflush(stdout); samples = cdio_paranoia_read(r->cdpa, read_status); if (samples == NULL) { msg = cdio_cddap_errors(r->cdda); ripncode_fatal(r, "failed to seek to LSN %d (%s)", t->lsn_beg, msg ? msg : "unknown error"); } n = write(fd, samples, CDIO_CD_FRAMESIZE_RAW); if (n < 0) ripncode_fatal(r, "failed to write sector data (%d: %s)", errno, strerror(errno)); } close(fd); } }