/* Mednafen - Multi-system Emulator * * Subchannel Q CRC Code: Copyright (C) 1998 Andreas Mueller * * 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 /* 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]; }