/*
Get cdtext information in p_user_data for track i_track.
For disc information i_track is 0.
Return the CD-TEXT or NULL if obj is NULL, CD-TEXT information does
not exist, or we don't know how to get this implemented.
*/
cdtext_t *
get_cdtext_generic (void *p_user_data)
{
generic_img_private_t *p_env = p_user_data;
uint8_t *p_cdtext_data = NULL;
size_t len;
if (!p_env) return NULL;
if (p_env->b_cdtext_error) return NULL;
if (NULL == p_env->cdtext) {
p_cdtext_data = read_cdtext_generic (p_env);
if (NULL != p_cdtext_data) {
len = CDIO_MMC_GET_LEN16(p_cdtext_data)-2;
p_env->cdtext = cdtext_init();
if(len <= 0 || 0 != cdtext_data_init (p_env->cdtext, &p_cdtext_data[4], len)) {
p_env->b_cdtext_error = true;
cdtext_destroy (p_env->cdtext);
free(p_env->cdtext);
p_env->cdtext = NULL;
}
free(p_cdtext_data);
}
}
return p_env->cdtext;
}
/*
Disk and track information for a Nero file are located at the end
of the file. This routine extracts that information.
FIXME: right now psz_nrg_name is not used. It will be in the future.
*/
static bool
parse_nrg (_img_private_t *p_env, const char *psz_nrg_name,
const cdio_log_level_t log_level)
{
off_t footer_start;
off_t size;
char *footer_buf = NULL;
if (!p_env) return false;
size = cdio_stream_stat (p_env->gen.data_source);
if (-1 == size) return false;
{
_footer_t buf;
cdio_assert (sizeof (buf) == 12);
cdio_stream_seek (p_env->gen.data_source, size - sizeof (buf), SEEK_SET);
cdio_stream_read (p_env->gen.data_source, (void *) &buf, sizeof (buf), 1);
if (buf.v50.ID == UINT32_TO_BE (NERO_ID)) {
cdio_debug ("detected Nero version 5.0 (32-bit offsets) NRG magic");
footer_start = uint32_to_be (buf.v50.footer_ofs);
} else if (buf.v55.ID == UINT32_TO_BE (NER5_ID)) {
cdio_debug ("detected Nero version 5.5.x (64-bit offsets) NRG magic");
footer_start = uint64_from_be (buf.v55.footer_ofs);
} else {
cdio_log (log_level, "Image not recognized as either version 5.0 or "
"version 5.5.x-6.x type NRG");
return false;
}
cdio_debug (".NRG footer start = %ld, length = %ld",
(long) footer_start, (long) (size - footer_start));
cdio_assert ((size - footer_start) <= 4096);
footer_buf = calloc(1, (size_t)(size - footer_start));
cdio_stream_seek (p_env->gen.data_source, footer_start, SEEK_SET);
cdio_stream_read (p_env->gen.data_source, footer_buf,
(size_t)(size - footer_start), 1);
}
{
int pos = 0;
while (pos < size - footer_start) {
_chunk_t *chunk = (void *) (footer_buf + pos);
uint32_t opcode = UINT32_FROM_BE (chunk->id);
bool break_out = false;
switch (opcode) {
case CUES_ID: /* "CUES" Seems to have sector size 2336 and 150 sector
pregap seems to be included at beginning of image.
*/
case CUEX_ID: /* "CUEX" */
{
unsigned entries = UINT32_FROM_BE (chunk->len);
_cuex_array_t *_entries = (void *) chunk->data;
cdio_assert (p_env->mapping == NULL);
cdio_assert ( sizeof (_cuex_array_t) == 8 );
cdio_assert ( UINT32_FROM_BE (chunk->len) % sizeof(_cuex_array_t)
== 0 );
entries /= sizeof (_cuex_array_t);
if (CUES_ID == opcode) {
lsn_t lsn = UINT32_FROM_BE (_entries[0].lsn);
unsigned int idx;
unsigned int i = 0;
cdio_debug ("CUES type image detected" );
/* CUES LSN has 150 pregap include at beginning? -/
cdio_assert (lsn == 0?);
*/
p_env->is_cues = true; /* HACK alert. */
p_env->gen.i_tracks = 0;
p_env->gen.i_first_track = 1;
for (idx = 1; idx < entries-1; idx += 2, i++) {
lsn_t sec_count;
int cdte_format = _entries[idx].addr_ctrl / 16;
int cdte_ctrl = _entries[idx].type >> 4;
if ( COPY_PERMITTED & cdte_ctrl ) {
if (p_env) p_env->tocent[i].flags |= COPY_PERMITTED;
} else {
if (p_env) p_env->tocent[i].flags &= ~COPY_PERMITTED;
}
if ( PRE_EMPHASIS & cdte_ctrl ) {
if (p_env) p_env->tocent[i].flags |= PRE_EMPHASIS;
} else {
if (p_env) p_env->tocent[i].flags &= ~PRE_EMPHASIS;
}
if ( FOUR_CHANNEL_AUDIO & cdte_ctrl ) {
if (p_env) p_env->tocent[i].flags |= FOUR_CHANNEL_AUDIO;
} else {
if (p_env) p_env->tocent[i].flags &= ~FOUR_CHANNEL_AUDIO;
}
cdio_assert (_entries[idx].track == _entries[idx + 1].track);
/* lsn and sec_count*2 aren't correct, but it comes closer on the
single example I have: svcdgs.nrg
We are picking up the wrong fields and/or not interpreting
them correctly.
*/
switch (cdte_format) {
case 0:
lsn = UINT32_FROM_BE (_entries[idx].lsn);
break;
case 1:
{
#if 0
msf_t msf = (msf_t) _entries[idx].lsn;
lsn = cdio_msf_to_lsn(&msf);
#else
lsn = CDIO_INVALID_LSN;
#endif
cdio_log (log_level,
"untested (i.e. probably wrong) CUE MSF code");
break;
}
default:
lsn = CDIO_INVALID_LSN;
cdio_log(log_level,
"unknown cdte_format %d", cdte_format);
}
sec_count = UINT32_FROM_BE (_entries[idx + 1].lsn);
_register_mapping (p_env, lsn, sec_count*2,
(lsn+CDIO_PREGAP_SECTORS) * M2RAW_SECTOR_SIZE,
M2RAW_SECTOR_SIZE, TRACK_FORMAT_XA, true);
}
} else {
lsn_t lsn = UINT32_FROM_BE (_entries[0].lsn);
unsigned int idx;
unsigned int i = 0;
cdio_debug ("CUEX type image detected");
/* LSN must start at -150 (LBA 0)? */
cdio_assert (lsn == -150);
for (idx = 2; idx < entries; idx += 2, i++) {
lsn_t sec_count;
int cdte_format = _entries[idx].addr_ctrl >> 4;
int cdte_ctrl = _entries[idx].type >> 4;
if ( COPY_PERMITTED & cdte_ctrl ) {
if (p_env) p_env->tocent[i].flags |= COPY_PERMITTED;
} else {
if (p_env) p_env->tocent[i].flags &= ~COPY_PERMITTED;
}
if ( PRE_EMPHASIS & cdte_ctrl ) {
if (p_env) p_env->tocent[i].flags |= PRE_EMPHASIS;
} else {
if (p_env) p_env->tocent[i].flags &= ~PRE_EMPHASIS;
}
if ( FOUR_CHANNEL_AUDIO & cdte_ctrl ) {
if (p_env) p_env->tocent[i].flags |= FOUR_CHANNEL_AUDIO;
} else {
if (p_env) p_env->tocent[i].flags &= ~FOUR_CHANNEL_AUDIO;
}
/* extractnrg.pl has cdte_format for LBA's 0, and
for MSF 1. ???
FIXME: Should decode as appropriate for cdte_format.
*/
cdio_assert ( cdte_format == 0 || cdte_format == 1 );
cdio_assert (_entries[idx].track != _entries[idx + 1].track);
lsn = UINT32_FROM_BE (_entries[idx].lsn);
sec_count = UINT32_FROM_BE (_entries[idx + 1].lsn);
_register_mapping (p_env, lsn, sec_count - lsn,
(lsn + CDIO_PREGAP_SECTORS)*M2RAW_SECTOR_SIZE,
M2RAW_SECTOR_SIZE, TRACK_FORMAT_XA, true);
}
}
break;
}
case DAOX_ID: /* "DAOX" */
case DAOI_ID: /* "DAOI" */
{
_daox_t *_xentries = NULL;
_daoi_t *_ientries = NULL;
_dao_array_common_t *_dao_array_common = NULL;
_dao_common_t *_dao_common = (void *) chunk->data;
int disc_mode = _dao_common->unknown[1];
track_format_t track_format;
int i;
/* We include an extra 0 byte so these can be used as C strings.*/
p_env->psz_mcn = calloc(1, CDIO_MCN_SIZE+1);
memcpy(p_env->psz_mcn, &(_dao_common->psz_mcn), CDIO_MCN_SIZE);
p_env->psz_mcn[CDIO_MCN_SIZE] = '\0';
if (DAOX_ID == opcode) {
_xentries = (void *) chunk->data;
p_env->dtyp = _xentries->track_info[0].common.unknown[2];
} else {
_ientries = (void *) chunk->data;
p_env->dtyp = _ientries->track_info[0].common.unknown[2];
}
p_env->is_dao = true;
cdio_debug ("DAO%c tag detected, track format %d, mode %x\n",
opcode==DAOX_ID ? 'X': 'I', p_env->dtyp, disc_mode);
switch (p_env->dtyp) {
case 0:
/* Mode 1 */
track_format = TRACK_FORMAT_DATA;
p_env->disc_mode = CDIO_DISC_MODE_CD_DATA;
break;
case 2:
/* Mode 2 form 1 */
disc_mode = 0;
track_format = TRACK_FORMAT_XA;
p_env->disc_mode = CDIO_DISC_MODE_CD_XA;
break;
case 3:
/* Mode 2 */
track_format = TRACK_FORMAT_XA;
p_env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ?? */
break;
case 0x6:
/* Mode2 form mix */
track_format = TRACK_FORMAT_XA;
p_env->disc_mode = CDIO_DISC_MODE_CD_MIXED;
break;
case 0x20: /* ??? Mode2 form 2, Mode2 raw?? */
track_format = TRACK_FORMAT_XA;
p_env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ??. */
break;
case 0x7:
track_format = TRACK_FORMAT_AUDIO;
p_env->disc_mode = CDIO_DISC_MODE_CD_DA;
break;
default:
cdio_log (log_level, "Unknown track format %x\n",
p_env->dtyp);
track_format = TRACK_FORMAT_AUDIO;
}
if (0 == disc_mode) {
for (i=0; i<p_env->gen.i_tracks; i++) {
p_env->tocent[i].track_format= track_format;
p_env->tocent[i].datastart = 0;
p_env->tocent[i].track_green = false;
if (TRACK_FORMAT_AUDIO == track_format) {
p_env->tocent[i].blocksize = CDIO_CD_FRAMESIZE_RAW;
p_env->tocent[i].datasize = CDIO_CD_FRAMESIZE_RAW;
p_env->tocent[i].endsize = 0;
} else {
p_env->tocent[i].datasize = CDIO_CD_FRAMESIZE;
p_env->tocent[i].datastart = 0;
}
}
} else if (2 == disc_mode) {
for (i=0; i<p_env->gen.i_tracks; i++) {
p_env->tocent[i].track_green = true;
p_env->tocent[i].track_format= track_format;
p_env->tocent[i].datasize = CDIO_CD_FRAMESIZE;
if (TRACK_FORMAT_XA == track_format) {
p_env->tocent[i].datastart = CDIO_CD_SYNC_SIZE
+ CDIO_CD_HEADER_SIZE + CDIO_CD_SUBHEADER_SIZE;
p_env->tocent[i].endsize = CDIO_CD_SYNC_SIZE
+ CDIO_CD_ECC_SIZE;
} else {
p_env->tocent[i].datastart = CDIO_CD_SYNC_SIZE
+ CDIO_CD_HEADER_SIZE;
p_env->tocent[i].endsize = CDIO_CD_EDC_SIZE
+ CDIO_CD_M1F1_ZERO_SIZE + CDIO_CD_ECC_SIZE;
}
}
} else if (0x20 == disc_mode) {
cdio_debug ("Mixed mode CD?\n");
} else {
/* Mixed mode CD */
cdio_log (log_level,
"Don't know if mode 1, mode 2 or mixed: %x\n",
disc_mode);
}
for (i=0; i<p_env->gen.i_tracks; i++) {
if (DAOX_ID == opcode) {
_dao_array_common = &_xentries->track_info[i].common;
} else {
_dao_array_common = &_ientries->track_info[i].common;
}
p_env->tocent[i].isrc = calloc(1, CDIO_ISRC_SIZE+1);
memcpy(p_env->tocent[i].isrc, _dao_array_common->psz_isrc, CDIO_ISRC_SIZE);
p_env->tocent[i].isrc[CDIO_ISRC_SIZE] = '\0';
if (p_env->tocent[i].isrc[0]) {
cdio_info("nrg isrc has value \"%s\"", p_env->tocent[i].isrc);
}
if (!p_env->tocent[i].datasize) {
continue;
}
if (DAOX_ID == opcode) {
p_env->tocent[i].pregap = (uint64_from_be
(_xentries->track_info[i].index0)) / (p_env->tocent[i].datasize);
} else {
p_env->tocent[i].pregap = (uint32_from_be
(_ientries->track_info[i].index0)) / (p_env->tocent[i].datasize);
}
}
break;
}
case NERO_ID:
case NER5_ID:
cdio_error ("unexpected nrg magic ID NER%c detected",
opcode==NERO_ID ? 'O': '5');
free(footer_buf);
return false;
case END1_ID: /* "END!" */
cdio_debug ("nrg end tag detected");
break_out = true;
break;
case ETNF_ID: /* "ETNF" */ {
unsigned entries = UINT32_FROM_BE (chunk->len);
_etnf_array_t *_entries = (void *) chunk->data;
cdio_assert (p_env->mapping == NULL);
cdio_assert ( sizeof (_etnf_array_t) == 20 );
cdio_assert ( UINT32_FROM_BE(chunk->len) % sizeof(_etnf_array_t)
== 0 );
entries /= sizeof (_etnf_array_t);
cdio_debug ("SAO type image (ETNF) detected");
{
int idx;
for (idx = 0; idx < entries; idx++) {
uint32_t _len = UINT32_FROM_BE (_entries[idx].length);
uint32_t _start = UINT32_FROM_BE (_entries[idx].start_lsn);
uint32_t _start2 = UINT32_FROM_BE (_entries[idx].start);
uint32_t track_mode= uint32_from_be (_entries[idx].type);
bool track_green = true;
track_format_t track_format = TRACK_FORMAT_XA;
uint16_t blocksize;
switch (track_mode) {
case 0:
/* Mode 1 */
track_format = TRACK_FORMAT_DATA;
track_green = false; /* ?? */
blocksize = CDIO_CD_FRAMESIZE;
p_env->disc_mode = CDIO_DISC_MODE_CD_DATA;
cdio_debug ("Format DATA, blocksize %u", CDIO_CD_FRAMESIZE);
break;
case 2:
/* Mode 2 form 1 */
track_format = TRACK_FORMAT_XA;
track_green = false; /* ?? */
blocksize = CDIO_CD_FRAMESIZE;
p_env->disc_mode = CDIO_DISC_MODE_CD_XA;
cdio_debug ("Format XA, blocksize %u", CDIO_CD_FRAMESIZE);
break;
case 3:
/* Mode 2 */
track_format = TRACK_FORMAT_XA;
track_green = true;
blocksize = M2RAW_SECTOR_SIZE;
p_env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ?? */
cdio_debug ("Format XA, blocksize %u", M2RAW_SECTOR_SIZE);
break;
case 06:
/* Mode2 form mix */
track_format = TRACK_FORMAT_XA;
track_green = true;
blocksize = M2RAW_SECTOR_SIZE;
p_env->disc_mode = CDIO_DISC_MODE_CD_MIXED;
cdio_debug ("Format MIXED CD, blocksize %u", M2RAW_SECTOR_SIZE);
break;
case 0x20: /* ??? Mode2 form 2, Mode2 raw?? */
track_format = TRACK_FORMAT_XA;
track_green = true;
blocksize = M2RAW_SECTOR_SIZE;
p_env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ??. */
cdio_debug ("Format MIXED CD, blocksize %u", M2RAW_SECTOR_SIZE);
break;
case 7:
track_format = TRACK_FORMAT_AUDIO;
track_green = false;
blocksize = CDIO_CD_FRAMESIZE_RAW;
p_env->disc_mode = CDIO_DISC_MODE_CD_DA;
cdio_debug ("Format CD_DA, blocksize %u", CDIO_CD_FRAMESIZE_RAW);
break;
default:
cdio_log (log_level,
"Don't know how to handle track mode (%lu)?",
(long unsigned int) track_mode);
free(footer_buf);
return false;
}
cdio_assert (_len % blocksize == 0);
_len /= blocksize;
cdio_assert (_start * blocksize == _start2);
_start += idx * CDIO_PREGAP_SECTORS;
_register_mapping (p_env, _start, _len, _start2, blocksize,
track_format, track_green);
}
}
break;
}
case ETN2_ID: { /* "ETN2", same as above, but with 64bit stuff instead */
unsigned entries = uint32_from_be (chunk->len);
_etn2_array_t *_entries = (void *) chunk->data;
cdio_assert (p_env->mapping == NULL);
cdio_assert (sizeof (_etn2_array_t) == 32);
cdio_assert (uint32_from_be (chunk->len) % sizeof (_etn2_array_t) == 0);
entries /= sizeof (_etn2_array_t);
cdio_debug ("SAO type image (ETN2) detected");
{
int idx;
for (idx = 0; idx < entries; idx++) {
uint32_t _len = uint64_from_be (_entries[idx].length);
uint32_t _start = uint32_from_be (_entries[idx].start_lsn);
uint32_t _start2 = uint64_from_be (_entries[idx].start);
uint32_t track_mode= uint32_from_be (_entries[idx].type);
bool track_green = true;
track_format_t track_format = TRACK_FORMAT_XA;
uint16_t blocksize;
switch (track_mode) {
case 0:
track_format = TRACK_FORMAT_DATA;
track_green = false; /* ?? */
blocksize = CDIO_CD_FRAMESIZE;
break;
case 2:
track_format = TRACK_FORMAT_XA;
track_green = false; /* ?? */
blocksize = CDIO_CD_FRAMESIZE;
break;
case 3:
track_format = TRACK_FORMAT_XA;
track_green = true;
blocksize = M2RAW_SECTOR_SIZE;
break;
case 7:
track_format = TRACK_FORMAT_AUDIO;
track_green = false;
blocksize = CDIO_CD_FRAMESIZE_RAW;
break;
default:
cdio_log (log_level,
"Don't know how to handle track mode (%lu)?",
(long unsigned int) track_mode);
free(footer_buf);
return false;
}
if (_len % blocksize != 0) {
cdio_log (log_level,
"length is not a multiple of blocksize "
"len %lu, size %d, rem %lu",
(long unsigned int) _len, blocksize,
(long unsigned int) _len % blocksize);
if (0 == _len % CDIO_CD_FRAMESIZE) {
cdio_log(log_level, "Adjusting blocksize to %d",
CDIO_CD_FRAMESIZE);
blocksize = CDIO_CD_FRAMESIZE;
} else if (0 == _len % M2RAW_SECTOR_SIZE) {
cdio_log(log_level,
"Adjusting blocksize to %d", M2RAW_SECTOR_SIZE);
blocksize = M2RAW_SECTOR_SIZE;
} else if (0 == _len % CDIO_CD_FRAMESIZE_RAW) {
cdio_log(log_level,
"Adjusting blocksize to %d", CDIO_CD_FRAMESIZE_RAW);
blocksize = CDIO_CD_FRAMESIZE_RAW;
}
}
_len /= blocksize;
if (_start * blocksize != _start2) {
cdio_log (log_level,
"%lu * %d != %lu",
(long unsigned int) _start, blocksize,
(long unsigned int) _start2);
if (_start * CDIO_CD_FRAMESIZE == _start2) {
cdio_log(log_level,
"Adjusting blocksize to %d", CDIO_CD_FRAMESIZE);
blocksize = CDIO_CD_FRAMESIZE;
} else if (_start * M2RAW_SECTOR_SIZE == _start2) {
cdio_log(log_level,
"Adjusting blocksize to %d", M2RAW_SECTOR_SIZE);
blocksize = M2RAW_SECTOR_SIZE;
} else if (_start * CDIO_CD_FRAMESIZE_RAW == _start2) {
cdio_log(log_level,
"Adjusting blocksize to %d", CDIO_CD_FRAMESIZE_RAW);
blocksize = CDIO_CD_FRAMESIZE_RAW;
}
}
_start += idx * CDIO_PREGAP_SECTORS;
_register_mapping (p_env, _start, _len, _start2, blocksize,
track_format, track_green);
}
}
break;
}
case SINF_ID: { /* "SINF" */
uint32_t _sessions;
cdio_assert (UINT32_FROM_BE (chunk->len) == 4);
memcpy(&_sessions, chunk->data, 4);
cdio_debug ("SINF: %lu sessions",
(long unsigned int) UINT32_FROM_BE (_sessions));
}
break;
case MTYP_ID: { /* "MTYP" */
uint32_t mtyp_be;
uint32_t mtyp;
cdio_assert (UINT32_FROM_BE (chunk->len) == 4);
memcpy(&mtyp_be, chunk->data, 4);
mtyp = UINT32_FROM_BE (mtyp_be);
cdio_debug ("MTYP: %lu",
(long unsigned int) mtyp);
if (mtyp != MTYP_AUDIO_CD) {
cdio_log (log_level,
"Unknown MTYP value: %u", (unsigned int) mtyp);
}
p_env->mtyp = mtyp;
}
break;
case CDTX_ID: { /* "CD TEXT" */
uint8_t *wdata = (uint8_t *) chunk->data;
int len = UINT32_FROM_BE (chunk->len);
cdio_assert (len % CDTEXT_LEN_PACK == 0);
p_env->gen.cdtext = cdtext_init ();
if(0 !=cdtext_data_init (p_env->gen.cdtext, wdata, len))
{
cdtext_destroy(p_env->gen.cdtext);
free(p_env->gen.cdtext);
p_env->gen.cdtext = NULL;
}
break;
}
default:
cdio_log (log_level,
"unknown tag %8.8x seen",
(unsigned int) UINT32_FROM_BE (chunk->id));
break;
}
if (break_out)
break;
pos += 8;
pos += UINT32_FROM_BE (chunk->len);
}
