Search
lxdream.org :: lxdream/src/gdrom/nrg.c
Latest Version
lxdream 0.9.1
released Jun 29
Download Now
Navigation
News Download Mailing Lists Mercurial Issues Dreamcast Wiki FAQ Forums
tree revision 644:ccae4bfa5f82
Jump to:
summary | tree | shortlog | changelog | graph | changeset

 

filename src/gdrom/nrg.c
changeset 644:ccae4bfa5f82
prev561:533f6b478071
next678:35eb00945316
author nkeynes
date Sun Mar 02 11:38:08 2008 +0000 (15 years ago)
permissions -rw-r--r--
last change Bug #59: Add provisional support for all CD read modes (not validated)
view annotate diff log raw 
     1 /**

     2  * $Id$

     3  *

     4  * Nero (NRG) CD file format. File information stolen shamelessly from

     5  * libcdio.

     6  *

     7  * Copyright (c) 2005 Nathan Keynes.

     8  *

     9  * This program is free software; you can redistribute it and/or modify

    10  * it under the terms of the GNU General Public License as published by

    11  * the Free Software Foundation; either version 2 of the License, or

    12  * (at your option) any later version.

    13  *

    14  * This program is distributed in the hope that it will be useful,

    15  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    17  * GNU General Public License for more details.

    18  */

    19 

    20 #include <assert.h>

    21 #include <stdio.h>

    22 #include <errno.h>

    23 #include <glib/gtypes.h>

    24 #include "gdrom/gdrom.h"

    25 #include "dream.h"

    26 

    27 static gboolean nrg_image_is_valid( FILE *f );

    28 static gdrom_disc_t nrg_image_open( const gchar *filename, FILE *f );

    29 

    30 struct gdrom_image_class nrg_image_class = { "Nero", "nrg", 

    31 					     nrg_image_is_valid, nrg_image_open };

    32 

    33 #define NERO_V55_ID  0x4e455235 

    34 #define NERO_V50_ID  0x4e45524f 

    35 

    36 /* Courtesy of libcdio */

    37 /* 5.0 or earlier */

    38 #define NERO_ID  0x4e45524f  /* Nero pre 5.5.x */

    39 #define CUES_ID  0x43554553  /* Nero pre version 5.5.x-6.x */

    40 #define DAOI_ID  0x44414f49

    41 #define ETNF_ID  0x45544e46

    42 #define SINF_ID  0x53494e46  /* Session information */

    43 #define END_ID  0x454e4421

    44 /* 5.5+ only */

    45 #define NER5_ID  0x4e455235  /* Nero version 5.5.x */

    46 #define CDTX_ID  0x43445458  /* CD TEXT */

    47 #define CUEX_ID  0x43554558  /* Nero version 5.5.x-6.x */

    48 #define DAOX_ID  0x44414f58  /* Nero version 5.5.x-6.x */

    49 #define ETN2_ID  0x45544e32

    50 #define MTYP_ID  0x4d545950  /* Disc Media type? */

    51 

    52 

    53 union nrg_footer {

    54     struct nrg_footer_v50 {

    55 	uint32_t dummy;

    56 	uint32_t id;

    57 	uint32_t offset;

    58     } v50;

    59     struct nrg_footer_v55 {

    60 	uint32_t id;

    61 	uint64_t offset;

    62     } v55;

    63 };

    64 

    65 struct nrg_chunk {

    66     uint32_t id;

    67     uint32_t length;

    68 };

    69 

    70 struct nrg_etnf {

    71     uint32_t offset;

    72     uint32_t length;

    73     uint32_t mode;

    74     uint32_t lba;

    75     uint32_t padding;

    76 };

    77 

    78 struct nrg_etn2 {

    79     uint64_t offset;

    80     uint64_t length;

    81     uint32_t mode;

    82     uint32_t lba;

    83     uint64_t padding;

    84 };

    85 

    86 struct nrg_cues {

    87     uint8_t type;

    88     uint8_t track;

    89     uint8_t control;

    90     uint8_t pad;

    91     uint32_t addr;

    92 };

    93 

    94 struct nrg_daoi {

    95     uint32_t length;

    96     char mcn[14];

    97     uint8_t disc_mode;

    98     uint8_t unknown[2]; /* always 01 01? */

    99     uint8_t track_count;

   100     struct nrg_daoi_track {

   101 	char unknown[10];

   102 	uint32_t sector_size __attribute__((packed)); /* Always 0? */

   103 	uint8_t mode;

   104 	uint8_t unknown2[3]; /* Always 00 00 01? */

   105 	uint32_t pregap __attribute__((packed));

   106 	uint32_t offset __attribute__((packed));

   107 	uint32_t end __attribute__((packed));

   108     } track[0];

   109 } __attribute__((packed));

   110 

   111 struct nrg_daox {

   112     uint32_t length;

   113     char mcn[14];

   114     uint8_t disc_mode;

   115     uint8_t unknown[2]; /* always 01 01? */

   116     uint8_t track_count;

   117     struct nrg_daox_track {

   118 	char unknown[10];

   119 	uint32_t sector_size __attribute__((packed)); /* Always 0? */

   120 	uint8_t mode;

   121 	uint8_t unknown2[3]; /* Always 00 00 01? */

   122 	uint64_t pregap __attribute__((packed));

   123 	uint64_t offset __attribute__((packed));

   124 	uint64_t end __attribute__((packed));

   125     } track[0];

   126 } __attribute__((packed));

   127 

   128 /**

   129  * Convert an 8-bit BCD number to normal integer form. 

   130  * Eg, 0x79 => 79

   131  */

   132 uint8_t static bcd_to_uint8( uint8_t bcd )

   133 {

   134     return (bcd & 0x0F) + (((bcd & 0xF0)>>4)*10);

   135 }

   136 

   137 

   138 /**

   139  * Convert a 32 bit MSF address (BCD coded) to the

   140  * equivalent LBA form. 

   141  * Eg, 0x

   142  */

   143 uint32_t static msf_to_lba( uint32_t msf )

   144 {

   145     msf = GUINT32_FROM_BE(msf);

   146     int f = bcd_to_uint8(msf);

   147     int s = bcd_to_uint8(msf>>8);

   148     int m = bcd_to_uint8(msf>>16);

   149     return (m * 60 + s) * 75 + f;

   150 

   151 }

   152 

   153 uint32_t static nrg_track_mode( uint8_t mode )

   154 {

   155     switch( mode ) {

   156     case 0: return GDROM_MODE1;

   157     case 2: return GDROM_MODE2_FORM1;

   158     case 3: return GDROM_SEMIRAW_MODE2;

   159     case 7: return GDROM_CDDA;

   160     default: 

   161 	ERROR( "Unrecognized track mode %d in Nero image", mode );

   162 	return -1;

   163     }

   164 }

   165 

   166 static gboolean nrg_image_is_valid( FILE *f )

   167 {

   168     union nrg_footer footer;

   169 

   170     fseek( f, -12, SEEK_END );

   171     fread( &footer, sizeof(footer), 1, f );

   172     if( GUINT32_FROM_BE(footer.v50.id) == NERO_V50_ID ||

   173 	GUINT32_FROM_BE(footer.v55.id) == NERO_V55_ID ) {

   174 	return TRUE;

   175     } else {

   176 	return FALSE;

   177     }

   178 }

   179 

   180 static gdrom_disc_t nrg_image_open( const gchar *filename, FILE *f )

   181 {

   182     union nrg_footer footer;

   183     struct nrg_chunk chunk;

   184     struct nrg_daoi *dao;

   185     struct nrg_daox *daox;

   186     struct nrg_etnf *etnf;

   187     struct nrg_etn2 *etn2;

   188     gdrom_disc_t disc;

   189     gdrom_image_t image;

   190     gboolean end = FALSE;

   191     uint32_t chunk_id;

   192     int session_id = 0;

   193     int session_track_id = 0;

   194     int track_id = 0;

   195     int cue_track_id = 0, cue_track_count = 0;

   196     int i, count;

   197 

   198     fseek( f, -12, SEEK_END );

   199     fread( &footer, sizeof(footer), 1, f );

   200     if( GUINT32_FROM_BE(footer.v50.id) == NERO_V50_ID ) {

   201 	INFO( "Loading Nero 5.0 image" );

   202 	fseek( f, GUINT32_FROM_BE(footer.v50.offset), SEEK_SET );

   203     } else if( GUINT32_FROM_BE(footer.v55.id) == NERO_V55_ID ) {

   204 	INFO( "Loading Nero 5.5+ image" );

   205 	fseek( f, (uint32_t)GUINT64_FROM_BE(footer.v55.offset), SEEK_SET );

   206     } else {

   207 	/* Not a (recognized) Nero image */

   208 	return NULL;

   209     }

   210     

   211     disc = gdrom_image_new(filename, f);

   212     if( disc == NULL ) {

   213 	ERROR("Unable to allocate memory!");

   214 	return NULL;

   215     }

   216     image = (gdrom_image_t)disc;

   217 

   218     do {

   219 	fread( &chunk, sizeof(chunk), 1, f );

   220 	chunk.length = GUINT32_FROM_BE(chunk.length);

   221 	char data[chunk.length];

   222 	fread( data, chunk.length, 1, f );

   223 	chunk_id = GUINT32_FROM_BE(chunk.id);

   224 	switch( chunk_id ) {

   225 	case CUES_ID:

   226 	case CUEX_ID:

   227 	    cue_track_id = track_id;

   228 	    cue_track_count = ((chunk.length / sizeof(struct nrg_cues)) >> 1) - 1;

   229 	    track_id += cue_track_count;

   230 	    for( i=0; i<chunk.length; i+= sizeof(struct nrg_cues) ) {

   231 		struct nrg_cues *cue = (struct nrg_cues *)(data+i);

   232 		int track = 0;

   233 		uint32_t lba;

   234 		if( chunk_id == CUEX_ID ) {

   235 		    lba = GUINT32_FROM_BE( cue->addr ) + GDROM_PREGAP;

   236 		} else {

   237 		    lba = msf_to_lba( cue->addr );

   238 		}

   239 		if( cue->track == 0 )

   240 		    continue; /* Track 0. Leadin? always 0? */

   241 		if( cue->track == 0xAA ) { /* end of disc */

   242 		    image->track[track_id-1].sector_count =

   243 			lba - image->track[track_id-1].lba;

   244 		} else {

   245 		    track = cue_track_id + bcd_to_uint8(cue->track) - 1;

   246 		    if( (cue->control & 0x01) == 0 ) { 

   247 			/* Pre-gap address. */

   248 			if( track != 0 ) {

   249 			    image->track[track-1].sector_count = 

   250 				lba - image->track[track-1].lba;

   251 			}

   252 		    } else { /* Track-start address */

   253 			image->track[track].lba = lba;

   254 			image->track[track].flags = cue->type;

   255 		    }

   256 		}

   257 	    }

   258 	    break;

   259 	case DAOI_ID:

   260 	    dao = (struct nrg_daoi *)data;

   261 	    memcpy( image->mcn, dao->mcn, 13 );

   262 	    image->mcn[13] = '\0';

   263 	    assert( dao->track_count * 30 + 22 == chunk.length );

   264 	    assert( dao->track_count == cue_track_count );

   265 	    for( i=0; i<dao->track_count; i++ ) {

   266 		image->track[cue_track_id].sector_size = GUINT32_FROM_BE(dao->track[i].sector_size);

   267 		image->track[cue_track_id].offset = GUINT32_FROM_BE(dao->track[i].offset);

   268 		image->track[cue_track_id].mode = nrg_track_mode( dao->track[i].mode );

   269 		image->track[cue_track_id].sector_count =

   270 		    (GUINT32_FROM_BE(dao->track[i].end) - GUINT32_FROM_BE(dao->track[i].offset))/

   271 		    GUINT32_FROM_BE(dao->track[i].sector_size);

   272 		cue_track_id++;

   273 	    }

   274 	    break;

   275 	case DAOX_ID:

   276 	    daox = (struct nrg_daox *)data;

   277 	    memcpy( image->mcn, daox->mcn, 13 );

   278 	    image->mcn[13] = '\0';

   279 	    assert( daox->track_count * 42 + 22 == chunk.length );

   280 	    assert( daox->track_count == cue_track_count );

   281 	    for( i=0; i<daox->track_count; i++ ) {

   282 		image->track[cue_track_id].sector_size = GUINT32_FROM_BE(daox->track[i].sector_size);

   283 		image->track[cue_track_id].offset = GUINT64_FROM_BE(daox->track[i].offset);

   284 		image->track[cue_track_id].mode = nrg_track_mode( daox->track[i].mode );

   285 		image->track[cue_track_id].sector_count =

   286 		    (GUINT64_FROM_BE(daox->track[i].end) - GUINT64_FROM_BE(daox->track[i].offset))/

   287 		    GUINT32_FROM_BE(daox->track[i].sector_size);

   288 		cue_track_id++;

   289 	    }

   290 	    break;

   291 	    

   292 	case SINF_ID: 

   293 	    /* Data is a single 32-bit number representing number of tracks in session */

   294 	    i = GUINT32_FROM_BE( *(uint32_t *)data );

   295 	    while( i-- > 0 )

   296 		image->track[session_track_id++].session = session_id;

   297 	    session_id++;

   298 	    break;

   299 	case ETNF_ID:

   300 	    etnf = (struct nrg_etnf *)data;

   301 	    count = chunk.length / sizeof(struct nrg_etnf);

   302 	    for( i=0; i < count; i++, etnf++ ) {

   303 		image->track[track_id].offset = GUINT32_FROM_BE(etnf->offset);

   304 		image->track[track_id].lba = GUINT32_FROM_BE(etnf->lba) + (i+1)*GDROM_PREGAP;

   305 		image->track[track_id].mode = nrg_track_mode( GUINT32_FROM_BE(etnf->mode) );

   306 		if( image->track[track_id].mode == -1 ) {

   307 		    gdrom_image_destroy_no_close(disc);

   308 		    return NULL;

   309 		}

   310 		if( image->track[track_id].mode == GDROM_CDDA )

   311 		    image->track[track_id].flags = 0x01;

   312 		else

   313 		    image->track[track_id].flags = 0x01 | TRACK_DATA;

   314 		image->track[track_id].sector_size = GDROM_SECTOR_SIZE(image->track[track_id].mode);

   315 		image->track[track_id].sector_count = GUINT32_FROM_BE(etnf->length) / 

   316 		    image->track[track_id].sector_size;

   317 		track_id++;

   318 	    }

   319 	    break;

   320 	case ETN2_ID:

   321 	    etn2 = (struct nrg_etn2 *)data;

   322 	    count = chunk.length / sizeof(struct nrg_etn2);

   323 	    for( i=0; i < count; i++, etn2++ ) {

   324 		image->track[track_id].offset = (uint32_t)GUINT64_FROM_BE(etn2->offset);

   325 		image->track[track_id].lba = GUINT32_FROM_BE(etn2->lba) + (i+1)*GDROM_PREGAP;

   326 		image->track[track_id].mode = nrg_track_mode( GUINT32_FROM_BE(etn2->mode) );

   327 		if( image->track[track_id].mode == -1 ) {

   328 		    gdrom_image_destroy_no_close(disc);

   329 		    return NULL;

   330 		}

   331 		if( image->track[track_id].mode == GDROM_CDDA )

   332 		    image->track[track_id].flags = 0x01;

   333 		else

   334 		    image->track[track_id].flags = 0x01 | TRACK_DATA;

   335 		image->track[track_id].sector_size = GDROM_SECTOR_SIZE(image->track[track_id].mode);

   336 		image->track[track_id].sector_count = (uint32_t)(GUINT64_FROM_BE(etn2->length) / 

   337 								 image->track[track_id].sector_size);

   338 		track_id++;

   339 	    }

   340 	    break;

   341 

   342 	case END_ID:

   343 	    end = TRUE;

   344 	    break;

   345 	}

   346     } while( !end );

   347     image->track_count = track_id;

   348     return disc;

   349 }

   350 

   351 

   352
.