aaru-dps/libaaruformat
1
0
Fork 0
mirror of https://github.com/aaru-dps/libaaruformat.git synced 2025-12-16 19:24:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement ImageInfo.

Browse Source
This commit is contained in:
Natalia Portillo
2019-03-20 22:31:50 +00:00
parent 0ebd1de272
commit 31cdaed693
3 changed files with 333 additions and 112 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
include/dic.h
View File

@@ -1,4 +1,4 @@
// /***************************************************************************
// /** *************************************************************************
// The Disc Image Chef
// ----------------------------------------------------------------------------
//
@@ -111,8 +111,7 @@ typedef enum
/** 120mm, Phase-Change, 1298496 sectors, 512 bytes/sector, PD650, ECMA-240, ISO 15485 */
PD650 = 32,
/** 120mm, Write-Once, 1281856 sectors, 512 bytes/sector, PD650, ECMA-240, ISO 15485 */
PD650_WORM = 33,
/**
PD650_WORM = 33, /**
* CD-i Ready, contains a track before the first TOC track, in mode 2, and all TOC tracks are Audio. Subchannel
* marks track as audio pause.
*/
@@ -330,13 +329,11 @@ typedef enum
/** 3.5", DS, HD, 80 tracks, 21 spt, 512 bytes/sector, MFM */
DMF = 201,
/** 3.5", DS, HD, 82 tracks, 21 spt, 512 bytes/sector, MFM */
DMF_82 = 202,
/**
DMF_82 = 202, /**
* 5.25", DS, HD, 80 tracks, ? spt, ??? + ??? + ??? bytes/sector, MFM track 0 = ??15 sectors, 512
* bytes/sector, falsified to DOS as 19 spt, 512 bps
*/
XDF_525 = 203,
/**
XDF_525 = 203, /**
* 3.5", DS, HD, 80 tracks, 4 spt, 8192 + 2048 + 1024 + 512 bytes/sector, MFM track 0 = 19 sectors, 512
* bytes/sector, falsified to DOS as 23 spt, 512 bps
*/
@@ -355,18 +352,15 @@ typedef enum
/** 8", DS, SD, 74 tracks, 26 spt, 128 bytes/sector, FM, track 0 = 26 sectors, 128 bytes/sector */
IBM43FD_128 = 214,
/** 8", DS, SD, 74 tracks, 26 spt, 256 bytes/sector, FM, track 0 = 26 sectors, 128 bytes/sector */
IBM43FD_256 = 215,
/**
IBM43FD_256 = 215, /**
* 8", DS, DD, 74 tracks, 26 spt, 256 bytes/sector, MFM, track 0 side 0 = 26 sectors, 128 bytes/sector, track 0
* side 1 = 26 sectors, 256 bytes/sector
*/
IBM53FD_256 = 216,
/**
IBM53FD_256 = 216, /**
* 8", DS, DD, 74 tracks, 15 spt, 512 bytes/sector, MFM, track 0 side 0 = 26 sectors, 128 bytes/sector, track 0
* side 1 = 26 sectors, 256 bytes/sector
*/
IBM53FD_512 = 217,
/**
IBM53FD_512 = 217, /**
* 8", DS, DD, 74 tracks, 8 spt, 1024 bytes/sector, MFM, track 0 side 0 = 26 sectors, 128 bytes/sector, track 0
* side 1 = 26 sectors, 256 bytes/sector
*/
@@ -461,17 +455,15 @@ typedef enum
// NEC/SHARP standard floppy formats, types 260 to 269
// ECMA floppy standards, types 270 to 289
/**
/**
* 5,25", DS, DD, 80 tracks, 8 spt, 1024 bytes/sector, MFM, track 0 side 0 = 26 sectors, 128 bytes/sector, track
* 0 side 1 = 26 sectors, 256 bytes/sector
*/
ECMA_99_8 = 270,
/**
ECMA_99_8 = 270, /**
* 5,25", DS, DD, 77 tracks, 15 spt, 512 bytes/sector, MFM, track 0 side 0 = 26 sectors, 128 bytes/sector, track
* 0 side 1 = 26 sectors, 256 bytes/sector
*/
ECMA_99_15 = 271,
/**
ECMA_99_15 = 271, /**
* 5,25", DS, DD, 77 tracks, 26 spt, 256 bytes/sector, MFM, track 0 side 0 = 26 sectors, 128 bytes/sector, track
* 0 side 1 = 26 sectors, 256 bytes/sector
*/
@@ -487,28 +479,23 @@ typedef enum
/** 8", DS, SD, 77 tracks, 26 spt, 128 bytes/sector, FM */
ECMA_59 = 274,
/** 5,25", SS, DD, 35 tracks, 9 spt, 256 bytes/sector, FM, track 0 side 0 = 16 sectors, 128 bytes/sector */
ECMA_66 = 275,
/**
ECMA_66 = 275, /**
* 8", DS, DD, 77 tracks, 8 spt, 1024 bytes/sector, FM, track 0 side 0 = 26 sectors, 128 bytes/sector, track 0
* side 1 = 26 sectors, 256 bytes/sector
*/
ECMA_69_8 = 276,
/**
ECMA_69_8 = 276, /**
* 8", DS, DD, 77 tracks, 15 spt, 512 bytes/sector, FM, track 0 side 0 = 26 sectors, 128 bytes/sector, track 0
* side 1 = 26 sectors, 256 bytes/sector
*/
ECMA_69_15 = 277,
/**
ECMA_69_15 = 277, /**
* 8", DS, DD, 77 tracks, 26 spt, 256 bytes/sector, FM, track 0 side 0 = 26 sectors, 128 bytes/sector, track 0
* side 1 = 26 sectors, 256 bytes/sector
*/
ECMA_69_26 = 278,
/**
ECMA_69_26 = 278, /**
* 5,25", DS, DD, 40 tracks, 16 spt, 256 bytes/sector, FM, track 0 side 0 = 16 sectors, 128 bytes/sector, track 0
* side 1 = 16 sectors, 256 bytes/sector
*/
ECMA_70 = 279,
/**
ECMA_70 = 279, /**
* 5,25", DS, DD, 80 tracks, 16 spt, 256 bytes/sector, FM, track 0 side 0 = 16 sectors, 128 bytes/sector, track 0
* side 1 = 16 sectors, 256 bytes/sector
*/
@@ -896,137 +883,111 @@ typedef enum
// Apple specific media, types 690 to 699
// DEC hard disks, types 700 to 729
/**
/**
* 2382 cylinders, 4 tracks/cylinder, 42 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 204890112 bytes
*/
RA60 = 700,
/**
RA60 = 700, /**
* 546 cylinders, 14 tracks/cylinder, 31 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 121325568 bytes
*/
RA80 = 701,
/**
RA80 = 701, /**
* 1248 cylinders, 14 tracks/cylinder, 51 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 456228864 bytes
*/
RA81 = 702,
/**
RA81 = 702, /**
* 302 cylinders, 4 tracks/cylinder, 42 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector, 25976832
* bytes
*/
RC25 = 703,
/**
RC25 = 703, /**
* 615 cylinders, 4 tracks/cylinder, 17 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector, 21411840
* bytes
*/
RD31 = 704,
/**
RD31 = 704, /**
* 820 cylinders, 6 tracks/cylinder, 17 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector, 42823680
* bytes
*/
RD32 = 705,
/**
RD32 = 705, /**
* 306 cylinders, 4 tracks/cylinder, 17 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector, 10653696
* bytes
*/
RD51 = 706,
/**
RD51 = 706, /**
* 480 cylinders, 7 tracks/cylinder, 18 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector, 30965760
* bytes
*/
RD52 = 707,
/**
RD52 = 707, /**
* 1024 cylinders, 7 tracks/cylinder, 18 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 75497472 bytes
*/
RD53 = 708,
/**
RD53 = 708, /**
* 1225 cylinders, 8 tracks/cylinder, 18 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 159936000 bytes
*/
RD54 = 709,
/**
RD54 = 709, /**
* 411 cylinders, 3 tracks/cylinder, 22 sectors/track, 256 words/sector, 16 bits/word, 512 bytes/sector, 13888512
* bytes
*/
RK06 = 710,
/**
RK06 = 710, /**
* 411 cylinders, 3 tracks/cylinder, 20 sectors/track, 256 words/sector, 18 bits/word, 576 bytes/sector, 14204160
* bytes
*/
RK06_18 = 711,
/**
RK06_18 = 711, /**
* 815 cylinders, 3 tracks/cylinder, 22 sectors/track, 256 words/sector, 16 bits/word, 512 bytes/sector, 27540480
* bytes
*/
RK07 = 712,
/**
RK07 = 712, /**
* 815 cylinders, 3 tracks/cylinder, 20 sectors/track, 256 words/sector, 18 bits/word, 576 bytes/sector, 28166400
* bytes
*/
RK07_18 = 713,
/**
RK07_18 = 713, /**
* 823 cylinders, 5 tracks/cylinder, 32 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector, 67420160
* bytes
*/
RM02 = 714,
/**
RM02 = 714, /**
* 823 cylinders, 5 tracks/cylinder, 32 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector, 67420160
* bytes
*/
RM03 = 715,
/**
RM03 = 715, /**
* 823 cylinders, 19 tracks/cylinder, 32 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 256196608 bytes
*/
RM05 = 716,
/**
RM05 = 716, /**
* 203 cylinders, 10 tracks/cylinder, 22 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 22865920 bytes
*/
RP02 = 717,
/**
RP02 = 717, /**
* 203 cylinders, 10 tracks/cylinder, 20 sectors/track, 128 words/sector, 36 bits/word, 576 bytes/sector,
* 23385600 bytes
*/
RP02_18 = 718,
/**
RP02_18 = 718, /**
* 400 cylinders, 10 tracks/cylinder, 22 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 45056000 bytes
*/
RP03 = 719,
/**
RP03 = 719, /**
* 400 cylinders, 10 tracks/cylinder, 20 sectors/track, 128 words/sector, 36 bits/word, 576 bytes/sector,
* 46080000 bytes
*/
RP03_18 = 720,
/**
RP03_18 = 720, /**
* 411 cylinders, 19 tracks/cylinder, 22 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 87960576 bytes
*/
RP04 = 721,
/**
RP04 = 721, /**
* 411 cylinders, 19 tracks/cylinder, 20 sectors/track, 128 words/sector, 36 bits/word, 576 bytes/sector,
* 89959680 bytes
*/
RP04_18 = 722,
/**
RP04_18 = 722, /**
* 411 cylinders, 19 tracks/cylinder, 22 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 87960576 bytes
*/
RP05 = 723,
/**
RP05 = 723, /**
* 411 cylinders, 19 tracks/cylinder, 20 sectors/track, 128 words/sector, 36 bits/word, 576 bytes/sector,
* 89959680 bytes
*/
RP05_18 = 724,
/**
RP05_18 = 724, /**
* 815 cylinders, 19 tracks/cylinder, 22 sectors/track, 128 words/sector, 32 bits/word, 512 bytes/sector,
* 174423040 bytes
*/
RP06 = 725,
/**
RP06 = 725, /**
* 815 cylinders, 19 tracks/cylinder, 20 sectors/track, 128 words/sector, 36 bits/word, 576 bytes/sector,
* 178387200 bytes
*/
@@ -1049,6 +1010,77 @@ typedef enum
//
} MediaType;
/**
* Contains information about a dump image and its contents
*/
typedef struct ImageInfo
{
/** Image contains partitions (or tracks for optical media) */
uint8_t HasPartitions;
/** Image contains sessions (optical media only) */
uint8_t HasSessions;
/** Size of the image without headers */
uint64_t ImageSize;
/** Sectors contained in the image */
uint64_t Sectors;
/** Size of sectors contained in the image */
uint32_t SectorSize;
/** Media tags contained by the image */
//List<MediaTagType> ReadableMediaTags;
/** Sector tags contained by the image */
//List<SectorTagType> ReadableSectorTags;
/** Image version */
unsigned char *Version;
/** Application that created the image */
unsigned char *Application;
/** Version of the application that created the image */
unsigned char *ApplicationVersion;
/** Who (person) created the image? */
unsigned char *Creator;
/** Image creation time */
int64_t CreationTime;
/** Image last modification time */
int64_t LastModificationTime;
/** Title of the media represented by the image */
unsigned char *MediaTitle;
/** Image comments */
unsigned char *Comments;
/** Manufacturer of the media represented by the image */
unsigned char *MediaManufacturer;
/** Model of the media represented by the image */
unsigned char *MediaModel;
/** Serial number of the media represented by the image */
unsigned char *MediaSerialNumber;
/** Barcode of the media represented by the image */
unsigned char *MediaBarcode;
/** Part number of the media represented by the image */
unsigned char *MediaPartNumber;
/** Media type represented by the image */
uint32_t MediaType;
/** Number in sequence for the media represented by the image */
int32_t MediaSequence;
/** Last media of the sequence the media represented by the image corresponds to */
int32_t LastMediaSequence;
/** Manufacturer of the drive used to read the media represented by the image */
unsigned char *DriveManufacturer;
/** Model of the drive used to read the media represented by the image */
unsigned char *DriveModel;
/** Serial number of the drive used to read the media represented by the image */
unsigned char *DriveSerialNumber;
/** Firmware revision of the drive used to read the media represented by the image */
unsigned char *DriveFirmwareRevision;
/** Type of the media represented by the image to use in XML sidecars */
int32_t XmlMediaType;
// CHS geometry...
/** Cylinders of the media represented by the image */
uint32_t Cylinders;
/** Heads of the media represented by the image */
uint32_t Heads;
/** Sectors per track of the media represented by the image (for variable image, the smallest) */
uint32_t SectorsPerTrack;
} ImageInfo;
#endif //LIBDICFORMAT_DIC_H
#pragma clang diagnostic pop

1
include/dicformat/context.h
View File

@@ -66,6 +66,7 @@ typedef struct dicformatContext
unsigned char *cicmBlock;
DumpHardwareHeader dumpHardwareHeader;
struct DumpHardwareEntriesWithData *dumpHardwareEntriesWithData;
struct ImageInfo imageInfo;
} dicformatContext;
typedef struct dataLinkedList

250
src/open.c
View File

@@ -39,7 +39,6 @@
#include <sys/mman.h>
// TODO: Check CRC64 on structures
// TODO: ImageInfo
void *open(const char *filepath)
{
dicformatContext *ctx = malloc(sizeof(dicformatContext));
@@ -48,7 +47,6 @@ void *open(const char *filepath)
long pos;
IndexHeader idxHeader;
IndexEntry *idxEntries;
uint64_t ImageSize; // TODO: This should be in ImageInfo
unsigned char *data;
memset(ctx, 0, sizeof(dicformatContext));
@@ -99,6 +97,24 @@ void *open(const char *filepath)
ctx->header.imageMajorVersion,
ctx->header.imageMinorVersion);
ctx->imageInfo.Application = ctx->header.application;
ctx->imageInfo.ApplicationVersion = malloc(32);
if(ctx->imageInfo.ApplicationVersion != NULL)
{
memset(ctx->imageInfo.ApplicationVersion, 0, 32);
sprintf((char *)ctx->imageInfo.ApplicationVersion,
"%d.%d",
ctx->header.applicationMajorVersion,
ctx->header.applicationMinorVersion);
}
ctx->imageInfo.Version = malloc(32);
if(ctx->imageInfo.Version != NULL)
{
memset(ctx->imageInfo.Version, 0, 32);
sprintf((char *)ctx->imageInfo.Version, "%d.%d", ctx->header.imageMajorVersion, ctx->header.imageMinorVersion);
}
ctx->imageInfo.MediaType = ctx->header.mediaType;
// Read the index header
pos = fseek(ctx->imageStream, ctx->header.indexOffset, SEEK_CUR);
if(pos < 0)
@@ -162,7 +178,7 @@ void *open(const char *filepath)
}
bool foundUserDataDdt = false;
ImageSize = 0;
ctx->imageInfo.ImageSize = 0;
for(int i = 0; i < idxHeader.entries; i++)
{
pos = fseek(ctx->imageStream, idxEntries[i].offset, SEEK_SET);
@@ -196,14 +212,13 @@ void *open(const char *filepath)
break;
}
ImageSize += blockHeader.cmpLength;
ctx->imageInfo.ImageSize += blockHeader.cmpLength;
// Unused, skip
if(idxEntries[i].dataType == UserData)
{
// TODO: ImageInfo
//if(blockHeader.sectorSize > imageInfo.SectorSize)
// imageInfo.SectorSize = blockHeader.sectorSize;
if(blockHeader.sectorSize > ctx->imageInfo.SectorSize)
ctx->imageInfo.SectorSize = blockHeader.sectorSize;
break;
}
@@ -340,7 +355,8 @@ void *open(const char *filepath)
}
}
// If we mediaTag is NULL means we have arrived the end of the list without finding a duplicate or the list was empty
// If we mediaTag is NULL means we have arrived the end of the list without finding a duplicate
// or the list was empty
if(mediaTag != NULL)
break;
@@ -386,9 +402,12 @@ void *open(const char *filepath)
foundUserDataDdt = true;
ctx->imageInfo.ImageSize += ddtHeader.cmpLength;
if(idxEntries[i].dataType == UserData)
{
ctx->shift = ddtHeader.shift;
ctx->imageInfo.Sectors = ddtHeader.entries;
ctx->shift = ddtHeader.shift;
// Check for DDT compression
switch(ddtHeader.compression)
@@ -473,12 +492,10 @@ void *open(const char *filepath)
ctx->geometryBlock.cylinders,
ctx->geometryBlock.heads,
ctx->geometryBlock.sectorsPerTrack);
// TODO: ImageInfo
/*
imageInfo.Cylinders = geometryBlock.cylinders;
imageInfo.Heads = geometryBlock.heads;
imageInfo.SectorsPerTrack = geometryBlock.sectorsPerTrack;
*/
ctx->imageInfo.Cylinders = ctx->geometryBlock.cylinders;
ctx->imageInfo.Heads = ctx->geometryBlock.heads;
ctx->imageInfo.SectorsPerTrack = ctx->geometryBlock.sectorsPerTrack;
}
else
memset(&ctx->geometryBlock, 0, sizeof(GeometryBlockHeader));
@@ -507,6 +524,8 @@ void *open(const char *filepath)
break;
}
ctx->imageInfo.ImageSize += ctx->metadataBlockHeader.blockSize;
ctx->metadataBlock = malloc(ctx->metadataBlockHeader.blockSize);
if(ctx->metadataBlock == NULL)
@@ -525,6 +544,172 @@ void *open(const char *filepath)
fprintf(stderr, "libdicformat: Could not read metadata block, continuing...");
}
if(ctx->metadataBlockHeader.mediaSequence > 0 && ctx->metadataBlockHeader.lastMediaSequence > 0)
{
ctx->imageInfo.MediaSequence = ctx->metadataBlockHeader.mediaSequence;
ctx->imageInfo.LastMediaSequence = ctx->metadataBlockHeader.lastMediaSequence;
fprintf(stderr,
"libdicformat: Setting media sequence as %d of %d",
ctx->imageInfo.MediaSequence,
ctx->imageInfo.LastMediaSequence);
}
if(ctx->metadataBlockHeader.creatorLength > 0 &&
ctx->metadataBlockHeader.creatorOffset + ctx->metadataBlockHeader.creatorLength <=
ctx->metadataBlock.blockSize)
{
ctx->imageInfo.Creator = malloc(ctx->metadataBlockHeader.creatorLength);
if(ctx->imageInfo.Creator != NULL)
{
memcpy(ctx->imageInfo.Creator,
ctx->metadataBlock + ctx->metadataBlockHeader.creatorOffset,
ctx->metadataBlockHeader.creatorLength);
}
}
if(ctx->metadataBlockHeader.commentsLength > 0 &&
ctx->metadataBlockHeader.commentsOffset + ctx->metadataBlockHeader.commentsLength <=
ctx->metadataBlock.blockSize)
{
ctx->imageInfo.Comments = malloc(ctx->metadataBlockHeader.commentsLength);
if(ctx->imageInfo.Comments != NULL)
{
memcpy(ctx->imageInfo.Comments,
ctx->metadataBlock + ctx->metadataBlockHeader.commentsOffset,
ctx->metadataBlockHeader.commentsLength);
}
}
if(ctx->metadataBlockHeader.mediaTitleLength > 0 &&
ctx->metadataBlockHeader.mediaTitleOffset + ctx->metadataBlockHeader.mediaTitleLength <=
ctx->metadataBlock.blockSize)
{
ctx->imageInfo.MediaTitle = malloc(ctx->metadataBlockHeader.mediaTitleLength);
if(ctx->imageInfo.MediaTitle != NULL)
{
memcpy(ctx->imageInfo.MediaTitle,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaTitleOffset,
ctx->metadataBlockHeader.mediaTitleLength);
}
}
if(ctx->metadataBlockHeader.mediaManufacturerLength > 0 &&
ctx->metadataBlockHeader.mediaManufacturerOffset +
ctx->metadataBlockHeader.mediaManufacturerLength <= ctx->metadataBlock.blockSize)
{
ctx->imageInfo.MediaManufacturer = malloc(ctx->metadataBlockHeader.mediaManufacturerLength);
if(ctx->imageInfo.MediaManufacturer != NULL)
{
memcpy(ctx->imageInfo.MediaManufacturer,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaManufacturerOffset,
ctx->metadataBlockHeader.mediaManufacturerLength);
}
}
if(ctx->metadataBlockHeader.mediaModelLength > 0 &&
ctx->metadataBlockHeader.mediaModelOffset + ctx->metadataBlockHeader.mediaModelLength <=
ctx->metadataBlock.blockSize)
{
ctx->imageInfo.MediaModel = malloc(ctx->metadataBlockHeader.mediaModelOffset);
if(ctx->imageInfo.MediaModel != NULL)
{
memcpy(ctx->imageInfo.MediaModel,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaModelOffset,
ctx->metadataBlockHeader.mediaModelLength);
}
}
if(ctx->metadataBlockHeader.mediaSerialNumberLength > 0 &&
ctx->metadataBlockHeader.mediaSerialNumberOffset +
ctx->metadataBlockHeader.mediaSerialNumberLength <= ctx->metadataBlock.blockSize)
{
ctx->imageInfo.MediaSerialNumber = malloc(ctx->metadataBlockHeader.mediaSerialNumberLength);
if(ctx->imageInfo.MediaSerialNumber != NULL)
{
memcpy(ctx->imageInfo.MediaSerialNumber,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaSerialNumberOffset,
ctx->metadataBlockHeader.mediaManufacturerLength);
}
}
if(ctx->metadataBlockHeader.mediaBarcodeLength > 0 &&
ctx->metadataBlockHeader.mediaBarcodeOffset + ctx->metadataBlockHeader.mediaBarcodeLength <=
ctx->metadataBlock.blockSize)
{
ctx->imageInfo.MediaBarcode = malloc(ctx->metadataBlockHeader.mediaBarcodeLength);
if(ctx->imageInfo.MediaBarcode != NULL)
{
memcpy(ctx->imageInfo.MediaBarcode,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaBarcodeOffset,
ctx->metadataBlockHeader.mediaBarcodeLength);
}
}
if(ctx->metadataBlockHeader.mediaPartNumberLength > 0 &&
ctx->metadataBlockHeader.mediaPartNumberOffset + ctx->metadataBlockHeader.mediaPartNumberLength <=
ctx->metadataBlock.blockSize)
{
ctx->imageInfo.MediaPartNumber = malloc(ctx->metadataBlockHeader.mediaPartNumberLength);
if(ctx->imageInfo.MediaPartNumber != NULL)
{
memcpy(ctx->imageInfo.MediaPartNumber,
ctx->metadataBlock + ctx->metadataBlockHeader.mediaPartNumberOffset,
ctx->metadataBlockHeader.mediaPartNumberLength);
}
}
if(ctx->metadataBlockHeader.driveManufacturerLength > 0 &&
ctx->metadataBlockHeader.driveManufacturerOffset +
ctx->metadataBlockHeader.driveManufacturerLength <= ctx->metadataBlock.blockSize)
{
ctx->imageInfo.DriveManufacturer = malloc(ctx->metadataBlockHeader.driveManufacturerLength);
if(ctx->imageInfo.DriveManufacturer != NULL)
{
memcpy(ctx->imageInfo.DriveManufacturer,
ctx->metadataBlock + ctx->metadataBlockHeader.driveManufacturerOffset,
ctx->metadataBlockHeader.driveManufacturerLength);
}
}
if(ctx->metadataBlockHeader.driveModelLength > 0 &&
ctx->metadataBlockHeader.driveModelOffset + ctx->metadataBlockHeader.driveModelLength <=
ctx->metadataBlock.blockSize)
{
ctx->imageInfo.DriveModel = malloc(ctx->metadataBlockHeader.driveModelLength);
if(ctx->imageInfo.DriveModel != NULL)
{
memcpy(ctx->imageInfo.DriveModel,
ctx->metadataBlock + ctx->metadataBlockHeader.driveModelOffset,
ctx->metadataBlockHeader.driveModelLength);
}
}
if(ctx->metadataBlockHeader.driveSerialNumberLength > 0 &&
ctx->metadataBlockHeader.driveSerialNumberOffset +
ctx->metadataBlockHeader.driveSerialNumberLength <= ctx->metadataBlock.blockSize)
{
ctx->imageInfo.DriveSerialNumber = malloc(ctx->metadataBlockHeader.driveSerialNumberLength);
if(ctx->imageInfo.DriveSerialNumber != NULL)
{
memcpy(ctx->imageInfo.DriveSerialNumber,
ctx->metadataBlock + ctx->metadataBlockHeader.driveSerialNumberOffset,
ctx->metadataBlockHeader.driveSerialNumberLength);
}
}
if(ctx->metadataBlockHeader.driveManufacturerLength > 0 &&
ctx->metadataBlockHeader.driveFirmwareRevisionOffset +
ctx->metadataBlockHeader.driveManufacturerLength <= ctx->metadataBlock.blockSize)
{
ctx->imageInfo.DriveFirmwareRevision = malloc(ctx->metadataBlockHeader.driveFirmwareRevisionLength);
if(ctx->imageInfo.DriveFirmwareRevision != NULL)
{
memcpy(ctx->imageInfo.DriveFirmwareRevision,
ctx->metadataBlock + ctx->metadataBlockHeader.driveFirmwareRevisionLength,
ctx->metadataBlockHeader.driveFirmwareRevisionLength);
}
}
break;
case TracksBlock: readBytes = fread(&ctx->tracksHeader, sizeof(TracksHeader), 1, ctx->imageStream);
@@ -543,6 +728,8 @@ void *open(const char *filepath)
idxEntries[i].offset);
}
ctx->imageInfo.ImageSize += sizeof(TrackEntry) * ctx->tracksHeader.entries;
ctx->trackEntries = malloc(sizeof(TrackEntry) * ctx->tracksHeader.entries);
if(ctx->trackEntries == NULL)
@@ -554,7 +741,7 @@ void *open(const char *filepath)
readBytes = fread(ctx->trackEntries, sizeof(TrackEntry), ctx->tracksHeader.entries, ctx->imageStream);
if(readBytes != ctx->metadataBlockHeader.blockSize)
if(readBytes != sizeof(TrackEntry) * ctx->tracksHeader.entries)
{
memset(&ctx->tracksHeader, 0, sizeof(TracksHeader));
free(ctx->trackEntries);
@@ -567,7 +754,9 @@ void *open(const char *filepath)
idxEntries[i].offset);
// TODO: Cache flags and ISRCs
// TODO: ImageInfo
ctx->imageInfo.HasPartitions = true;
ctx->imageInfo.HasSessions = true;
break;
// CICM XML metadata block
@@ -588,6 +777,8 @@ void *open(const char *filepath)
idxEntries[i].offset);
}
ctx->imageInfo.ImageSize += ctx->cicmBlockHeader.length;
ctx->cicmBlock = malloc(ctx->cicmBlockHeader.length);
if(ctx->cicmBlock == NULL)
@@ -888,21 +1079,18 @@ void *open(const char *filepath)
return NULL;
}
// TODO: ImageInfo
/*
imageInfo.CreationTime = DateTime.FromFileTimeUtc(header.creationTime);
DicConsole.DebugWriteLine("DiscImageChef format plugin", "Image created on {0}", imageInfo.CreationTime);
imageInfo.LastModificationTime = DateTime.FromFileTimeUtc(header.lastWrittenTime);
DicConsole.DebugWriteLine("DiscImageChef format plugin", "Image last written on {0}",
imageInfo.LastModificationTime);
ctx->imageInfo.CreationTime = ctx->header.creationTime;
ctx->imageInfo.LastModificationTime = ctx->header.lastWrittenTime;
if(geometryBlock.identifier != BlockType.GeometryBlock && imageInfo.XmlMediaType == XmlMediaType.BlockMedia)
{
imageInfo.Cylinders = (uint)(imageInfo.Sectors / 16 / 63);
imageInfo.Heads = 16;
imageInfo.SectorsPerTrack = 63;
}
*/
// TODO: GetXmlMediaType
// imageInfo.XmlMediaType = GetXmlMediaType(header.mediaType);
if(ctx->geometryBlock.identifier != GeometryBlock/* && ctx->imageInfo.XmlMediaType == XmlMediaType.BlockMedia*/)
{
ctx->imageInfo.Cylinders = (uint32_t)(ctx->imageInfo.Sectors / 16 / 63);
ctx->imageInfo.Heads = 16;
ctx->imageInfo.SectorsPerTrack = 63;
}
// TODO: Caches
/*