claunia/libcdio-osx
Archived
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Classified one more disc mode perhaps. Variable name change and

Browse Source 
probably clarification.
This commit is contained in:
rocky
2004-12-17 04:57:14 +00:00
parent bdc5d3ff6e
commit a8f67b6163
1 changed files with 149 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

294
lib/image/nrg.c
View File

@@ -1,5 +1,5 @@
/* /*
$Id: nrg.c,v 1.43 2004/10/31 06:07:26 rocky Exp $ $Id: nrg.c,v 1.44 2004/12/17 04:57:14 rocky Exp $
Copyright (C) 2003, 2004 Rocky Bernstein <rocky@panix.com> Copyright (C) 2003, 2004 Rocky Bernstein <rocky@panix.com>
Copyright (C) 2001, 2003 Herbert Valerio Riedel <hvr@gnu.org> Copyright (C) 2001, 2003 Herbert Valerio Riedel <hvr@gnu.org>
@@ -46,7 +46,7 @@
#include "_cdio_stdio.h" #include "_cdio_stdio.h"
#include "nrg.h" #include "nrg.h"
static const char _rcsid[] = "$Id: nrg.c,v 1.43 2004/10/31 06:07:26 rocky Exp $"; static const char _rcsid[] = "$Id: nrg.c,v 1.44 2004/12/17 04:57:14 rocky Exp $";
/* reader */ /* reader */
@@ -204,22 +204,22 @@ _register_mapping (_img_private_t *env, lsn_t start_lsn, uint32_t sec_count,
FIXME: right now psz_nrg_name is not used. It will be in the future. FIXME: right now psz_nrg_name is not used. It will be in the future.
*/ */
static bool static bool
parse_nrg (_img_private_t *env, const char *psz_nrg_name) parse_nrg (_img_private_t *p_env, const char *psz_nrg_name)
{ {
long unsigned int footer_start; long unsigned int footer_start;
long unsigned int size; long unsigned int size;
char *footer_buf = NULL; char *footer_buf = NULL;
cdio_log_level_t log_level = (NULL == env) ? CDIO_LOG_INFO : CDIO_LOG_WARN; cdio_log_level_t log_level = (NULL == p_env) ? CDIO_LOG_INFO : CDIO_LOG_WARN;
size = cdio_stream_stat (env->gen.data_source); size = cdio_stream_stat (p_env->gen.data_source);
if (-1 == size) return false; if (-1 == size) return false;
{ {
_footer_t buf; _footer_t buf;
cdio_assert (sizeof (buf) == 12); cdio_assert (sizeof (buf) == 12);
cdio_stream_seek (env->gen.data_source, size - sizeof (buf), SEEK_SET); cdio_stream_seek (p_env->gen.data_source, size - sizeof (buf), SEEK_SET);
cdio_stream_read (env->gen.data_source, (void *) &buf, sizeof (buf), 1); cdio_stream_read (p_env->gen.data_source, (void *) &buf, sizeof (buf), 1);
if (buf.v50.ID == UINT32_TO_BE (NERO_ID)) { if (buf.v50.ID == UINT32_TO_BE (NERO_ID)) {
cdio_info ("detected Nero version 5.0 (32-bit offsets) NRG magic"); cdio_info ("detected Nero version 5.0 (32-bit offsets) NRG magic");
@@ -240,8 +240,8 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
footer_buf = _cdio_malloc (size - footer_start); footer_buf = _cdio_malloc (size - footer_start);
cdio_stream_seek (env->gen.data_source, footer_start, SEEK_SET); cdio_stream_seek (p_env->gen.data_source, footer_start, SEEK_SET);
cdio_stream_read (env->gen.data_source, footer_buf, cdio_stream_read (p_env->gen.data_source, footer_buf,
size - footer_start, 1); size - footer_start, 1);
} }
{ {
@@ -263,7 +263,7 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
unsigned entries = UINT32_FROM_BE (chunk->len); unsigned entries = UINT32_FROM_BE (chunk->len);
_cuex_array_t *_entries = (void *) chunk->data; _cuex_array_t *_entries = (void *) chunk->data;
cdio_assert (env->mapping == NULL); cdio_assert (p_env->mapping == NULL);
cdio_assert ( sizeof (_cuex_array_t) == 8 ); cdio_assert ( sizeof (_cuex_array_t) == 8 );
cdio_assert ( UINT32_FROM_BE (chunk->len) % sizeof(_cuex_array_t) cdio_assert ( UINT32_FROM_BE (chunk->len) % sizeof(_cuex_array_t)
@@ -281,9 +281,9 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
cdio_assert (lsn == 0?); cdio_assert (lsn == 0?);
*/ */
env->is_cues = true; /* HACK alert. */ p_env->is_cues = true; /* HACK alert. */
env->gen.i_tracks = 0; p_env->gen.i_tracks = 0;
env->gen.i_first_track = 1; p_env->gen.i_first_track = 1;
for (idx = 1; idx < entries-1; idx += 2) { for (idx = 1; idx < entries-1; idx += 2) {
lsn_t sec_count; lsn_t sec_count;
int addrtype = _entries[idx].addr_ctrl / 16; int addrtype = _entries[idx].addr_ctrl / 16;
@@ -322,7 +322,7 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
sec_count = UINT32_FROM_BE (_entries[idx + 1].lsn); sec_count = UINT32_FROM_BE (_entries[idx + 1].lsn);
_register_mapping (env, lsn, sec_count*2, _register_mapping (p_env, lsn, sec_count*2,
(lsn+CDIO_PREGAP_SECTORS) * M2RAW_SECTOR_SIZE, (lsn+CDIO_PREGAP_SECTORS) * M2RAW_SECTOR_SIZE,
M2RAW_SECTOR_SIZE, TRACK_FORMAT_XA, true, M2RAW_SECTOR_SIZE, TRACK_FORMAT_XA, true,
flags); flags);
@@ -356,7 +356,7 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
lsn = UINT32_FROM_BE (_entries[idx].lsn); lsn = UINT32_FROM_BE (_entries[idx].lsn);
sec_count = UINT32_FROM_BE (_entries[idx + 1].lsn); sec_count = UINT32_FROM_BE (_entries[idx + 1].lsn);
_register_mapping (env, lsn, sec_count - lsn, _register_mapping (p_env, lsn, sec_count - lsn,
(lsn + CDIO_PREGAP_SECTORS)*M2RAW_SECTOR_SIZE, (lsn + CDIO_PREGAP_SECTORS)*M2RAW_SECTOR_SIZE,
M2RAW_SECTOR_SIZE, TRACK_FORMAT_XA, true, M2RAW_SECTOR_SIZE, TRACK_FORMAT_XA, true,
flags); flags);
@@ -369,102 +369,106 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
case DAOI_ID: /* "DAOI" */ case DAOI_ID: /* "DAOI" */
{ {
track_format_t track_format; track_format_t track_format;
int form2; int disc_mode;
/* We include an extra 0 byte so these can be used as C strings.*/ /* We include an extra 0 byte so these can be used as C strings.*/
env->psz_mcn = _cdio_malloc (CDIO_MCN_SIZE+1); p_env->psz_mcn = _cdio_malloc (CDIO_MCN_SIZE+1);
if (DAOX_ID == opcode) { if (DAOX_ID == opcode) {
_daox_array_t *_entries = (void *) chunk->data; _daox_array_t *_entries = (void *) chunk->data;
form2 = _entries->_unknown[1]; disc_mode = _entries->_unknown[1];
env->dtyp = _entries->_unknown[19]; p_env->dtyp = _entries->_unknown[19];
memcpy(env->psz_mcn, &(_entries->psz_mcn), CDIO_MCN_SIZE); memcpy(p_env->psz_mcn, &(_entries->psz_mcn), CDIO_MCN_SIZE);
env->psz_mcn[CDIO_MCN_SIZE] = '\0'; p_env->psz_mcn[CDIO_MCN_SIZE] = '\0';
} else { } else {
_daoi_array_t *_entries = (void *) chunk->data; _daoi_array_t *_entries = (void *) chunk->data;
form2 = _entries->_unknown[1]; disc_mode = _entries->_unknown[1];
env->dtyp = _entries->_unknown[19]; p_env->dtyp = _entries->_unknown[19];
memcpy(env->psz_mcn, &(_entries->psz_mcn), CDIO_MCN_SIZE); memcpy(p_env->psz_mcn, &(_entries->psz_mcn), CDIO_MCN_SIZE);
env->psz_mcn[CDIO_MCN_SIZE] = '\0'; p_env->psz_mcn[CDIO_MCN_SIZE] = '\0';
} }
env->is_dao = true; p_env->is_dao = true;
cdio_debug ("DAO%c tag detected, track format %d, form %x\n", cdio_debug ("DAO%c tag detected, track format %d, mode %x\n",
opcode==DAOX_ID ? 'X': 'I', env->dtyp, form2); opcode==DAOX_ID ? 'X': 'I', p_env->dtyp, disc_mode);
switch (env->dtyp) { switch (p_env->dtyp) {
case 0: case 0:
/* Mode 1 */ /* Mode 1 */
track_format = TRACK_FORMAT_DATA; track_format = TRACK_FORMAT_DATA;
env->disc_mode = CDIO_DISC_MODE_CD_DATA; p_env->disc_mode = CDIO_DISC_MODE_CD_DATA;
break; break;
case 2: case 2:
/* Mode 2 form 1 */ /* Mode 2 form 1 */
form2 = 0; disc_mode = 0;
track_format = TRACK_FORMAT_XA; track_format = TRACK_FORMAT_XA;
env->disc_mode = CDIO_DISC_MODE_CD_XA; p_env->disc_mode = CDIO_DISC_MODE_CD_XA;
break; break;
case 3: case 3:
/* Mode 2 */ /* Mode 2 */
track_format = TRACK_FORMAT_XA; track_format = TRACK_FORMAT_XA;
env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ?? */ p_env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ?? */
break; break;
case 0x6: case 0x6:
/* Mode2 form mix */ /* Mode2 form mix */
track_format = TRACK_FORMAT_XA; track_format = TRACK_FORMAT_XA;
env->disc_mode = CDIO_DISC_MODE_CD_MIXED; p_env->disc_mode = CDIO_DISC_MODE_CD_MIXED;
break; break;
case 0x20: /* ??? Mode2 form 2, Mode2 raw?? */ case 0x20: /* ??? Mode2 form 2, Mode2 raw?? */
track_format = TRACK_FORMAT_XA; track_format = TRACK_FORMAT_XA;
env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ??. */ p_env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ??. */
break; break;
case 0x7: case 0x7:
track_format = TRACK_FORMAT_AUDIO; track_format = TRACK_FORMAT_AUDIO;
env->disc_mode = CDIO_DISC_MODE_CD_DA; p_env->disc_mode = CDIO_DISC_MODE_CD_DA;
break; break;
default: default:
cdio_log (log_level, "Unknown track format %x\n", cdio_log (log_level, "Unknown track format %x\n",
env->dtyp); p_env->dtyp);
track_format = TRACK_FORMAT_AUDIO; track_format = TRACK_FORMAT_AUDIO;
} }
if (0 == form2) { if (0 == disc_mode) {
int i; int i;
for (i=0; i<env->gen.i_tracks; i++) { for (i=0; i<p_env->gen.i_tracks; i++) {
cdtext_init (&(env->gen.cdtext_track[i])); cdtext_init (&(p_env->gen.cdtext_track[i]));
env->tocent[i].track_format= track_format; p_env->tocent[i].track_format= track_format;
env->tocent[i].datastart = 0; p_env->tocent[i].datastart = 0;
env->tocent[i].track_green = false; p_env->tocent[i].track_green = false;
if (TRACK_FORMAT_AUDIO == track_format) { if (TRACK_FORMAT_AUDIO == track_format) {
env->tocent[i].blocksize = CDIO_CD_FRAMESIZE_RAW; p_env->tocent[i].blocksize = CDIO_CD_FRAMESIZE_RAW;
env->tocent[i].datasize = CDIO_CD_FRAMESIZE_RAW; p_env->tocent[i].datasize = CDIO_CD_FRAMESIZE_RAW;
env->tocent[i].endsize = 0; p_env->tocent[i].endsize = 0;
} else { } else {
env->tocent[i].datasize = CDIO_CD_FRAMESIZE; p_env->tocent[i].datasize = CDIO_CD_FRAMESIZE;
env->tocent[i].datastart = 0; p_env->tocent[i].datastart = 0;
} }
} }
} else if (2 == form2) { } else if (2 == disc_mode) {
int i; int i;
for (i=0; i<env->gen.i_tracks; i++) { for (i=0; i<p_env->gen.i_tracks; i++) {
cdtext_init (&(env->gen.cdtext_track[i])); cdtext_init (&(p_env->gen.cdtext_track[i]));
env->tocent[i].track_green = true; p_env->tocent[i].track_green = true;
env->tocent[i].track_format= track_format; p_env->tocent[i].track_format= track_format;
env->tocent[i].datasize = CDIO_CD_FRAMESIZE; p_env->tocent[i].datasize = CDIO_CD_FRAMESIZE;
if (TRACK_FORMAT_XA == track_format) { if (TRACK_FORMAT_XA == track_format) {
env->tocent[i].datastart = CDIO_CD_SYNC_SIZE p_env->tocent[i].datastart = CDIO_CD_SYNC_SIZE
+ CDIO_CD_HEADER_SIZE + CDIO_CD_SUBHEADER_SIZE; + CDIO_CD_HEADER_SIZE + CDIO_CD_SUBHEADER_SIZE;
env->tocent[i].endsize = CDIO_CD_SYNC_SIZE p_env->tocent[i].endsize = CDIO_CD_SYNC_SIZE
+ CDIO_CD_ECC_SIZE; + CDIO_CD_ECC_SIZE;
} else { } else {
env->tocent[i].datastart = CDIO_CD_SYNC_SIZE p_env->tocent[i].datastart = CDIO_CD_SYNC_SIZE
+ CDIO_CD_HEADER_SIZE; + CDIO_CD_HEADER_SIZE;
env->tocent[i].endsize = CDIO_CD_EDC_SIZE p_env->tocent[i].endsize = CDIO_CD_EDC_SIZE
+ CDIO_CD_M1F1_ZERO_SIZE + CDIO_CD_ECC_SIZE; + CDIO_CD_M1F1_ZERO_SIZE + CDIO_CD_ECC_SIZE;
} }
} }
} else if (0x20 == disc_mode) {
cdio_debug ("Mixed mode CD?\n");
} else { } else {
cdio_log (log_level, "Don't know if form1 or form2 form2: %x\n", /* Mixed mode CD */
form2); cdio_log (log_level,
"Don't know if mode 1, mode 2 or mixed: %x\n",
disc_mode);
} }
break; break;
} }
@@ -485,7 +489,7 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
unsigned entries = UINT32_FROM_BE (chunk->len); unsigned entries = UINT32_FROM_BE (chunk->len);
_etnf_array_t *_entries = (void *) chunk->data; _etnf_array_t *_entries = (void *) chunk->data;
cdio_assert (env->mapping == NULL); cdio_assert (p_env->mapping == NULL);
cdio_assert ( sizeof (_etnf_array_t) == 20 ); cdio_assert ( sizeof (_etnf_array_t) == 20 );
cdio_assert ( UINT32_FROM_BE(chunk->len) % sizeof(_etnf_array_t) cdio_assert ( UINT32_FROM_BE(chunk->len) % sizeof(_etnf_array_t)
@@ -512,40 +516,40 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
track_format = TRACK_FORMAT_DATA; track_format = TRACK_FORMAT_DATA;
track_green = false; /* ?? */ track_green = false; /* ?? */
blocksize = CDIO_CD_FRAMESIZE; blocksize = CDIO_CD_FRAMESIZE;
env->disc_mode = CDIO_DISC_MODE_CD_DATA; p_env->disc_mode = CDIO_DISC_MODE_CD_DATA;
break; break;
case 2: case 2:
/* Mode 2 form 1 */ /* Mode 2 form 1 */
track_format = TRACK_FORMAT_XA; track_format = TRACK_FORMAT_XA;
track_green = false; /* ?? */ track_green = false; /* ?? */
blocksize = CDIO_CD_FRAMESIZE; blocksize = CDIO_CD_FRAMESIZE;
env->disc_mode = CDIO_DISC_MODE_CD_XA; p_env->disc_mode = CDIO_DISC_MODE_CD_XA;
break; break;
case 3: case 3:
/* Mode 2 */ /* Mode 2 */
track_format = TRACK_FORMAT_XA; track_format = TRACK_FORMAT_XA;
track_green = true; track_green = true;
blocksize = M2RAW_SECTOR_SIZE; blocksize = M2RAW_SECTOR_SIZE;
env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ?? */ p_env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ?? */
break; break;
case 06: case 06:
/* Mode2 form mix */ /* Mode2 form mix */
track_format = TRACK_FORMAT_XA; track_format = TRACK_FORMAT_XA;
track_green = true; track_green = true;
blocksize = M2RAW_SECTOR_SIZE; blocksize = M2RAW_SECTOR_SIZE;
env->disc_mode = CDIO_DISC_MODE_CD_MIXED; p_env->disc_mode = CDIO_DISC_MODE_CD_MIXED;
break; break;
case 0x20: /* ??? Mode2 form 2, Mode2 raw?? */ case 0x20: /* ??? Mode2 form 2, Mode2 raw?? */
track_format = TRACK_FORMAT_XA; track_format = TRACK_FORMAT_XA;
track_green = true; track_green = true;
blocksize = M2RAW_SECTOR_SIZE; blocksize = M2RAW_SECTOR_SIZE;
env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ??. */ p_env->disc_mode = CDIO_DISC_MODE_CD_XA; /* ??. */
break; break;
case 7: case 7:
track_format = TRACK_FORMAT_AUDIO; track_format = TRACK_FORMAT_AUDIO;
track_green = false; track_green = false;
blocksize = CDIO_CD_FRAMESIZE_RAW; blocksize = CDIO_CD_FRAMESIZE_RAW;
env->disc_mode = CDIO_DISC_MODE_CD_DA; p_env->disc_mode = CDIO_DISC_MODE_CD_DA;
break; break;
default: default:
cdio_log (log_level, cdio_log (log_level,
@@ -562,7 +566,7 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
cdio_assert (_start * blocksize == _start2); cdio_assert (_start * blocksize == _start2);
_start += idx * CDIO_PREGAP_SECTORS; _start += idx * CDIO_PREGAP_SECTORS;
_register_mapping (env, _start, _len, _start2, blocksize, _register_mapping (p_env, _start, _len, _start2, blocksize,
track_format, track_green, 0); track_format, track_green, 0);
} }
@@ -574,7 +578,7 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
unsigned entries = uint32_from_be (chunk->len); unsigned entries = uint32_from_be (chunk->len);
_etn2_array_t *_entries = (void *) chunk->data; _etn2_array_t *_entries = (void *) chunk->data;
cdio_assert (env->mapping == NULL); cdio_assert (p_env->mapping == NULL);
cdio_assert (sizeof (_etn2_array_t) == 32); cdio_assert (sizeof (_etn2_array_t) == 32);
cdio_assert (uint32_from_be (chunk->len) % sizeof (_etn2_array_t) == 0); cdio_assert (uint32_from_be (chunk->len) % sizeof (_etn2_array_t) == 0);
@@ -668,7 +672,7 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
} }
_start += idx * CDIO_PREGAP_SECTORS; _start += idx * CDIO_PREGAP_SECTORS;
_register_mapping (env, _start, _len, _start2, blocksize, _register_mapping (p_env, _start, _len, _start2, blocksize,
track_format, track_green, 0); track_format, track_green, 0);
} }
} }
@@ -699,7 +703,7 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
cdio_log (log_level, cdio_log (log_level,
"Unknown MTYP value: %u", (unsigned int) mtyp); "Unknown MTYP value: %u", (unsigned int) mtyp);
} }
env->mtyp = mtyp; p_env->mtyp = mtyp;
} }
break; break;
@@ -729,14 +733,14 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
/* Don't use _stat_size_nrg since that will lead to recursion since /* Don't use _stat_size_nrg since that will lead to recursion since
we haven't fully initialized things yet. we haven't fully initialized things yet.
*/ */
cdio_lsn_to_msf (env->size, &env->tocent[env->gen.i_tracks].start_msf); cdio_lsn_to_msf (p_env->size, &p_env->tocent[p_env->gen.i_tracks].start_msf);
env->tocent[env->gen.i_tracks].start_lba = cdio_lsn_to_lba(env->size); p_env->tocent[p_env->gen.i_tracks].start_lba = cdio_lsn_to_lba(p_env->size);
env->tocent[env->gen.i_tracks-1].sec_count = p_env->tocent[p_env->gen.i_tracks-1].sec_count =
cdio_lsn_to_lba(env->size - env->tocent[env->gen.i_tracks-1].start_lba); cdio_lsn_to_lba(p_env->size - p_env->tocent[p_env->gen.i_tracks-1].start_lba);
env->gen.b_cdtext_init = true; p_env->gen.b_cdtext_init = true;
env->gen.b_cdtext_error = false; p_env->gen.b_cdtext_error = false;
env->gen.toc_init = true; p_env->gen.toc_init = true;
free(footer_buf); free(footer_buf);
return true; return true;
} }
@@ -745,31 +749,31 @@ parse_nrg (_img_private_t *env, const char *psz_nrg_name)
Initialize image structures. Initialize image structures.
*/ */
static bool static bool
_init_nrg (_img_private_t *env) _init_nrg (_img_private_t *p_env)
{ {
if (env->gen.init) { if (p_env->gen.init) {
cdio_error ("init called more than once"); cdio_error ("init called more than once");
return false; return false;
} }
if (!(env->gen.data_source = cdio_stdio_new (env->gen.source_name))) { if (!(p_env->gen.data_source = cdio_stdio_new (p_env->gen.source_name))) {
cdio_warn ("can't open nrg image file %s for reading", cdio_warn ("can't open nrg image file %s for reading",
env->gen.source_name); p_env->gen.source_name);
return false; return false;
} }
env->psz_mcn = NULL; p_env->psz_mcn = NULL;
env->disc_mode = CDIO_DISC_MODE_NO_INFO; p_env->disc_mode = CDIO_DISC_MODE_NO_INFO;
cdtext_init (&(env->gen.cdtext)); cdtext_init (&(p_env->gen.cdtext));
if ( !parse_nrg (env, env->gen.source_name) ) { if ( !parse_nrg (p_env, p_env->gen.source_name) ) {
cdio_warn ("image file %s is not a Nero image", cdio_warn ("image file %s is not a Nero image",
env->gen.source_name); p_env->gen.source_name);
return false; return false;
} }
env->gen.init = true; p_env->gen.init = true;
return true; return true;
} }
@@ -783,38 +787,38 @@ _init_nrg (_img_private_t *env)
static off_t static off_t
_lseek_nrg (void *user_data, off_t offset, int whence) _lseek_nrg (void *user_data, off_t offset, int whence)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
/* real_offset is the real byte offset inside the disk image /* real_offset is the real byte offset inside the disk image
The number below was determined empirically. The number below was determined empirically.
*/ */
off_t real_offset= env->is_dao ? 0x4b000 : 0; off_t real_offset= p_env->is_dao ? 0x4b000 : 0;
unsigned int i; unsigned int i;
for (i=0; i<env->gen.i_tracks; i++) { for (i=0; i<p_env->gen.i_tracks; i++) {
track_info_t *this_track=&(env->tocent[i]); track_info_t *this_track=&(p_env->tocent[i]);
env->pos.index = i; p_env->pos.index = i;
if ( (this_track->sec_count*this_track->datasize) >= offset) { if ( (this_track->sec_count*this_track->datasize) >= offset) {
int blocks = offset / this_track->datasize; int blocks = offset / this_track->datasize;
int rem = offset % this_track->datasize; int rem = offset % this_track->datasize;
int block_offset = blocks * this_track->blocksize; int block_offset = blocks * this_track->blocksize;
real_offset += block_offset + rem; real_offset += block_offset + rem;
env->pos.buff_offset = rem; p_env->pos.buff_offset = rem;
env->pos.lba += blocks; p_env->pos.lba += blocks;
break; break;
} }
real_offset += this_track->sec_count*this_track->blocksize; real_offset += this_track->sec_count*this_track->blocksize;
offset -= this_track->sec_count*this_track->datasize; offset -= this_track->sec_count*this_track->datasize;
env->pos.lba += this_track->sec_count; p_env->pos.lba += this_track->sec_count;
} }
if (i==env->gen.i_tracks) { if (i==p_env->gen.i_tracks) {
cdio_warn ("seeking outside range of disk image"); cdio_warn ("seeking outside range of disk image");
return -1; return -1;
} else } else
real_offset += env->tocent[i].datastart; real_offset += p_env->tocent[i].datastart;
return cdio_stream_seek(env->gen.data_source, real_offset, whence); return cdio_stream_seek(p_env->gen.data_source, real_offset, whence);
} }
/*! /*!
@@ -827,16 +831,16 @@ _lseek_nrg (void *user_data, off_t offset, int whence)
static ssize_t static ssize_t
_read_nrg (void *user_data, void *buf, size_t size) _read_nrg (void *user_data, void *buf, size_t size)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
return cdio_stream_read(env->gen.data_source, buf, size, 1); return cdio_stream_read(p_env->gen.data_source, buf, size, 1);
} }
static uint32_t static uint32_t
_stat_size_nrg (void *user_data) _stat_size_nrg (void *user_data)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
return env->size; return p_env->size;
} }
/*! /*!
@@ -847,18 +851,18 @@ static int
_read_audio_sectors_nrg (void *user_data, void *data, lsn_t lsn, _read_audio_sectors_nrg (void *user_data, void *data, lsn_t lsn,
unsigned int nblocks) unsigned int nblocks)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
CdioListNode *node; CdioListNode *node;
if (lsn >= env->size) if (lsn >= p_env->size)
{ {
cdio_warn ("trying to read beyond image size (%lu >= %lu)", cdio_warn ("trying to read beyond image size (%lu >= %lu)",
(long unsigned int) lsn, (long unsigned int) env->size); (long unsigned int) lsn, (long unsigned int) p_env->size);
return -1; return -1;
} }
_CDIO_LIST_FOREACH (node, env->mapping) { _CDIO_LIST_FOREACH (node, p_env->mapping) {
_mapping_t *_map = _cdio_list_node_data (node); _mapping_t *_map = _cdio_list_node_data (node);
if (IN (lsn, _map->start_lsn, (_map->start_lsn + _map->sec_count - 1))) { if (IN (lsn, _map->start_lsn, (_map->start_lsn + _map->sec_count - 1))) {
@@ -867,10 +871,10 @@ _read_audio_sectors_nrg (void *user_data, void *data, lsn_t lsn,
img_offset += (lsn - _map->start_lsn) * CDIO_CD_FRAMESIZE_RAW; img_offset += (lsn - _map->start_lsn) * CDIO_CD_FRAMESIZE_RAW;
ret = cdio_stream_seek (env->gen.data_source, img_offset, ret = cdio_stream_seek (p_env->gen.data_source, img_offset,
SEEK_SET); SEEK_SET);
if (ret!=0) return ret; if (ret!=0) return ret;
ret = cdio_stream_read (env->gen.data_source, data, ret = cdio_stream_read (p_env->gen.data_source, data,
CDIO_CD_FRAMESIZE_RAW, nblocks); CDIO_CD_FRAMESIZE_RAW, nblocks);
if (ret==0) return ret; if (ret==0) return ret;
break; break;
@@ -887,19 +891,19 @@ static int
_read_mode1_sector_nrg (void *user_data, void *data, lsn_t lsn, _read_mode1_sector_nrg (void *user_data, void *data, lsn_t lsn,
bool b_form2) bool b_form2)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, }; char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, };
CdioListNode *node; CdioListNode *node;
if (lsn >= env->size) if (lsn >= p_env->size)
{ {
cdio_warn ("trying to read beyond image size (%lu >= %lu)", cdio_warn ("trying to read beyond image size (%lu >= %lu)",
(long unsigned int) lsn, (long unsigned int) env->size); (long unsigned int) lsn, (long unsigned int) p_env->size);
return -1; return -1;
} }
_CDIO_LIST_FOREACH (node, env->mapping) { _CDIO_LIST_FOREACH (node, p_env->mapping) {
_mapping_t *_map = _cdio_list_node_data (node); _mapping_t *_map = _cdio_list_node_data (node);
if (IN (lsn, _map->start_lsn, (_map->start_lsn + _map->sec_count - 1))) { if (IN (lsn, _map->start_lsn, (_map->start_lsn + _map->sec_count - 1))) {
@@ -908,12 +912,12 @@ _read_mode1_sector_nrg (void *user_data, void *data, lsn_t lsn,
img_offset += (lsn - _map->start_lsn) * _map->blocksize; img_offset += (lsn - _map->start_lsn) * _map->blocksize;
ret = cdio_stream_seek (env->gen.data_source, img_offset, ret = cdio_stream_seek (p_env->gen.data_source, img_offset,
SEEK_SET); SEEK_SET);
if (ret!=0) return ret; if (ret!=0) return ret;
/* FIXME: Not completely sure the below is correct. */ /* FIXME: Not completely sure the below is correct. */
ret = cdio_stream_read (env->gen.data_source, ret = cdio_stream_read (p_env->gen.data_source,
(M2RAW_SECTOR_SIZE == _map->blocksize) (M2RAW_SECTOR_SIZE == _map->blocksize)
? (buf + CDIO_CD_SYNC_SIZE + CDIO_CD_HEADER_SIZE) ? (buf + CDIO_CD_SYNC_SIZE + CDIO_CD_HEADER_SIZE)
: buf, : buf,
@@ -941,13 +945,13 @@ static int
_read_mode1_sectors_nrg (void *user_data, void *data, lsn_t lsn, _read_mode1_sectors_nrg (void *user_data, void *data, lsn_t lsn,
bool b_form2, unsigned nblocks) bool b_form2, unsigned nblocks)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
int i; int i;
int retval; int retval;
unsigned int blocksize = b_form2 ? M2RAW_SECTOR_SIZE : CDIO_CD_FRAMESIZE; unsigned int blocksize = b_form2 ? M2RAW_SECTOR_SIZE : CDIO_CD_FRAMESIZE;
for (i = 0; i < nblocks; i++) { for (i = 0; i < nblocks; i++) {
if ( (retval = _read_mode1_sector_nrg (env, if ( (retval = _read_mode1_sector_nrg (p_env,
((char *)data) + (blocksize * i), ((char *)data) + (blocksize * i),
lsn + i, b_form2)) ) lsn + i, b_form2)) )
return retval; return retval;
@@ -959,19 +963,19 @@ static int
_read_mode2_sector_nrg (void *user_data, void *data, lsn_t lsn, _read_mode2_sector_nrg (void *user_data, void *data, lsn_t lsn,
bool b_form2) bool b_form2)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, }; char buf[CDIO_CD_FRAMESIZE_RAW] = { 0, };
CdioListNode *node; CdioListNode *node;
if (lsn >= env->size) if (lsn >= p_env->size)
{ {
cdio_warn ("trying to read beyond image size (%lu >= %lu)", cdio_warn ("trying to read beyond image size (%lu >= %lu)",
(long unsigned int) lsn, (long unsigned int) env->size); (long unsigned int) lsn, (long unsigned int) p_env->size);
return -1; return -1;
} }
_CDIO_LIST_FOREACH (node, env->mapping) { _CDIO_LIST_FOREACH (node, p_env->mapping) {
_mapping_t *_map = _cdio_list_node_data (node); _mapping_t *_map = _cdio_list_node_data (node);
if (IN (lsn, _map->start_lsn, (_map->start_lsn + _map->sec_count - 1))) { if (IN (lsn, _map->start_lsn, (_map->start_lsn + _map->sec_count - 1))) {
@@ -980,10 +984,10 @@ _read_mode2_sector_nrg (void *user_data, void *data, lsn_t lsn,
img_offset += (lsn - _map->start_lsn) * _map->blocksize; img_offset += (lsn - _map->start_lsn) * _map->blocksize;
ret = cdio_stream_seek (env->gen.data_source, img_offset, ret = cdio_stream_seek (p_env->gen.data_source, img_offset,
SEEK_SET); SEEK_SET);
if (ret!=0) return ret; if (ret!=0) return ret;
ret = cdio_stream_read (env->gen.data_source, ret = cdio_stream_read (p_env->gen.data_source,
(M2RAW_SECTOR_SIZE == _map->blocksize) (M2RAW_SECTOR_SIZE == _map->blocksize)
? (buf + CDIO_CD_SYNC_SIZE + CDIO_CD_HEADER_SIZE) ? (buf + CDIO_CD_SYNC_SIZE + CDIO_CD_HEADER_SIZE)
: buf, : buf,
@@ -1014,13 +1018,13 @@ static int
_read_mode2_sectors_nrg (void *user_data, void *data, lsn_t lsn, _read_mode2_sectors_nrg (void *user_data, void *data, lsn_t lsn,
bool b_form2, unsigned nblocks) bool b_form2, unsigned nblocks)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
int i; int i;
int retval; int retval;
unsigned int blocksize = b_form2 ? M2RAW_SECTOR_SIZE : CDIO_CD_FRAMESIZE; unsigned int blocksize = b_form2 ? M2RAW_SECTOR_SIZE : CDIO_CD_FRAMESIZE;
for (i = 0; i < nblocks; i++) { for (i = 0; i < nblocks; i++) {
if ( (retval = _read_mode2_sector_nrg (env, if ( (retval = _read_mode2_sector_nrg (p_env,
((char *)data) + (blocksize * i), ((char *)data) + (blocksize * i),
lsn + i, b_form2)) ) lsn + i, b_form2)) )
return retval; return retval;
@@ -1034,11 +1038,11 @@ _read_mode2_sectors_nrg (void *user_data, void *data, lsn_t lsn,
static void static void
_free_nrg (void *user_data) _free_nrg (void *user_data)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
if (NULL == env) return; if (NULL == p_env) return;
if (NULL != env->mapping) if (NULL != p_env->mapping)
_cdio_list_free (env->mapping, true); _cdio_list_free (p_env->mapping, true);
/* The remaining part of the image is like the other image drivers, /* The remaining part of the image is like the other image drivers,
so free that in the same way. */ so free that in the same way. */
@@ -1109,13 +1113,13 @@ get_hwinfo_nrg ( const CdIo *p_cdio, /*out*/ cdio_hwinfo_t *hw_info)
static track_format_t static track_format_t
get_track_format_nrg(void *user_data, track_t track_num) get_track_format_nrg(void *user_data, track_t track_num)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
if (track_num > env->gen.i_tracks || track_num == 0) if (track_num > p_env->gen.i_tracks || track_num == 0)
return TRACK_FORMAT_ERROR; return TRACK_FORMAT_ERROR;
if ( env->dtyp != DTYP_INVALID) { if ( p_env->dtyp != DTYP_INVALID) {
switch (env->dtyp) { switch (p_env->dtyp) {
case DTYP_MODE2_XA: case DTYP_MODE2_XA:
return TRACK_FORMAT_XA; return TRACK_FORMAT_XA;
case DTYP_MODE1: case DTYP_MODE1:
@@ -1124,8 +1128,8 @@ get_track_format_nrg(void *user_data, track_t track_num)
} }
} }
/*if ( MTYP_AUDIO_CD == env->mtyp) return TRACK_FORMAT_AUDIO; */ /*if ( MTYP_AUDIO_CD == p_env->mtyp) return TRACK_FORMAT_AUDIO; */
return env->tocent[track_num-1].track_format; return p_env->tocent[track_num-1].track_format;
} }
/*! /*!
@@ -1139,13 +1143,13 @@ get_track_format_nrg(void *user_data, track_t track_num)
static bool static bool
_get_track_green_nrg(void *user_data, track_t track_num) _get_track_green_nrg(void *user_data, track_t track_num)
{ {
_img_private_t *env = user_data; _img_private_t *p_env = user_data;
if (track_num > env->gen.i_tracks || track_num == 0) if (track_num > p_env->gen.i_tracks || track_num == 0)
return false; return false;
if ( MTYP_AUDIO_CD == env->mtyp) return false; if ( MTYP_AUDIO_CD == p_env->mtyp) return false;
return env->tocent[track_num-1].track_green; return p_env->tocent[track_num-1].track_green;
} }
/*! /*!