mirror of
https://github.com/libretro/beetle-psx-libretro.git
synced 2024-11-27 02:40:31 +00:00
325 lines
9.3 KiB
C
325 lines
9.3 KiB
C
/* Mednafen - Multi-system Emulator
|
|
*
|
|
* Subchannel Q CRC Code: Copyright (C) 1998 Andreas Mueller <mueller@daneb.ping.de>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "CDUtility.h"
|
|
#include "edc_crc32.h"
|
|
#include "galois.h"
|
|
#include "l-ec.h"
|
|
#include "recover-raw.h"
|
|
#include "lec.h"
|
|
|
|
#include <assert.h>
|
|
|
|
/* lookup table for crc calculation */
|
|
static uint16_t subq_crctab[256] =
|
|
{
|
|
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108,
|
|
0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210,
|
|
0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B,
|
|
0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401,
|
|
0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE,
|
|
0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6,
|
|
0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D,
|
|
0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
|
|
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5,
|
|
0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC,
|
|
0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4,
|
|
0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD,
|
|
0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13,
|
|
0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A,
|
|
0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E,
|
|
0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
|
|
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1,
|
|
0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB,
|
|
0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0,
|
|
0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8,
|
|
0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657,
|
|
0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9,
|
|
0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882,
|
|
0x28A3, 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
|
|
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E,
|
|
0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07,
|
|
0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D,
|
|
0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74,
|
|
0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
|
|
};
|
|
|
|
|
|
static uint8_t cdutil_scramble_table[2352 - 12];
|
|
|
|
static bool CDUtility_Inited = false;
|
|
|
|
static void InitScrambleTable(void)
|
|
{
|
|
unsigned i, b;
|
|
unsigned cv = 1;
|
|
|
|
for(i = 12; i < 2352; i++)
|
|
{
|
|
unsigned char z = 0;
|
|
|
|
for(b = 0; b < 8; b++)
|
|
{
|
|
z |= (cv & 1) << b;
|
|
|
|
int feedback = ((cv >> 1) & 1) ^ (cv & 1);
|
|
cv = (cv >> 1) | (feedback << 14);
|
|
}
|
|
|
|
cdutil_scramble_table[i - 12] = z;
|
|
}
|
|
}
|
|
|
|
void CDUtility_Init(void)
|
|
{
|
|
if(!CDUtility_Inited)
|
|
{
|
|
Init_LEC_Correct();
|
|
|
|
InitScrambleTable();
|
|
lec_tables_init();
|
|
|
|
CDUtility_Inited = true;
|
|
}
|
|
}
|
|
|
|
void encode_mode0_sector(uint32_t aba, uint8_t *sector_data)
|
|
{
|
|
CDUtility_Init();
|
|
|
|
lec_encode_mode0_sector(aba, sector_data);
|
|
}
|
|
|
|
void encode_mode1_sector(uint32_t aba, uint8_t *sector_data)
|
|
{
|
|
CDUtility_Init();
|
|
|
|
lec_encode_mode1_sector(aba, sector_data);
|
|
}
|
|
|
|
void encode_mode2_sector(uint32_t aba, uint8_t *sector_data)
|
|
{
|
|
CDUtility_Init();
|
|
|
|
lec_encode_mode2_sector(aba, sector_data);
|
|
}
|
|
|
|
void encode_mode2_form1_sector(uint32_t aba, uint8_t *sector_data)
|
|
{
|
|
CDUtility_Init();
|
|
|
|
lec_encode_mode2_form1_sector(aba, sector_data);
|
|
}
|
|
|
|
void encode_mode2_form2_sector(uint32_t aba, uint8_t *sector_data)
|
|
{
|
|
CDUtility_Init();
|
|
|
|
lec_encode_mode2_form2_sector(aba, sector_data);
|
|
}
|
|
|
|
bool edc_check(const uint8_t *sector_data, bool xa)
|
|
{
|
|
CDUtility_Init();
|
|
|
|
return(CheckEDC(sector_data, xa));
|
|
}
|
|
|
|
bool edc_lec_check_and_correct(uint8_t *sector_data, bool xa)
|
|
{
|
|
CDUtility_Init();
|
|
|
|
return(ValidateRawSector(sector_data, xa));
|
|
}
|
|
|
|
|
|
bool subq_check_checksum(const uint8_t *SubQBuf)
|
|
{
|
|
unsigned i;
|
|
uint16_t crc = 0;
|
|
uint16_t stored_crc = SubQBuf[0xA] << 8;
|
|
|
|
stored_crc |= SubQBuf[0xB];
|
|
|
|
for(i = 0; i < 0xA; i++)
|
|
crc = subq_crctab[(crc >> 8) ^ SubQBuf[i]] ^ (crc << 8);
|
|
|
|
crc = ~crc;
|
|
|
|
return(crc == stored_crc);
|
|
}
|
|
|
|
void subq_generate_checksum(uint8_t *buf)
|
|
{
|
|
unsigned i;
|
|
uint16_t crc = 0;
|
|
|
|
for(i = 0; i < 0xA; i++)
|
|
crc = subq_crctab[(crc >> 8) ^ buf[i]] ^ (crc << 8);
|
|
|
|
/* Checksum */
|
|
buf[0xa] = ~(crc >> 8);
|
|
buf[0xb] = ~(crc);
|
|
}
|
|
|
|
void subq_deinterleave(const uint8_t *SubPWBuf, uint8_t *qbuf)
|
|
{
|
|
unsigned i;
|
|
|
|
memset(qbuf, 0, 0xC);
|
|
|
|
for(i = 0; i < 96; i++)
|
|
qbuf[i >> 3] |= ((SubPWBuf[i] >> 6) & 0x1) << (7 - (i & 0x7));
|
|
}
|
|
|
|
|
|
// Deinterleaves 96 bytes of subchannel P-W data from 96 bytes of interleaved subchannel PW data.
|
|
void subpw_deinterleave(const uint8_t *in_buf, uint8_t *out_buf)
|
|
{
|
|
unsigned ch, i;
|
|
assert(in_buf != out_buf);
|
|
|
|
memset(out_buf, 0, 96);
|
|
|
|
for(ch = 0; ch < 8; ch++)
|
|
{
|
|
for(i = 0; i < 96; i++)
|
|
out_buf[(ch * 12) + (i >> 3)] |= ((in_buf[i] >> (7 - ch)) & 0x1) << (7 - (i & 0x7));
|
|
}
|
|
|
|
}
|
|
|
|
// Interleaves 96 bytes of subchannel P-W data from 96 bytes of uninterleaved subchannel PW data.
|
|
void subpw_interleave(const uint8_t *in_buf, uint8_t *out_buf)
|
|
{
|
|
unsigned d, bitpoodle, ch;
|
|
|
|
assert(in_buf != out_buf);
|
|
|
|
for(d = 0; d < 12; d++)
|
|
{
|
|
for(bitpoodle = 0; bitpoodle < 8; bitpoodle++)
|
|
{
|
|
uint8_t rawb = 0;
|
|
|
|
for(ch = 0; ch < 8; ch++)
|
|
rawb |= ((in_buf[ch * 12 + d] >> (7 - bitpoodle)) & 1) << (7 - ch);
|
|
out_buf[(d << 3) + bitpoodle] = rawb;
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTES ON LEADOUT AREA SYNTHESIS
|
|
//
|
|
// I'm not trusting that the "control" field for the TOC leadout entry will always be set properly, so | the control fields for the last track entry
|
|
// and the leadout entry together before extracting the D2 bit. Audio track->data leadout is fairly benign though maybe noisy(especially if we ever implement
|
|
// data scrambling properly), but data track->audio leadout could break things in an insidious manner for the more accurate drive emulation code).
|
|
//
|
|
void subpw_synth_leadout_lba(const struct TOC *toc, const int32_t lba, uint8_t* SubPWBuf)
|
|
{
|
|
unsigned i;
|
|
uint8_t buf[0xC];
|
|
uint32_t lba_relative = lba - toc->tracks[100].lba;
|
|
uint32_t f = (lba_relative % 75);
|
|
uint32_t s = ((lba_relative / 75) % 60);
|
|
uint32_t m = (lba_relative / 75 / 60);
|
|
uint32_t fa = (lba + 150) % 75;
|
|
uint32_t sa = ((lba + 150) / 75) % 60;
|
|
uint32_t ma = ((lba + 150) / 75 / 60);
|
|
|
|
uint8_t adr = 0x1; // Q channel data encodes position
|
|
uint8_t control = toc->tracks[100].control;
|
|
|
|
if (toc->tracks[toc->last_track].valid)
|
|
control |= toc->tracks[toc->last_track].control & 0x4;
|
|
else if (toc->disc_type == DISC_TYPE_CD_I)
|
|
control |= 0x4;
|
|
|
|
memset(buf, 0, 0xC);
|
|
buf[0] = (adr << 0) | (control << 4);
|
|
buf[1] = 0xAA;
|
|
buf[2] = 0x01;
|
|
|
|
/* Track relative MSF address */
|
|
buf[3] = U8_to_BCD(m);
|
|
buf[4] = U8_to_BCD(s);
|
|
buf[5] = U8_to_BCD(f);
|
|
|
|
buf[6] = 0; /* Zerroooo */
|
|
|
|
/* Absolute MSF address */
|
|
buf[7] = U8_to_BCD(ma);
|
|
buf[8] = U8_to_BCD(sa);
|
|
buf[9] = U8_to_BCD(fa);
|
|
|
|
subq_generate_checksum(buf);
|
|
|
|
for(i = 0; i < 96; i++)
|
|
SubPWBuf[i] = (((buf[i >> 3] >> (7 - (i & 0x7))) & 1) ? 0x40 : 0x00) | 0x80;
|
|
}
|
|
|
|
void synth_leadout_sector_lba(uint8_t mode, const struct TOC *toc, const int32_t lba, uint8_t* out_buf)
|
|
{
|
|
memset(out_buf, 0, 2352 + 96);
|
|
subpw_synth_leadout_lba(toc, lba, out_buf + 2352);
|
|
|
|
if(out_buf[2352 + 1] & 0x40)
|
|
{
|
|
if(mode == 0xFF)
|
|
{
|
|
if(toc->disc_type == DISC_TYPE_CD_XA || toc->disc_type == DISC_TYPE_CD_I)
|
|
mode = 0x02;
|
|
else
|
|
mode = 0x01;
|
|
}
|
|
|
|
switch(mode)
|
|
{
|
|
default:
|
|
encode_mode0_sector(LBA_to_ABA(lba), out_buf);
|
|
break;
|
|
|
|
case 0x01:
|
|
encode_mode1_sector(LBA_to_ABA(lba), out_buf);
|
|
break;
|
|
|
|
case 0x02:
|
|
out_buf[12 + 6] = 0x20;
|
|
out_buf[12 + 10] = 0x20;
|
|
encode_mode2_form2_sector(LBA_to_ABA(lba), out_buf);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* ISO/IEC 10149:1995 (E): 20.2 */
|
|
#if 0
|
|
/* TODO/FIXME - missing functions */
|
|
void subpw_synth_udapp_lba(const TOC& toc, const int32 lba, const int32 lba_subq_relative_offs, uint8* SubPWBuf);
|
|
void synth_udapp_sector_lba(uint8 mode, const TOC& toc, const int32 lba, int32 lba_subq_relative_offs, uint8* out_buf);
|
|
#endif
|
|
|
|
void scrambleize_data_sector(uint8_t *sector_data)
|
|
{
|
|
unsigned i;
|
|
for(i = 12; i < 2352; i++)
|
|
sector_data[i] ^= cdutil_scramble_table[i - 12];
|
|
}
|