/* * 86Box A hypervisor and IBM PC system emulator that specializes in * running old operating systems and software designed for IBM * PC systems and compatibles from 1981 through fairly recent * system designs based on the PCI bus. * * This file is part of the 86Box distribution. * * CD-ROM image support. * * Version: @(#)cdrom_image.cc 1.0.7 2018/10/28 * * Author: RichardG867, * Miran Grca, * bit, * * Copyright 2015-2018 Richardg867. * Copyright 2015-2018 Miran Grca. * Copyright 2017,2018 bit. */ #define __USE_LARGEFILE64 #define _LARGEFILE_SOURCE #define _LARGEFILE64_SOURCE #include #include #include #include #include #include #include "../config.h" #include "../plat.h" #include "../scsi/scsi_device.h" #include "cdrom_dosbox.h" #include "cdrom.h" #include "cdrom_image.h" #ifdef ENABLE_CDROM_IMAGE_LOG int cdrom_image_do_log = ENABLE_CDROM_IMAGE_LOG; void cdrom_image_log(const char *fmt, ...) { va_list ap; if (cdrom_image_do_log) { va_start(ap, fmt); pclog_ex(fmt, ap); va_end(ap); } } #else #define cdrom_image_log(fmt, ...) #endif /* The addresses sent from the guest are absolute, ie. a LBA of 0 corresponds to a MSF of 00:00:00. Otherwise, the counter displayed by the guest is wrong: there is a seeming 2 seconds in which audio plays but counter does not move, while a data track before audio jumps to 2 seconds before the actual start of the audio while audio still plays. With an absolute conversion, the counter is fine. */ #define MSFtoLBA(m,s,f) ((((m*60)+s)*75)+f) static void image_get_tracks(cdrom_t *dev, int *first, int *last) { CDROM_Interface_Image *img = (CDROM_Interface_Image *)dev->image; TMSF tmsf; img->GetAudioTracks(*first, *last, tmsf); } static void image_get_track_info(cdrom_t *dev, uint32_t track, int end, track_info_t *ti) { CDROM_Interface_Image *img = (CDROM_Interface_Image *)dev->image; TMSF tmsf; if (end) img->GetAudioTrackEndInfo(track, ti->number, tmsf, ti->attr); else img->GetAudioTrackInfo(track, ti->number, tmsf, ti->attr); ti->m = tmsf.min; ti->s = tmsf.sec; ti->f = tmsf.fr; } static void image_get_subchannel(cdrom_t *dev, uint32_t lba, subchannel_t *subc) { CDROM_Interface_Image *img = (CDROM_Interface_Image *)dev->image; TMSF rel_pos, abs_pos; img->GetAudioSub(lba, subc->attr, subc->track, subc->index, rel_pos, abs_pos); subc->abs_m = abs_pos.min; subc->abs_s = abs_pos.sec; subc->abs_f = abs_pos.fr; subc->rel_m = rel_pos.min; subc->rel_s = rel_pos.sec; subc->rel_f = rel_pos.fr; } static int image_get_last_block(cdrom_t *dev) { CDROM_Interface_Image *img = (CDROM_Interface_Image *)dev->image; int first_track, last_track; int number, c; unsigned char attr; TMSF tmsf; uint32_t lb = 0; uint32_t address; if (!img) return 0; img->GetAudioTracks(first_track, last_track, tmsf); for (c = 0; c <= last_track; c++) { img->GetAudioTrackInfo(c+1, number, tmsf, attr); address = MSFtoLBA(tmsf.min, tmsf.sec, tmsf.fr) - 150; /* Do the - 150 here as well. */ if (address > lb) lb = address; } return lb; } static int image_is_track_audio(cdrom_t *dev, uint32_t pos, int ismsf) { CDROM_Interface_Image *img = (CDROM_Interface_Image *)dev->image; uint8_t attr; TMSF tmsf; int m, s, f; int number; if (!img || (dev->cd_status == CD_STATUS_DATA_ONLY)) return 0; if (ismsf) { m = (pos >> 16) & 0xff; s = (pos >> 8) & 0xff; f = pos & 0xff; pos = MSFtoLBA(m, s, f) - 150; } /* GetTrack requires LBA. */ img->GetAudioTrackInfo(img->GetTrack(pos), number, tmsf, attr); return attr == AUDIO_TRACK; } static int image_sector_size(struct cdrom *dev, uint32_t lba) { CDROM_Interface_Image *img = (CDROM_Interface_Image *)dev->image; return img->GetSectorSize(lba); } static int image_read_sector(struct cdrom *dev, int type, uint8_t *b, uint32_t lba) { CDROM_Interface_Image *img = (CDROM_Interface_Image *)dev->image; switch (type) { case CD_READ_DATA: return img->ReadSector(b, false, lba); case CD_READ_AUDIO: return img->ReadSector(b, true, lba); case CD_READ_RAW: if (img->GetSectorSize(lba) == 2352) return img->ReadSector(b, true, lba); else return img->ReadSectorSub(b, lba); default: cdrom_image_log("CD-ROM %i: Unknown CD read type\n", dev->id); return 0; } } static int image_track_type(cdrom_t *dev, uint32_t lba) { CDROM_Interface_Image *img = (CDROM_Interface_Image *)dev->image; if (img) { if (image_is_track_audio(dev, lba, 0)) return CD_TRACK_AUDIO; else { if (img->IsMode2(lba)) return CD_TRACK_MODE2 | img->GetMode2Form(lba); } } return 0; } static void image_exit(cdrom_t *dev) { CDROM_Interface_Image *img = (CDROM_Interface_Image *)dev->image; cdrom_image_log("CDROM: image_exit(%ls)\n", dev->image_path); dev->cd_status = CD_STATUS_EMPTY; if (img) { delete img; dev->image = NULL; } dev->ops = NULL; } static const cdrom_ops_t cdrom_image_ops = { image_get_tracks, image_get_track_info, image_get_subchannel, image_sector_size, image_read_sector, image_track_type, image_exit }; static int image_open_abort(cdrom_t *dev) { cdrom_image_close(dev); dev->ops = NULL; dev->host_drive = 0; return 1; } int cdrom_image_open(cdrom_t *dev, const wchar_t *fn) { char temp[1024]; CDROM_Interface_Image *img; wcscpy(dev->image_path, fn); /* Create new instance of the CDROM_Image class. */ img = new CDROM_Interface_Image(); /* This guarantees that if ops is not NULL, then neither is the image pointer. */ if (!img) return image_open_abort(dev); dev->image = img; /* Convert filename and open the image. */ memset(temp, '\0', sizeof(temp)); wcstombs(temp, fn, sizeof(temp)); if (!img->SetDevice(temp, false)) return image_open_abort(dev); /* All good, reset state. */ if (! wcscasecmp(plat_get_extension((wchar_t *) fn), L"ISO")) dev->cd_status = CD_STATUS_DATA_ONLY; else dev->cd_status = CD_STATUS_STOPPED; dev->seek_pos = 0; dev->cd_buflen = 0; dev->cdrom_capacity = image_get_last_block(dev) + 1; /* Attach this handler to the drive. */ dev->ops = &cdrom_image_ops; return 0; } void cdrom_image_close(cdrom_t *dev) { cdrom_image_log("CDROM: image_close(%ls)\n", dev->image_path); if (dev->ops->exit) dev->ops->exit(dev); }