lxdream.org :: lxdream/src/gdrom/gdimage.c r464:8e099fad42a6

tree revision 465:3bd7be575792

filename	src/gdrom/gdimage.c
changeset	464:8e099fad42a6
prev	422:61a0598e07ff
next	468:3a49695e081a
author	nkeynes
date	Sat Oct 27 05:47:21 2007 +0000 (16 years ago)
permissions	-rw-r--r--
last change	Fix AICA save state section to include the current audio + IO state

view

     1 /**

     2  * $Id: gdimage.c,v 1.3 2007-10-27 05:44:54 nkeynes Exp $

     3  *

     4  * GD-Rom image-file common functions.

     5  *

     6  * Copyright (c) 2005 Nathan Keynes.

     7  *

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

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

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

    11  * (at your option) any later version.

    12  *

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

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

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

    16  * GNU General Public License for more details.

    17  */

    19 #include <netinet/in.h>

    21 #include "gdrom/gdrom.h"

    22 #include "gdrom/packet.h"

    23 #include "bootstrap.h"

    25 static void gdrom_image_destroy( gdrom_disc_t disc );

    26 static gdrom_error_t gdrom_image_read_sector( gdrom_disc_t disc, uint32_t lba, int mode,

    27 					      unsigned char *buf, uint32_t *readlength );

    28 static gdrom_error_t gdrom_image_read_toc( gdrom_disc_t disc, unsigned char *buf );

    29 static gdrom_error_t gdrom_image_read_session( gdrom_disc_t disc, int session, unsigned char *buf );

    30 static gdrom_error_t gdrom_image_read_position( gdrom_disc_t disc, uint32_t lba, unsigned char *buf );

    31 static int gdrom_image_drive_status( gdrom_disc_t disc );

    34 /**

    35  * Initialize a gdrom_disc structure with the gdrom_image_* methods

    36  */

    37 void gdrom_image_init( gdrom_disc_t disc )

    38 {

    39     memset( disc, 0, sizeof(struct gdrom_disc) ); /* safety */

    40     disc->read_sector = gdrom_image_read_sector;

    41     disc->read_toc = gdrom_image_read_toc;

    42     disc->read_session = gdrom_image_read_session;

    43     disc->read_position = gdrom_image_read_position;

    44     disc->drive_status = gdrom_image_drive_status;

    45     disc->play_audio = NULL; /* not supported yet */

    46     disc->run_time_slice = NULL; /* not needed */

    47     disc->close = gdrom_image_destroy;

    48 }

    50 gdrom_disc_t gdrom_image_new( const gchar *filename, FILE *f )

    51 {

    52     gdrom_image_t image = (gdrom_image_t)calloc(sizeof(struct gdrom_image), 1);

    53     if( image == NULL ) {

    54 	return NULL;

    55     }

    56     image->disc_type = IDE_DISC_CDROM;

    57     image->file = f;

    58     gdrom_disc_t disc = (gdrom_disc_t)image;

    59     gdrom_image_init(disc);

    60     if( filename == NULL ) {

    61 	disc->name = NULL;

    62     } else {

    63 	disc->name = g_strdup(filename);

    64     }

    66     return disc;

    67 }

    69 static void gdrom_image_destroy( gdrom_disc_t disc )

    70 {

    71     gdrom_image_t img = (gdrom_image_t)disc;

    72     if( img->file != NULL ) {

    73 	fclose(img->file);

    74 	img->file = NULL;

    75     }

    76     if( disc->name != NULL ) {

    77 	g_free( disc->name );

    78 	disc->name = NULL;

    79     }

    80     free( disc );

    81 }

    83 static int gdrom_image_get_track_by_lba( gdrom_image_t image, uint32_t lba )

    84 {

    85     int i;

    86     for( i=0; i<image->track_count; i++ ) {

    87 	if( image->track[i].lba <= lba &&

    88 	    lba < (image->track[i].lba + image->track[i].sector_count) ) {

    89 	    return i+1;

    90 	}

    91     }

    92     return -1;

    93 }

    95 static gdrom_error_t gdrom_image_read_sector( gdrom_disc_t disc, uint32_t lba,

    96 					      int mode, unsigned char *buf, uint32_t *length )

    97 {

    98     gdrom_image_t image = (gdrom_image_t)disc;

    99     int file_offset, read_len, track_no;

   101     track_no = gdrom_image_get_track_by_lba( image, lba );

   102     if( track_no == -1 ) {

   103 	return PKT_ERR_BADREAD;

   104     }

   105     struct gdrom_track *track = &image->track[track_no-1];

   106     file_offset = track->offset + track->sector_size * (lba - track->lba);

   107     read_len = track->sector_size;

   109     switch( mode ) {

   110     case 0x24:

   111     case 0x28:

   112 	switch( track->mode ) {

   113 	case GDROM_MODE1:

   114 	case GDROM_MODE2_XA1:

   115 	    fseek( image->file, file_offset, SEEK_SET );

   116 	    fread( buf, track->sector_size, 1, image->file );

   117 	    break;

   118 	case GDROM_MODE2:

   119 	    read_len = 2048;

   120 	    file_offset += 8; /* skip the subheader */

   121 	    fseek( image->file, file_offset, SEEK_SET );

   122 	    fread( buf, 2048, 1, image->file );

   123 	    break;

   124 	default:

   125 	    return PKT_ERR_BADREADMODE;

   126 	}

   127 	break;

   128     default:

   129 	return PKT_ERR_BADREADMODE;

   130     }

   132     *length = read_len;

   133     return PKT_ERR_OK;

   135 }

   137 static gdrom_error_t gdrom_image_read_toc( gdrom_disc_t disc, unsigned char *buf )

   138 {

   139     gdrom_image_t image = (gdrom_image_t)disc;

   140     struct gdrom_toc *toc = (struct gdrom_toc *)buf;

   141     int i;

   143     for( i=0; i<image->track_count; i++ ) {

   144 	toc->track[i] = htonl( image->track[i].lba ) | image->track[i].flags;

   145     }

   146     toc->first = 0x0100 | image->track[0].flags;

   147     toc->last = (image->track_count<<8) | image->track[i-1].flags;

   148     toc->leadout = htonl(image->track[i-1].lba + image->track[i-1].sector_count) |

   149 	image->track[i-1].flags;

   150     for( ;i<99; i++ )

   151 	toc->track[i] = 0xFFFFFFFF;

   152     return PKT_ERR_OK;

   153 }

   155 static gdrom_error_t gdrom_image_read_session( gdrom_disc_t disc, int session, unsigned char *buf )

   156 {

   157     gdrom_image_t image = (gdrom_image_t)disc;

   158     struct gdrom_track *last_track = &image->track[image->track_count-1];

   159     unsigned int end_of_disc = last_track->lba + last_track->sector_count;

   160     int i;

   161     buf[0] = 0x01; /* Disc status? */

   162     buf[1] = 0;

   164     if( session == 0 ) {

   165 	buf[2] = last_track->session+1; /* last session */

   166 	buf[3] = (end_of_disc >> 16) & 0xFF;

   167 	buf[4] = (end_of_disc >> 8) & 0xFF;

   168 	buf[5] = end_of_disc & 0xFF;

   169 	return PKT_ERR_OK;

   170     } else {

   171 	session--;

   172 	for( i=0; i<image->track_count; i++ ) {

   173 	    if( image->track[i].session == session ) {

   174 		buf[2] = i+1; /* first track of session */

   175 		buf[3] = (image->track[i].lba >> 16) & 0xFF;

   176 		buf[4] = (image->track[i].lba >> 8) & 0xFF;

   177 		buf[5] = image->track[i].lba & 0xFF;

   178 		return PKT_ERR_OK;

   179 	    }

   180 	}

   181 	return PKT_ERR_BADFIELD; /* No such session */

   182     }

   183 }

   185 static gdrom_error_t gdrom_image_read_position( gdrom_disc_t disc, uint32_t lba, unsigned char *buf )

   186 {

   187     gdrom_image_t image = (gdrom_image_t)disc;

   188     int track_no = gdrom_image_get_track_by_lba( image, lba );

   189     if( track_no == -1 ) {

   190 	track_no = 1;

   191 	lba = 150;

   192     }

   193     struct gdrom_track *track = &image->track[track_no-1];

   194     uint32_t offset = lba - track->lba;

   195     buf[4] = track->flags;

   196     buf[5] = track_no;

   197     buf[6] = 0x01; /* ?? */

   198     buf[7] = (offset >> 16) & 0xFF;

   199     buf[8] = (offset >> 8) & 0xFF;

   200     buf[9] = offset & 0xFF;

   201     buf[10] = 0;

   202     buf[11] = (lba >> 16) & 0xFF;

   203     buf[12] = (lba >> 8) & 0xFF;

   204     buf[13] = lba & 0xFF;

   205     return PKT_ERR_OK;

   206 }

   208 static int gdrom_image_drive_status( gdrom_disc_t disc )

   209 {

   210     gdrom_image_t image = (gdrom_image_t)disc;

   211     return image->disc_type | IDE_DISC_READY;

   212 }

   214 void gdrom_image_dump_info( gdrom_disc_t d ) {

   215     gdrom_image_t disc = (gdrom_image_t)d;

   216     int i;

   217     int last_session = disc->track[disc->track_count-1].session;

   218     gboolean is_bootable = FALSE;

   220     INFO( "Disc ID: %s, %d tracks in %d sessions", disc->mcn, disc->track_count,

   221 	  disc->track[disc->track_count-1].session + 1 );

   222     if( last_session > 0 ) {

   223 	/* Boot track is the first data track of the last session, provided that it

   224 	 * cannot be a single-session disc.

   225 	 */

   226 	int boot_track = -1;

   227 	for( i=disc->track_count-1; i>=0 && disc->track[i].session == last_session; i-- ) {

   228 	    if( disc->track[i].flags & TRACK_DATA ) {

   229 		boot_track = i;

   230 	    }

   231 	}

   232 	if( boot_track != -1 ) {

   233 	    unsigned char boot_sector[MAX_SECTOR_SIZE];

   234 	    uint32_t length = sizeof(boot_sector);

   235 	    if( d->read_sector( d, disc->track[boot_track].lba, 0x28,

   236 				   boot_sector, &length ) == PKT_ERR_OK ) {

   237 		bootstrap_dump(boot_sector, FALSE);

   238 		is_bootable = TRUE;

   239 	    }

   240 	}

   241     }

   242     if( !is_bootable ) {

   243 	WARN( "Disc does not appear to be bootable" );

   244     }

   245 }