scrc32.c000664 001750 001750 00000007776 12726204343 013171 0ustar00sergiosergio000000 000000 #ifdef __cplusplus extern "C" { #endif #ifdef WANT_CRC32 static const unsigned long crc_table[256] = { 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL, 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L, 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L, 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L, 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL, 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L, 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL, 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L, 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L, 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L, 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL, 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL, 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L, 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL, 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L, 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L, 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L, 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL, 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L, 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L, 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL, 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L, 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L, 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L, 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L, 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L, 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL, 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL, 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L, 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L, 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL, 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL, 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L, 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL, 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L, 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL, 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L, 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL, 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L, 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L, 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL, 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L, 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L, 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L, 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L, 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL }; #define DO1_CRC32(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8); #define DO2_CRC32(buf) DO1_CRC32(buf); DO1_CRC32(buf); #define DO4_CRC32(buf) DO2_CRC32(buf); DO2_CRC32(buf); #define DO8_CRC32(buf) DO4_CRC32(buf); DO4_CRC32(buf); unsigned long crc32(unsigned long crc, const unsigned char *buf, unsigned int len) { if (buf == 0) return 0L; crc = crc ^ 0xffffffffL; while (len >= 8) { DO8_CRC32(buf); len -= 8; } if (len) do { DO1_CRC32(buf); } while (--len); return crc ^ 0xffffffffL; } #endif #ifdef __cplusplus } #endif libretro-common/include/libco.h000664 001750 001750 00000000734 12726204343 017705 0ustar00sergiosergio000000 000000 /* libco version: 0.16 (2010-12-24) license: public domain */ #ifndef LIBCO_H #define LIBCO_H #ifdef LIBCO_C #ifdef LIBCO_MP #define thread_local __thread #else #define thread_local #endif #endif #ifdef __cplusplus extern "C" { #endif typedef void* cothread_t; cothread_t co_active(); cothread_t co_create(unsigned int, void (*)(void)); void co_delete(cothread_t); void co_switch(cothread_t); #ifdef __cplusplus } #endif /* ifndef LIBCO_H */ #endif mednafen/tremor/codec_internal.h000664 001750 001750 00000006014 12726204343 020115 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: libvorbis codec headers ********************************************************************/ #ifndef _V_CODECI_H_ #define _V_CODECI_H_ #include "codebook.h" typedef void vorbis_look_mapping; typedef void vorbis_look_floor; typedef void vorbis_look_residue; typedef void vorbis_look_transform; /* mode ************************************************************/ typedef struct { int blockflag; int windowtype; int transformtype; int mapping; } vorbis_info_mode; typedef void vorbis_info_floor; typedef void vorbis_info_residue; typedef void vorbis_info_mapping; typedef struct private_state { /* local lookup storage */ const void *window[2]; /* backend lookups are tied to the mode, not the backend or naked mapping */ int modebits; vorbis_look_mapping **mode; ogg_int64_t sample_count; } private_state; /* codec_setup_info contains all the setup information specific to the specific compression/decompression mode in progress (eg, psychoacoustic settings, channel setup, options, codebook etc). *********************************************************************/ typedef struct codec_setup_info { /* Vorbis supports only short and long blocks, but allows the encoder to choose the sizes */ long blocksizes[2]; /* modes are the primary means of supporting on-the-fly different blocksizes, different channel mappings (LR or M/A), different residue backends, etc. Each mode consists of a blocksize flag and a mapping (along with the mapping setup */ int modes; int maps; int times; int floors; int residues; int books; vorbis_info_mode *mode_param[64]; int map_type[64]; vorbis_info_mapping *map_param[64]; int time_type[64]; int floor_type[64]; vorbis_info_floor *floor_param[64]; int residue_type[64]; vorbis_info_residue *residue_param[64]; static_codebook *book_param[256]; codebook *fullbooks; int passlimit[32]; /* iteration limit per couple/quant pass */ int coupling_passes; } codec_setup_info; #endif msvc/msvc-2010/msvc-2010.vcxproj000664 001750 001750 00000030341 12726204343 017153 0ustar00sergiosergio000000 000000  Debug Win32 Release Win32 CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsCpp CompileAsCpp {38462FE9-E3FC-4336-B241-50F5599C537B} Win32Proj DynamicLibrary MultiByte DynamicLibrary MultiByte $(OutDir)mednafen_pce_fast_libretro_xdk360$(TargetExt) $(SolutionDir)msvc-2010\$(Configuration)\ $(OutDir)mednafen_pce_fast_libretro_xdk360$(TargetExt) $(SolutionDir)msvc-2010\$(Configuration)\ NotUsing Level3 ProgramDatabase Disabled false true false $(OutDir)$(ProjectName).pch MultiThreadedDebug _DEBUG;_WIN32;_LIB;LSB_FIRST;WANT_PCE_FAST_EMU;WANT_16BPP;SIZEOF_DOUBLE=8;MEDNAFEN_VERSION=0.9.26;MPC_FIXED_POINT;__LIBRETRO__;_LOW_ACCURACY;WANT_STEREO_SOUND;FRONTEND_SUPPORTS_RGB565;PSS_STYLE=2;MEDNAFEN_VERSION_NUMERIC=926;NEED_CD;WANT_CRC32;%(PreprocessorDefinitions);WANT_THREADING;_CRT_SECURE_NO_WARNINGS;WANT_NEW_API Callcap $(SolutionDir)\..\..\;$(SolutionDir)\..\..\mednafen;$(SolutionDir)\..\..\mednafen\cdrom;$(SolutionDir)\..\..\mednafen\include;$(SolutionDir)\..\..\mednafen\sound;$(SolutionDir)\..\..\mednafen\ngp;%(AdditionalIncludeDirectories) true libretro.def Level3 NotUsing Full true true ProgramDatabase Size false false $(OutDir)$(ProjectName).pch MultiThreaded NDEBUG;_WIN32;_LIB;LSB_FIRST;WANT_PCE_FAST_EMU;WANT_16BPP;SIZEOF_DOUBLE=8;MEDNAFEN_VERSION=0.9.26;MPC_FIXED_POINT;__LIBRETRO__;_LOW_ACCURACY;WANT_STEREO_SOUND;FRONTEND_SUPPORTS_RGB565;PSS_STYLE=2;MEDNAFEN_VERSION_NUMERIC=926;NEED_CD;WANT_CRC32;%(PreprocessorDefinitions);WANT_THREADING;_CRT_SECURE_NO_WARNINGS;WANT_NEW_API $(SolutionDir)\..\..\;$(SolutionDir)\..\..\mednafen;$(SolutionDir)\..\..\mednafen\cdrom;$(SolutionDir)\..\..\mednafen\include;$(SolutionDir)\..\..\mednafen\sound;$(SolutionDir)\..\..\mednafen\ngp;$(SolutionDir)\..\..\mednafen\hw_misc;%(AdditionalIncludeDirectories) true true true libretro.def mednafen/tremor/!!!VERSION000664 001750 001750 00000000341 12726204343 016203 0ustar00sergiosergio000000 000000 tremor svn 18222 libogg 1.3.0 With modifications like: perl -p -i -e "s//\"ogg.h\"/g" * && perl -p -i -e "s//\"os_types.h\"/g" * && perl -p -i -e "s//\"config_types.h\"/g" * mednafen/tremor/000700 001750 001750 00000000000 12727366154 014770 5ustar00sergiosergio000000 000000 mednafen/pce_fast/psg.h000664 001750 001750 00000005044 12726204343 016213 0ustar00sergiosergio000000 000000 #ifndef _PCEFast_PSG_H #define _PCEFast_PSG_H #include "../include/blip/Blip_Buffer.h" class PCEFast_PSG; struct psg_channel { uint8 waveform[32]; /* Waveform data */ uint8 waveform_index; /* Waveform data index */ uint8 dda; uint8 control; /* Channel enable, DDA, volume */ uint8 noisectrl; /* Noise enable/ctrl (channels 4,5 only) */ int32 vl[2]; //vll, vlr; int32 counter; void (PCEFast_PSG::*UpdateOutput)(const int32 timestamp, psg_channel *ch); uint32 freq_cache; uint32 noise_freq_cache; // Channel 4,5 only int32 noisecount; uint32 lfsr; int32 samp_accum; // The result of adding up all the samples in the waveform buffer(part of an optimization for high-frequency playback). int32 blip_prev_samp[2]; int32 lastts; uint16 frequency; /* Channel frequency */ uint8 balance; /* Channel balance */ }; class PCEFast_PSG { public: PCEFast_PSG(Blip_Buffer *bb_l, Blip_Buffer *bb_r) MDFN_COLD; ~PCEFast_PSG() MDFN_COLD; int StateAction(StateMem *sm, int load, int data_only) MDFN_COLD; void Power(const int32 timestamp) MDFN_COLD; void Write(int32 timestamp, uint8 A, uint8 V); void SetVolume(double new_volume) MDFN_COLD; void EndFrame(int32 timestamp); private: void Update(int32 timestamp); void UpdateSubLFO(int32 timestamp); void UpdateSubNonLFO(int32 timestamp); void RecalcUOFunc(int chnum); void UpdateOutput_Off(const int32 timestamp, psg_channel *ch); void UpdateOutput_Accum(const int32 timestamp, psg_channel *ch); void UpdateOutput_Norm(const int32 timestamp, psg_channel *ch); void UpdateOutput_Noise(const int32 timestamp, psg_channel *ch); int32 GetVL(const int chnum, const int lr); void RecalcFreqCache(int chnum); void RecalcNoiseFreqCache(int chnum); template void RunChannel(int chc, int32 timestamp); double OutputVolume; uint8 select; /* Selected channel (0-5) */ uint8 globalbalance; /* Global sound balance */ uint8 lfofreq; /* LFO frequency */ uint8 lfoctrl; /* LFO control */ int32 vol_update_counter; int32 vol_update_which; int32 vol_update_vllatch; bool vol_pending; psg_channel channel[6]; int32 lastts; Blip_Buffer *sbuf[2]; Blip_Synth Synth; int32 dbtable_volonly[32]; int32 dbtable[32][32]; }; #endif mednafen/okiadpcm-deltatable.h000664 001750 001750 00000010124 12726204343 017517 0ustar00sergiosergio000000 000000 { 2, 6, 10, 14, 18, 22, 26, 30, -2, -6, -10, -14, -18, -22, -26, -30 }, { 2, 6, 10, 14, 19, 23, 27, 31, -2, -6, -10, -14, -19, -23, -27, -31 }, { 2, 6, 11, 15, 21, 25, 30, 34, -2, -6, -11, -15, -21, -25, -30, -34 }, { 2, 7, 12, 17, 23, 28, 33, 38, -2, -7, -12, -17, -23, -28, -33, -38 }, { 2, 7, 13, 18, 25, 30, 36, 41, -2, -7, -13, -18, -25, -30, -36, -41 }, { 3, 9, 15, 21, 28, 34, 40, 46, -3, -9, -15, -21, -28, -34, -40, -46 }, { 3, 10, 17, 24, 31, 38, 45, 52, -3, -10, -17, -24, -31, -38, -45, -52 }, { 3, 10, 18, 25, 34, 41, 49, 56, -3, -10, -18, -25, -34, -41, -49, -56 }, { 4, 12, 21, 29, 38, 46, 55, 63, -4, -12, -21, -29, -38, -46, -55, -63 }, { 4, 13, 22, 31, 41, 50, 59, 68, -4, -13, -22, -31, -41, -50, -59, -68 }, { 5, 15, 25, 35, 46, 56, 66, 76, -5, -15, -25, -35, -46, -56, -66, -76 }, { 5, 16, 27, 38, 50, 61, 72, 83, -5, -16, -27, -38, -50, -61, -72, -83 }, { 6, 18, 31, 43, 56, 68, 81, 93, -6, -18, -31, -43, -56, -68, -81, -93 }, { 6, 19, 33, 46, 61, 74, 88, 101, -6, -19, -33, -46, -61, -74, -88, -101 }, { 7, 22, 37, 52, 67, 82, 97, 112, -7, -22, -37, -52, -67, -82, -97, -112 }, { 8, 24, 41, 57, 74, 90, 107, 123, -8, -24, -41, -57, -74, -90, -107, -123 }, { 9, 27, 45, 63, 82, 100, 118, 136, -9, -27, -45, -63, -82, -100, -118, -136 }, { 10, 30, 50, 70, 90, 110, 130, 150, -10, -30, -50, -70, -90, -110, -130, -150 }, { 11, 33, 55, 77, 99, 121, 143, 165, -11, -33, -55, -77, -99, -121, -143, -165 }, { 12, 36, 60, 84, 109, 133, 157, 181, -12, -36, -60, -84, -109, -133, -157, -181 }, { 13, 39, 66, 92, 120, 146, 173, 199, -13, -39, -66, -92, -120, -146, -173, -199 }, { 14, 43, 73, 102, 132, 161, 191, 220, -14, -43, -73, -102, -132, -161, -191, -220 }, { 16, 48, 81, 113, 146, 178, 211, 243, -16, -48, -81, -113, -146, -178, -211, -243 }, { 17, 52, 88, 123, 160, 195, 231, 266, -17, -52, -88, -123, -160, -195, -231, -266 }, { 19, 58, 97, 136, 176, 215, 254, 293, -19, -58, -97, -136, -176, -215, -254, -293 }, { 21, 64, 107, 150, 194, 237, 280, 323, -21, -64, -107, -150, -194, -237, -280, -323 }, { 23, 70, 118, 165, 213, 260, 308, 355, -23, -70, -118, -165, -213, -260, -308, -355 }, { 26, 78, 130, 182, 235, 287, 339, 391, -26, -78, -130, -182, -235, -287, -339, -391 }, { 28, 85, 143, 200, 258, 315, 373, 430, -28, -85, -143, -200, -258, -315, -373, -430 }, { 31, 94, 157, 220, 284, 347, 410, 473, -31, -94, -157, -220, -284, -347, -410, -473 }, { 34, 103, 173, 242, 313, 382, 452, 521, -34, -103, -173, -242, -313, -382, -452, -521 }, { 38, 114, 191, 267, 345, 421, 498, 574, -38, -114, -191, -267, -345, -421, -498, -574 }, { 42, 126, 210, 294, 379, 463, 547, 631, -42, -126, -210, -294, -379, -463, -547, -631 }, { 46, 138, 231, 323, 417, 509, 602, 694, -46, -138, -231, -323, -417, -509, -602, -694 }, { 51, 153, 255, 357, 459, 561, 663, 765, -51, -153, -255, -357, -459, -561, -663, -765 }, { 56, 168, 280, 392, 505, 617, 729, 841, -56, -168, -280, -392, -505, -617, -729, -841 }, { 61, 184, 308, 431, 555, 678, 802, 925, -61, -184, -308, -431, -555, -678, -802, -925 }, { 68, 204, 340, 476, 612, 748, 884, 1020, -68, -204, -340, -476, -612, -748, -884, -1020 }, { 74, 223, 373, 522, 672, 821, 971, 1120, -74, -223, -373, -522, -672, -821, -971, -1120 }, { 82, 246, 411, 575, 740, 904, 1069, 1233, -82, -246, -411, -575, -740, -904, -1069, -1233 }, { 90, 271, 452, 633, 814, 995, 1176, 1357, -90, -271, -452, -633, -814, -995, -1176, -1357 }, { 99, 298, 497, 696, 895, 1094, 1293, 1492, -99, -298, -497, -696, -895, -1094, -1293, -1492 }, { 109, 328, 547, 766, 985, 1204, 1423, 1642, -109, -328, -547, -766, -985, -1204, -1423, -1642 }, { 120, 360, 601, 841, 1083, 1323, 1564, 1804, -120, -360, -601, -841, -1083, -1323, -1564, -1804 }, { 132, 397, 662, 927, 1192, 1457, 1722, 1987, -132, -397, -662, -927, -1192, -1457, -1722, -1987 }, { 145, 436, 728, 1019, 1311, 1602, 1894, 2185, -145, -436, -728, -1019, -1311, -1602, -1894, -2185 }, { 160, 480, 801, 1121, 1442, 1762, 2083, 2403, -160, -480, -801, -1121, -1442, -1762, -2083, -2403 }, { 176, 528, 881, 1233, 1587, 1939, 2292, 2644, -176, -528, -881, -1233, -1587, -1939, -2292, -2644 }, { 194, 582, 970, 1358, 1746, 2134, 2522, 2910, -194, -582, -970, -1358, -1746, -2134, -2522, -2910 }, libretro-common/rthreads/gx_pthread.h000664 001750 001750 00000011473 12726204343 021135 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2015 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (gx_pthread.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef _GX_PTHREAD_WRAP_GX_ #define _GX_PTHREAD_WRAP_GX_ #include #include #include #include #ifndef OSThread #define OSThread lwp_t #endif #ifndef OSCond #define OSCond lwpq_t #endif #ifndef OSThreadQueue #define OSThreadQueue lwpq_t #endif #ifndef OSInitMutex #define OSInitMutex(mutex) LWP_MutexInit(mutex, 0) #endif #ifndef OSLockMutex #define OSLockMutex(mutex) LWP_MutexLock(mutex) #endif #ifndef OSUnlockMutex #define OSUnlockMutex(mutex) LWP_MutexUnlock(mutex) #endif #ifndef OSTryLockMutex #define OSTryLockMutex(mutex) LWP_MutexTryLock(mutex) #endif #ifndef OSInitCond #define OSInitCond(cond) LWP_CondInit(cond) #endif #if 0 #ifndef OSSignalCond #define OSSignalCond(cond) LWP_ThreadSignal(cond) #endif #endif #ifndef OSWaitCond #define OSWaitCond(cond, mutex) LWP_CondWait(cond, mutex) #endif #ifndef OSInitThreadQueue #define OSInitThreadQueue(queue) LWP_InitQueue(queue) #endif #ifndef OSSleepThread #define OSSleepThread(queue) LWP_ThreadSleep(queue) #endif #ifndef OSJoinThread #define OSJoinThread(thread, val) LWP_JoinThread(thread, val) #endif #ifndef OSSignalCond #define OSSignalCond(thread) LWP_CondSignal(thread) #endif #ifndef OSCreateThread #define OSCreateThread(thread, func, intarg, ptrarg, stackbase, stacksize, priority, attrs) LWP_CreateThread(thread, func, ptrarg, stackbase, stacksize, priority) #endif #define STACKSIZE (8 * 1024) typedef OSThread pthread_t; typedef mutex_t pthread_mutex_t; typedef void* pthread_mutexattr_t; typedef int pthread_attr_t; typedef OSCond pthread_cond_t; typedef OSCond pthread_condattr_t; static INLINE int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg) { *thread = 0; return OSCreateThread(thread, start_routine, 0 /* unused */, arg, 0, STACKSIZE, 64, 0 /* unused */); } static INLINE int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr) { return OSInitMutex(mutex); } static INLINE int pthread_mutex_destroy(pthread_mutex_t *mutex) { return LWP_MutexDestroy(*mutex); } static INLINE int pthread_mutex_lock(pthread_mutex_t *mutex) { return OSLockMutex(*mutex); } static INLINE int pthread_mutex_unlock(pthread_mutex_t *mutex) { return OSUnlockMutex(*mutex); } static INLINE void pthread_exit(void *retval) { /* FIXME: No LWP equivalent for this? */ (void)retval; } static INLINE int pthread_detach(pthread_t thread) { /* FIXME: pthread_detach equivalent missing? */ (void)thread; return 0; } static INLINE int pthread_join(pthread_t thread, void **retval) { return OSJoinThread(thread, retval); } static INLINE int pthread_mutex_trylock(pthread_mutex_t *mutex) { return OSTryLockMutex(*mutex); } static INLINE int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) { return OSWaitCond(*cond, *mutex); } static INLINE int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime) { return LWP_CondTimedWait(*cond, *mutex, abstime); } static INLINE int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) { return OSInitCond(cond); } static INLINE int pthread_cond_signal(pthread_cond_t *cond) { OSSignalCond(*cond); return 0; } static INLINE int pthread_cond_broadcast(pthread_cond_t *cond) { return LWP_CondBroadcast(*cond); } static INLINE int pthread_cond_destroy(pthread_cond_t *cond) { return LWP_CondDestroy(*cond); } #endif mednafen/FileStream.h000664 001750 001750 00000002676 12726204343 015701 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 */ // TODO/WIP #ifndef __MDFN_FILESTREAM_H #define __MDFN_FILESTREAM_H #include #include #include "Stream.h" class FileStream : public Stream { public: FileStream(const char *path, const int mode); virtual ~FileStream(); virtual uint64_t attributes(void); virtual uint64_t read(void *data, uint64_t count, bool error_on_eos = true); virtual void write(const void *data, uint64_t count); virtual void seek(int64_t offset, int whence); virtual int64_t tell(void); virtual int64_t size(void); virtual void close(void); private: RFILE *fp; char *original_path; const int OpenedMode; }; #endif msvc/msvc-2010-360/msvc-2010-360.vcxproj000664 001750 001750 00000072306 12726204343 017776 0ustar00sergiosergio000000 000000  CodeAnalysis Xbox 360 Debug Xbox 360 Profile Xbox 360 Profile_FastCap Xbox 360 Release Xbox 360 Release_LTCG Xbox 360 CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsC CompileAsCpp CompileAsCpp CompileAsCpp CompileAsCpp CompileAsCpp CompileAsCpp {38462FE9-E3FC-4336-B241-50F5599C537B} Xbox360Proj StaticLibrary MultiByte StaticLibrary MultiByte StaticLibrary MultiByte StaticLibrary MultiByte StaticLibrary MultiByte StaticLibrary true MultiByte $(OutDir)msvc-2010-360$(TargetExt) $(OutDir)msvc-2010-360$(TargetExt) $(OutDir)msvc-2010-360$(TargetExt) $(OutDir)msvc-2010-360$(TargetExt) $(OutDir)msvc-2010-360$(TargetExt) $(OutDir)msvc-2010-360$(TargetExt) NotUsing Level3 ProgramDatabase Disabled false true false $(OutDir)$(ProjectName).pch MultiThreadedDebug _DEBUG;_XBOX;_LIB;MSB_FIRST;WANT_PCE_FAST_EMU;WANT_16BPP;SIZEOF_DOUBLE=8;MEDNAFEN_VERSION=0.9.26;MPC_FIXED_POINT;__LIBRETRO__;_LOW_ACCURACY;WANT_STEREO_SOUND;FRONTEND_SUPPORTS_RGB565;PSS_STYLE=2;MEDNAFEN_VERSION_NUMERIC=926;BYTE_ORDER=1;NEED_CD;WANT_CRC32;%(PreprocessorDefinitions);WANT_THREADING;WANT_NEW_API Callcap $(SolutionDir)\..\..\;$(SolutionDir)\..\..\mednafen;$(SolutionDir)\..\..\mednafen\cdrom;$(SolutionDir)\..\..\mednafen\include;$(SolutionDir)\..\..\mednafen\sound;$(SolutionDir)\..\..\mednafen\ngp;%(AdditionalIncludeDirectories) true NotUsing Level4 ProgramDatabase Disabled false true AnalyzeOnly false $(OutDir)$(ProjectName).pch MultiThreadedDebug _DEBUG;_XBOX;_LIB;MSB_FIRST;WANT_PCE_FAST_EMU;WANT_16BPP;SIZEOF_DOUBLE=8;MEDNAFEN_VERSION=0.9.26;MPC_FIXED_POINT;__LIBRETRO__;_LOW_ACCURACY;WANT_STEREO_SOUND;FRONTEND_SUPPORTS_RGB565;PSS_STYLE=2;MEDNAFEN_VERSION_NUMERIC=926;BYTE_ORDER=1;NEED_CD;WANT_CRC32;%(PreprocessorDefinitions);WANT_THREADING;WANT_NEW_API Callcap $(SolutionDir)\..\..\;$(SolutionDir)\..\..\mednafen;$(SolutionDir)\..\..\mednafen\cdrom;$(SolutionDir)\..\..\mednafen\include;$(SolutionDir)\..\..\mednafen\sound;$(SolutionDir)\..\..\mednafen\ngp;%(AdditionalIncludeDirectories) true Level3 NotUsing Full true false true ProgramDatabase Size false $(OutDir)$(ProjectName).pch MultiThreaded NDEBUG;_XBOX;PROFILE;_LIB;MSB_FIRST;WANT_PCE_FAST_EMU;WANT_16BPP;SIZEOF_DOUBLE=8;MEDNAFEN_VERSION=0.9.26;MPC_FIXED_POINT;__LIBRETRO__;_LOW_ACCURACY;WANT_STEREO_SOUND;FRONTEND_SUPPORTS_RGB565;PSS_STYLE=2;MEDNAFEN_VERSION_NUMERIC=926;BYTE_ORDER=1;NEED_CD;WANT_CRC32;%(PreprocessorDefinitions);WANT_THREADING;WANT_NEW_API Callcap $(SolutionDir)\..\..\;$(SolutionDir)\..\..\mednafen;$(SolutionDir)\..\..\mednafen\cdrom;$(SolutionDir)\..\..\mednafen\include;$(SolutionDir)\..\..\mednafen\sound;$(SolutionDir)\..\..\mednafen\ngp;%(AdditionalIncludeDirectories) true false xapilib.lib;%(IgnoreSpecificDefaultLibraries) true Level3 NotUsing Full true false true ProgramDatabase Fastcap Size false $(OutDir)$(ProjectName).pch MultiThreaded NDEBUG;_XBOX;PROFILE;FASTCAP;_LIB;MSB_FIRST;WANT_PCE_FAST_EMU;WANT_16BPP;SIZEOF_DOUBLE=8;MEDNAFEN_VERSION=0.9.26;MPC_FIXED_POINT;__LIBRETRO__;_LOW_ACCURACY;WANT_STEREO_SOUND;FRONTEND_SUPPORTS_RGB565;PSS_STYLE=2;MEDNAFEN_VERSION_NUMERIC=926;BYTE_ORDER=1;NEED_CD;WANT_CRC32;%(PreprocessorDefinitions);WANT_THREADING;WANT_NEW_API $(SolutionDir)\..\..\;$(SolutionDir)\..\..\mednafen;$(SolutionDir)\..\..\mednafen\cdrom;$(SolutionDir)\..\..\mednafen\include;$(SolutionDir)\..\..\mednafen\sound;$(SolutionDir)\..\..\mednafen\ngp;$(SolutionDir)\..\..\mednafen\hw_misc;%(AdditionalIncludeDirectories) true false true Level3 NotUsing Full true true ProgramDatabase Size false false $(OutDir)$(ProjectName).pch MultiThreaded NDEBUG;_XBOX;_LIB;MSB_FIRST;WANT_PCE_FAST_EMU;WANT_16BPP;SIZEOF_DOUBLE=8;MEDNAFEN_VERSION=0.9.26;MPC_FIXED_POINT;__LIBRETRO__;_LOW_ACCURACY;WANT_STEREO_SOUND;FRONTEND_SUPPORTS_RGB565;PSS_STYLE=2;MEDNAFEN_VERSION_NUMERIC=926;BYTE_ORDER=1;NEED_CD;WANT_CRC32;%(PreprocessorDefinitions);WANT_THREADING;WANT_NEW_API $(SolutionDir)\..\..\;$(SolutionDir)\..\..\mednafen;$(SolutionDir)\..\..\mednafen\cdrom;$(SolutionDir)\..\..\mednafen\include;$(SolutionDir)\..\..\mednafen\sound;$(SolutionDir)\..\..\mednafen\ngp;$(SolutionDir)\..\..\mednafen\hw_misc;%(AdditionalIncludeDirectories) true true true Level3 NotUsing Full true true ProgramDatabase Size false false $(OutDir)$(ProjectName).pch MultiThreaded NDEBUG;_XBOX;LTCG;_LIB;MSB_FIRST;WANT_PCE_FAST_EMU;WANT_16BPP;SIZEOF_DOUBLE=8;MEDNAFEN_VERSION=0.9.26;MPC_FIXED_POINT;__LIBRETRO__;_LOW_ACCURACY;WANT_STEREO_SOUND;FRONTEND_SUPPORTS_RGB565;PSS_STYLE=2;MEDNAFEN_VERSION_NUMERIC=926;BYTE_ORDER=1;NEED_CD;WANT_CRC32;%(PreprocessorDefinitions);WANT_THREADING;WANT_NEW_API $(SolutionDir)\..\..\;$(SolutionDir)\..\..\mednafen;$(SolutionDir)\..\..\mednafen\cdrom;$(SolutionDir)\..\..\mednafen\include;$(SolutionDir)\..\..\mednafen\sound;$(SolutionDir)\..\..\mednafen\ngp;$(SolutionDir)\..\..\mednafen\hw_misc;%(AdditionalIncludeDirectories) true true true scrc32.h000664 001750 001750 00000000310 12726204343 013147 0ustar00sergiosergio000000 000000 #ifndef _S_CRC32_H #define _S_CRC32_H #ifdef __cplusplus extern "C" { #endif unsigned long crc32(unsigned long crc, const unsigned char *buf, unsigned int len); #ifdef __cplusplus } #endif #endif mednafen/settings.h000755 001750 001750 00000001323 12726204343 015473 0ustar00sergiosergio000000 000000 #ifndef MDFN_SETTINGS_H #define MDFN_SETTINGS_H #include extern int setting_initial_scanline; extern int setting_last_scanline; extern int setting_pce_fast_nospritelimit; extern int setting_pce_fast_cddavolume; extern int setting_pce_fast_adpcmvolume; extern int setting_pce_fast_cdpsgvolume; extern uint32_t setting_pce_fast_cdspeed; extern uint32_t setting_pce_keepaspect; // This should assert() or something if the setting isn't found, since it would // be a totally tubular error! uint64 MDFN_GetSettingUI(const char *name); int64 MDFN_GetSettingI(const char *name); double MDFN_GetSettingF(const char *name); bool MDFN_GetSettingB(const char *name); std::string MDFN_GetSettingS(const char *name); #endif msvc/msvc-2010.bat000664 001750 001750 00000007745 12726204343 014712 0ustar00sergiosergio000000 000000 @echo off @echo Setting environment for using Microsoft Visual Studio 2010 x86 tools. @call :GetVSCommonToolsDir @if "%VS100COMNTOOLS%"=="" goto error_no_VS100COMNTOOLSDIR @call "%VS100COMNTOOLS%VCVarsQueryRegistry.bat" 32bit No64bit @if "%VSINSTALLDIR%"=="" goto error_no_VSINSTALLDIR @if "%FrameworkDir32%"=="" goto error_no_FrameworkDIR32 @if "%FrameworkVersion32%"=="" goto error_no_FrameworkVer32 @if "%Framework35Version%"=="" goto error_no_Framework35Version @set FrameworkDir=%FrameworkDir32% @set FrameworkVersion=%FrameworkVersion32% @if not "%WindowsSdkDir%" == "" ( @set "PATH=%WindowsSdkDir%bin\NETFX 4.0 Tools;%WindowsSdkDir%bin;%PATH%" @set "INCLUDE=%WindowsSdkDir%include;%INCLUDE%" @set "LIB=%WindowsSdkDir%lib;%LIB%" ) @rem @rem Root of Visual Studio IDE installed files. @rem @set DevEnvDir=%VSINSTALLDIR%Common7\IDE\ @rem PATH @rem ---- @if exist "%VSINSTALLDIR%Team Tools\Performance Tools" ( @set "PATH=%VSINSTALLDIR%Team Tools\Performance Tools;%PATH%" ) @if exist "%ProgramFiles%\HTML Help Workshop" set PATH=%ProgramFiles%\HTML Help Workshop;%PATH% @if exist "%ProgramFiles(x86)%\HTML Help Workshop" set PATH=%ProgramFiles(x86)%\HTML Help Workshop;%PATH% @if exist "%VCINSTALLDIR%VCPackages" set PATH=%VCINSTALLDIR%VCPackages;%PATH% @set PATH=%FrameworkDir%%Framework35Version%;%PATH% @set PATH=%FrameworkDir%%FrameworkVersion%;%PATH% @set PATH=%VSINSTALLDIR%Common7\Tools;%PATH% @if exist "%VCINSTALLDIR%BIN" set PATH=%VCINSTALLDIR%BIN;%PATH% @set PATH=%DevEnvDir%;%PATH% @if exist "%VSINSTALLDIR%VSTSDB\Deploy" ( @set "PATH=%VSINSTALLDIR%VSTSDB\Deploy;%PATH%" ) @if not "%FSHARPINSTALLDIR%" == "" ( @set "PATH=%FSHARPINSTALLDIR%;%PATH%" ) @rem INCLUDE @rem ------- @if exist "%VCINSTALLDIR%ATLMFC\INCLUDE" set INCLUDE=%VCINSTALLDIR%ATLMFC\INCLUDE;%INCLUDE% @if exist "%VCINSTALLDIR%INCLUDE" set INCLUDE=%VCINSTALLDIR%INCLUDE;%INCLUDE% @rem LIB @rem --- @if exist "%VCINSTALLDIR%ATLMFC\LIB" set LIB=%VCINSTALLDIR%ATLMFC\LIB;%LIB% @if exist "%VCINSTALLDIR%LIB" set LIB=%VCINSTALLDIR%LIB;%LIB% @rem LIBPATH @rem ------- @if exist "%VCINSTALLDIR%ATLMFC\LIB" set LIBPATH=%VCINSTALLDIR%ATLMFC\LIB;%LIBPATH% @if exist "%VCINSTALLDIR%LIB" set LIBPATH=%VCINSTALLDIR%LIB;%LIBPATH% @set LIBPATH=%FrameworkDir%%Framework35Version%;%LIBPATH% @set LIBPATH=%FrameworkDir%%FrameworkVersion%;%LIBPATH% @goto end @REM ----------------------------------------------------------------------- :GetVSCommonToolsDir @set VS100COMNTOOLS= @call :GetVSCommonToolsDirHelper32 HKLM > nul 2>&1 @if errorlevel 1 call :GetVSCommonToolsDirHelper32 HKCU > nul 2>&1 @if errorlevel 1 call :GetVSCommonToolsDirHelper64 HKLM > nul 2>&1 @if errorlevel 1 call :GetVSCommonToolsDirHelper64 HKCU > nul 2>&1 @exit /B 0 :GetVSCommonToolsDirHelper32 @for /F "tokens=1,2*" %%i in ('reg query "%1\SOFTWARE\Microsoft\VisualStudio\SxS\VS7" /v "10.0"') DO ( @if "%%i"=="10.0" ( @SET "VS100COMNTOOLS=%%k" ) ) @if "%VS100COMNTOOLS%"=="" exit /B 1 @SET "VS100COMNTOOLS=%VS100COMNTOOLS%Common7\Tools\" @exit /B 0 :GetVSCommonToolsDirHelper64 @for /F "tokens=1,2*" %%i in ('reg query "%1\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\SxS\VS7" /v "10.0"') DO ( @if "%%i"=="10.0" ( @SET "VS100COMNTOOLS=%%k" ) ) @if "%VS100COMNTOOLS%"=="" exit /B 1 @SET "VS100COMNTOOLS=%VS100COMNTOOLS%Common7\Tools\" @exit /B 0 @REM ----------------------------------------------------------------------- :error_no_VS100COMNTOOLSDIR @echo ERROR: Cannot determine the location of the VS Common Tools folder. @goto end :error_no_VSINSTALLDIR @echo ERROR: Cannot determine the location of the VS installation. @goto end :error_no_FrameworkDIR32 @echo ERROR: Cannot determine the location of the .NET Framework 32bit installation. @goto end :error_no_FrameworkVer32 @echo ERROR: Cannot determine the version of the .NET Framework 32bit installation. @goto end :error_no_Framework35Version @echo ERROR: Cannot determine the .NET Framework 3.5 version. @goto end :end msbuild msvc-2010.sln /p:Configuration=Release /target:clean msbuild msvc-2010.sln /p:Configuration=Release exit libretro-common/rthreads/async_job.c000664 001750 001750 00000006745 12726204343 020760 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2015 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (async_job.c). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include #include #include #include typedef struct async_job_node async_job_node_t; struct async_job_node { async_task_t task; void *payload; async_job_node_t *next; }; struct async_job { async_job_node_t *first; async_job_node_t *last; volatile int finish; slock_t *lock; ssem_t *sem; sthread_t* thread; }; static void async_job_processor(void *userdata) { async_job_node_t *node = NULL; async_job_t *ajob = (async_job_t*)userdata; for (;;) { ssem_wait(ajob->sem); if (ajob->finish) return; slock_lock(ajob->lock); node = ajob->first; ajob->first = node->next; slock_unlock(ajob->lock); node->task(node->payload); free((void*)node); } } async_job_t *async_job_new(void) { async_job_t *ajob = (async_job_t*)calloc(1, sizeof(*ajob)); if (!ajob) return NULL; ajob->lock = slock_new(); if (!ajob->lock) goto error; ajob->sem = ssem_new(0); if (!ajob->sem) goto error; ajob->thread = sthread_create(async_job_processor, (void*)ajob); if (!ajob->thread) goto error; return ajob; error: if (ajob->lock) slock_free(ajob->lock); ajob->lock = NULL; if (ajob->sem) ssem_free(ajob->sem); if (ajob) free((void*)ajob); return NULL; } void async_job_free(async_job_t *ajob) { if (!ajob) return; ajob->finish = 1; ssem_signal(ajob->sem); sthread_join(ajob->thread); ssem_free(ajob->sem); free((void*)ajob); } int async_job_add(async_job_t *ajob, async_task_t task, void *payload) { async_job_node_t *node; if (!ajob) return -1; node = (async_job_node_t*)calloc(1, sizeof(*node)); if (!node) return -1; node->task = task; node->payload = payload; slock_lock(ajob->lock); if (ajob->first) { ajob->last->next = node; ajob->last = node; } else ajob->first = ajob->last = node; slock_unlock(ajob->lock); ssem_signal(ajob->sem); return 0; } jni/Application.mk000664 001750 001750 00000000051 12726204343 015255 0ustar00sergiosergio000000 000000 APP_STL := gnustl_static APP_ABI := all mednafen/tremor/os_types.h000664 001750 001750 00000010257 12726204343 017015 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * by the Xiph.Org Foundation http://www.xiph.org/ * * * ******************************************************************** function: #ifdef jail to whip a few platforms into the UNIX ideal. last mod: $Id: os_types.h 17712 2010-12-03 17:10:02Z xiphmont $ ********************************************************************/ #ifndef _OS_TYPES_H #define _OS_TYPES_H /* make it easy on the folks that want to compile the libs with a different malloc than stdlib */ #define _ogg_malloc malloc #define _ogg_calloc calloc #define _ogg_realloc realloc #define _ogg_free free #if defined(_WIN32) # if defined(__CYGWIN__) # include typedef int16_t ogg_int16_t; typedef uint16_t ogg_uint16_t; typedef int32_t ogg_int32_t; typedef uint32_t ogg_uint32_t; typedef int64_t ogg_int64_t; typedef uint64_t ogg_uint64_t; # elif defined(__MINGW32__) # include typedef short ogg_int16_t; typedef unsigned short ogg_uint16_t; typedef int ogg_int32_t; typedef unsigned int ogg_uint32_t; typedef long long ogg_int64_t; typedef unsigned long long ogg_uint64_t; # elif defined(__MWERKS__) typedef long long ogg_int64_t; typedef int ogg_int32_t; typedef unsigned int ogg_uint32_t; typedef short ogg_int16_t; typedef unsigned short ogg_uint16_t; # else /* MSVC/Borland */ typedef __int64 ogg_int64_t; typedef __int32 ogg_int32_t; typedef unsigned __int32 ogg_uint32_t; typedef __int16 ogg_int16_t; typedef unsigned __int16 ogg_uint16_t; # endif #elif defined(__MACOS__) # include typedef SInt16 ogg_int16_t; typedef UInt16 ogg_uint16_t; typedef SInt32 ogg_int32_t; typedef UInt32 ogg_uint32_t; typedef SInt64 ogg_int64_t; #elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */ # include typedef int16_t ogg_int16_t; typedef uint16_t ogg_uint16_t; typedef int32_t ogg_int32_t; typedef uint32_t ogg_uint32_t; typedef int64_t ogg_int64_t; #elif defined(__HAIKU__) /* Haiku */ # include typedef short ogg_int16_t; typedef unsigned short ogg_uint16_t; typedef int ogg_int32_t; typedef unsigned int ogg_uint32_t; typedef long long ogg_int64_t; #elif defined(__BEOS__) /* Be */ # include typedef int16_t ogg_int16_t; typedef uint16_t ogg_uint16_t; typedef int32_t ogg_int32_t; typedef uint32_t ogg_uint32_t; typedef int64_t ogg_int64_t; #elif defined (__EMX__) /* OS/2 GCC */ typedef short ogg_int16_t; typedef unsigned short ogg_uint16_t; typedef int ogg_int32_t; typedef unsigned int ogg_uint32_t; typedef long long ogg_int64_t; #elif defined (DJGPP) /* DJGPP */ typedef short ogg_int16_t; typedef int ogg_int32_t; typedef unsigned int ogg_uint32_t; typedef long long ogg_int64_t; #elif defined(R5900) /* PS2 EE */ typedef long ogg_int64_t; typedef int ogg_int32_t; typedef unsigned ogg_uint32_t; typedef short ogg_int16_t; #elif defined(__SYMBIAN32__) /* Symbian GCC */ typedef signed short ogg_int16_t; typedef unsigned short ogg_uint16_t; typedef signed int ogg_int32_t; typedef unsigned int ogg_uint32_t; typedef long long int ogg_int64_t; #elif defined(__TMS320C6X__) /* TI C64x compiler */ typedef signed short ogg_int16_t; typedef unsigned short ogg_uint16_t; typedef signed int ogg_int32_t; typedef unsigned int ogg_uint32_t; typedef long long int ogg_int64_t; #else # include "config_types.h" #endif #endif /* _OS_TYPES_H */ mednafen/tremor/ivorbisfile.h000664 001750 001750 00000011251 12726204343 017460 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: stdio-based convenience library for opening/seeking/decoding ********************************************************************/ #ifndef _OV_FILE_H_ #define _OV_FILE_H_ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ #include #include "ivorbiscodec.h" #define CHUNKSIZE 1024 /* The function prototypes for the callbacks are basically the same as for * the stdio functions fread, fseek, fclose, ftell. * The one difference is that the FILE * arguments have been replaced with * a void * - this is to be used as a pointer to whatever internal data these * functions might need. In the stdio case, it's just a FILE * cast to a void * * * If you use other functions, check the docs for these functions and return * the right values. For seek_func(), you *MUST* return -1 if the stream is * unseekable */ typedef struct { size_t (*read_func) (void *ptr, size_t size, size_t nmemb, void *datasource); int (*seek_func) (void *datasource, ogg_int64_t offset, int whence); int (*close_func) (void *datasource); long (*tell_func) (void *datasource); } ov_callbacks; #define NOTOPEN 0 #define PARTOPEN 1 #define OPENED 2 #define STREAMSET 3 #define INITSET 4 typedef struct OggVorbis_File { void *datasource; /* Pointer to a FILE *, etc. */ int seekable; ogg_int64_t offset; ogg_int64_t end; ogg_sync_state oy; /* If the FILE handle isn't seekable (eg, a pipe), only the current stream appears */ int links; ogg_int64_t *offsets; ogg_int64_t *dataoffsets; ogg_uint32_t *serialnos; ogg_int64_t *pcmlengths; vorbis_info *vi; vorbis_comment *vc; /* Decoding working state local storage */ ogg_int64_t pcm_offset; int ready_state; ogg_uint32_t current_serialno; int current_link; ogg_int64_t bittrack; ogg_int64_t samptrack; ogg_stream_state os; /* take physical pages, weld into a logical stream of packets */ vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */ vorbis_block vb; /* local working space for packet->PCM decode */ ov_callbacks callbacks; } OggVorbis_File; extern int ov_clear(OggVorbis_File *vf); extern int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes); extern int ov_open_callbacks(void *datasource, OggVorbis_File *vf, const char *initial, long ibytes, ov_callbacks callbacks); extern int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes); extern int ov_test_callbacks(void *datasource, OggVorbis_File *vf, const char *initial, long ibytes, ov_callbacks callbacks); extern int ov_test_open(OggVorbis_File *vf); extern long ov_bitrate(OggVorbis_File *vf,int i); extern long ov_bitrate_instant(OggVorbis_File *vf); extern long ov_streams(OggVorbis_File *vf); extern long ov_seekable(OggVorbis_File *vf); extern long ov_serialnumber(OggVorbis_File *vf,int i); extern ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i); extern ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i); extern ogg_int64_t ov_time_total(OggVorbis_File *vf,int i); extern int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos); extern int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos); extern int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos); extern int ov_time_seek(OggVorbis_File *vf,ogg_int64_t pos); extern int ov_time_seek_page(OggVorbis_File *vf,ogg_int64_t pos); extern ogg_int64_t ov_raw_tell(OggVorbis_File *vf); extern ogg_int64_t ov_pcm_tell(OggVorbis_File *vf); extern ogg_int64_t ov_time_tell(OggVorbis_File *vf); extern vorbis_info *ov_info(OggVorbis_File *vf,int link); extern vorbis_comment *ov_comment(OggVorbis_File *vf,int link); extern long ov_read(OggVorbis_File *vf,char *buffer,int length, int *bitstream); #ifdef __cplusplus } #endif /* __cplusplus */ #endif thread/000700 001750 001750 00000000000 12727366154 013152 5ustar00sergiosergio000000 000000 msvc/msvc-2010-360/000700 001750 001750 00000000000 12727366154 014511 5ustar00sergiosergio000000 000000 libretro-common/include/compat/posix_string.h000664 001750 001750 00000004155 12726204343 022631 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (posix_string.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_COMPAT_POSIX_STRING_H #define __LIBRETRO_SDK_COMPAT_POSIX_STRING_H #ifdef _MSC_VER #include #endif #ifdef __cplusplus extern "C" { #endif #ifdef _WIN32 #undef strtok_r #define strtok_r(str, delim, saveptr) retro_strtok_r__(str, delim, saveptr) char *strtok_r(char *str, const char *delim, char **saveptr); #endif #ifdef _MSC_VER #undef strcasecmp #undef strdup #define strcasecmp(a, b) retro_strcasecmp__(a, b) #define strdup(orig) retro_strdup__(orig) int strcasecmp(const char *a, const char *b); char *strdup(const char *orig); /* isblank is available since MSVC 2013 */ #if _MSC_VER < 1800 #undef isblank #define isblank(c) retro_isblank__(c) int isblank(int c); #endif #endif #ifdef __cplusplus } #endif #endif mednafen/tremor/configure.in000664 001750 001750 00000007313 12726204343 017307 0ustar00sergiosergio000000 000000 dnl Process this file with autoconf to produce a configure script dnl ------------------------------------------------ dnl Initialization and Versioning dnl ------------------------------------------------ AC_INIT(mdct.c) AC_CANONICAL_HOST AC_CANONICAL_TARGET AM_CONFIG_HEADER([config.h]) AM_INIT_AUTOMAKE(libvorbisidec,1.2.1) dnl AM_MAINTAINER_MODE only provides the option to configure to enable it AM_MAINTAINER_MODE dnl Library versioning V_LIB_CURRENT=1 V_LIB_REVISION=3 V_LIB_AGE=0 AC_SUBST(V_LIB_CURRENT) AC_SUBST(V_LIB_REVISION) AC_SUBST(V_LIB_AGE) dnl -------------------------------------------------- dnl Check for programs dnl -------------------------------------------------- dnl save $CFLAGS since AC_PROG_CC likes to insert "-g -O2" dnl if $CFLAGS is blank cflags_save="$CFLAGS" AC_PROG_CC AC_PROG_CPP CFLAGS="$cflags_save" AM_PROG_LIBTOOL dnl -------------------------------------------------- dnl Set build flags based on environment dnl -------------------------------------------------- dnl Set some target options cflags_save="$CFLAGS" ldflags_save="$LDFLAGS" if test -z "$GCC"; then case $host in arm-*-*) DEBUG="-g -D_ARM_ASSEM_" CFLAGS="-O -D_ARM_ASSEM_" PROFILE="-p -g -O -D_ARM_ASSEM_" ;; *) DEBUG="-g" CFLAGS="-O" PROFILE="-g -p" ;; esac else case $host in arm-*-*) DEBUG="-g -Wall -D__NO_MATH_INLINES -fsigned-char -D_ARM_ASSEM_" CFLAGS="-O2 -D_ARM_ASSEM_ -fsigned-char" PROFILE="-W -pg -g -O2 -D_ARM_ASSEM_ -fsigned-char -fno-inline-functions";; *) DEBUG="-g -Wall -D__NO_MATH_INLINES -fsigned-char" CFLAGS="-O2 -Wall -fsigned-char" PROFILE="-Wall -pg -g -O2 -fsigned-char -fno-inline-functions";; esac fi CFLAGS="$CFLAGS $cflags_save -D_REENTRANT" LDFLAGS="$LDFLAGS $ldflags_save" # Test whenever ld supports -version-script AC_PROG_LD AC_PROG_LD_GNU if test "x$lt_cv_prog_gnu_ld" = "xyes"; then SHLIB_VERSION_ARG="-Wl,--version-script=Version_script" LDFLAGS="$LDFLAGS $SHLIB_VERSION_ARG" fi dnl -------------------------------------------------- dnl Options dnl -------------------------------------------------- AC_ARG_ENABLE( low-accuracy, [ --enable-low-accuracy enable 32 bit only multiply operations], CFLAGS="$CFLAGS -D_LOW_ACCURACY_" ) dnl -------------------------------------------------- dnl Check for headers dnl -------------------------------------------------- AC_CHECK_HEADER(memory.h,CFLAGS="$CFLAGS -DUSE_MEMORY_H",:) dnl -------------------------------------------------- dnl Check for typedefs, structures, etc dnl -------------------------------------------------- dnl none dnl -------------------------------------------------- dnl Check for libraries dnl -------------------------------------------------- PKG_PROG_PKG_CONFIG HAVE_OGG=no if test "x$PKG_CONFIG" != "x" then PKG_CHECK_MODULES(OGG, ogg >= 1.0, HAVE_OGG=yes, HAVE_OGG=no) fi if test "x$HAVE_OGG" = "xno" then dnl fall back to the old school test XIPH_PATH_OGG(, AC_MSG_ERROR(must have Ogg installed!)) libs_save=$LIBS LIBS="$OGG_LIBS" AC_CHECK_FUNC(oggpack_writealign, , AC_MSG_ERROR(Ogg >= 1.0 required !)) LIBS=$libs_save fi dnl -------------------------------------------------- dnl Check for library functions dnl -------------------------------------------------- AC_FUNC_ALLOCA AC_FUNC_MEMCMP dnl -------------------------------------------------- dnl Do substitutions dnl -------------------------------------------------- LIBS="$LIBS" AC_SUBST(LIBS) AC_SUBST(DEBUG) AC_SUBST(PROFILE) AC_OUTPUT(Makefile Version_script vorbisidec.pc) libretro-common/include/rthreads/rthreads.h000664 001750 001750 00000012340 12726204343 022241 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2015 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (rthreads.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_RTHREADS_H__ #define __LIBRETRO_SDK_RTHREADS_H__ #include #include #include #include #if defined(__cplusplus) && !defined(_MSC_VER) extern "C" { #endif typedef struct sthread sthread_t; typedef struct slock slock_t; typedef struct scond scond_t; /** * sthread_create: * @start_routine : thread entry callback function * @userdata : pointer to userdata that will be made * available in thread entry callback function * * Create a new thread. * * Returns: pointer to new thread if successful, otherwise NULL. */ sthread_t *sthread_create(void (*thread_func)(void*), void *userdata); /** * sthread_detach: * @thread : pointer to thread object * * Detach a thread. When a detached thread terminates, its * resource sare automatically released back to the system * without the need for another thread to join with the * terminated thread. * * Returns: 0 on success, otherwise it returns a non-zero error number. */ int sthread_detach(sthread_t *thread); /** * sthread_join: * @thread : pointer to thread object * * Join with a terminated thread. Waits for the thread specified by * @thread to terminate. If that thread has already terminated, then * it will return immediately. The thread specified by @thread must * be joinable. * * Returns: 0 on success, otherwise it returns a non-zero error number. */ void sthread_join(sthread_t *thread); /** * slock_new: * * Create and initialize a new mutex. Must be manually * freed. * * Returns: pointer to a new mutex if successful, otherwise NULL. **/ slock_t *slock_new(void); /** * slock_free: * @lock : pointer to mutex object * * Frees a mutex. **/ void slock_free(slock_t *lock); /** * slock_lock: * @lock : pointer to mutex object * * Locks a mutex. If a mutex is already locked by * another thread, the calling thread shall block until * the mutex becomes available. **/ void slock_lock(slock_t *lock); /** * slock_unlock: * @lock : pointer to mutex object * * Unlocks a mutex. **/ void slock_unlock(slock_t *lock); /** * scond_new: * * Creates and initializes a condition variable. Must * be manually freed. * * Returns: pointer to new condition variable on success, * otherwise NULL. **/ scond_t *scond_new(void); /** * scond_free: * @cond : pointer to condition variable object * * Frees a condition variable. **/ void scond_free(scond_t *cond); /** * scond_wait: * @cond : pointer to condition variable object * @lock : pointer to mutex object * * Block on a condition variable (i.e. wait on a condition). **/ void scond_wait(scond_t *cond, slock_t *lock); /** * scond_wait_timeout: * @cond : pointer to condition variable object * @lock : pointer to mutex object * @timeout_us : timeout (in microseconds) * * Try to block on a condition variable (i.e. wait on a condition) until * @timeout_us elapses. * * Returns: false (0) if timeout elapses before condition variable is * signaled or broadcast, otherwise true (1). **/ bool scond_wait_timeout(scond_t *cond, slock_t *lock, int64_t timeout_us); /** * scond_broadcast: * @cond : pointer to condition variable object * * Broadcast a condition. Unblocks all threads currently blocked * on the specified condition variable @cond. **/ int scond_broadcast(scond_t *cond); /** * scond_signal: * @cond : pointer to condition variable object * * Signal a condition. Unblocks at least one of the threads currently blocked * on the specified condition variable @cond. **/ void scond_signal(scond_t *cond); #if defined(__cplusplus) && !defined(_MSC_VER) } #endif #endif mednafen/settings.cpp000755 001750 001750 00000010232 12726204343 016025 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "mednafen.h" #include #include #include #include "settings.h" int setting_initial_scanline = 0; int setting_last_scanline = 242; int setting_pce_fast_nospritelimit = 0; int setting_pce_fast_cddavolume = 100; int setting_pce_fast_adpcmvolume = 100; int setting_pce_fast_cdpsgvolume = 100; uint32_t setting_pce_fast_cdspeed = 1; uint32_t setting_pce_keepaspect = 1; uint64 MDFN_GetSettingUI(const char *name) { if (!strcmp("pce_fast.cddavolume", name)) return setting_pce_fast_cddavolume; if (!strcmp("pce_fast.adpcmvolume", name)) return setting_pce_fast_adpcmvolume; if (!strcmp("pce_fast.cdpsgvolume", name)) return setting_pce_fast_cdpsgvolume; if (!strcmp("pce_fast.cdspeed", name)) return setting_pce_fast_cdspeed; if (!strcmp("pce_fast.ocmultiplier", name)) /* make configurable */ return 1; if (!strcmp("pce_fast.slstart", name)) return setting_initial_scanline; if (!strcmp("pce_fast.slend", name)) return setting_last_scanline; fprintf(stderr, "unhandled setting UI: %s\n", name); return 0; } int64 MDFN_GetSettingI(const char *name) { fprintf(stderr, "unhandled setting I: %s\n", name); return 0; } double MDFN_GetSettingF(const char *name) { fprintf(stderr, "unhandled setting F: %s\n", name); return 0; } bool MDFN_GetSettingB(const char *name) { if (!strcmp("cheats", name)) return 0; /* LIBRETRO */ if (!strcmp("libretro.cd_load_into_ram", name)) return 0; if (!strcmp("pce_fast.input.multitap", name)) return 1; if (!strcmp("pce_fast.arcadecard", name)) return 1; if (!strcmp("pce_fast.nospritelimit", name)) return setting_pce_fast_nospritelimit; if (!strcmp("pce_fast.forcemono", name)) return 0; if (!strcmp("pce_fast.disable_softreset", name)) return 0; if (!strcmp("pce_fast.adpcmlp", name)) return 0; if (!strcmp("pce_fast.correct_aspect", name)) return setting_pce_keepaspect; /* CDROM */ if (!strcmp("cdrom.lec_eval", name)) return 1; /* FILESYS */ if (!strcmp("filesys.untrusted_fip_check", name)) return 0; if (!strcmp("filesys.disablesavegz", name)) return 1; fprintf(stderr, "unhandled setting B: %s\n", name); return 0; } extern std::string retro_base_directory; extern std::string retro_base_name; std::string MDFN_GetSettingS(const char *name) { if (!strcmp("pce_fast.cdbios", name)) return std::string("syscard3.pce"); /* FILESYS */ if (!strcmp("filesys.path_firmware", name)) return retro_base_directory; if (!strcmp("filesys.path_palette", name)) return retro_base_directory; if (!strcmp("filesys.path_sav", name)) return retro_base_directory; if (!strcmp("filesys.path_state", name)) return retro_base_directory; if (!strcmp("filesys.path_cheat", name)) return retro_base_directory; if (!strcmp("filesys.fname_state", name)) return retro_base_name + std::string(".sav"); if (!strcmp("filesys.fname_sav", name)) return retro_base_name + std::string(".bsv"); fprintf(stderr, "unhandled setting S: %s\n", name); return 0; } bool MDFNI_SetSetting(const char *name, const char *value, bool NetplayOverride) { return false; } bool MDFNI_SetSettingB(const char *name, bool value) { return false; } bool MDFNI_SetSettingUI(const char *name, uint64 value) { return false; } void MDFNI_DumpSettingsDef(const char *path) { } msvc/msvc-2003-xbox1/000700 001750 001750 00000000000 12727366154 015244 5ustar00sergiosergio000000 000000 mednafen/include/blip/Blip_Buffer.h000664 001750 001750 00000031130 12726204343 020361 0ustar00sergiosergio000000 000000 // Band-limited sound synthesis buffer // Various changes and hacks for use in Mednafen. #ifdef __GNUC__ #define blip_inline inline __attribute__((always_inline)) #else #define blip_inline inline #endif #include #include // Blip_Buffer 0.4.1 #ifndef BLIP_BUFFER_H #define BLIP_BUFFER_H // Internal typedef int32_t blip_long; typedef uint32_t blip_ulong; typedef int64_t blip_s64; typedef uint64_t blip_u64; // Time unit at source clock rate typedef blip_long blip_time_t; // Output samples are 16-bit signed, with a range of -32768 to 32767 typedef short blip_sample_t; enum { blip_sample_max = 32767 }; class Blip_Buffer { public: typedef const char* blargg_err_t; // Set output sample rate and buffer length in milliseconds (1/1000 sec, defaults // to 1/4 second), then clear buffer. Returns NULL on success, otherwise if there // isn't enough memory, returns error without affecting current buffer setup. blargg_err_t set_sample_rate( long samples_per_sec, int msec_length = 1000 / 4 ); // Set number of source time units per second void clock_rate( long ); // End current time frame of specified duration and make its samples available // (along with any still-unread samples) for reading with read_samples(). Begins // a new time frame at the end of the current frame. void end_frame( blip_time_t time ); // Read at most 'max_samples' out of buffer into 'dest', removing them from from // the buffer. Returns number of samples actually read and removed. If stereo is // true, increments 'dest' one extra time after writing each sample, to allow // easy interleving of two channels into a stereo output buffer. long read_samples( blip_sample_t* dest, long max_samples, int stereo = 0 ); // Additional optional features // Current output sample rate long sample_rate() const; // Length of buffer, in milliseconds int length() const; // Number of source time units per second long clock_rate() const; // Set frequency high-pass filter frequency, where higher values reduce bass more void bass_freq( int frequency ); // Number of samples delay from synthesis to samples read out int output_latency() const; // Remove all available samples and clear buffer to silence. If 'entire_buffer' is // false, just clears out any samples waiting rather than the entire buffer. void clear( int entire_buffer = 1 ); // Number of samples available for reading with read_samples() long samples_avail() const; // Remove 'count' samples from those waiting to be read void remove_samples( long count ); // Experimental features // Count number of clocks needed until 'count' samples will be available. // If buffer can't even hold 'count' samples, returns number of clocks until // buffer becomes full. blip_time_t count_clocks( long count ) const; // Number of raw samples that can be mixed within frame of specified duration. long count_samples( blip_time_t duration ) const; // not documented yet void set_modified() { modified_ = 1; } int clear_modified() { int b = modified_; modified_ = 0; return b; } typedef blip_u64 blip_resampled_time_t; void remove_silence( long count ); blip_resampled_time_t resampled_duration( int t ) const { return t * factor_; } blip_resampled_time_t resampled_time( blip_time_t t ) const { return t * factor_ + offset_; } blip_resampled_time_t clock_rate_factor( long clock_rate ) const; public: Blip_Buffer(); ~Blip_Buffer(); // Deprecated typedef blip_resampled_time_t resampled_time_t; blargg_err_t sample_rate( long r ) { return set_sample_rate( r ); } blargg_err_t sample_rate( long r, int msec ) { return set_sample_rate( r, msec ); } private: // noncopyable Blip_Buffer( const Blip_Buffer& ); Blip_Buffer& operator = ( const Blip_Buffer& ); public: typedef blip_time_t buf_t_; blip_u64 factor_; blip_resampled_time_t offset_; buf_t_* buffer_; blip_long buffer_size_; blip_long reader_accum_; int bass_shift_; private: long sample_rate_; long clock_rate_; int bass_freq_; int length_; int modified_; friend class Blip_Reader; }; #ifdef HAVE_CONFIG_H #include "config.h" #endif #define BLIP_BUFFER_ACCURACY 32 #define BLIP_PHASE_BITS 8 // Number of bits in resample ratio fraction. Higher values give a more accurate ratio // but reduce maximum buffer size. //#ifndef BLIP_BUFFER_ACCURACY // #define BLIP_BUFFER_ACCURACY 16 //#endif // Number bits in phase offset. Fewer than 6 bits (64 phase offsets) results in // noticeable broadband noise when synthesizing high frequency square waves. // Affects size of Blip_Synth objects since they store the waveform directly. //#ifndef BLIP_PHASE_BITS // #if BLIP_BUFFER_FAST // #define BLIP_PHASE_BITS 8 // #else // #define BLIP_PHASE_BITS 6 // #endif //#endif // Internal typedef blip_u64 blip_resampled_time_t; int const blip_widest_impulse_ = 16; int const blip_buffer_extra_ = blip_widest_impulse_ + 2; int const blip_res = 1 << BLIP_PHASE_BITS; class blip_eq_t; class Blip_Synth_Fast_ { public: Blip_Buffer* buf; int last_amp; int delta_factor; void volume_unit( double ); Blip_Synth_Fast_(); void treble_eq( blip_eq_t const& ) { } }; class Blip_Synth_ { public: Blip_Buffer* buf; int last_amp; int delta_factor; void volume_unit( double ); Blip_Synth_( short* impulses, int width ); void treble_eq( blip_eq_t const& ); private: double volume_unit_; short* const impulses; int const width; blip_long kernel_unit; int impulses_size() const { return blip_res / 2 * width + 1; } void adjust_impulse(); }; // Quality level. Start with blip_good_quality. const int blip_med_quality = 8; const int blip_good_quality = 12; const int blip_high_quality = 16; // Range specifies the greatest expected change in amplitude. Calculate it // by finding the difference between the maximum and minimum expected // amplitudes (max - min). template class Blip_Synth { public: // Set overall volume of waveform void volume( double v ) { impl.volume_unit( v * (1.0 / (range < 0 ? -range : range)) ); } // Configure low-pass filter (see blip_buffer.txt) void treble_eq( blip_eq_t const& eq ) { impl.treble_eq( eq ); } // Get/set Blip_Buffer used for output Blip_Buffer* output() const { return impl.buf; } void output( Blip_Buffer* b ) { impl.buf = b; impl.last_amp = 0; } // Update amplitude of waveform at given time. Using this requires a separate // Blip_Synth for each waveform. void update( blip_time_t time, int amplitude ); // Low-level interface // Add an amplitude transition of specified delta, optionally into specified buffer // rather than the one set with output(). Delta can be positive or negative. // The actual change in amplitude is delta * (volume / range) void offset( blip_time_t, int delta, Blip_Buffer* ) const; void offset( blip_time_t t, int delta ) const { offset( t, delta, impl.buf ); } // Works directly in terms of fractional output samples. Contact author for more info. void offset_resampled( blip_resampled_time_t, int delta, Blip_Buffer* ) const; // Same as offset(), except code is inlined for higher performance void offset_inline( blip_time_t t, int delta, Blip_Buffer* buf ) const { offset_resampled( t * buf->factor_ + buf->offset_, delta, buf ); } void offset_inline( blip_time_t t, int delta ) const { offset_resampled( t * impl.buf->factor_ + impl.buf->offset_, delta, impl.buf ); } private: Blip_Synth_Fast_ impl; }; // Low-pass equalization parameters class blip_eq_t { public: // Logarithmic rolloff to treble dB at half sampling rate. Negative values reduce // treble, small positive values (0 to 5.0) increase treble. blip_eq_t( double treble_db = 0 ); // See blip_buffer.txt blip_eq_t( double treble, long rolloff_freq, long sample_rate, long cutoff_freq = 0 ); private: double treble; long rolloff_freq; long sample_rate; long cutoff_freq; void generate( float* out, int count ) const; friend class Blip_Synth_; }; int const blip_sample_bits = 30; #define BLIP_RESTRICT // Optimized reading from Blip_Buffer, for use in custom sample output // Begin reading from buffer. Name should be unique to the current block. #define BLIP_READER_BEGIN( name, blip_buffer ) \ const Blip_Buffer::buf_t_* BLIP_RESTRICT name##_reader_buf = (blip_buffer).buffer_;\ blip_long name##_reader_accum = (blip_buffer).reader_accum_ // Get value to pass to BLIP_READER_NEXT() #define BLIP_READER_BASS( blip_buffer ) ((blip_buffer).bass_shift_) // Constant value to use instead of BLIP_READER_BASS(), for slightly more optimal // code at the cost of having no bass control int const blip_reader_default_bass = 9; // Current sample #define BLIP_READER_READ( name ) (name##_reader_accum >> (blip_sample_bits - 16)) // Current raw sample in full internal resolution #define BLIP_READER_READ_RAW( name ) (name##_reader_accum) // Advance to next sample #define BLIP_READER_NEXT( name, bass ) \ (void) (name##_reader_accum += *name##_reader_buf++ - (name##_reader_accum >> (bass))) // End reading samples from buffer. The number of samples read must now be removed // using Blip_Buffer::remove_samples(). #define BLIP_READER_END( name, blip_buffer ) \ (void) ((blip_buffer).reader_accum_ = name##_reader_accum) // Compatibility with older version const long blip_unscaled = 65535; const int blip_low_quality = blip_med_quality; const int blip_best_quality = blip_high_quality; // Deprecated; use BLIP_READER macros as follows: // Blip_Reader r; r.begin( buf ); -> BLIP_READER_BEGIN( r, buf ); // int bass = r.begin( buf ) -> BLIP_READER_BEGIN( r, buf ); int bass = BLIP_READER_BASS( buf ); // r.read() -> BLIP_READER_READ( r ) // r.read_raw() -> BLIP_READER_READ_RAW( r ) // r.next( bass ) -> BLIP_READER_NEXT( r, bass ) // r.next() -> BLIP_READER_NEXT( r, blip_reader_default_bass ) // r.end( buf ) -> BLIP_READER_END( r, buf ) class Blip_Reader { public: int begin( Blip_Buffer& ); blip_long read() const { return accum >> (blip_sample_bits - 16); } blip_long read_raw() const { return accum; } void next( int bass_shift = 9 ) { accum += *buf++ - (accum >> bass_shift); } void end( Blip_Buffer& b ) { b.reader_accum_ = accum; } private: const Blip_Buffer::buf_t_* buf; blip_long accum; }; // End of public interface #include template blip_inline void Blip_Synth::offset_resampled( blip_resampled_time_t time, int delta, Blip_Buffer* blip_buf ) const { // Fails if time is beyond end of Blip_Buffer, due to a bug in caller code or the // need for a longer buffer as set by set_sample_rate(). assert( (blip_long) (time >> BLIP_BUFFER_ACCURACY) < blip_buf->buffer_size_ ); delta *= impl.delta_factor; blip_long* BLIP_RESTRICT buf = blip_buf->buffer_ + (time >> BLIP_BUFFER_ACCURACY); int phase = (int) (time >> (BLIP_BUFFER_ACCURACY - BLIP_PHASE_BITS) & (blip_res - 1)); blip_long left = buf [0] + delta; // Kind of crappy, but doing shift after multiply results in overflow. // Alternate way of delaying multiply by delta_factor results in worse // sub-sample resolution. blip_long right = (delta >> BLIP_PHASE_BITS) * phase; left -= right; right += buf [1]; buf [0] = left; buf [1] = right; } #undef BLIP_FWD #undef BLIP_REV template blip_inline void Blip_Synth::offset( blip_time_t t, int delta, Blip_Buffer* buf ) const { offset_resampled( t * buf->factor_ + buf->offset_, delta, buf ); } template blip_inline void Blip_Synth::update( blip_time_t t, int amp ) { int delta = amp - impl.last_amp; impl.last_amp = amp; offset_resampled( t * impl.buf->factor_ + impl.buf->offset_, delta, impl.buf ); } blip_inline blip_eq_t::blip_eq_t( double t ) : treble( t ), rolloff_freq( 0 ), sample_rate( 44100 ), cutoff_freq( 0 ) { } blip_inline blip_eq_t::blip_eq_t( double t, long rf, long sr, long cf ) : treble( t ), rolloff_freq( rf ), sample_rate( sr ), cutoff_freq( cf ) { } blip_inline int Blip_Buffer::length() const { return length_; } blip_inline long Blip_Buffer::samples_avail() const { return (long) (offset_ >> BLIP_BUFFER_ACCURACY); } blip_inline long Blip_Buffer::sample_rate() const { return sample_rate_; } blip_inline int Blip_Buffer::output_latency() const { return blip_widest_impulse_ / 2; } blip_inline void Blip_Buffer::clock_rate( long cps ) { factor_ = clock_rate_factor( clock_rate_ = cps ); } blip_inline int Blip_Reader::begin( Blip_Buffer& blip_buf ) { buf = blip_buf.buffer_; accum = blip_buf.reader_accum_; return blip_buf.bass_shift_; } int const blip_max_length = 0; int const blip_default_length = 250; #endif mednafen/cdrom/SimpleFIFO.cpp000664 001750 001750 00000000065 12726204343 017170 0ustar00sergiosergio000000 000000 #include "../mednafen.h" #include "SimpleFIFO.h" mednafen/include/blip/000700 001750 001750 00000000000 12727366154 016031 5ustar00sergiosergio000000 000000 Makefile.common000664 001750 001750 00000005534 12726204343 014643 0ustar00sergiosergio000000 000000 SOURCES_CXX := SOURCES_C := LIBRETRO_DIR := $(CORE_DIR)/libretro-common MEDNAFEN_DIR := $(CORE_DIR)/mednafen CORE_EMU_DIR := $(MEDNAFEN_DIR)/pce_fast INCFLAGS := -I$(CORE_DIR) -I$(MEDNAFEN_DIR) -I$(MEDNAFEN_DIR)/include -I$(MEDNAFEN_DIR)/intl -I$(MEDNAFEN_DIR)/hw_sound -I$(MEDNAFEN_DIR)/hw_cpu -I$(MEDNAFEN_DIR)/hw_misc -I$(LIBRETRO_DIR)/include ifneq ($(HAVE_GRIFFIN),1) SOURCES_CXX += \ $(CORE_EMU_DIR)/huc6280.cpp \ $(CORE_EMU_DIR)/input.cpp \ $(CORE_EMU_DIR)/pcecd.cpp \ $(CORE_EMU_DIR)/pcecd_drive.cpp \ $(CORE_EMU_DIR)/psg.cpp \ $(CORE_EMU_DIR)/vdc.cpp \ $(MEDNAFEN_DIR)/hw_misc/arcade_card/arcade_card.cpp endif ifeq ($(NEED_BLIP), 1) SOURCES_CXX += $(MEDNAFEN_DIR)/sound/Blip_Buffer.cpp endif ifeq ($(HAVE_HES), 1) SOURCES_CXX += $(CORE_EMU_DIR)/hes.cpp endif ifeq ($(NEED_THREADING), 1) FLAGS += -DWANT_THREADING endif ifeq ($(NEED_CRC32), 1) FLAGS += -DWANT_CRC32 SOURCES_C += $(CORE_DIR)/scrc32.c endif ifeq ($(NEED_DEINTERLACER), 1) FLAGS += -DNEED_DEINTERLACER endif ifeq ($(IS_X86), 1) FLAGS += -DARCH_X86 endif ifeq ($(NEED_BPP), 8) FLAGS += -DWANT_8BPP endif ifeq ($(NEED_BPP), 16) FLAGS += -DWANT_16BPP endif ifeq ($(NEED_BPP), 32) FLAGS += -DWANT_32BPP endif ifeq ($(WANT_NEW_API), 1) FLAGS += -DWANT_NEW_API endif ifeq ($(NO_COMPUTED_GOTO), 1) FLAGS += -DNO_COMPUTED_GOTO endif ifeq ($(NEED_STEREO_SOUND), 1) FLAGS += -DWANT_STEREO_SOUND endif ifeq ($(FRONTEND_SUPPORTS_RGB565), 1) FLAGS += -DFRONTEND_SUPPORTS_RGB565 endif ifeq ($(CACHE_CD), 1) FLAGS += -D__LIBRETRO_CACHE_CD__ endif ifeq ($(NEED_CD), 1) ifneq ($(HAVE_GRIFFIN),1) SOURCES_CXX += $(MEDNAFEN_DIR)/cdrom/CDAccess.cpp \ $(MEDNAFEN_DIR)/cdrom/CDAccess_Image.cpp \ $(MEDNAFEN_DIR)/cdrom/CDAccess_CCD.cpp \ $(MEDNAFEN_DIR)/cdrom/CDUtility.cpp \ $(MEDNAFEN_DIR)/cdrom/lec.cpp \ $(MEDNAFEN_DIR)/cdrom/SimpleFIFO.cpp \ $(MEDNAFEN_DIR)/cdrom/audioreader.cpp \ $(MEDNAFEN_DIR)/cdrom/galois.cpp \ $(MEDNAFEN_DIR)/cdrom/recover-raw.cpp \ $(MEDNAFEN_DIR)/cdrom/l-ec.cpp \ $(MEDNAFEN_DIR)/cdrom/crc32.cpp \ $(MEDNAFEN_DIR)/cdrom/cdromif.cpp endif FLAGS += -DNEED_CD endif ifeq ($(NEED_TREMOR), 1) SOURCES_C += $(wildcard $(MEDNAFEN_DIR)/tremor/*.c) FLAGS += -DNEED_TREMOR endif ifneq ($(HAVE_GRIFFIN), 1) SOURCES_CXX += \ $(MEDNAFEN_DIR)/error.cpp \ $(MEDNAFEN_DIR)/settings.cpp \ $(MEDNAFEN_DIR)/general.cpp \ $(MEDNAFEN_DIR)/file.cpp \ $(MEDNAFEN_DIR)/FileStream.cpp \ $(MEDNAFEN_DIR)/MemoryStream.cpp \ $(MEDNAFEN_DIR)/Stream.cpp \ $(MEDNAFEN_DIR)/state.cpp \ $(MEDNAFEN_DIR)/mempatcher.cpp \ $(MEDNAFEN_DIR)/okiadpcm.cpp \ $(CORE_DIR)/libretro.cpp SOURCES_C += \ $(MEDNAFEN_DIR)/mednafen-endian.c endif ifneq ($(STATIC_LINKING), 1) SOURCES_C += $(LIBRETRO_DIR)/streams/file_stream.c \ $(LIBRETRO_DIR)/file/retro_stat.c \ $(LIBRETRO_DIR)/string/stdstring.c ifeq ($(NEED_THREADING), 1) SOURCES_C += $(LIBRETRO_DIR)/rthreads/rthreads.c endif endif mednafen/pce_fast/ioread.inc000664 001750 001750 00000006213 12726204343 017206 0ustar00sergiosergio000000 000000 A &= 0x1FFF; #if defined(__GNUC__) || defined(__clang__) || defined(__ICC) || defined(__INTEL_COMPILER) const void * const IOReadHandlers[0x20] = { &&VDC_00, &&VDC_01, &&VDC_02, &&VDC_03, &&VCE_00, &&VCE_01, &&VCE_02, &&VCE_03, &&PSG_00, &&PSG_01, &&PSG_02, &&PSG_03, &&TIMER_00, &&TIMER_01, &&TIMER_02, &&TIMER_03, &&INPUT_00, &&INPUT_01, &&INPUT_02, &&INPUT_03, &&IRQ_00, &&IRQ_01, &&IRQ_02, &&IRQ_03, &&CDROM_00, &&CDROM_01, &&CDROM_02, &&CDROM_03, &&EXP_00, &&EXP_01, &&EXP_02, &&EXP_03 }; goto *IOReadHandlers[((A & 0x1C00) >> 8) | (A & 0x3)]; { #define PCEF_CASEL(label, caseval) label #else #define PCEF_CASEL(label, caseval) case (caseval) switch(((A & 0x1C00) >> 8) | (A & 0x3)) { #endif // // // PCEF_CASEL(VDC_00, 0x00): HuC6280_StealCycle(); return(VDC_Read(0, FALSE)); PCEF_CASEL(VDC_01, 0x01): HuC6280_StealCycle(); return(VDC_Read(1, FALSE)); PCEF_CASEL(VDC_02, 0x02): HuC6280_StealCycle(); return(VDC_Read(2, FALSE)); PCEF_CASEL(VDC_03, 0x03): HuC6280_StealCycle(); return(VDC_Read(3, FALSE)); PCEF_CASEL(VCE_00, 0x04): PCEF_CASEL(VCE_01, 0x05): PCEF_CASEL(VCE_02, 0x06): PCEF_CASEL(VCE_03, 0x07): HuC6280_StealCycle(); return(VCE_Read(A)); PCEF_CASEL(PSG_00, 0x08): PCEF_CASEL(PSG_01, 0x09): PCEF_CASEL(PSG_02, 0x0A): PCEF_CASEL(PSG_03, 0x0B): if(HuCPU.in_block_move) return(0); return(PCEIODataBuffer); PCEF_CASEL(TIMER_00, 0x0C): PCEF_CASEL(TIMER_01, 0x0D): PCEF_CASEL(TIMER_02, 0x0E): PCEF_CASEL(TIMER_03, 0x0F): if(HuCPU.in_block_move) return(0); { uint8 ret = HuC6280_TimerRead(A); PCEIODataBuffer = ret; return(ret); } PCEF_CASEL(INPUT_00, 0x10): PCEF_CASEL(INPUT_01, 0x11): PCEF_CASEL(INPUT_02, 0x12): PCEF_CASEL(INPUT_03, 0x13): if(HuCPU.in_block_move) return(0); { uint8 ret = INPUT_Read(A); PCEIODataBuffer = ret; return(ret); } PCEF_CASEL(IRQ_00, 0x14): PCEF_CASEL(IRQ_01, 0x15): PCEF_CASEL(IRQ_02, 0x16): PCEF_CASEL(IRQ_03, 0x17): if(HuCPU.in_block_move) return(0); { uint8 ret = HuC6280_IRQStatusRead(A); PCEIODataBuffer = ret; return(ret); } PCEF_CASEL(CDROM_00, 0x18): PCEF_CASEL(CDROM_01, 0x19): PCEF_CASEL(CDROM_02, 0x1A): PCEF_CASEL(CDROM_03, 0x1B): if(!PCE_IsCD) return(0xFF); if((A & 0x1E00) == 0x1A00) { if(arcade_card) return(arcade_card->Read(A & 0x1FFF)); else return(0); } else { return(PCECD_Read(HuCPU.timestamp * 3, A)); } PCEF_CASEL(EXP_00, 0x1C): PCEF_CASEL(EXP_01, 0x1D): PCEF_CASEL(EXP_02, 0x1E): PCEF_CASEL(EXP_03, 0x1F): #ifdef HAVE_HES if(IsHES) return(ReadIBP(A)); #endif return(0xFF); } #undef PCEF_CASEL //printf("Meow: %08x, %02x:%04x\n", A, A >> 13, A & 0x1FFF); libretro-common/include/rthreads/000700 001750 001750 00000000000 12727366154 020252 5ustar00sergiosergio000000 000000 libretro-common/include/rthreads/async_job.h000664 001750 001750 00000003273 12726204343 022401 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2015 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (async_job.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_ASYNC_JOB_H #define __LIBRETRO_SDK_ASYNC_JOB_H typedef struct async_job async_job_t; typedef void (*async_task_t)(void *payload); async_job_t *async_job_new(void); void async_job_free(async_job_t *ajob); int async_job_add(async_job_t *ajob, async_task_t task, void *payload); #endif /* __LIBRETRO_SDK_ASYNC_JOB_H */ thread/gx_pthread.h000664 001750 001750 00000010112 12726204343 015445 0ustar00sergiosergio000000 000000 /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2014 - Hans-Kristian Arntzen * Copyright (C) 2011-2014 - Daniel De Matteis * * RetroArch 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 Found- * ation, either version 3 of the License, or (at your option) any later version. * * RetroArch 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 RetroArch. * If not, see . */ #ifndef _GX_PTHREAD_WRAP_GX_ #define _GX_PTHREAD_WRAP_GX_ #include #include #include #ifndef OSThread #define OSThread lwp_t #endif #ifndef OSCond #define OSCond lwpq_t #endif #ifndef OSThreadQueue #define OSThreadQueue lwpq_t #endif #ifndef OSInitMutex #define OSInitMutex(mutex) LWP_MutexInit(mutex, 0) #endif #ifndef OSLockMutex #define OSLockMutex(mutex) LWP_MutexLock(mutex) #endif #ifndef OSUnlockMutex #define OSUnlockMutex(mutex) LWP_MutexUnlock(mutex) #endif #ifndef OSTryLockMutex #define OSTryLockMutex(mutex) LWP_MutexTryLock(mutex) #endif #ifndef OSInitCond #define OSInitCond(cond) LWP_CondInit(cond) #endif #ifndef OSSignalCond #define OSSignalCond(cond) LWP_ThreadSignal(cond) #endif #ifndef OSWaitCond #define OSWaitCond(cond, mutex) LWP_CondWait(cond, mutex) #endif #ifndef OSInitThreadQueue #define OSInitThreadQueue(queue) LWP_InitQueue(queue) #endif #ifndef OSSleepThread #define OSSleepThread(queue) LWP_ThreadSleep(queue) #endif #ifndef OSJoinThread #define OSJoinThread(thread, val) LWP_JoinThread(thread, val) #endif #ifndef OSCreateThread #define OSCreateThread(thread, func, intarg, ptrarg, stackbase, stacksize, priority, attrs) LWP_CreateThread(thread, func, ptrarg, stackbase, stacksize, priority) #endif #define STACKSIZE (8 * 1024) typedef OSThread pthread_t; typedef mutex_t pthread_mutex_t; typedef void* pthread_mutexattr_t; typedef int pthread_attr_t; typedef cond_t pthread_cond_t; typedef cond_t pthread_condattr_t; static inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg) { *thread = 0; return OSCreateThread(thread, start_routine, 0 /* unused */, arg, 0, STACKSIZE, 64, 0 /* unused */); } static inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr) { return OSInitMutex(mutex); } static inline int pthread_mutex_destroy(pthread_mutex_t *mutex) { return LWP_MutexDestroy(*mutex); } static inline int pthread_mutex_lock(pthread_mutex_t *mutex) { return OSLockMutex(*mutex); } static inline int pthread_mutex_unlock(pthread_mutex_t *mutex) { return OSUnlockMutex(*mutex); } static inline void pthread_exit(void *retval) { /* FIXME: No LWP equivalent for this? */ (void)retval; } static inline int pthread_detach(pthread_t thread) { /* FIXME: pthread_detach equivalent missing? */ (void)thread; return 0; } static inline int pthread_join(pthread_t thread, void **retval) { return OSJoinThread(thread, retval); } static inline int pthread_mutex_trylock(pthread_mutex_t *mutex) { return OSTryLockMutex(*mutex); } static inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) { return OSWaitCond(*cond, *mutex); } static inline int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime) { return LWP_CondTimedWait(*cond, *mutex, abstime); } static inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) { return OSInitCond(cond); } static inline int pthread_cond_signal(pthread_cond_t *cond) { return LWP_CondSignal(*cond); } static inline int pthread_cond_broadcast(pthread_cond_t *cond) { return LWP_CondBroadcast(*cond); } static inline int pthread_cond_destroy(pthread_cond_t *cond) { return LWP_CondDestroy(*cond); } #endif mednafen/tremor/COPYING000664 001750 001750 00000002672 12726204343 016034 0ustar00sergiosergio000000 000000 Copyright (c) 2002, Xiph.org Foundation Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - Neither the name of the Xiph.org Foundation nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. mednafen/sound/000700 001750 001750 00000000000 12727366154 014610 5ustar00sergiosergio000000 000000 mednafen/state.cpp000664 001750 001750 00000030665 12726204343 015320 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "mednafen.h" #include #include "driver.h" #include "general.h" #include "state.h" #include "video.h" #include "msvc_compat.h" #define RLSB MDFNSTATE_RLSB //0x80000000 int32 smem_read(StateMem *st, void *buffer, uint32 len) { if ((len + st->loc) > st->len) return 0; memcpy(buffer, st->data + st->loc, len); st->loc += len; return(len); } int32 smem_write(StateMem *st, void *buffer, uint32 len) { if ((len + st->loc) > st->malloced) { uint32 newsize = (st->malloced >= 32768) ? st->malloced : (st->initial_malloc ? st->initial_malloc : 32768); while(newsize < (len + st->loc)) newsize *= 2; st->data = (uint8 *)realloc(st->data, newsize); st->malloced = newsize; } memcpy(st->data + st->loc, buffer, len); st->loc += len; if (st->loc > st->len) st->len = st->loc; return(len); } int32 smem_putc(StateMem *st, int value) { uint8 tmpval = value; if(smem_write(st, &tmpval, 1) != 1) return(-1); return(1); } int32 smem_tell(StateMem *st) { return(st->loc); } int32 smem_seek(StateMem *st, uint32 offset, int whence) { switch(whence) { case SEEK_SET: st->loc = offset; break; case SEEK_END: st->loc = st->len - offset; break; case SEEK_CUR: st->loc += offset; break; } if(st->loc > st->len) { st->loc = st->len; return(-1); } if(st->loc < 0) { st->loc = 0; return(-1); } return(0); } int smem_write32le(StateMem *st, uint32 b) { uint8 s[4]; s[0]=b; s[1]=b>>8; s[2]=b>>16; s[3]=b>>24; return((smem_write(st, s, 4)<4)?0:4); } int smem_read32le(StateMem *st, uint32 *b) { uint8 s[4]; if(smem_read(st, s, 4) < 4) return(0); *b = s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24); return(4); } static bool SubWrite(StateMem *st, SFORMAT *sf, const char *name_prefix = NULL) { while(sf->size || sf->name) // Size can sometimes be zero, so also check for the text name. These two should both be zero only at the end of a struct. { if(!sf->size || !sf->v) { sf++; continue; } if(sf->size == (uint32)~0) /* Link to another struct. */ { if(!SubWrite(st, (SFORMAT *)sf->v, name_prefix)) return(0); sf++; continue; } int32 bytesize = sf->size; char nameo[1 + 256]; int slen; slen = snprintf(nameo + 1, 256, "%s%s", name_prefix ? name_prefix : "", sf->name); nameo[0] = slen; if(slen >= 255) { printf("Warning: state variable name possibly too long: %s %s %s %d\n", sf->name, name_prefix, nameo, slen); slen = 255; } smem_write(st, nameo, 1 + nameo[0]); smem_write32le(st, bytesize); /* Flip the byte order... */ if(sf->flags & MDFNSTATE_BOOL) { } else if(sf->flags & MDFNSTATE_RLSB64) Endian_A64_NE_to_LE(sf->v, bytesize / sizeof(uint64)); else if(sf->flags & MDFNSTATE_RLSB32) Endian_A32_NE_to_LE(sf->v, bytesize / sizeof(uint32)); else if(sf->flags & MDFNSTATE_RLSB16) Endian_A16_NE_to_LE(sf->v, bytesize / sizeof(uint16)); else if(sf->flags & RLSB) Endian_V_NE_to_LE(sf->v, bytesize); // Special case for the evil bool type, to convert bool to 1-byte elements. // Don't do it if we're only saving the raw data. if(sf->flags & MDFNSTATE_BOOL) { for(int32 bool_monster = 0; bool_monster < bytesize; bool_monster++) { uint8 tmp_bool = ((bool *)sf->v)[bool_monster]; //printf("Bool write: %.31s\n", sf->name); smem_write(st, &tmp_bool, 1); } } else smem_write(st, (uint8 *)sf->v, bytesize); /* Now restore the original byte order. */ if(sf->flags & MDFNSTATE_BOOL) { } else if(sf->flags & MDFNSTATE_RLSB64) Endian_A64_LE_to_NE(sf->v, bytesize / sizeof(uint64)); else if(sf->flags & MDFNSTATE_RLSB32) Endian_A32_LE_to_NE(sf->v, bytesize / sizeof(uint32)); else if(sf->flags & MDFNSTATE_RLSB16) Endian_A16_LE_to_NE(sf->v, bytesize / sizeof(uint16)); else if(sf->flags & RLSB) Endian_V_LE_to_NE(sf->v, bytesize); sf++; } return(TRUE); } static int WriteStateChunk(StateMem *st, const char *sname, SFORMAT *sf) { int32 data_start_pos; int32 end_pos; uint8 sname_tmp[32]; memset(sname_tmp, 0, sizeof(sname_tmp)); strncpy((char *)sname_tmp, sname, 32); if(strlen(sname) > 32) printf("Warning: section name is too long: %s\n", sname); smem_write(st, sname_tmp, 32); smem_write32le(st, 0); // We'll come back and write this later. data_start_pos = smem_tell(st); if(!SubWrite(st, sf)) return(0); end_pos = smem_tell(st); smem_seek(st, data_start_pos - 4, SEEK_SET); smem_write32le(st, end_pos - data_start_pos); smem_seek(st, end_pos, SEEK_SET); return(end_pos - data_start_pos); } struct compare_cstr { bool operator()(const char *s1, const char *s2) const { return(strcmp(s1, s2) < 0); } }; typedef std::map SFMap_t; static void MakeSFMap(SFORMAT *sf, SFMap_t &sfmap) { while(sf->size || sf->name) // Size can sometimes be zero, so also check for the text name. These two should both be zero only at the end of a struct. { if(!sf->size || !sf->v) { sf++; continue; } if(sf->size == (uint32)~0) /* Link to another SFORMAT structure. */ MakeSFMap((SFORMAT *)sf->v, sfmap); else { assert(sf->name); if(sfmap.find(sf->name) != sfmap.end()) printf("Duplicate save state variable in internal emulator structures(CLUB THE PROGRAMMERS WITH BREADSTICKS): %s\n", sf->name); sfmap[sf->name] = sf; } sf++; } } // Fast raw chunk reader static void DOReadChunk(StateMem *st, SFORMAT *sf) { while(sf->size || sf->name) // Size can sometimes be zero, so also check for the text name. // These two should both be zero only at the end of a struct. { if(!sf->size || !sf->v) { sf++; continue; } if(sf->size == (uint32) ~0) // Link to another SFORMAT struct { DOReadChunk(st, (SFORMAT *)sf->v); sf++; continue; } int32 bytesize = sf->size; // Loading raw data, bool types are stored as they appear in memory, not as single bytes in the full state format. // In the SFORMAT structure, the size member for bool entries is the number of bool elements, not the total in-memory size, // so we adjust it here. if(sf->flags & MDFNSTATE_BOOL) bytesize *= sizeof(bool); smem_read(st, (uint8 *)sf->v, bytesize); sf++; } } static int ReadStateChunk(StateMem *st, SFORMAT *sf, int size) { int temp; { SFMap_t sfmap; SFMap_t sfmap_found; // Used for identifying variables that are missing in the save state. MakeSFMap(sf, sfmap); temp = smem_tell(st); while(smem_tell(st) < (temp + size)) { uint32 recorded_size; // In bytes uint8 toa[1 + 256]; // Don't change to char unless cast toa[0] to unsigned to smem_read() and other places. if(smem_read(st, toa, 1) != 1) { puts("Unexpected EOF"); return(0); } if(smem_read(st, toa + 1, toa[0]) != toa[0]) { puts("Unexpected EOF?"); return 0; } toa[1 + toa[0]] = 0; smem_read32le(st, &recorded_size); SFMap_t::iterator sfmit; sfmit = sfmap.find((char *)toa + 1); if(sfmit != sfmap.end()) { SFORMAT *tmp = sfmit->second; uint32 expected_size = tmp->size; // In bytes if(recorded_size != expected_size) { printf("Variable in save state wrong size: %s. Need: %d, got: %d\n", toa + 1, expected_size, recorded_size); if(smem_seek(st, recorded_size, SEEK_CUR) < 0) { puts("Seek error"); return(0); } } else { sfmap_found[tmp->name] = tmp; smem_read(st, (uint8 *)tmp->v, expected_size); if(tmp->flags & MDFNSTATE_BOOL) { // Converting downwards is necessary for the case of sizeof(bool) > 1 for(int32 bool_monster = expected_size - 1; bool_monster >= 0; bool_monster--) { ((bool *)tmp->v)[bool_monster] = ((uint8 *)tmp->v)[bool_monster]; } } if(tmp->flags & MDFNSTATE_RLSB64) Endian_A64_LE_to_NE(tmp->v, expected_size / sizeof(uint64)); else if(tmp->flags & MDFNSTATE_RLSB32) Endian_A32_LE_to_NE(tmp->v, expected_size / sizeof(uint32)); else if(tmp->flags & MDFNSTATE_RLSB16) Endian_A16_LE_to_NE(tmp->v, expected_size / sizeof(uint16)); else if(tmp->flags & RLSB) Endian_V_LE_to_NE(tmp->v, expected_size); } } else { printf("Unknown variable in save state: %s\n", toa + 1); if(smem_seek(st, recorded_size, SEEK_CUR) < 0) { puts("Seek error"); return(0); } } } // while(...) for(SFMap_t::const_iterator it = sfmap.begin(); it != sfmap.end(); it++) { if(sfmap_found.find(it->second->name) == sfmap_found.end()) { printf("Variable missing from save state: %s\n", it->second->name); } } assert(smem_tell(st) == (temp + size)); } return 1; } static int CurrentState = 0; /* This function is called by the game driver(NES, GB, GBA) to save a state. */ int MDFNSS_StateAction(void *st_p, int load, int data_only, std::vector §ions) { StateMem *st = (StateMem*)st_p; std::vector::iterator section; if(load) { { char sname[32]; for(section = sections.begin(); section != sections.end(); section++) { int found = 0; uint32 tmp_size; uint32 total = 0; while(smem_read(st, (uint8 *)sname, 32) == 32) { if(smem_read32le(st, &tmp_size) != 4) return(0); total += tmp_size + 32 + 4; // Yay, we found the section if(!strncmp(sname, section->name, 32)) { if(!ReadStateChunk(st, section->sf, tmp_size)) { printf("Error reading chunk: %s\n", section->name); return(0); } found = 1; break; } else { if(smem_seek(st, tmp_size, SEEK_CUR) < 0) { puts("Chunk seek failure"); return(0); } } } if(smem_seek(st, -total, SEEK_CUR) < 0) { puts("Reverse seek error"); return(0); } if(!found && !section->optional) // Not found. We are sad! { printf("Section missing: %.32s\n", section->name); return(0); } } } } else { for(section = sections.begin(); section != sections.end(); section++) { if(!WriteStateChunk(st, section->name, section->sf)) return(0); } } return(1); } int MDFNSS_StateAction(void *st_p, int load, int data_only, SFORMAT *sf, const char *name, bool optional) { StateMem *st = (StateMem*)st_p; std::vector love; love.push_back(SSDescriptor(sf, name, optional)); return(MDFNSS_StateAction(st, load, 0, love)); } int MDFNSS_SaveSM(void *st_p, int, int, const void*, const void*, const void*) { StateMem *st = (StateMem*)st_p; static const char *header_magic = "MDFNSVST"; uint8 header[32]; int neowidth = 0, neoheight = 0; memset(header, 0, sizeof(header)); memcpy(header, header_magic, 8); MDFN_en32lsb(header + 16, MEDNAFEN_VERSION_NUMERIC); MDFN_en32lsb(header + 24, neowidth); MDFN_en32lsb(header + 28, neoheight); smem_write(st, header, 32); if(!MDFNGameInfo->StateAction(st, 0, 0)) return(0); uint32 sizy = smem_tell(st); smem_seek(st, 16 + 4, SEEK_SET); smem_write32le(st, sizy); return(1); } int MDFNSS_LoadSM(void *st_p, int, int) { StateMem *st = (StateMem*)st_p; uint8 header[32]; uint32 stateversion; smem_read(st, header, 32); if(memcmp(header, "MEDNAFENSVESTATE", 16) && memcmp(header, "MDFNSVST", 8)) return(0); stateversion = MDFN_de32lsb(header + 16); return(MDFNGameInfo->StateAction(st, stateversion, 0)); } libretro-common/include/string/000700 001750 001750 00000000000 12727366154 017744 5ustar00sergiosergio000000 000000 mednafen/tremor/mdct_lookup.h000664 001750 001750 00000100331 12726204343 017461 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: sin,cos lookup tables ********************************************************************/ #include "misc.h" /* {sin(2*i*PI/4096), cos(2*i*PI/4096)}, with i = 0 to 512 */ static const LOOKUP_T sincos_lookup0[1026] = { X(0x00000000), X(0x7fffffff), X(0x003243f5), X(0x7ffff621), X(0x006487e3), X(0x7fffd886), X(0x0096cbc1), X(0x7fffa72c), X(0x00c90f88), X(0x7fff6216), X(0x00fb5330), X(0x7fff0943), X(0x012d96b1), X(0x7ffe9cb2), X(0x015fda03), X(0x7ffe1c65), X(0x01921d20), X(0x7ffd885a), X(0x01c45ffe), X(0x7ffce093), X(0x01f6a297), X(0x7ffc250f), X(0x0228e4e2), X(0x7ffb55ce), X(0x025b26d7), X(0x7ffa72d1), X(0x028d6870), X(0x7ff97c18), X(0x02bfa9a4), X(0x7ff871a2), X(0x02f1ea6c), X(0x7ff75370), X(0x03242abf), X(0x7ff62182), X(0x03566a96), X(0x7ff4dbd9), X(0x0388a9ea), X(0x7ff38274), X(0x03bae8b2), X(0x7ff21553), X(0x03ed26e6), X(0x7ff09478), X(0x041f6480), X(0x7feeffe1), X(0x0451a177), X(0x7fed5791), X(0x0483ddc3), X(0x7feb9b85), X(0x04b6195d), X(0x7fe9cbc0), X(0x04e8543e), X(0x7fe7e841), X(0x051a8e5c), X(0x7fe5f108), X(0x054cc7b1), X(0x7fe3e616), X(0x057f0035), X(0x7fe1c76b), X(0x05b137df), X(0x7fdf9508), X(0x05e36ea9), X(0x7fdd4eec), X(0x0615a48b), X(0x7fdaf519), X(0x0647d97c), X(0x7fd8878e), X(0x067a0d76), X(0x7fd6064c), X(0x06ac406f), X(0x7fd37153), X(0x06de7262), X(0x7fd0c8a3), X(0x0710a345), X(0x7fce0c3e), X(0x0742d311), X(0x7fcb3c23), X(0x077501be), X(0x7fc85854), X(0x07a72f45), X(0x7fc560cf), X(0x07d95b9e), X(0x7fc25596), X(0x080b86c2), X(0x7fbf36aa), X(0x083db0a7), X(0x7fbc040a), X(0x086fd947), X(0x7fb8bdb8), X(0x08a2009a), X(0x7fb563b3), X(0x08d42699), X(0x7fb1f5fc), X(0x09064b3a), X(0x7fae7495), X(0x09386e78), X(0x7faadf7c), X(0x096a9049), X(0x7fa736b4), X(0x099cb0a7), X(0x7fa37a3c), X(0x09cecf89), X(0x7f9faa15), X(0x0a00ece8), X(0x7f9bc640), X(0x0a3308bd), X(0x7f97cebd), X(0x0a6522fe), X(0x7f93c38c), X(0x0a973ba5), X(0x7f8fa4b0), X(0x0ac952aa), X(0x7f8b7227), X(0x0afb6805), X(0x7f872bf3), X(0x0b2d7baf), X(0x7f82d214), X(0x0b5f8d9f), X(0x7f7e648c), X(0x0b919dcf), X(0x7f79e35a), X(0x0bc3ac35), X(0x7f754e80), X(0x0bf5b8cb), X(0x7f70a5fe), X(0x0c27c389), X(0x7f6be9d4), X(0x0c59cc68), X(0x7f671a05), X(0x0c8bd35e), X(0x7f62368f), X(0x0cbdd865), X(0x7f5d3f75), X(0x0cefdb76), X(0x7f5834b7), X(0x0d21dc87), X(0x7f531655), X(0x0d53db92), X(0x7f4de451), X(0x0d85d88f), X(0x7f489eaa), X(0x0db7d376), X(0x7f434563), X(0x0de9cc40), X(0x7f3dd87c), X(0x0e1bc2e4), X(0x7f3857f6), X(0x0e4db75b), X(0x7f32c3d1), X(0x0e7fa99e), X(0x7f2d1c0e), X(0x0eb199a4), X(0x7f2760af), X(0x0ee38766), X(0x7f2191b4), X(0x0f1572dc), X(0x7f1baf1e), X(0x0f475bff), X(0x7f15b8ee), X(0x0f7942c7), X(0x7f0faf25), X(0x0fab272b), X(0x7f0991c4), X(0x0fdd0926), X(0x7f0360cb), X(0x100ee8ad), X(0x7efd1c3c), X(0x1040c5bb), X(0x7ef6c418), X(0x1072a048), X(0x7ef05860), X(0x10a4784b), X(0x7ee9d914), X(0x10d64dbd), X(0x7ee34636), X(0x11082096), X(0x7edc9fc6), X(0x1139f0cf), X(0x7ed5e5c6), X(0x116bbe60), X(0x7ecf1837), X(0x119d8941), X(0x7ec8371a), X(0x11cf516a), X(0x7ec14270), X(0x120116d5), X(0x7eba3a39), X(0x1232d979), X(0x7eb31e78), X(0x1264994e), X(0x7eabef2c), X(0x1296564d), X(0x7ea4ac58), X(0x12c8106f), X(0x7e9d55fc), X(0x12f9c7aa), X(0x7e95ec1a), X(0x132b7bf9), X(0x7e8e6eb2), X(0x135d2d53), X(0x7e86ddc6), X(0x138edbb1), X(0x7e7f3957), X(0x13c0870a), X(0x7e778166), X(0x13f22f58), X(0x7e6fb5f4), X(0x1423d492), X(0x7e67d703), X(0x145576b1), X(0x7e5fe493), X(0x148715ae), X(0x7e57dea7), X(0x14b8b17f), X(0x7e4fc53e), X(0x14ea4a1f), X(0x7e47985b), X(0x151bdf86), X(0x7e3f57ff), X(0x154d71aa), X(0x7e37042a), X(0x157f0086), X(0x7e2e9cdf), X(0x15b08c12), X(0x7e26221f), X(0x15e21445), X(0x7e1d93ea), X(0x16139918), X(0x7e14f242), X(0x16451a83), X(0x7e0c3d29), X(0x1676987f), X(0x7e0374a0), X(0x16a81305), X(0x7dfa98a8), X(0x16d98a0c), X(0x7df1a942), X(0x170afd8d), X(0x7de8a670), X(0x173c6d80), X(0x7ddf9034), X(0x176dd9de), X(0x7dd6668f), X(0x179f429f), X(0x7dcd2981), X(0x17d0a7bc), X(0x7dc3d90d), X(0x1802092c), X(0x7dba7534), X(0x183366e9), X(0x7db0fdf8), X(0x1864c0ea), X(0x7da77359), X(0x18961728), X(0x7d9dd55a), X(0x18c7699b), X(0x7d9423fc), X(0x18f8b83c), X(0x7d8a5f40), X(0x192a0304), X(0x7d808728), X(0x195b49ea), X(0x7d769bb5), X(0x198c8ce7), X(0x7d6c9ce9), X(0x19bdcbf3), X(0x7d628ac6), X(0x19ef0707), X(0x7d58654d), X(0x1a203e1b), X(0x7d4e2c7f), X(0x1a517128), X(0x7d43e05e), X(0x1a82a026), X(0x7d3980ec), X(0x1ab3cb0d), X(0x7d2f0e2b), X(0x1ae4f1d6), X(0x7d24881b), X(0x1b161479), X(0x7d19eebf), X(0x1b4732ef), X(0x7d0f4218), X(0x1b784d30), X(0x7d048228), X(0x1ba96335), X(0x7cf9aef0), X(0x1bda74f6), X(0x7ceec873), X(0x1c0b826a), X(0x7ce3ceb2), X(0x1c3c8b8c), X(0x7cd8c1ae), X(0x1c6d9053), X(0x7ccda169), X(0x1c9e90b8), X(0x7cc26de5), X(0x1ccf8cb3), X(0x7cb72724), X(0x1d00843d), X(0x7cabcd28), X(0x1d31774d), X(0x7ca05ff1), X(0x1d6265dd), X(0x7c94df83), X(0x1d934fe5), X(0x7c894bde), X(0x1dc4355e), X(0x7c7da505), X(0x1df5163f), X(0x7c71eaf9), X(0x1e25f282), X(0x7c661dbc), X(0x1e56ca1e), X(0x7c5a3d50), X(0x1e879d0d), X(0x7c4e49b7), X(0x1eb86b46), X(0x7c4242f2), X(0x1ee934c3), X(0x7c362904), X(0x1f19f97b), X(0x7c29fbee), X(0x1f4ab968), X(0x7c1dbbb3), X(0x1f7b7481), X(0x7c116853), X(0x1fac2abf), X(0x7c0501d2), X(0x1fdcdc1b), X(0x7bf88830), X(0x200d888d), X(0x7bebfb70), X(0x203e300d), X(0x7bdf5b94), X(0x206ed295), X(0x7bd2a89e), X(0x209f701c), X(0x7bc5e290), X(0x20d0089c), X(0x7bb9096b), X(0x21009c0c), X(0x7bac1d31), X(0x21312a65), X(0x7b9f1de6), X(0x2161b3a0), X(0x7b920b89), X(0x219237b5), X(0x7b84e61f), X(0x21c2b69c), X(0x7b77ada8), X(0x21f3304f), X(0x7b6a6227), X(0x2223a4c5), X(0x7b5d039e), X(0x225413f8), X(0x7b4f920e), X(0x22847de0), X(0x7b420d7a), X(0x22b4e274), X(0x7b3475e5), X(0x22e541af), X(0x7b26cb4f), X(0x23159b88), X(0x7b190dbc), X(0x2345eff8), X(0x7b0b3d2c), X(0x23763ef7), X(0x7afd59a4), X(0x23a6887f), X(0x7aef6323), X(0x23d6cc87), X(0x7ae159ae), X(0x24070b08), X(0x7ad33d45), X(0x243743fa), X(0x7ac50dec), X(0x24677758), X(0x7ab6cba4), X(0x2497a517), X(0x7aa8766f), X(0x24c7cd33), X(0x7a9a0e50), X(0x24f7efa2), X(0x7a8b9348), X(0x25280c5e), X(0x7a7d055b), X(0x2558235f), X(0x7a6e648a), X(0x2588349d), X(0x7a5fb0d8), X(0x25b84012), X(0x7a50ea47), X(0x25e845b6), X(0x7a4210d8), X(0x26184581), X(0x7a332490), X(0x26483f6c), X(0x7a24256f), X(0x26783370), X(0x7a151378), X(0x26a82186), X(0x7a05eead), X(0x26d809a5), X(0x79f6b711), X(0x2707ebc7), X(0x79e76ca7), X(0x2737c7e3), X(0x79d80f6f), X(0x27679df4), X(0x79c89f6e), X(0x27976df1), X(0x79b91ca4), X(0x27c737d3), X(0x79a98715), X(0x27f6fb92), X(0x7999dec4), X(0x2826b928), X(0x798a23b1), X(0x2856708d), X(0x797a55e0), X(0x288621b9), X(0x796a7554), X(0x28b5cca5), X(0x795a820e), X(0x28e5714b), X(0x794a7c12), X(0x29150fa1), X(0x793a6361), X(0x2944a7a2), X(0x792a37fe), X(0x29743946), X(0x7919f9ec), X(0x29a3c485), X(0x7909a92d), X(0x29d34958), X(0x78f945c3), X(0x2a02c7b8), X(0x78e8cfb2), X(0x2a323f9e), X(0x78d846fb), X(0x2a61b101), X(0x78c7aba2), X(0x2a911bdc), X(0x78b6fda8), X(0x2ac08026), X(0x78a63d11), X(0x2aefddd8), X(0x789569df), X(0x2b1f34eb), X(0x78848414), X(0x2b4e8558), X(0x78738bb3), X(0x2b7dcf17), X(0x786280bf), X(0x2bad1221), X(0x7851633b), X(0x2bdc4e6f), X(0x78403329), X(0x2c0b83fa), X(0x782ef08b), X(0x2c3ab2b9), X(0x781d9b65), X(0x2c69daa6), X(0x780c33b8), X(0x2c98fbba), X(0x77fab989), X(0x2cc815ee), X(0x77e92cd9), X(0x2cf72939), X(0x77d78daa), X(0x2d263596), X(0x77c5dc01), X(0x2d553afc), X(0x77b417df), X(0x2d843964), X(0x77a24148), X(0x2db330c7), X(0x7790583e), X(0x2de2211e), X(0x777e5cc3), X(0x2e110a62), X(0x776c4edb), X(0x2e3fec8b), X(0x775a2e89), X(0x2e6ec792), X(0x7747fbce), X(0x2e9d9b70), X(0x7735b6af), X(0x2ecc681e), X(0x77235f2d), X(0x2efb2d95), X(0x7710f54c), X(0x2f29ebcc), X(0x76fe790e), X(0x2f58a2be), X(0x76ebea77), X(0x2f875262), X(0x76d94989), X(0x2fb5fab2), X(0x76c69647), X(0x2fe49ba7), X(0x76b3d0b4), X(0x30133539), X(0x76a0f8d2), X(0x3041c761), X(0x768e0ea6), X(0x30705217), X(0x767b1231), X(0x309ed556), X(0x76680376), X(0x30cd5115), X(0x7654e279), X(0x30fbc54d), X(0x7641af3d), X(0x312a31f8), X(0x762e69c4), X(0x3158970e), X(0x761b1211), X(0x3186f487), X(0x7607a828), X(0x31b54a5e), X(0x75f42c0b), X(0x31e39889), X(0x75e09dbd), X(0x3211df04), X(0x75ccfd42), X(0x32401dc6), X(0x75b94a9c), X(0x326e54c7), X(0x75a585cf), X(0x329c8402), X(0x7591aedd), X(0x32caab6f), X(0x757dc5ca), X(0x32f8cb07), X(0x7569ca99), X(0x3326e2c3), X(0x7555bd4c), X(0x3354f29b), X(0x75419de7), X(0x3382fa88), X(0x752d6c6c), X(0x33b0fa84), X(0x751928e0), X(0x33def287), X(0x7504d345), X(0x340ce28b), X(0x74f06b9e), X(0x343aca87), X(0x74dbf1ef), X(0x3468aa76), X(0x74c7663a), X(0x34968250), X(0x74b2c884), X(0x34c4520d), X(0x749e18cd), X(0x34f219a8), X(0x7489571c), X(0x351fd918), X(0x74748371), X(0x354d9057), X(0x745f9dd1), X(0x357b3f5d), X(0x744aa63f), X(0x35a8e625), X(0x74359cbd), X(0x35d684a6), X(0x74208150), X(0x36041ad9), X(0x740b53fb), X(0x3631a8b8), X(0x73f614c0), X(0x365f2e3b), X(0x73e0c3a3), X(0x368cab5c), X(0x73cb60a8), X(0x36ba2014), X(0x73b5ebd1), X(0x36e78c5b), X(0x73a06522), X(0x3714f02a), X(0x738acc9e), X(0x37424b7b), X(0x73752249), X(0x376f9e46), X(0x735f6626), X(0x379ce885), X(0x73499838), X(0x37ca2a30), X(0x7333b883), X(0x37f76341), X(0x731dc70a), X(0x382493b0), X(0x7307c3d0), X(0x3851bb77), X(0x72f1aed9), X(0x387eda8e), X(0x72db8828), X(0x38abf0ef), X(0x72c54fc1), X(0x38d8fe93), X(0x72af05a7), X(0x39060373), X(0x7298a9dd), X(0x3932ff87), X(0x72823c67), X(0x395ff2c9), X(0x726bbd48), X(0x398cdd32), X(0x72552c85), X(0x39b9bebc), X(0x723e8a20), X(0x39e6975e), X(0x7227d61c), X(0x3a136712), X(0x7211107e), X(0x3a402dd2), X(0x71fa3949), X(0x3a6ceb96), X(0x71e35080), X(0x3a99a057), X(0x71cc5626), X(0x3ac64c0f), X(0x71b54a41), X(0x3af2eeb7), X(0x719e2cd2), X(0x3b1f8848), X(0x7186fdde), X(0x3b4c18ba), X(0x716fbd68), X(0x3b78a007), X(0x71586b74), X(0x3ba51e29), X(0x71410805), X(0x3bd19318), X(0x7129931f), X(0x3bfdfecd), X(0x71120cc5), X(0x3c2a6142), X(0x70fa74fc), X(0x3c56ba70), X(0x70e2cbc6), X(0x3c830a50), X(0x70cb1128), X(0x3caf50da), X(0x70b34525), X(0x3cdb8e09), X(0x709b67c0), X(0x3d07c1d6), X(0x708378ff), X(0x3d33ec39), X(0x706b78e3), X(0x3d600d2c), X(0x70536771), X(0x3d8c24a8), X(0x703b44ad), X(0x3db832a6), X(0x7023109a), X(0x3de4371f), X(0x700acb3c), X(0x3e10320d), X(0x6ff27497), X(0x3e3c2369), X(0x6fda0cae), X(0x3e680b2c), X(0x6fc19385), X(0x3e93e950), X(0x6fa90921), X(0x3ebfbdcd), X(0x6f906d84), X(0x3eeb889c), X(0x6f77c0b3), X(0x3f1749b8), X(0x6f5f02b2), X(0x3f430119), X(0x6f463383), X(0x3f6eaeb8), X(0x6f2d532c), X(0x3f9a5290), X(0x6f1461b0), X(0x3fc5ec98), X(0x6efb5f12), X(0x3ff17cca), X(0x6ee24b57), X(0x401d0321), X(0x6ec92683), X(0x40487f94), X(0x6eaff099), X(0x4073f21d), X(0x6e96a99d), X(0x409f5ab6), X(0x6e7d5193), X(0x40cab958), X(0x6e63e87f), X(0x40f60dfb), X(0x6e4a6e66), X(0x4121589b), X(0x6e30e34a), X(0x414c992f), X(0x6e174730), X(0x4177cfb1), X(0x6dfd9a1c), X(0x41a2fc1a), X(0x6de3dc11), X(0x41ce1e65), X(0x6dca0d14), X(0x41f93689), X(0x6db02d29), X(0x42244481), X(0x6d963c54), X(0x424f4845), X(0x6d7c3a98), X(0x427a41d0), X(0x6d6227fa), X(0x42a5311b), X(0x6d48047e), X(0x42d0161e), X(0x6d2dd027), X(0x42faf0d4), X(0x6d138afb), X(0x4325c135), X(0x6cf934fc), X(0x4350873c), X(0x6cdece2f), X(0x437b42e1), X(0x6cc45698), X(0x43a5f41e), X(0x6ca9ce3b), X(0x43d09aed), X(0x6c8f351c), X(0x43fb3746), X(0x6c748b3f), X(0x4425c923), X(0x6c59d0a9), X(0x4450507e), X(0x6c3f055d), X(0x447acd50), X(0x6c242960), X(0x44a53f93), X(0x6c093cb6), X(0x44cfa740), X(0x6bee3f62), X(0x44fa0450), X(0x6bd3316a), X(0x452456bd), X(0x6bb812d1), X(0x454e9e80), X(0x6b9ce39b), X(0x4578db93), X(0x6b81a3cd), X(0x45a30df0), X(0x6b66536b), X(0x45cd358f), X(0x6b4af279), X(0x45f7526b), X(0x6b2f80fb), X(0x4621647d), X(0x6b13fef5), X(0x464b6bbe), X(0x6af86c6c), X(0x46756828), X(0x6adcc964), X(0x469f59b4), X(0x6ac115e2), X(0x46c9405c), X(0x6aa551e9), X(0x46f31c1a), X(0x6a897d7d), X(0x471cece7), X(0x6a6d98a4), X(0x4746b2bc), X(0x6a51a361), X(0x47706d93), X(0x6a359db9), X(0x479a1d67), X(0x6a1987b0), X(0x47c3c22f), X(0x69fd614a), X(0x47ed5be6), X(0x69e12a8c), X(0x4816ea86), X(0x69c4e37a), X(0x48406e08), X(0x69a88c19), X(0x4869e665), X(0x698c246c), X(0x48935397), X(0x696fac78), X(0x48bcb599), X(0x69532442), X(0x48e60c62), X(0x69368bce), X(0x490f57ee), X(0x6919e320), X(0x49389836), X(0x68fd2a3d), X(0x4961cd33), X(0x68e06129), X(0x498af6df), X(0x68c387e9), X(0x49b41533), X(0x68a69e81), X(0x49dd282a), X(0x6889a4f6), X(0x4a062fbd), X(0x686c9b4b), X(0x4a2f2be6), X(0x684f8186), X(0x4a581c9e), X(0x683257ab), X(0x4a8101de), X(0x68151dbe), X(0x4aa9dba2), X(0x67f7d3c5), X(0x4ad2a9e2), X(0x67da79c3), X(0x4afb6c98), X(0x67bd0fbd), X(0x4b2423be), X(0x679f95b7), X(0x4b4ccf4d), X(0x67820bb7), X(0x4b756f40), X(0x676471c0), X(0x4b9e0390), X(0x6746c7d8), X(0x4bc68c36), X(0x67290e02), X(0x4bef092d), X(0x670b4444), X(0x4c177a6e), X(0x66ed6aa1), X(0x4c3fdff4), X(0x66cf8120), X(0x4c6839b7), X(0x66b187c3), X(0x4c9087b1), X(0x66937e91), X(0x4cb8c9dd), X(0x6675658c), X(0x4ce10034), X(0x66573cbb), X(0x4d092ab0), X(0x66390422), X(0x4d31494b), X(0x661abbc5), X(0x4d595bfe), X(0x65fc63a9), X(0x4d8162c4), X(0x65ddfbd3), X(0x4da95d96), X(0x65bf8447), X(0x4dd14c6e), X(0x65a0fd0b), X(0x4df92f46), X(0x65826622), X(0x4e210617), X(0x6563bf92), X(0x4e48d0dd), X(0x6545095f), X(0x4e708f8f), X(0x6526438f), X(0x4e984229), X(0x65076e25), X(0x4ebfe8a5), X(0x64e88926), X(0x4ee782fb), X(0x64c99498), X(0x4f0f1126), X(0x64aa907f), X(0x4f369320), X(0x648b7ce0), X(0x4f5e08e3), X(0x646c59bf), X(0x4f857269), X(0x644d2722), X(0x4faccfab), X(0x642de50d), X(0x4fd420a4), X(0x640e9386), X(0x4ffb654d), X(0x63ef3290), X(0x50229da1), X(0x63cfc231), X(0x5049c999), X(0x63b0426d), X(0x5070e92f), X(0x6390b34a), X(0x5097fc5e), X(0x637114cc), X(0x50bf031f), X(0x635166f9), X(0x50e5fd6d), X(0x6331a9d4), X(0x510ceb40), X(0x6311dd64), X(0x5133cc94), X(0x62f201ac), X(0x515aa162), X(0x62d216b3), X(0x518169a5), X(0x62b21c7b), X(0x51a82555), X(0x6292130c), X(0x51ced46e), X(0x6271fa69), X(0x51f576ea), X(0x6251d298), X(0x521c0cc2), X(0x62319b9d), X(0x524295f0), X(0x6211557e), X(0x5269126e), X(0x61f1003f), X(0x528f8238), X(0x61d09be5), X(0x52b5e546), X(0x61b02876), X(0x52dc3b92), X(0x618fa5f7), X(0x53028518), X(0x616f146c), X(0x5328c1d0), X(0x614e73da), X(0x534ef1b5), X(0x612dc447), X(0x537514c2), X(0x610d05b7), X(0x539b2af0), X(0x60ec3830), X(0x53c13439), X(0x60cb5bb7), X(0x53e73097), X(0x60aa7050), X(0x540d2005), X(0x60897601), X(0x5433027d), X(0x60686ccf), X(0x5458d7f9), X(0x604754bf), X(0x547ea073), X(0x60262dd6), X(0x54a45be6), X(0x6004f819), X(0x54ca0a4b), X(0x5fe3b38d), X(0x54efab9c), X(0x5fc26038), X(0x55153fd4), X(0x5fa0fe1f), X(0x553ac6ee), X(0x5f7f8d46), X(0x556040e2), X(0x5f5e0db3), X(0x5585adad), X(0x5f3c7f6b), X(0x55ab0d46), X(0x5f1ae274), X(0x55d05faa), X(0x5ef936d1), X(0x55f5a4d2), X(0x5ed77c8a), X(0x561adcb9), X(0x5eb5b3a2), X(0x56400758), X(0x5e93dc1f), X(0x566524aa), X(0x5e71f606), X(0x568a34a9), X(0x5e50015d), X(0x56af3750), X(0x5e2dfe29), X(0x56d42c99), X(0x5e0bec6e), X(0x56f9147e), X(0x5de9cc33), X(0x571deefa), X(0x5dc79d7c), X(0x5742bc06), X(0x5da5604f), X(0x57677b9d), X(0x5d8314b1), X(0x578c2dba), X(0x5d60baa7), X(0x57b0d256), X(0x5d3e5237), X(0x57d5696d), X(0x5d1bdb65), X(0x57f9f2f8), X(0x5cf95638), X(0x581e6ef1), X(0x5cd6c2b5), X(0x5842dd54), X(0x5cb420e0), X(0x58673e1b), X(0x5c9170bf), X(0x588b9140), X(0x5c6eb258), X(0x58afd6bd), X(0x5c4be5b0), X(0x58d40e8c), X(0x5c290acc), X(0x58f838a9), X(0x5c0621b2), X(0x591c550e), X(0x5be32a67), X(0x594063b5), X(0x5bc024f0), X(0x59646498), X(0x5b9d1154), X(0x598857b2), X(0x5b79ef96), X(0x59ac3cfd), X(0x5b56bfbd), X(0x59d01475), X(0x5b3381ce), X(0x59f3de12), X(0x5b1035cf), X(0x5a1799d1), X(0x5aecdbc5), X(0x5a3b47ab), X(0x5ac973b5), X(0x5a5ee79a), X(0x5aa5fda5), X(0x5a82799a), X(0x5a82799a) }; /* {sin((2*i+1)*PI/4096), cos((2*i+1)*PI/4096)}, with i = 0 to 511 */ static const LOOKUP_T sincos_lookup1[1024] = { X(0x001921fb), X(0x7ffffd88), X(0x004b65ee), X(0x7fffe9cb), X(0x007da9d4), X(0x7fffc251), X(0x00afeda8), X(0x7fff8719), X(0x00e23160), X(0x7fff3824), X(0x011474f6), X(0x7ffed572), X(0x0146b860), X(0x7ffe5f03), X(0x0178fb99), X(0x7ffdd4d7), X(0x01ab3e97), X(0x7ffd36ee), X(0x01dd8154), X(0x7ffc8549), X(0x020fc3c6), X(0x7ffbbfe6), X(0x024205e8), X(0x7ffae6c7), X(0x027447b0), X(0x7ff9f9ec), X(0x02a68917), X(0x7ff8f954), X(0x02d8ca16), X(0x7ff7e500), X(0x030b0aa4), X(0x7ff6bcf0), X(0x033d4abb), X(0x7ff58125), X(0x036f8a51), X(0x7ff4319d), X(0x03a1c960), X(0x7ff2ce5b), X(0x03d407df), X(0x7ff1575d), X(0x040645c7), X(0x7fefcca4), X(0x04388310), X(0x7fee2e30), X(0x046abfb3), X(0x7fec7c02), X(0x049cfba7), X(0x7feab61a), X(0x04cf36e5), X(0x7fe8dc78), X(0x05017165), X(0x7fe6ef1c), X(0x0533ab20), X(0x7fe4ee06), X(0x0565e40d), X(0x7fe2d938), X(0x05981c26), X(0x7fe0b0b1), X(0x05ca5361), X(0x7fde7471), X(0x05fc89b8), X(0x7fdc247a), X(0x062ebf22), X(0x7fd9c0ca), X(0x0660f398), X(0x7fd74964), X(0x06932713), X(0x7fd4be46), X(0x06c5598a), X(0x7fd21f72), X(0x06f78af6), X(0x7fcf6ce8), X(0x0729bb4e), X(0x7fcca6a7), X(0x075bea8c), X(0x7fc9ccb2), X(0x078e18a7), X(0x7fc6df08), X(0x07c04598), X(0x7fc3dda9), X(0x07f27157), X(0x7fc0c896), X(0x08249bdd), X(0x7fbd9fd0), X(0x0856c520), X(0x7fba6357), X(0x0888ed1b), X(0x7fb7132b), X(0x08bb13c5), X(0x7fb3af4e), X(0x08ed3916), X(0x7fb037bf), X(0x091f5d06), X(0x7facac7f), X(0x09517f8f), X(0x7fa90d8e), X(0x0983a0a7), X(0x7fa55aee), X(0x09b5c048), X(0x7fa1949e), X(0x09e7de6a), X(0x7f9dbaa0), X(0x0a19fb04), X(0x7f99ccf4), X(0x0a4c1610), X(0x7f95cb9a), X(0x0a7e2f85), X(0x7f91b694), X(0x0ab0475c), X(0x7f8d8de1), X(0x0ae25d8d), X(0x7f895182), X(0x0b147211), X(0x7f850179), X(0x0b4684df), X(0x7f809dc5), X(0x0b7895f0), X(0x7f7c2668), X(0x0baaa53b), X(0x7f779b62), X(0x0bdcb2bb), X(0x7f72fcb4), X(0x0c0ebe66), X(0x7f6e4a5e), X(0x0c40c835), X(0x7f698461), X(0x0c72d020), X(0x7f64aabf), X(0x0ca4d620), X(0x7f5fbd77), X(0x0cd6da2d), X(0x7f5abc8a), X(0x0d08dc3f), X(0x7f55a7fa), X(0x0d3adc4e), X(0x7f507fc7), X(0x0d6cda53), X(0x7f4b43f2), X(0x0d9ed646), X(0x7f45f47b), X(0x0dd0d01f), X(0x7f409164), X(0x0e02c7d7), X(0x7f3b1aad), X(0x0e34bd66), X(0x7f359057), X(0x0e66b0c3), X(0x7f2ff263), X(0x0e98a1e9), X(0x7f2a40d2), X(0x0eca90ce), X(0x7f247ba5), X(0x0efc7d6b), X(0x7f1ea2dc), X(0x0f2e67b8), X(0x7f18b679), X(0x0f604faf), X(0x7f12b67c), X(0x0f923546), X(0x7f0ca2e7), X(0x0fc41876), X(0x7f067bba), X(0x0ff5f938), X(0x7f0040f6), X(0x1027d784), X(0x7ef9f29d), X(0x1059b352), X(0x7ef390ae), X(0x108b8c9b), X(0x7eed1b2c), X(0x10bd6356), X(0x7ee69217), X(0x10ef377d), X(0x7edff570), X(0x11210907), X(0x7ed94538), X(0x1152d7ed), X(0x7ed28171), X(0x1184a427), X(0x7ecbaa1a), X(0x11b66dad), X(0x7ec4bf36), X(0x11e83478), X(0x7ebdc0c6), X(0x1219f880), X(0x7eb6aeca), X(0x124bb9be), X(0x7eaf8943), X(0x127d7829), X(0x7ea85033), X(0x12af33ba), X(0x7ea1039b), X(0x12e0ec6a), X(0x7e99a37c), X(0x1312a230), X(0x7e922fd6), X(0x13445505), X(0x7e8aa8ac), X(0x137604e2), X(0x7e830dff), X(0x13a7b1bf), X(0x7e7b5fce), X(0x13d95b93), X(0x7e739e1d), X(0x140b0258), X(0x7e6bc8eb), X(0x143ca605), X(0x7e63e03b), X(0x146e4694), X(0x7e5be40c), X(0x149fe3fc), X(0x7e53d462), X(0x14d17e36), X(0x7e4bb13c), X(0x1503153a), X(0x7e437a9c), X(0x1534a901), X(0x7e3b3083), X(0x15663982), X(0x7e32d2f4), X(0x1597c6b7), X(0x7e2a61ed), X(0x15c95097), X(0x7e21dd73), X(0x15fad71b), X(0x7e194584), X(0x162c5a3b), X(0x7e109a24), X(0x165dd9f0), X(0x7e07db52), X(0x168f5632), X(0x7dff0911), X(0x16c0cef9), X(0x7df62362), X(0x16f2443e), X(0x7ded2a47), X(0x1723b5f9), X(0x7de41dc0), X(0x17552422), X(0x7ddafdce), X(0x17868eb3), X(0x7dd1ca75), X(0x17b7f5a3), X(0x7dc883b4), X(0x17e958ea), X(0x7dbf298d), X(0x181ab881), X(0x7db5bc02), X(0x184c1461), X(0x7dac3b15), X(0x187d6c82), X(0x7da2a6c6), X(0x18aec0db), X(0x7d98ff17), X(0x18e01167), X(0x7d8f4409), X(0x19115e1c), X(0x7d85759f), X(0x1942a6f3), X(0x7d7b93da), X(0x1973ebe6), X(0x7d719eba), X(0x19a52ceb), X(0x7d679642), X(0x19d669fc), X(0x7d5d7a74), X(0x1a07a311), X(0x7d534b50), X(0x1a38d823), X(0x7d4908d9), X(0x1a6a0929), X(0x7d3eb30f), X(0x1a9b361d), X(0x7d3449f5), X(0x1acc5ef6), X(0x7d29cd8c), X(0x1afd83ad), X(0x7d1f3dd6), X(0x1b2ea43a), X(0x7d149ad5), X(0x1b5fc097), X(0x7d09e489), X(0x1b90d8bb), X(0x7cff1af5), X(0x1bc1ec9e), X(0x7cf43e1a), X(0x1bf2fc3a), X(0x7ce94dfb), X(0x1c240786), X(0x7cde4a98), X(0x1c550e7c), X(0x7cd333f3), X(0x1c861113), X(0x7cc80a0f), X(0x1cb70f43), X(0x7cbcccec), X(0x1ce80906), X(0x7cb17c8d), X(0x1d18fe54), X(0x7ca618f3), X(0x1d49ef26), X(0x7c9aa221), X(0x1d7adb73), X(0x7c8f1817), X(0x1dabc334), X(0x7c837ad8), X(0x1ddca662), X(0x7c77ca65), X(0x1e0d84f5), X(0x7c6c06c0), X(0x1e3e5ee5), X(0x7c602fec), X(0x1e6f342c), X(0x7c5445e9), X(0x1ea004c1), X(0x7c4848ba), X(0x1ed0d09d), X(0x7c3c3860), X(0x1f0197b8), X(0x7c3014de), X(0x1f325a0b), X(0x7c23de35), X(0x1f63178f), X(0x7c179467), X(0x1f93d03c), X(0x7c0b3777), X(0x1fc4840a), X(0x7bfec765), X(0x1ff532f2), X(0x7bf24434), X(0x2025dcec), X(0x7be5ade6), X(0x205681f1), X(0x7bd9047c), X(0x208721f9), X(0x7bcc47fa), X(0x20b7bcfe), X(0x7bbf7860), X(0x20e852f6), X(0x7bb295b0), X(0x2118e3dc), X(0x7ba59fee), X(0x21496fa7), X(0x7b989719), X(0x2179f64f), X(0x7b8b7b36), X(0x21aa77cf), X(0x7b7e4c45), X(0x21daf41d), X(0x7b710a49), X(0x220b6b32), X(0x7b63b543), X(0x223bdd08), X(0x7b564d36), X(0x226c4996), X(0x7b48d225), X(0x229cb0d5), X(0x7b3b4410), X(0x22cd12bd), X(0x7b2da2fa), X(0x22fd6f48), X(0x7b1feee5), X(0x232dc66d), X(0x7b1227d3), X(0x235e1826), X(0x7b044dc7), X(0x238e646a), X(0x7af660c2), X(0x23beab33), X(0x7ae860c7), X(0x23eeec78), X(0x7ada4dd8), X(0x241f2833), X(0x7acc27f7), X(0x244f5e5c), X(0x7abdef25), X(0x247f8eec), X(0x7aafa367), X(0x24afb9da), X(0x7aa144bc), X(0x24dfdf20), X(0x7a92d329), X(0x250ffeb7), X(0x7a844eae), X(0x25401896), X(0x7a75b74f), X(0x25702cb7), X(0x7a670d0d), X(0x25a03b11), X(0x7a584feb), X(0x25d0439f), X(0x7a497feb), X(0x26004657), X(0x7a3a9d0f), X(0x26304333), X(0x7a2ba75a), X(0x26603a2c), X(0x7a1c9ece), X(0x26902b39), X(0x7a0d836d), X(0x26c01655), X(0x79fe5539), X(0x26effb76), X(0x79ef1436), X(0x271fda96), X(0x79dfc064), X(0x274fb3ae), X(0x79d059c8), X(0x277f86b5), X(0x79c0e062), X(0x27af53a6), X(0x79b15435), X(0x27df1a77), X(0x79a1b545), X(0x280edb23), X(0x79920392), X(0x283e95a1), X(0x79823f20), X(0x286e49ea), X(0x797267f2), X(0x289df7f8), X(0x79627e08), X(0x28cd9fc1), X(0x79528167), X(0x28fd4140), X(0x79427210), X(0x292cdc6d), X(0x79325006), X(0x295c7140), X(0x79221b4b), X(0x298bffb2), X(0x7911d3e2), X(0x29bb87bc), X(0x790179cd), X(0x29eb0957), X(0x78f10d0f), X(0x2a1a847b), X(0x78e08dab), X(0x2a49f920), X(0x78cffba3), X(0x2a796740), X(0x78bf56f9), X(0x2aa8ced3), X(0x78ae9fb0), X(0x2ad82fd2), X(0x789dd5cb), X(0x2b078a36), X(0x788cf94c), X(0x2b36ddf7), X(0x787c0a36), X(0x2b662b0e), X(0x786b088c), X(0x2b957173), X(0x7859f44f), X(0x2bc4b120), X(0x7848cd83), X(0x2bf3ea0d), X(0x7837942b), X(0x2c231c33), X(0x78264849), X(0x2c52478a), X(0x7814e9df), X(0x2c816c0c), X(0x780378f1), X(0x2cb089b1), X(0x77f1f581), X(0x2cdfa071), X(0x77e05f91), X(0x2d0eb046), X(0x77ceb725), X(0x2d3db928), X(0x77bcfc3f), X(0x2d6cbb10), X(0x77ab2ee2), X(0x2d9bb5f6), X(0x77994f11), X(0x2dcaa9d5), X(0x77875cce), X(0x2df996a3), X(0x7775581d), X(0x2e287c5a), X(0x776340ff), X(0x2e575af3), X(0x77511778), X(0x2e863267), X(0x773edb8b), X(0x2eb502ae), X(0x772c8d3a), X(0x2ee3cbc1), X(0x771a2c88), X(0x2f128d99), X(0x7707b979), X(0x2f41482e), X(0x76f5340e), X(0x2f6ffb7a), X(0x76e29c4b), X(0x2f9ea775), X(0x76cff232), X(0x2fcd4c19), X(0x76bd35c7), X(0x2ffbe95d), X(0x76aa670d), X(0x302a7f3a), X(0x76978605), X(0x30590dab), X(0x768492b4), X(0x308794a6), X(0x76718d1c), X(0x30b61426), X(0x765e7540), X(0x30e48c22), X(0x764b4b23), X(0x3112fc95), X(0x76380ec8), X(0x31416576), X(0x7624c031), X(0x316fc6be), X(0x76115f63), X(0x319e2067), X(0x75fdec60), X(0x31cc7269), X(0x75ea672a), X(0x31fabcbd), X(0x75d6cfc5), X(0x3228ff5c), X(0x75c32634), X(0x32573a3f), X(0x75af6a7b), X(0x32856d5e), X(0x759b9c9b), X(0x32b398b3), X(0x7587bc98), X(0x32e1bc36), X(0x7573ca75), X(0x330fd7e1), X(0x755fc635), X(0x333debab), X(0x754bafdc), X(0x336bf78f), X(0x7537876c), X(0x3399fb85), X(0x75234ce8), X(0x33c7f785), X(0x750f0054), X(0x33f5eb89), X(0x74faa1b3), X(0x3423d78a), X(0x74e63108), X(0x3451bb81), X(0x74d1ae55), X(0x347f9766), X(0x74bd199f), X(0x34ad6b32), X(0x74a872e8), X(0x34db36df), X(0x7493ba34), X(0x3508fa66), X(0x747eef85), X(0x3536b5be), X(0x746a12df), X(0x356468e2), X(0x74552446), X(0x359213c9), X(0x744023bc), X(0x35bfb66e), X(0x742b1144), X(0x35ed50c9), X(0x7415ece2), X(0x361ae2d3), X(0x7400b69a), X(0x36486c86), X(0x73eb6e6e), X(0x3675edd9), X(0x73d61461), X(0x36a366c6), X(0x73c0a878), X(0x36d0d746), X(0x73ab2ab4), X(0x36fe3f52), X(0x73959b1b), X(0x372b9ee3), X(0x737ff9ae), X(0x3758f5f2), X(0x736a4671), X(0x37864477), X(0x73548168), X(0x37b38a6d), X(0x733eaa96), X(0x37e0c7cc), X(0x7328c1ff), X(0x380dfc8d), X(0x7312c7a5), X(0x383b28a9), X(0x72fcbb8c), X(0x38684c19), X(0x72e69db7), X(0x389566d6), X(0x72d06e2b), X(0x38c278d9), X(0x72ba2cea), X(0x38ef821c), X(0x72a3d9f7), X(0x391c8297), X(0x728d7557), X(0x39497a43), X(0x7276ff0d), X(0x39766919), X(0x7260771b), X(0x39a34f13), X(0x7249dd86), X(0x39d02c2a), X(0x72333251), X(0x39fd0056), X(0x721c7580), X(0x3a29cb91), X(0x7205a716), X(0x3a568dd4), X(0x71eec716), X(0x3a834717), X(0x71d7d585), X(0x3aaff755), X(0x71c0d265), X(0x3adc9e86), X(0x71a9bdba), X(0x3b093ca3), X(0x71929789), X(0x3b35d1a5), X(0x717b5fd3), X(0x3b625d86), X(0x7164169d), X(0x3b8ee03e), X(0x714cbbeb), X(0x3bbb59c7), X(0x71354fc0), X(0x3be7ca1a), X(0x711dd220), X(0x3c143130), X(0x7106430e), X(0x3c408f03), X(0x70eea28e), X(0x3c6ce38a), X(0x70d6f0a4), X(0x3c992ec0), X(0x70bf2d53), X(0x3cc5709e), X(0x70a7589f), X(0x3cf1a91c), X(0x708f728b), X(0x3d1dd835), X(0x70777b1c), X(0x3d49fde1), X(0x705f7255), X(0x3d761a19), X(0x70475839), X(0x3da22cd7), X(0x702f2ccd), X(0x3dce3614), X(0x7016f014), X(0x3dfa35c8), X(0x6ffea212), X(0x3e262bee), X(0x6fe642ca), X(0x3e52187f), X(0x6fcdd241), X(0x3e7dfb73), X(0x6fb5507a), X(0x3ea9d4c3), X(0x6f9cbd79), X(0x3ed5a46b), X(0x6f841942), X(0x3f016a61), X(0x6f6b63d8), X(0x3f2d26a0), X(0x6f529d40), X(0x3f58d921), X(0x6f39c57d), X(0x3f8481dd), X(0x6f20dc92), X(0x3fb020ce), X(0x6f07e285), X(0x3fdbb5ec), X(0x6eeed758), X(0x40074132), X(0x6ed5bb10), X(0x4032c297), X(0x6ebc8db0), X(0x405e3a16), X(0x6ea34f3d), X(0x4089a7a8), X(0x6e89ffb9), X(0x40b50b46), X(0x6e709f2a), X(0x40e064ea), X(0x6e572d93), X(0x410bb48c), X(0x6e3daaf8), X(0x4136fa27), X(0x6e24175c), X(0x416235b2), X(0x6e0a72c5), X(0x418d6729), X(0x6df0bd35), X(0x41b88e84), X(0x6dd6f6b1), X(0x41e3abbc), X(0x6dbd1f3c), X(0x420ebecb), X(0x6da336dc), X(0x4239c7aa), X(0x6d893d93), X(0x4264c653), X(0x6d6f3365), X(0x428fbabe), X(0x6d551858), X(0x42baa4e6), X(0x6d3aec6e), X(0x42e584c3), X(0x6d20afac), X(0x43105a50), X(0x6d066215), X(0x433b2585), X(0x6cec03af), X(0x4365e65b), X(0x6cd1947c), X(0x43909ccd), X(0x6cb71482), X(0x43bb48d4), X(0x6c9c83c3), X(0x43e5ea68), X(0x6c81e245), X(0x44108184), X(0x6c67300b), X(0x443b0e21), X(0x6c4c6d1a), X(0x44659039), X(0x6c319975), X(0x449007c4), X(0x6c16b521), X(0x44ba74bd), X(0x6bfbc021), X(0x44e4d71c), X(0x6be0ba7b), X(0x450f2edb), X(0x6bc5a431), X(0x45397bf4), X(0x6baa7d49), X(0x4563be60), X(0x6b8f45c7), X(0x458df619), X(0x6b73fdae), X(0x45b82318), X(0x6b58a503), X(0x45e24556), X(0x6b3d3bcb), X(0x460c5cce), X(0x6b21c208), X(0x46366978), X(0x6b0637c1), X(0x46606b4e), X(0x6aea9cf8), X(0x468a624a), X(0x6acef1b2), X(0x46b44e65), X(0x6ab335f4), X(0x46de2f99), X(0x6a9769c1), X(0x470805df), X(0x6a7b8d1e), X(0x4731d131), X(0x6a5fa010), X(0x475b9188), X(0x6a43a29a), X(0x478546de), X(0x6a2794c1), X(0x47aef12c), X(0x6a0b7689), X(0x47d8906d), X(0x69ef47f6), X(0x48022499), X(0x69d3090e), X(0x482badab), X(0x69b6b9d3), X(0x48552b9b), X(0x699a5a4c), X(0x487e9e64), X(0x697dea7b), X(0x48a805ff), X(0x69616a65), X(0x48d16265), X(0x6944da10), X(0x48fab391), X(0x6928397e), X(0x4923f97b), X(0x690b88b5), X(0x494d341e), X(0x68eec7b9), X(0x49766373), X(0x68d1f68f), X(0x499f8774), X(0x68b5153a), X(0x49c8a01b), X(0x689823bf), X(0x49f1ad61), X(0x687b2224), X(0x4a1aaf3f), X(0x685e106c), X(0x4a43a5b0), X(0x6840ee9b), X(0x4a6c90ad), X(0x6823bcb7), X(0x4a957030), X(0x68067ac3), X(0x4abe4433), X(0x67e928c5), X(0x4ae70caf), X(0x67cbc6c0), X(0x4b0fc99d), X(0x67ae54ba), X(0x4b387af9), X(0x6790d2b6), X(0x4b6120bb), X(0x677340ba), X(0x4b89badd), X(0x67559eca), X(0x4bb24958), X(0x6737ecea), X(0x4bdacc28), X(0x671a2b20), X(0x4c034345), X(0x66fc596f), X(0x4c2baea9), X(0x66de77dc), X(0x4c540e4e), X(0x66c0866d), X(0x4c7c622d), X(0x66a28524), X(0x4ca4aa41), X(0x66847408), X(0x4ccce684), X(0x6666531d), X(0x4cf516ee), X(0x66482267), X(0x4d1d3b7a), X(0x6629e1ec), X(0x4d455422), X(0x660b91af), X(0x4d6d60df), X(0x65ed31b5), X(0x4d9561ac), X(0x65cec204), X(0x4dbd5682), X(0x65b0429f), X(0x4de53f5a), X(0x6591b38c), X(0x4e0d1c30), X(0x657314cf), X(0x4e34ecfc), X(0x6554666d), X(0x4e5cb1b9), X(0x6535a86b), X(0x4e846a60), X(0x6516dacd), X(0x4eac16eb), X(0x64f7fd98), X(0x4ed3b755), X(0x64d910d1), X(0x4efb4b96), X(0x64ba147d), X(0x4f22d3aa), X(0x649b08a0), X(0x4f4a4f89), X(0x647bed3f), X(0x4f71bf2e), X(0x645cc260), X(0x4f992293), X(0x643d8806), X(0x4fc079b1), X(0x641e3e38), X(0x4fe7c483), X(0x63fee4f8), X(0x500f0302), X(0x63df7c4d), X(0x50363529), X(0x63c0043b), X(0x505d5af1), X(0x63a07cc7), X(0x50847454), X(0x6380e5f6), X(0x50ab814d), X(0x63613fcd), X(0x50d281d5), X(0x63418a50), X(0x50f975e6), X(0x6321c585), X(0x51205d7b), X(0x6301f171), X(0x5147388c), X(0x62e20e17), X(0x516e0715), X(0x62c21b7e), X(0x5194c910), X(0x62a219aa), X(0x51bb7e75), X(0x628208a1), X(0x51e22740), X(0x6261e866), X(0x5208c36a), X(0x6241b8ff), X(0x522f52ee), X(0x62217a72), X(0x5255d5c5), X(0x62012cc2), X(0x527c4bea), X(0x61e0cff5), X(0x52a2b556), X(0x61c06410), X(0x52c91204), X(0x619fe918), X(0x52ef61ee), X(0x617f5f12), X(0x5315a50e), X(0x615ec603), X(0x533bdb5d), X(0x613e1df0), X(0x536204d7), X(0x611d66de), X(0x53882175), X(0x60fca0d2), X(0x53ae3131), X(0x60dbcbd1), X(0x53d43406), X(0x60bae7e1), X(0x53fa29ed), X(0x6099f505), X(0x542012e1), X(0x6078f344), X(0x5445eedb), X(0x6057e2a2), X(0x546bbdd7), X(0x6036c325), X(0x54917fce), X(0x601594d1), X(0x54b734ba), X(0x5ff457ad), X(0x54dcdc96), X(0x5fd30bbc), X(0x5502775c), X(0x5fb1b104), X(0x55280505), X(0x5f90478a), X(0x554d858d), X(0x5f6ecf53), X(0x5572f8ed), X(0x5f4d4865), X(0x55985f20), X(0x5f2bb2c5), X(0x55bdb81f), X(0x5f0a0e77), X(0x55e303e6), X(0x5ee85b82), X(0x5608426e), X(0x5ec699e9), X(0x562d73b2), X(0x5ea4c9b3), X(0x565297ab), X(0x5e82eae5), X(0x5677ae54), X(0x5e60fd84), X(0x569cb7a8), X(0x5e3f0194), X(0x56c1b3a1), X(0x5e1cf71c), X(0x56e6a239), X(0x5dfade20), X(0x570b8369), X(0x5dd8b6a7), X(0x5730572e), X(0x5db680b4), X(0x57551d80), X(0x5d943c4e), X(0x5779d65b), X(0x5d71e979), X(0x579e81b8), X(0x5d4f883b), X(0x57c31f92), X(0x5d2d189a), X(0x57e7afe4), X(0x5d0a9a9a), X(0x580c32a7), X(0x5ce80e41), X(0x5830a7d6), X(0x5cc57394), X(0x58550f6c), X(0x5ca2ca99), X(0x58796962), X(0x5c801354), X(0x589db5b3), X(0x5c5d4dcc), X(0x58c1f45b), X(0x5c3a7a05), X(0x58e62552), X(0x5c179806), X(0x590a4893), X(0x5bf4a7d2), X(0x592e5e19), X(0x5bd1a971), X(0x595265df), X(0x5bae9ce7), X(0x59765fde), X(0x5b8b8239), X(0x599a4c12), X(0x5b68596d), X(0x59be2a74), X(0x5b452288), X(0x59e1faff), X(0x5b21dd90), X(0x5a05bdae), X(0x5afe8a8b), X(0x5a29727b), X(0x5adb297d), X(0x5a4d1960), X(0x5ab7ba6c), X(0x5a70b258), X(0x5a943d5e), }; msvc/000700 001750 001750 00000000000 12727366154 012653 5ustar00sergiosergio000000 000000 mednafen/tremor/os.h000664 001750 001750 00000003337 12726204343 015572 0ustar00sergiosergio000000 000000 #ifndef _OS_H #define _OS_H /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: #ifdef jail to whip a few platforms into the UNIX ideal. ********************************************************************/ #include #include "os_types.h" #ifndef _V_IFDEFJAIL_H_ # define _V_IFDEFJAIL_H_ # ifdef __GNUC__ # define STIN static __inline__ # elif _WIN32 # define STIN static __inline # endif #else # define STIN static #endif #ifndef M_PI # define M_PI (3.1415926536f) #endif #ifdef _WIN32 # include # define rint(x) (floor((x)+0.5f)) # define NO_FLOAT_MATH_LIB # define FAST_HYPOT(a, b) sqrt((a)*(a) + (b)*(b)) # define LITTLE_ENDIAN 1 # define BYTE_ORDER LITTLE_ENDIAN #endif #ifdef HAVE_ALLOCA_H # include #endif #ifdef USE_MEMORY_H # include #endif #ifndef min # define min(x,y) ((x)>(y)?(y):(x)) #endif #ifndef max # define max(x,y) ((x)<(y)?(y):(x)) #endif #endif /* _OS_H */ mednafen/cdrom/recover-raw.cpp000664 001750 001750 00000012047 12726204343 017532 0ustar00sergiosergio000000 000000 /* dvdisaster: Additional error correction for optical media. * Copyright (C) 2004-2007 Carsten Gnoerlich. * Project home page: http://www.dvdisaster.com * Email: carsten@dvdisaster.com -or- cgnoerlich@fsfe.org * * 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, * or direct your browser at http://www.gnu.org. */ #include "dvdisaster.h" static GaloisTables *gt = NULL; /* for L-EC Reed-Solomon */ static ReedSolomonTables *rt = NULL; bool Init_LEC_Correct(void) { gt = CreateGaloisTables(0x11d); rt = CreateReedSolomonTables(gt, 0, 1, 10); return(1); } void Kill_LEC_Correct(void) { FreeGaloisTables(gt); FreeReedSolomonTables(rt); } /*** *** CD level CRC calculation ***/ /* * Test raw sector against its 32bit CRC. * Returns TRUE if frame is good. */ int CheckEDC(const unsigned char *cd_frame, bool xa_mode) { unsigned int expected_crc, real_crc; unsigned int crc_base = xa_mode ? 2072 : 2064; expected_crc = cd_frame[crc_base + 0] << 0; expected_crc |= cd_frame[crc_base + 1] << 8; expected_crc |= cd_frame[crc_base + 2] << 16; expected_crc |= cd_frame[crc_base + 3] << 24; if(xa_mode) real_crc = EDCCrc32(cd_frame+16, 2056); else real_crc = EDCCrc32(cd_frame, 2064); if(expected_crc == real_crc) return(1); else { //printf("Bad EDC CRC: Calculated: %08x, Recorded: %08x\n", real_crc, expected_crc); return(0); } } /*** *** A very simple L-EC error correction. *** * Perform just one pass over the Q and P vectors to see if everything * is okay respectively correct minor errors. This is pretty much the * same stuff the drive is supposed to do in the final L-EC stage. */ static int simple_lec(unsigned char *frame) { unsigned char byte_state[2352]; unsigned char p_vector[P_VECTOR_SIZE]; unsigned char q_vector[Q_VECTOR_SIZE]; unsigned char p_state[P_VECTOR_SIZE]; int erasures[Q_VECTOR_SIZE], erasure_count; int ignore[2]; int p_failures, q_failures; int p_corrected, q_corrected; int p,q; /* Setup */ memset(byte_state, 0, 2352); p_failures = q_failures = 0; p_corrected = q_corrected = 0; /* Perform Q-Parity error correction */ for(q=0; q 2) { GetPVector(byte_state, p_state, p); erasure_count = 0; for(i=0; i 0 && erasure_count <= 2) { GetPVector(frame, p_vector, p); err = DecodePQ(rt, p_vector, P_PADDING, erasures, erasure_count); } } /* See what we've got */ if(err < 0) /* Uncorrectable. */ { p_failures++; } else /* Correctable. */ { if(err == 1 || err == 2) /* Store back corrected vector */ { SetPVector(frame, p_vector, p); p_corrected++; } } } /* Sum up */ if(q_failures || p_failures || q_corrected || p_corrected) { return 1; } return 0; } /*** *** Validate CD raw sector ***/ int ValidateRawSector(unsigned char *frame, bool xaMode) { int lec_did_sth = FALSE; /* Do simple L-EC. It seems that drives stop their internal L-EC as soon as the EDC is okay, so we may see uncorrected errors in the parity bytes. Since we are also interested in the user data only and doing the L-EC is expensive, we skip our L-EC as well when the EDC is fine. */ if(!CheckEDC(frame, xaMode)) { lec_did_sth = simple_lec(frame); } /* Test internal sector checksum again */ if(!CheckEDC(frame, xaMode)) { /* EDC failure in RAW sector */ return FALSE; } return TRUE; } mednafen/cdrom/CDAccess_CCD.cpp000664 001750 001750 00000025511 12726204343 017357 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "../mednafen.h" #include "../general.h" #include "../msvc_compat.h" #include "CDAccess_CCD.h" #include #include #include using namespace CDUtility; static void MDFN_strtoupper(std::string &str) { const size_t len = str.length(); for(size_t x = 0; x < len; x++) { if(str[x] >= 'a' && str[x] <= 'z') { str[x] = str[x] - 'a' + 'A'; } } } typedef std::map CCD_Section; template static T CCD_ReadInt(CCD_Section &s, const std::string &propname, const bool have_defval = false, const int defval = 0) { CCD_Section::iterator zit = s.find(propname); if(zit == s.end()) { if(have_defval) return defval; else throw MDFN_Error(0, _("Missing property: %s"), propname.c_str()); } const std::string &v = zit->second; int scan_base = 10; size_t scan_offset = 0; long ret = 0; if(v.length() >= 3 && v[0] == '0' && v[1] == 'x') { scan_base = 16; scan_offset = 2; } const char *vp = v.c_str() + scan_offset; char *ep = NULL; if(std::numeric_limits::is_signed) ret = strtol(vp, &ep, scan_base); else ret = strtoul(vp, &ep, scan_base); if(!vp[0] || ep[0]) { throw MDFN_Error(0, _("Property %s: Malformed integer: %s"), propname.c_str(), v.c_str()); } //if(ret < minv || ret > maxv) //{ // throw MDFN_Error(0, _("Property %s: Integer %ld out of range(accepted: %d through %d)."), propname.c_str(), ret, minv, maxv); //} return ret; } CDAccess_CCD::CDAccess_CCD(const char *path, bool image_memcache) : img_stream(NULL), sub_stream(NULL), img_numsectors(0) { try { Load(path, image_memcache); } catch(...) { Cleanup(); throw; } } void CDAccess_CCD::Load(const char *path, bool image_memcache) { FileStream cf(path, MODE_READ); std::map Sections; std::string linebuf; std::string cur_section_name; std::string dir_path, file_base, file_ext; char img_extsd[4] = { 'i', 'm', 'g', 0 }; char sub_extsd[4] = { 's', 'u', 'b', 0 }; MDFN_GetFilePathComponents(path, &dir_path, &file_base, &file_ext); if(file_ext.length() == 4 && file_ext[0] == '.') { signed char extupt[3] = { -1, -1, -1 }; for(int i = 1; i < 4; i++) { if(file_ext[i] >= 'A' && file_ext[i] <= 'Z') extupt[i - 1] = 'A' - 'a'; else if(file_ext[i] >= 'a' && file_ext[i] <= 'z') extupt[i - 1] = 0; } signed char av = -1; for(int i = 0; i < 3; i++) { if(extupt[i] != -1) av = extupt[i]; else extupt[i] = av; } if(av == -1) av = 0; for(int i = 0; i < 3; i++) { if(extupt[i] == -1) extupt[i] = av; } for(int i = 0; i < 3; i++) { img_extsd[i] += extupt[i]; sub_extsd[i] += extupt[i]; } } //printf("%s %d %d %d\n", file_ext.c_str(), extupt[0], extupt[1], extupt[2]); linebuf.reserve(256); while(cf.get_line(linebuf) >= 0) { MDFN_trim(linebuf); if(linebuf.length() == 0) // Skip blank lines. continue; if(linebuf[0] == '[') { if(linebuf.length() < 3 || linebuf[linebuf.length() - 1] != ']') throw MDFN_Error(0, _("Malformed section specifier: %s"), linebuf.c_str()); cur_section_name = linebuf.substr(1, linebuf.length() - 2); MDFN_strtoupper(cur_section_name); } else { const size_t feqpos = linebuf.find('='); const size_t leqpos = linebuf.rfind('='); std::string k, v; if(feqpos == std::string::npos || feqpos != leqpos) throw MDFN_Error(0, _("Malformed value pair specifier: %s"), linebuf.c_str()); k = linebuf.substr(0, feqpos); v = linebuf.substr(feqpos + 1); MDFN_trim(k); MDFN_trim(v); MDFN_strtoupper(k); Sections[cur_section_name][k] = v; } } { CCD_Section& ds = Sections["DISC"]; unsigned toc_entries = CCD_ReadInt(ds, "TOCENTRIES"); unsigned num_sessions = CCD_ReadInt(ds, "SESSIONS"); bool data_tracks_scrambled = CCD_ReadInt(ds, "DATATRACKSSCRAMBLED"); if(num_sessions != 1) throw MDFN_Error(0, _("Unsupported number of sessions: %u"), num_sessions); if(data_tracks_scrambled) throw MDFN_Error(0, _("Scrambled CCD data tracks currently not supported.")); //printf("MOO: %d\n", toc_entries); for(unsigned te = 0; te < toc_entries; te++) { char tmpbuf[64]; snprintf(tmpbuf, sizeof(tmpbuf), "ENTRY %u", te); CCD_Section& ts = Sections[std::string(tmpbuf)]; unsigned session = CCD_ReadInt(ts, "SESSION"); uint8 point = CCD_ReadInt(ts, "POINT"); uint8 adr = CCD_ReadInt(ts, "ADR"); uint8 control = CCD_ReadInt(ts, "CONTROL"); uint8 pmin = CCD_ReadInt(ts, "PMIN"); uint8 psec = CCD_ReadInt(ts, "PSEC"); uint8 pframe = CCD_ReadInt(ts, "PFRAME"); signed plba = CCD_ReadInt(ts, "PLBA"); if(session != 1) throw MDFN_Error(0, "Unsupported TOC entry Session value: %u", session); // Reference: ECMA-394, page 5-14 switch(point) { default: throw MDFN_Error(0, "Unsupported TOC entry Point value: %u", point); break; case 0xA0: tocd.first_track = pmin; tocd.disc_type = psec; break; case 0xA1: tocd.last_track = pmin; break; case 0xA2: tocd.tracks[100].adr = adr; tocd.tracks[100].control = control; tocd.tracks[100].lba = plba; break; case 99: case 98: case 97: case 96: case 95: case 94: case 93: case 92: case 91: case 90: case 89: case 88: case 87: case 86: case 85: case 84: case 83: case 82: case 81: case 80: case 79: case 78: case 77: case 76: case 75: case 74: case 73: case 72: case 71: case 70: case 69: case 68: case 67: case 66: case 65: case 64: case 63: case 62: case 61: case 60: case 59: case 58: case 57: case 56: case 55: case 54: case 53: case 52: case 51: case 50: case 49: case 48: case 47: case 46: case 45: case 44: case 43: case 42: case 41: case 40: case 39: case 38: case 37: case 36: case 35: case 34: case 33: case 32: case 31: case 30: case 29: case 28: case 27: case 26: case 25: case 24: case 23: case 22: case 21: case 20: case 19: case 18: case 17: case 16: case 15: case 14: case 13: case 12: case 11: case 10: case 9: case 8: case 7: case 6: case 5: case 4: case 3: case 2: case 1: tocd.tracks[point].adr = adr; tocd.tracks[point].control = control; tocd.tracks[point].lba = plba; break; } } } // Convenience leadout track duplication. if(tocd.last_track < 99) tocd.tracks[tocd.last_track + 1] = tocd.tracks[100]; // // Open image stream. { std::string image_path = MDFN_EvalFIP(dir_path, file_base + std::string(".") + std::string(img_extsd), true); if(image_memcache) { img_stream = new MemoryStream(new FileStream(image_path.c_str(), MODE_READ)); } else { img_stream = new FileStream(image_path.c_str(), MODE_READ); } int64 ss = img_stream->size(); if(ss % 2352) throw MDFN_Error(0, _("CCD image size is not evenly divisible by 2352.")); img_numsectors = ss / 2352; } // // Open subchannel stream { std::string sub_path = MDFN_EvalFIP(dir_path, file_base + std::string(".") + std::string(sub_extsd), true); if(image_memcache) sub_stream = new MemoryStream(new FileStream(sub_path.c_str(), MODE_READ)); else sub_stream = new FileStream(sub_path.c_str(), MODE_READ); if(sub_stream->size() != (int64)img_numsectors * 96) throw MDFN_Error(0, _("CCD SUB file size mismatch.")); } CheckSubQSanity(); } // // Checks for Q subchannel mode 1(current time) data that has a correct checksum, but the data is nonsensical or corrupted nonetheless; this is the // case for some bad rips floating around on the Internet. Allowing these bad rips to be used will cause all sorts of problems during emulation, so we // error out here if a bad rip is detected. // // This check is not as aggressive or exhaustive as it could be, and will not detect all potential Q subchannel rip errors; as such, it should definitely NOT be // used in an effort to "repair" a broken rip. // void CDAccess_CCD::CheckSubQSanity(void) { size_t checksum_pass_counter = 0; int prev_lba = INT_MAX; uint8 prev_track = 0; for(size_t s = 0; s < img_numsectors; s++) { union { uint8 full[96]; struct { uint8 pbuf[12]; uint8 qbuf[12]; }; } buf; sub_stream->seek(s * 96, SEEK_SET); sub_stream->read(buf.full, 96); if(subq_check_checksum(buf.qbuf)) { uint8 adr = buf.qbuf[0] & 0xF; if(adr == 0x01) { uint8 track_bcd = buf.qbuf[1]; uint8 index_bcd = buf.qbuf[2]; uint8 rm_bcd = buf.qbuf[3]; uint8 rs_bcd = buf.qbuf[4]; uint8 rf_bcd = buf.qbuf[5]; uint8 am_bcd = buf.qbuf[7]; uint8 as_bcd = buf.qbuf[8]; uint8 af_bcd = buf.qbuf[9]; //printf("%2x %2x %2x\n", am_bcd, as_bcd, af_bcd); if(!BCD_is_valid(track_bcd) || !BCD_is_valid(index_bcd) || !BCD_is_valid(rm_bcd) || !BCD_is_valid(rs_bcd) || !BCD_is_valid(rf_bcd) || !BCD_is_valid(am_bcd) || !BCD_is_valid(as_bcd) || !BCD_is_valid(af_bcd) || rs_bcd > 0x59 || rf_bcd > 0x74 || as_bcd > 0x59 || af_bcd > 0x74) { throw MDFN_Error(0, _("Garbage subchannel Q data detected(bad BCD/out of range): %02x:%02x:%02x %02x:%02x:%02x"), rm_bcd, rs_bcd, rf_bcd, am_bcd, as_bcd, af_bcd); } else { int lba = ((BCD_to_U8(am_bcd) * 60 + BCD_to_U8(as_bcd)) * 75 + BCD_to_U8(af_bcd)) - 150; uint8 track = BCD_to_U8(track_bcd); prev_lba = lba; if(track < prev_track) throw MDFN_Error(0, _("Garbage subchannel Q data detected(bad track number)")); //else if(prev_track && track - pre prev_track = track; } checksum_pass_counter++; } } } //printf("%u/%u\n", checksum_pass_counter, img_numsectors); } void CDAccess_CCD::Cleanup(void) { if(img_stream) { delete img_stream; img_stream = NULL; } if(sub_stream) { delete sub_stream; sub_stream = NULL; } } CDAccess_CCD::~CDAccess_CCD() { Cleanup(); } void CDAccess_CCD::Read_Raw_Sector(uint8 *buf, int32 lba) { if(lba < 0 || (size_t)lba >= img_numsectors) throw(MDFN_Error(0, _("LBA out of range."))); uint8 sub_buf[96]; img_stream->seek(lba * 2352, SEEK_SET); img_stream->read(buf, 2352); sub_stream->seek(lba * 96, SEEK_SET); sub_stream->read(sub_buf, 96); subpw_interleave(sub_buf, buf + 2352); } void CDAccess_CCD::Read_TOC(CDUtility::TOC *toc) { *toc = tocd; } bool CDAccess_CCD::Is_Physical(void) throw() { return false; } void CDAccess_CCD::Eject(bool eject_status) { } mednafen/mednafen-driver.h000664 001750 001750 00000003642 12726204343 016706 0ustar00sergiosergio000000 000000 #ifndef __MDFN_MEDNAFEN_DRIVER_H #define __MDFN_MEDNAFEN_DRIVER_H #include #include #include #include "settings-common.h" extern std::vectorMDFNSystems; /* Indent stdout newlines +- "indent" amount */ void MDFN_indent(int indent); void MDFN_printf(const char *format, ...); #define MDFNI_printf MDFN_printf /* Displays an error. Can block or not. */ void MDFND_PrintError(const char *s); void MDFND_Message(const char *s); uint32 MDFND_GetTime(void); void MDFND_Sleep(uint32 ms); #ifdef WANT_THREADING /* Being threading support. */ // Mostly based off SDL's prototypes and semantics. // Driver code should actually define MDFN_Thread and MDFN_Mutex. struct MDFN_Thread; struct MDFN_Mutex; struct MDFN_Cond; MDFN_Thread *MDFND_CreateThread(int (*fn)(void *), void *data); void MDFND_WaitThread(MDFN_Thread *thread, int *status); void MDFND_KillThread(MDFN_Thread *thread); MDFN_Mutex *MDFND_CreateMutex(void); MDFN_Cond *MDFND_CreateCond(void); void MDFND_DestroyCond(MDFN_Cond *cond); void MDFND_DestroyMutex(MDFN_Mutex *mutex); int MDFND_WaitCond(MDFN_Cond *cond, MDFN_Mutex *mutex); int MDFND_SignalCond(MDFN_Cond *cond); int MDFND_LockMutex(MDFN_Mutex *mutex); int MDFND_UnlockMutex(MDFN_Mutex *mutex); /* End threading support. */ #endif /* path = path of game/file to load. returns NULL on failure. */ MDFNGI *MDFNI_LoadGame(const char *force_module, const char *path); MDFNGI *MDFNI_LoadCD(const char *sysname, const char *devicename); /* Sets the base directory(save states, snapshots, etc. are saved in directories below this directory. */ void MDFNI_SetBaseDirectory(const char *dir); void MDFN_DispMessage(const char *format, ...); #define MDFNI_DispMessage MDFN_DispMessage uint32 MDFNI_CRC32(uint32 crc, uint8 *buf, uint32 len); // NES hackish function. Should abstract in the future. int MDFNI_DatachSet(const uint8 *rcode); void MDFNI_DumpModulesDef(const char *fn); #endif jni/Android.mk000664 001750 001750 00000002763 12726204343 014406 0ustar00sergiosergio000000 000000 LOCAL_PATH := $(call my-dir) DEBUG = 0 FRONTEND_SUPPORTS_RGB565 = 1 FAST = 1 include $(CLEAR_VARS) ifeq ($(TARGET_ARCH),arm) ANDROID_FLAGS := -DANDROID_ARM LOCAL_ARM_MODE := arm endif ifeq ($(TARGET_ARCH),x86) ANDROID_FLAGS := -DANDROID_X86 IS_X86 = 1 endif ifeq ($(TARGET_ARCH),mips) ANDROID_FLAGS := -DANDROID_MIPS -D__mips__ -D__MIPSEL__ endif LOCAL_CXXFLAGS += $(ANDROID_FLAGS) LOCAL_CFLAGS += $(ANDROID_FLAGS) CORE_DIR := .. LOCAL_MODULE := libretro # If you have a system with 1GB RAM or more - cache the whole # CD for CD-based systems in order to prevent file access delays/hiccups CACHE_CD = 0 PTHREAD_FLAGS = -pthread NEED_CD = 1 NEED_BPP = 16 WANT_NEW_API = 1 NEED_BLIP = 1 NEED_STEREO_SOUND = 1 NEED_THREADING = 1 NEED_TREMOR = 1 NEED_CRC32 = 1 CORE_DEFINE := -DWANT_PCE_FAST_EMU TARGET_NAME := mednafen_pce_fast_libretro include ../Makefile.common LOCAL_SRC_FILES += $(SOURCES_CXX) $(SOURCES_C) EXTRA_GCC_FLAGS := -funroll-loops ifeq ($(DEBUG),0) FLAGS += -O3 $(EXTRA_GCC_FLAGS) else FLAGS += -O0 -g endif LDFLAGS += $(fpic) $(SHARED) FLAGS += $(fpic) $(NEW_GCC_FLAGS) $(INCFLAGS) FLAGS += $(ENDIANNESS_DEFINES) -DSIZEOF_DOUBLE=8 $(WARNINGS) -DMEDNAFEN_VERSION=\"0.9.26\" -DPACKAGE=\"mednafen\" -DMEDNAFEN_VERSION_NUMERIC=926 -DPSS_STYLE=1 -DMPC_FIXED_POINT $(CORE_DEFINE) -DSTDC_HEADERS -D__STDC_LIMIT_MACROS -D__LIBRETRO__ -DNDEBUG -D_LOW_ACCURACY_ $(SOUND_DEFINE) -DLSB_FIRST LOCAL_CFLAGS = $(FLAGS) LOCAL_CXXFLAGS = $(FLAGS) -fexceptions include $(BUILD_SHARED_LIBRARY) mednafen/tremor/window.h000664 001750 001750 00000002215 12726204343 016452 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: window functions ********************************************************************/ #ifndef _V_WINDOW_ #define _V_WINDOW_ extern const void *_vorbis_window(int type,int left); extern void _vorbis_apply_window(ogg_int32_t *d,const void *window[2], long *blocksizes, int lW,int W,int nW); #endif libretro-common/include/rthreads/rsemaphore.h000664 001750 001750 00000003467 12726204343 022604 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2015 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (rsemaphore.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_SEMAPHORE_H #define __LIBRETRO_SDK_SEMAPHORE_H typedef struct ssem ssem_t; /** * ssem_create: * @value : initial value for the semaphore * * Create a new semaphore. * * Returns: pointer to new semaphore if successful, otherwise NULL. */ ssem_t *ssem_new(int value); void ssem_free(ssem_t *semaphore); void ssem_wait(ssem_t *semaphore); void ssem_signal(ssem_t *semaphore); #endif /* __LIBRETRO_SDK_SEMAPHORE_H */ mednafen/tremor/codebook.h000664 001750 001750 00000007752 12726204343 016743 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: basic shared codebook operations ********************************************************************/ #ifndef _V_CODEBOOK_H_ #define _V_CODEBOOK_H_ #include "ogg.h" /* This structure encapsulates huffman and VQ style encoding books; it doesn't do anything specific to either. valuelist/quantlist are nonNULL (and q_* significant) only if there's entry->value mapping to be done. If encode-side mapping must be done (and thus the entry needs to be hunted), the auxiliary encode pointer will point to a decision tree. This is true of both VQ and huffman, but is mostly useful with VQ. */ typedef struct static_codebook{ long dim; /* codebook dimensions (elements per vector) */ long entries; /* codebook entries */ long *lengthlist; /* codeword lengths in bits */ /* mapping ***************************************************************/ int maptype; /* 0=none 1=implicitly populated values from map column 2=listed arbitrary values */ /* The below does a linear, single monotonic sequence mapping. */ long q_min; /* packed 32 bit float; quant value 0 maps to minval */ long q_delta; /* packed 32 bit float; val 1 - val 0 == delta */ int q_quant; /* bits: 0 < quant <= 16 */ int q_sequencep; /* bitflag */ long *quantlist; /* map == 1: (int)(entries^(1/dim)) element column map map == 2: list of dim*entries quantized entry vals */ } static_codebook; typedef struct codebook{ long dim; /* codebook dimensions (elements per vector) */ long entries; /* codebook entries */ long used_entries; /* populated codebook entries */ /* the below are ordered by bitreversed codeword and only used entries are populated */ int binarypoint; ogg_int32_t *valuelist; /* list of dim*entries actual entry values */ ogg_uint32_t *codelist; /* list of bitstream codewords for each entry */ int *dec_index; char *dec_codelengths; ogg_uint32_t *dec_firsttable; int dec_firsttablen; int dec_maxlength; long q_min; /* packed 32 bit float; quant value 0 maps to minval */ long q_delta; /* packed 32 bit float; val 1 - val 0 == delta */ } codebook; extern void vorbis_staticbook_destroy(static_codebook *b); extern int vorbis_book_init_decode(codebook *dest,const static_codebook *source); extern void vorbis_book_clear(codebook *b); extern long _book_maptype1_quantvals(const static_codebook *b); extern static_codebook *vorbis_staticbook_unpack(oggpack_buffer *b); extern long vorbis_book_decode(codebook *book, oggpack_buffer *b); extern long vorbis_book_decodevs_add(codebook *book, ogg_int32_t *a, oggpack_buffer *b,int n,int point); extern long vorbis_book_decodev_set(codebook *book, ogg_int32_t *a, oggpack_buffer *b,int n,int point); extern long vorbis_book_decodev_add(codebook *book, ogg_int32_t *a, oggpack_buffer *b,int n,int point); extern long vorbis_book_decodevv_add(codebook *book, ogg_int32_t **a, long off,int ch, oggpack_buffer *b,int n,int point); extern int _ilog(unsigned int v); #endif mednafen/tremor/window.c000664 001750 001750 00000004107 12726204343 016447 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: window functions ********************************************************************/ #include #include #include "misc.h" #include "window.h" #include "window_lookup.h" const void *_vorbis_window(int type, int left){ switch(type){ case 0: switch(left){ case 32: return vwin64; case 64: return vwin128; case 128: return vwin256; case 256: return vwin512; case 512: return vwin1024; case 1024: return vwin2048; case 2048: return vwin4096; case 4096: return vwin8192; default: return(0); } break; default: return(0); } } void _vorbis_apply_window(ogg_int32_t *d,const void *window_p[2], long *blocksizes, int lW,int W,int nW){ LOOKUP_T *window[2]={window_p[0],window_p[1]}; long n=blocksizes[W]; long ln=blocksizes[lW]; long rn=blocksizes[nW]; long leftbegin=n/4-ln/4; long leftend=leftbegin+ln/2; long rightbegin=n/2+n/4-rn/4; long rightend=rightbegin+rn/2; int i,p; for(i=0;i #include #include #else #define HAVE_MMAN #include #endif #if !defined(HAVE_MMAN) || defined(_WIN32) void* mmap(void *addr, size_t len, int mmap_prot, int mmap_flags, int fildes, size_t off); int munmap(void *addr, size_t len); int mprotect(void *addr, size_t len, int prot); #endif int memsync(void *start, void *end); int memprotect(void *addr, size_t len); #endif mednafen/cdrom/audioreader.h000664 001750 001750 00000001602 12726204343 017222 0ustar00sergiosergio000000 000000 #ifndef __MDFN_AUDIOREADER_H #define __MDFN_AUDIOREADER_H #include "../Stream.h" class AudioReader { public: AudioReader(); virtual ~AudioReader(); virtual int64 FrameCount(void); INLINE int64 Read(int64 frame_offset, int16 *buffer, int64 frames) { int64 ret; //if(frame_offset >= 0) { if(LastReadPos != frame_offset) { //puts("SEEK"); if(!Seek_(frame_offset)) return(0); LastReadPos = frame_offset; } } ret = Read_(buffer, frames); LastReadPos += ret; return(ret); } private: virtual int64 Read_(int16 *buffer, int64 frames); virtual bool Seek_(int64 frame_offset); int64 LastReadPos; }; // AR_Open(), and AudioReader, will NOT take "ownership" of the Stream object(IE it won't ever delete it). Though it does assume it has exclusive access // to it for as long as the AudioReader object exists. AudioReader *AR_Open(Stream *fp); #endif mednafen/tremor/codebook.c000664 001750 001750 00000024732 12726204343 016733 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: basic codebook pack/unpack/code/decode operations ********************************************************************/ #include #include #include #include "ogg.h" #include "ivorbiscodec.h" #include "codebook.h" #include "misc.h" /* unpacks a codebook from the packet buffer into the codebook struct, readies the codebook auxiliary structures for decode *************/ static_codebook *vorbis_staticbook_unpack(oggpack_buffer *opb){ long i,j; static_codebook *s=_ogg_calloc(1,sizeof(*s)); /* make sure alignment is correct */ if(oggpack_read(opb,24)!=0x564342)goto _eofout; /* first the basic parameters */ s->dim=oggpack_read(opb,16); s->entries=oggpack_read(opb,24); if(s->entries==-1)goto _eofout; if(_ilog(s->dim)+_ilog(s->entries)>24)goto _eofout; /* codeword ordering.... length ordered or unordered? */ switch((int)oggpack_read(opb,1)){ case 0:{ long unused; /* allocated but unused entries? */ unused=oggpack_read(opb,1); if((s->entries*(unused?1:5)+7)>>3>opb->storage-oggpack_bytes(opb)) goto _eofout; /* unordered */ s->lengthlist=(long *)_ogg_malloc(sizeof(*s->lengthlist)*s->entries); /* allocated but unused entries? */ if(unused){ /* yes, unused entries */ for(i=0;ientries;i++){ if(oggpack_read(opb,1)){ long num=oggpack_read(opb,5); if(num==-1)goto _eofout; s->lengthlist[i]=num+1; }else s->lengthlist[i]=0; } }else{ /* all entries used; no tagging */ for(i=0;ientries;i++){ long num=oggpack_read(opb,5); if(num==-1)goto _eofout; s->lengthlist[i]=num+1; } } break; } case 1: /* ordered */ { long length=oggpack_read(opb,5)+1; if(length==0)goto _eofout; s->lengthlist=(long *)_ogg_malloc(sizeof(*s->lengthlist)*s->entries); for(i=0;ientries;){ long num=oggpack_read(opb,_ilog(s->entries-i)); if(num==-1)goto _eofout; if(length>32 || num>s->entries-i || (num>0 && (num-1)>>(length>>1)>>((length+1)>>1))>0){ goto _errout; } for(j=0;jlengthlist[i]=length; length++; } } break; default: /* EOF */ goto _eofout; } /* Do we have a mapping to unpack? */ switch((s->maptype=oggpack_read(opb,4))){ case 0: /* no mapping */ break; case 1: case 2: /* implicitly populated value mapping */ /* explicitly populated value mapping */ s->q_min=oggpack_read(opb,32); s->q_delta=oggpack_read(opb,32); s->q_quant=oggpack_read(opb,4)+1; s->q_sequencep=oggpack_read(opb,1); if(s->q_sequencep==-1)goto _eofout; { int quantvals=0; switch(s->maptype){ case 1: quantvals=(s->dim==0?0:_book_maptype1_quantvals(s)); break; case 2: quantvals=s->entries*s->dim; break; } /* quantized values */ if((quantvals*s->q_quant+7)>>3>opb->storage-oggpack_bytes(opb)) goto _eofout; s->quantlist=(long *)_ogg_malloc(sizeof(*s->quantlist)*quantvals); for(i=0;iquantlist[i]=oggpack_read(opb,s->q_quant); if(quantvals&&s->quantlist[quantvals-1]==-1)goto _eofout; } break; default: goto _errout; } /* all set */ return(s); _errout: _eofout: vorbis_staticbook_destroy(s); return(NULL); } /* the 'eliminate the decode tree' optimization actually requires the codewords to be MSb first, not LSb. This is an annoying inelegancy (and one of the first places where carefully thought out design turned out to be wrong; Vorbis II and future Ogg codecs should go to an MSb bitpacker), but not actually the huge hit it appears to be. The first-stage decode table catches most words so that bitreverse is not in the main execution path. */ static ogg_uint32_t bitreverse(ogg_uint32_t x){ x= ((x>>16)&0x0000ffff) | ((x<<16)&0xffff0000); x= ((x>> 8)&0x00ff00ff) | ((x<< 8)&0xff00ff00); x= ((x>> 4)&0x0f0f0f0f) | ((x<< 4)&0xf0f0f0f0); x= ((x>> 2)&0x33333333) | ((x<< 2)&0xcccccccc); return((x>> 1)&0x55555555) | ((x<< 1)&0xaaaaaaaa); } STIN long decode_packed_entry_number(codebook *book, oggpack_buffer *b){ int read=book->dec_maxlength; long lo,hi; long lok = oggpack_look(b,book->dec_firsttablen); if (lok >= 0) { long entry = book->dec_firsttable[lok]; if(entry&0x80000000UL){ lo=(entry>>15)&0x7fff; hi=book->used_entries-(entry&0x7fff); }else{ oggpack_adv(b, book->dec_codelengths[entry-1]); return(entry-1); } }else{ lo=0; hi=book->used_entries; } lok = oggpack_look(b, read); while(lok<0 && read>1) lok = oggpack_look(b, --read); if(lok<0){ oggpack_adv(b,1); /* force eop */ return -1; } /* bisect search for the codeword in the ordered list */ { ogg_uint32_t testword=bitreverse((ogg_uint32_t)lok); while(hi-lo>1){ long p=(hi-lo)>>1; long test=book->codelist[lo+p]>testword; lo+=p&(test-1); hi-=p&(-test); } if(book->dec_codelengths[lo]<=read){ oggpack_adv(b, book->dec_codelengths[lo]); return(lo); } } oggpack_adv(b, read+1); return(-1); } /* Decode side is specced and easier, because we don't need to find matches using different criteria; we simply read and map. There are two things we need to do 'depending': We may need to support interleave. We don't really, but it's convenient to do it here rather than rebuild the vector later. Cascades may be additive or multiplicitive; this is not inherent in the codebook, but set in the code using the codebook. Like interleaving, it's easiest to do it here. addmul==0 -> declarative (set the value) addmul==1 -> additive addmul==2 -> multiplicitive */ /* returns the [original, not compacted] entry number or -1 on eof *********/ long vorbis_book_decode(codebook *book, oggpack_buffer *b){ if(book->used_entries>0){ long packed_entry=decode_packed_entry_number(book,b); if(packed_entry>=0) return(book->dec_index[packed_entry]); } /* if there's no dec_index, the codebook unpacking isn't collapsed */ return(-1); } /* returns 0 on OK or -1 on eof *************************************/ /* decode vector / dim granularity gaurding is done in the upper layer */ long vorbis_book_decodevs_add(codebook *book,ogg_int32_t *a, oggpack_buffer *b,int n,int point){ if(book->used_entries>0){ int step=n/book->dim; long *entry = (long *)alloca(sizeof(*entry)*step); ogg_int32_t **t = (ogg_int32_t **)alloca(sizeof(*t)*step); int i,j,o; int shift=point-book->binarypoint; if(shift>=0){ for (i = 0; i < step; i++) { entry[i]=decode_packed_entry_number(book,b); if(entry[i]==-1)return(-1); t[i] = book->valuelist+entry[i]*book->dim; } for(i=0,o=0;idim;i++,o+=step) for (j=0;j>shift; }else{ for (i = 0; i < step; i++) { entry[i]=decode_packed_entry_number(book,b); if(entry[i]==-1)return(-1); t[i] = book->valuelist+entry[i]*book->dim; } for(i=0,o=0;idim;i++,o+=step) for (j=0;jused_entries>0){ int i,j,entry; ogg_int32_t *t; int shift=point-book->binarypoint; if(shift>=0){ for(i=0;ivaluelist+entry*book->dim; for (j=0;jdim;) a[i++]+=t[j++]>>shift; } }else{ for(i=0;ivaluelist+entry*book->dim; for (j=0;jdim;) a[i++]+=t[j++]<<-shift; } } } return(0); } /* unlike the others, we guard against n not being an integer number of internally rather than in the upper layer (called only by floor0) */ long vorbis_book_decodev_set(codebook *book,ogg_int32_t *a, oggpack_buffer *b,int n,int point){ if(book->used_entries>0){ int i,j,entry; ogg_int32_t *t; int shift=point-book->binarypoint; if(shift>=0){ for(i=0;ivaluelist+entry*book->dim; for (j=0;idim;){ a[i++]=t[j++]>>shift; } } }else{ for(i=0;ivaluelist+entry*book->dim; for (j=0;idim;){ a[i++]=t[j++]<<-shift; } } } }else{ int i,j; for(i=0;iused_entries>0){ long i,j,entry; int chptr=0; int shift=point-book->binarypoint; if(shift>=0){ for(i=offset;ivaluelist+entry*book->dim; for (j=0;jdim;j++){ a[chptr++][i]+=t[j]>>shift; if(chptr==ch){ chptr=0; i++; } } } } }else{ for(i=offset;ivaluelist+entry*book->dim; for (j=0;jdim;j++){ a[chptr++][i]+=t[j]<<-shift; if(chptr==ch){ chptr=0; i++; } } } } } } return(0); } libretro-common/rthreads/000700 001750 001750 00000000000 12727366154 016627 5ustar00sergiosergio000000 000000 msvc/msvc-2010/000700 001750 001750 00000000000 12727366154 014203 5ustar00sergiosergio000000 000000 mednafen/cdrom/CDAccess_Image.cpp000664 001750 001750 00000070575 12726204343 020022 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 */ /* Notes and TODO: POSTGAP in CUE sheets may not be handled properly, should the directive automatically increment the index number? INDEX nn where 02 <= nn <= 99 is not supported in CUE sheets. TOC reading code is extremely barebones, leaving out support for more esoteric features. A PREGAP statement in the first track definition in a CUE sheet may not work properly(depends on what is proper); it will be added onto the implicit default 00:02:00 of pregap. Trying to read sectors at an LBA of less than 0 is not supported. TODO: support it(at least up to -150). */ #include "../mednafen.h" #include #include #include #include #include "../general.h" #include "../FileStream.h" #include "../MemoryStream.h" #include "CDAccess.h" #include "CDAccess_Image.h" #include "audioreader.h" #include using namespace CDUtility; enum { CDRF_SUBM_NONE = 0, CDRF_SUBM_RW = 1, CDRF_SUBM_RW_RAW = 2 }; // Disk-image(rip) track/sector formats enum { DI_FORMAT_AUDIO = 0x00, DI_FORMAT_MODE1 = 0x01, DI_FORMAT_MODE1_RAW = 0x02, DI_FORMAT_MODE2 = 0x03, DI_FORMAT_MODE2_FORM1 = 0x04, DI_FORMAT_MODE2_FORM2 = 0x05, DI_FORMAT_MODE2_RAW = 0x06, _DI_FORMAT_COUNT }; static const int32 DI_Size_Table[7] = { 2352, // Audio 2048, // MODE1 2352, // MODE1 RAW 2336, // MODE2 2048, // MODE2 Form 1 2324, // Mode 2 Form 2 2352 }; static const char *DI_CDRDAO_Strings[7] = { "AUDIO", "MODE1", "MODE1_RAW", "MODE2", "MODE2_FORM1", "MODE2_FORM2", "MODE2_RAW" }; static const char *DI_CUE_Strings[7] = { "AUDIO", "MODE1/2048", "MODE1/2352", // FIXME: These are just guesses: "MODE2/2336", "MODE2/2048", "MODE2/2324", "MODE2/2352" }; // Should return an offset to the start of the next argument(past any whitespace), or if there isn't a next argument, // it'll return the length of the src string. static size_t UnQuotify(const std::string &src, size_t source_offset, std::string &dest, bool parse_quotes = true) { const size_t source_len = src.length(); bool in_quote = 0; bool already_normal = 0; dest.clear(); while(source_offset < source_len) { if(src[source_offset] == ' ' || src[source_offset] == '\t') { if(!in_quote) { if(already_normal) // Trailing whitespace(IE we're done with this argument) break; else // Leading whitespace, ignore it. { source_offset++; continue; } } } if(src[source_offset] == '"' && parse_quotes) { if(in_quote) { source_offset++; // Not sure which behavior is most useful(or correct :b). #if 0 in_quote = false; already_normal = true; #else break; #endif } else in_quote = 1; } else { dest.push_back(src[source_offset]); already_normal = 1; } source_offset++; } while(source_offset < source_len) { if(src[source_offset] != ' ' && src[source_offset] != '\t') break; source_offset++; } return source_offset; } uint32 CDAccess_Image::GetSectorCount(CDRFILE_TRACK_INFO *track) { if(track->DIFormat == DI_FORMAT_AUDIO) { if(track->AReader) return(((track->AReader->FrameCount() * 4) - track->FileOffset) / 2352); else { const int64 size = track->fp->size(); //printf("%d %d %d\n", (int)stat_buf.st_size, (int)track->FileOffset, (int)stat_buf.st_size - (int)track->FileOffset); if(track->SubchannelMode) return((size - track->FileOffset) / (2352 + 96)); else return((size - track->FileOffset) / 2352); } } else { const int64 size = track->fp->size(); return((size - track->FileOffset) / DI_Size_Table[track->DIFormat]); } return(0); } void CDAccess_Image::ParseTOCFileLineInfo(CDRFILE_TRACK_INFO *track, const int tracknum, const std::string &filename, const char *binoffset, const char *msfoffset, const char *length, bool image_memcache, std::map &toc_streamcache) { long offset = 0; // In bytes! long tmp_long; int m, s, f; uint32 sector_mult; long sectors; std::map::iterator ribbit; ribbit = toc_streamcache.find(filename); if(ribbit != toc_streamcache.end()) { track->FirstFileInstance = 0; track->fp = ribbit->second; } else { std::string efn; track->FirstFileInstance = 1; efn = MDFN_EvalFIP(base_dir, filename); if(image_memcache) track->fp = new MemoryStream(new FileStream(efn.c_str(), MODE_READ)); else track->fp = new FileStream(efn.c_str(), MODE_READ); toc_streamcache[filename] = track->fp; } if(filename.length() >= 4 && !strcasecmp(filename.c_str() + filename.length() - 4, ".wav")) { track->AReader = AR_Open(track->fp); if(!track->AReader) throw MDFN_Error(0, "TODO ERROR"); } sector_mult = DI_Size_Table[track->DIFormat]; if(track->SubchannelMode) sector_mult += 96; if(binoffset && sscanf(binoffset, "%ld", &tmp_long) == 1) { offset += tmp_long; } if(msfoffset && sscanf(msfoffset, "%d:%d:%d", &m, &s, &f) == 3) { offset += ((m * 60 + s) * 75 + f) * sector_mult; } track->FileOffset = offset; // Make sure this is set before calling GetSectorCount()! sectors = GetSectorCount(track); //printf("Track: %d, offset: %ld, %ld\n", tracknum, offset, sectors); if(length) { tmp_long = sectors; if(sscanf(length, "%d:%d:%d", &m, &s, &f) == 3) tmp_long = (m * 60 + s) * 75 + f; else if(track->DIFormat == DI_FORMAT_AUDIO) { char *endptr = NULL; tmp_long = strtol(length, &endptr, 10); // Error? if(endptr == length) { tmp_long = sectors; } else tmp_long /= 588; } if(tmp_long > sectors) { throw MDFN_Error(0, _("Length specified in TOC file for track %d is too large by %ld sectors!\n"), tracknum, (long)(tmp_long - sectors)); } sectors = tmp_long; } track->sectors = sectors; } static void MDFN_strtoupper(char *str) { for(size_t x = 0; str[x]; x++) { if(str[x] >= 'a' && str[x] <= 'z') { str[x] = str[x] - 'a' + 'A'; } } } static void MDFN_strtoupper(std::string &str) { const size_t len = str.length(); for(size_t x = 0; x < len; x++) { if(str[x] >= 'a' && str[x] <= 'z') { str[x] = str[x] - 'a' + 'A'; } } } #if 0 std::string MDFN_toupper(const std::string &str) { const size_t len = str.length(); std::string new_str; new_str.reserve(len); for(size_t x = 0; x < len; x++) { int c = str[x]; if(c >= 'a' && c <= 'z') c = c - 'a' + 'A'; new_str.push_back(c); } } #endif void CDAccess_Image::ImageOpen(const char *path, bool image_memcache) { MemoryStream fp(new FileStream(path, MODE_READ)); static const unsigned max_args = 4; std::string linebuf; std::string cmdbuf, args[max_args]; bool IsTOC = FALSE; int32 active_track = -1; int32 AutoTrackInc = 1; // For TOC CDRFILE_TRACK_INFO TmpTrack; std::string file_base, file_ext; std::map toc_streamcache; disc_type = DISC_TYPE_CDDA_OR_M1; memset(&TmpTrack, 0, sizeof(TmpTrack)); MDFN_GetFilePathComponents(path, &base_dir, &file_base, &file_ext); if(!strcasecmp(file_ext.c_str(), ".toc")) { MDFN_printf(_("TOC file detected.\n")); IsTOC = true; } // Check for annoying UTF-8 BOM. if(!IsTOC) { uint8 bom_tmp[3]; if(fp.read(bom_tmp, 3, false) == 3 && bom_tmp[0] == 0xEF && bom_tmp[1] == 0xBB && bom_tmp[2] == 0xBF) { // Print an annoying error message, but don't actually error out. MDFN_PrintError(_("UTF-8 BOM detected at start of CUE sheet.")); } else fp.seek(0, SEEK_SET); } // Assign opposite maximum values so our tests will work! FirstTrack = 99; LastTrack = 0; linebuf.reserve(1024); while(fp.get_line(linebuf) >= 0) { unsigned argcount = 0; if(IsTOC) { // Handle TOC format comments size_t ss_loc = linebuf.find("//"); if(ss_loc != std::string::npos) linebuf.resize(ss_loc); } // Call trim AFTER we handle TOC-style comments, so we'll be sure to remove trailing whitespace in lines like: MONKEY // BABIES MDFN_trim(linebuf); if(linebuf.length() == 0) // Skip blank lines. continue; // Grab command and arguments. { size_t offs = 0; offs = UnQuotify(linebuf, offs, cmdbuf, false); for(argcount = 0; argcount < max_args && offs < linebuf.length(); argcount++) offs = UnQuotify(linebuf, offs, args[argcount]); // Make sure unused arguments are cleared out so we don't have inter-line leaks! for(unsigned x = argcount; x < max_args; x++) args[x].clear(); MDFN_strtoupper(cmdbuf); } //printf("%s\n", cmdbuf.c_str()); //: %s %s %s %s\n", cmdbuf.c_str(), args[0].c_str(), args[1].c_str(), args[2].c_str(), args[3].c_str()); if(IsTOC) { if(cmdbuf == "TRACK") { if(active_track >= 0) { memcpy(&Tracks[active_track], &TmpTrack, sizeof(TmpTrack)); memset(&TmpTrack, 0, sizeof(TmpTrack)); active_track = -1; } if(AutoTrackInc > 99) { throw(MDFN_Error(0, _("Invalid track number: %d"), AutoTrackInc)); } active_track = AutoTrackInc++; if(active_track < FirstTrack) FirstTrack = active_track; if(active_track > LastTrack) LastTrack = active_track; int format_lookup; for(format_lookup = 0; format_lookup < _DI_FORMAT_COUNT; format_lookup++) { if(!strcasecmp(args[0].c_str(), DI_CDRDAO_Strings[format_lookup])) { TmpTrack.DIFormat = format_lookup; break; } } if(format_lookup == _DI_FORMAT_COUNT) { throw(MDFN_Error(0, _("Invalid track format: %s"), args[0].c_str())); } if(TmpTrack.DIFormat == DI_FORMAT_AUDIO) TmpTrack.RawAudioMSBFirst = TRUE; // Silly cdrdao... if(!strcasecmp(args[1].c_str(), "RW")) { TmpTrack.SubchannelMode = CDRF_SUBM_RW; throw(MDFN_Error(0, _("\"RW\" format subchannel data not supported, only \"RW_RAW\" is!"))); } else if(!strcasecmp(args[1].c_str(), "RW_RAW")) TmpTrack.SubchannelMode = CDRF_SUBM_RW_RAW; } // end to TRACK else if(cmdbuf == "SILENCE") { //throw MDFN_Error(0, _("Unsupported directive: %s"), cmdbuf.c_str()); } else if(cmdbuf == "ZERO") { //throw MDFN_Error(0, _("Unsupported directive: %s"), cmdbuf.c_str()); } else if(cmdbuf == "FIFO") { throw MDFN_Error(0, _("Unsupported directive: %s"), cmdbuf.c_str()); } else if(cmdbuf == "FILE" || cmdbuf == "AUDIOFILE") { const char *binoffset = NULL; const char *msfoffset = NULL; const char *length = NULL; if(args[1].c_str()[0] == '#') { binoffset = args[1].c_str() + 1; msfoffset = args[2].c_str(); length = args[3].c_str(); } else { msfoffset = args[1].c_str(); length = args[2].c_str(); } //printf("%s, %s, %s, %s\n", args[0].c_str(), binoffset, msfoffset, length); ParseTOCFileLineInfo(&TmpTrack, active_track, args[0], binoffset, msfoffset, length, image_memcache, toc_streamcache); } else if(cmdbuf == "DATAFILE") { const char *binoffset = NULL; const char *length = NULL; if(args[1].c_str()[0] == '#') { binoffset = args[1].c_str() + 1; length = args[2].c_str(); } else length = args[1].c_str(); ParseTOCFileLineInfo(&TmpTrack, active_track, args[0], binoffset, NULL, length, image_memcache, toc_streamcache); } else if(cmdbuf == "INDEX") { } else if(cmdbuf == "PREGAP") { if(active_track < 0) { throw(MDFN_Error(0, _("Command %s is outside of a TRACK definition!\n"), cmdbuf.c_str())); } int m,s,f; sscanf(args[0].c_str(), "%d:%d:%d", &m, &s, &f); TmpTrack.pregap = (m * 60 + s) * 75 + f; } // end to PREGAP else if(cmdbuf == "START") { if(active_track < 0) { throw(MDFN_Error(0, _("Command %s is outside of a TRACK definition!\n"), cmdbuf.c_str())); } int m,s,f; sscanf(args[0].c_str(), "%d:%d:%d", &m, &s, &f); TmpTrack.pregap = (m * 60 + s) * 75 + f; } else if(cmdbuf == "TWO_CHANNEL_AUDIO") { TmpTrack.subq_control &= ~SUBQ_CTRLF_4CH; } else if(cmdbuf == "FOUR_CHANNEL_AUDIO") { TmpTrack.subq_control |= SUBQ_CTRLF_4CH; } else if(cmdbuf == "NO") { MDFN_strtoupper(args[0]); if(args[0] == "COPY") { TmpTrack.subq_control &= ~SUBQ_CTRLF_DCP; } else if(args[0] == "PRE_EMPHASIS") { TmpTrack.subq_control &= ~SUBQ_CTRLF_PRE; } else { throw MDFN_Error(0, _("Unsupported argument to \"NO\" directive: %s"), args[0].c_str()); } } else if(cmdbuf == "COPY") { TmpTrack.subq_control |= SUBQ_CTRLF_DCP; } else if(cmdbuf == "PRE_EMPHASIS") { TmpTrack.subq_control |= SUBQ_CTRLF_PRE; } // TODO: Confirm that these are taken from the TOC of the disc, and not synthesized by cdrdao. else if(cmdbuf == "CD_DA") disc_type = DISC_TYPE_CDDA_OR_M1; else if(cmdbuf == "CD_ROM") disc_type = DISC_TYPE_CDDA_OR_M1; else if(cmdbuf == "CD_ROM_XA") disc_type = DISC_TYPE_CD_XA; else { //throw MDFN_Error(0, _("Unsupported directive: %s"), cmdbuf.c_str()); } // TODO: CATALOG } /*********** END TOC HANDLING ************/ else // now for CUE sheet handling { if(cmdbuf == "FILE") { if(active_track >= 0) { memcpy(&Tracks[active_track], &TmpTrack, sizeof(TmpTrack)); memset(&TmpTrack, 0, sizeof(TmpTrack)); active_track = -1; } if(!MDFN_IsFIROPSafe(args[0])) { throw(MDFN_Error(0, _("Referenced path \"%s\" is potentially unsafe. See \"filesys.untrusted_fip_check\" setting.\n"), args[0].c_str())); } std::string efn = MDFN_EvalFIP(base_dir, args[0]); TmpTrack.fp = new FileStream(efn.c_str(), MODE_READ); TmpTrack.FirstFileInstance = 1; if(image_memcache) TmpTrack.fp = new MemoryStream(TmpTrack.fp); if(!strcasecmp(args[1].c_str(), "BINARY")) { //TmpTrack.Format = TRACK_FORMAT_DATA; //struct stat stat_buf; //fstat(fileno(TmpTrack.fp), &stat_buf); //TmpTrack.sectors = stat_buf.st_size; // / 2048; } else if(!strcasecmp(args[1].c_str(), "OGG") || !strcasecmp(args[1].c_str(), "VORBIS") || !strcasecmp(args[1].c_str(), "WAVE") || !strcasecmp(args[1].c_str(), "WAV") || !strcasecmp(args[1].c_str(), "PCM") || !strcasecmp(args[1].c_str(), "MPC") || !strcasecmp(args[1].c_str(), "MP+")) { TmpTrack.AReader = AR_Open(TmpTrack.fp); if(!TmpTrack.AReader) { throw(MDFN_Error(0, _("Unsupported audio track file format: %s\n"), args[0].c_str())); } } else { throw(MDFN_Error(0, _("Unsupported track format: %s\n"), args[1].c_str())); } } else if(cmdbuf == "TRACK") { if(active_track >= 0) { memcpy(&Tracks[active_track], &TmpTrack, sizeof(TmpTrack)); TmpTrack.FirstFileInstance = 0; TmpTrack.pregap = 0; TmpTrack.pregap_dv = 0; TmpTrack.postgap = 0; TmpTrack.index[0] = -1; TmpTrack.index[1] = 0; } active_track = atoi(args[0].c_str()); if(active_track < FirstTrack) FirstTrack = active_track; if(active_track > LastTrack) LastTrack = active_track; int format_lookup; for(format_lookup = 0; format_lookup < _DI_FORMAT_COUNT; format_lookup++) { if(!strcasecmp(args[1].c_str(), DI_CUE_Strings[format_lookup])) { TmpTrack.DIFormat = format_lookup; break; } } if(format_lookup == _DI_FORMAT_COUNT) { throw(MDFN_Error(0, _("Invalid track format: %s\n"), args[1].c_str())); } if(active_track < 0 || active_track > 99) { throw(MDFN_Error(0, _("Invalid track number: %d\n"), active_track)); } } else if(cmdbuf == "INDEX") { if(active_track >= 0) { unsigned int m,s,f; if(sscanf(args[1].c_str(), "%u:%u:%u", &m, &s, &f) != 3) { throw MDFN_Error(0, _("Malformed m:s:f time in \"%s\" directive: %s"), cmdbuf.c_str(), args[0].c_str()); } if(!strcasecmp(args[0].c_str(), "01") || !strcasecmp(args[0].c_str(), "1")) TmpTrack.index[1] = (m * 60 + s) * 75 + f; else if(!strcasecmp(args[0].c_str(), "00") || !strcasecmp(args[0].c_str(), "0")) TmpTrack.index[0] = (m * 60 + s) * 75 + f; } } else if(cmdbuf == "PREGAP") { if(active_track >= 0) { unsigned int m,s,f; if(sscanf(args[0].c_str(), "%u:%u:%u", &m, &s, &f) != 3) { throw MDFN_Error(0, _("Malformed m:s:f time in \"%s\" directive: %s"), cmdbuf.c_str(), args[0].c_str()); } TmpTrack.pregap = (m * 60 + s) * 75 + f; } } else if(cmdbuf == "POSTGAP") { if(active_track >= 0) { unsigned int m,s,f; if(sscanf(args[0].c_str(), "%u:%u:%u", &m, &s, &f) != 3) { throw MDFN_Error(0, _("Malformed m:s:f time in \"%s\" directive: %s"), cmdbuf.c_str(), args[0].c_str()); } TmpTrack.postgap = (m * 60 + s) * 75 + f; } } else if(cmdbuf == "REM") { } else if(cmdbuf == "FLAGS") { TmpTrack.subq_control &= ~(SUBQ_CTRLF_PRE | SUBQ_CTRLF_DCP | SUBQ_CTRLF_4CH); for(unsigned i = 0; i < argcount; i++) { if(args[i] == "DCP") { TmpTrack.subq_control |= SUBQ_CTRLF_DCP; } else if(args[i] == "4CH") { TmpTrack.subq_control |= SUBQ_CTRLF_4CH; } else if(args[i] == "PRE") { TmpTrack.subq_control |= SUBQ_CTRLF_PRE; } else if(args[i] == "SCMS") { // Not implemented, likely pointless. PROBABLY indicates that the copy bit of the subchannel Q control field is supposed to // alternate between 1 and 0 at 9.375 Hz(four 1, four 0, four 1, four 0, etc.). } else { throw MDFN_Error(0, _("Unknown CUE sheet \"FLAGS\" directive flag \"%s\".\n"), args[i].c_str()); } } } else if(cmdbuf == "CDTEXTFILE" || cmdbuf == "CATALOG" || cmdbuf == "ISRC" || cmdbuf == "TITLE" || cmdbuf == "PERFORMER" || cmdbuf == "SONGWRITER") { MDFN_printf(_("Unsupported CUE sheet directive: \"%s\".\n"), cmdbuf.c_str()); // FIXME, generic logger passed by pointer to constructor } else { throw MDFN_Error(0, _("Unknown CUE sheet directive \"%s\".\n"), cmdbuf.c_str()); } } // end of CUE sheet handling } // end of fgets() loop if(active_track >= 0) memcpy(&Tracks[active_track], &TmpTrack, sizeof(TmpTrack)); if(FirstTrack > LastTrack) { throw(MDFN_Error(0, _("No tracks found!\n"))); } FirstTrack = FirstTrack; NumTracks = 1 + LastTrack - FirstTrack; int32 RunningLBA = 0; int32 LastIndex = 0; long FileOffset = 0; for(int x = FirstTrack; x < (FirstTrack + NumTracks); x++) { if(Tracks[x].DIFormat == DI_FORMAT_AUDIO) Tracks[x].subq_control &= ~SUBQ_CTRLF_DATA; else Tracks[x].subq_control |= SUBQ_CTRLF_DATA; if(!IsTOC) // TOC-format disc_type calculation is handled differently. { switch(Tracks[x].DIFormat) { default: break; case DI_FORMAT_MODE2: case DI_FORMAT_MODE2_FORM1: case DI_FORMAT_MODE2_FORM2: case DI_FORMAT_MODE2_RAW: disc_type = DISC_TYPE_CD_XA; break; } } if(IsTOC) { RunningLBA += Tracks[x].pregap; Tracks[x].LBA = RunningLBA; RunningLBA += Tracks[x].sectors; RunningLBA += Tracks[x].postgap; } else // else handle CUE sheet... { if(Tracks[x].FirstFileInstance) { LastIndex = 0; FileOffset = 0; } RunningLBA += Tracks[x].pregap; Tracks[x].pregap_dv = 0; if(Tracks[x].index[0] != -1) Tracks[x].pregap_dv = Tracks[x].index[1] - Tracks[x].index[0]; FileOffset += Tracks[x].pregap_dv * DI_Size_Table[Tracks[x].DIFormat]; RunningLBA += Tracks[x].pregap_dv; Tracks[x].LBA = RunningLBA; // Make sure FileOffset this is set before the call to GetSectorCount() Tracks[x].FileOffset = FileOffset; Tracks[x].sectors = GetSectorCount(&Tracks[x]); if((x + 1) >= (FirstTrack + NumTracks) || Tracks[x+1].FirstFileInstance) { } else { // Fix the sector count if we have multiple tracks per one binary image file. if(Tracks[x + 1].index[0] == -1) Tracks[x].sectors = Tracks[x + 1].index[1] - Tracks[x].index[1]; else Tracks[x].sectors = Tracks[x + 1].index[0] - Tracks[x].index[1]; //Tracks[x + 1].index - Tracks[x].index; } //printf("Poo: %d %d\n", x, Tracks[x].sectors); RunningLBA += Tracks[x].sectors; RunningLBA += Tracks[x].postgap; //printf("%d, %ld %d %d %d %d\n", x, FileOffset, Tracks[x].index, Tracks[x].pregap, Tracks[x].sectors, Tracks[x].LBA); FileOffset += Tracks[x].sectors * DI_Size_Table[Tracks[x].DIFormat]; } // end to cue sheet handling } // end to track loop total_sectors = RunningLBA; } void CDAccess_Image::Cleanup(void) { for(int32 track = 0; track < 100; track++) { CDRFILE_TRACK_INFO *this_track = &Tracks[track]; if(this_track->FirstFileInstance) { if(Tracks[track].AReader) { delete Tracks[track].AReader; Tracks[track].AReader = NULL; } if(this_track->fp) { delete this_track->fp; this_track->fp = NULL; } } } } CDAccess_Image::CDAccess_Image(const char *path, bool image_memcache) : NumTracks(0), FirstTrack(0), LastTrack(0), total_sectors(0) { memset(Tracks, 0, sizeof(Tracks)); ImageOpen(path, image_memcache); } CDAccess_Image::~CDAccess_Image() { Cleanup(); } void CDAccess_Image::Read_Raw_Sector(uint8 *buf, int32 lba) { bool TrackFound = FALSE; uint8 SimuQ[0xC]; memset(buf + 2352, 0, 96); MakeSubPQ(lba, buf + 2352); subq_deinterleave(buf + 2352, SimuQ); for(int32 track = FirstTrack; track < (FirstTrack + NumTracks); track++) { CDRFILE_TRACK_INFO *ct = &Tracks[track]; if(lba >= (ct->LBA - ct->pregap_dv - ct->pregap) && lba < (ct->LBA + ct->sectors + ct->postgap)) { TrackFound = TRUE; // Handle pregap and postgap reading if(lba < (ct->LBA - ct->pregap_dv) || lba >= (ct->LBA + ct->sectors)) { //printf("Pre/post-gap read, LBA=%d(LBA-track_start_LBA=%d)\n", lba, lba - ct->LBA); memset(buf, 0, 2352); // Null sector data, per spec } else { if(ct->AReader) { int16 AudioBuf[588 * 2]; int frames_read = ct->AReader->Read((ct->FileOffset / 4) + (lba - ct->LBA) * 588, AudioBuf, 588); ct->LastSamplePos += frames_read; if(frames_read < 0 || frames_read > 588) // This shouldn't happen. { printf("Error: frames_read out of range: %d\n", frames_read); frames_read = 0; } if(frames_read < 588) memset((uint8 *)AudioBuf + frames_read * 2 * sizeof(int16), 0, (588 - frames_read) * 2 * sizeof(int16)); for(int i = 0; i < 588 * 2; i++) MDFN_en16lsb(buf + i * 2, AudioBuf[i]); } else // Binary, woo. { long SeekPos = ct->FileOffset; long LBARelPos = lba - ct->LBA; SeekPos += LBARelPos * DI_Size_Table[ct->DIFormat]; if(ct->SubchannelMode) SeekPos += 96 * (lba - ct->LBA); ct->fp->seek(SeekPos, SEEK_SET); switch(ct->DIFormat) { case DI_FORMAT_AUDIO: ct->fp->read(buf, 2352); if(ct->RawAudioMSBFirst) Endian_A16_Swap(buf, 588 * 2); break; case DI_FORMAT_MODE1: ct->fp->read(buf + 12 + 3 + 1, 2048); encode_mode1_sector(lba + 150, buf); break; case DI_FORMAT_MODE1_RAW: case DI_FORMAT_MODE2_RAW: ct->fp->read(buf, 2352); break; case DI_FORMAT_MODE2: ct->fp->read(buf + 16, 2336); encode_mode2_sector(lba + 150, buf); break; // FIXME: M2F1, M2F2, does sub-header come before or after user data(standards say before, but I wonder // about cdrdao...). case DI_FORMAT_MODE2_FORM1: ct->fp->read(buf + 24, 2048); //encode_mode2_form1_sector(lba + 150, buf); break; case DI_FORMAT_MODE2_FORM2: ct->fp->read(buf + 24, 2324); //encode_mode2_form2_sector(lba + 150, buf); break; } if(ct->SubchannelMode) ct->fp->read(buf + 2352, 96); } } // end if audible part of audio track read. break; } // End if LBA is in range } // end track search loop if(!TrackFound) { throw(MDFN_Error(0, _("Could not find track for sector %u!"), lba)); } #if 0 if(qbuf[0] & 0x40) { uint8 dummy_buf[2352 + 96]; bool any_mismatch = FALSE; memcpy(dummy_buf + 16, buf + 16, 2048); memset(dummy_buf + 2352, 0, 96); MakeSubPQ(lba, dummy_buf + 2352); encode_mode1_sector(lba + 150, dummy_buf); for(int i = 0; i < 2352 + 96; i++) { if(dummy_buf[i] != buf[i]) { printf("Mismatch at %d, %d: %02x:%02x; ", lba, i, dummy_buf[i], buf[i]); any_mismatch = TRUE; } } if(any_mismatch) puts("\n"); } #endif //subq_deinterleave(buf + 2352, qbuf); //printf("%02x\n", qbuf[0]); //printf("%02x\n", buf[12 + 3]); } // // Note: this function makes use of the current contents(as in |=) in SubPWBuf. // void CDAccess_Image::MakeSubPQ(int32 lba, uint8 *SubPWBuf) { uint8 buf[0xC]; int32 track; uint32 lba_relative; uint32 ma, sa, fa; uint32 m, s, f; uint8 pause_or = 0x00; bool track_found = FALSE; for(track = FirstTrack; track < (FirstTrack + NumTracks); track++) { if(lba >= (Tracks[track].LBA - Tracks[track].pregap_dv - Tracks[track].pregap) && lba < (Tracks[track].LBA + Tracks[track].sectors + Tracks[track].postgap)) { track_found = TRUE; break; } } //printf("%d %d\n", Tracks[1].LBA, Tracks[1].sectors); if(!track_found) { printf("MakeSubPQ error for sector %u!", lba); track = FirstTrack; } lba_relative = abs((int32)lba - Tracks[track].LBA); f = (lba_relative % 75); s = ((lba_relative / 75) % 60); m = (lba_relative / 75 / 60); fa = (lba + 150) % 75; sa = ((lba + 150) / 75) % 60; ma = ((lba + 150) / 75 / 60); uint8 adr = 0x1; // Q channel data encodes position uint8 control = Tracks[track].subq_control; // Handle pause(D7 of interleaved subchannel byte) bit, should be set to 1 when in pregap or postgap. if((lba < Tracks[track].LBA) || (lba >= Tracks[track].LBA + Tracks[track].sectors)) { //printf("pause_or = 0x80 --- %d\n", lba); pause_or = 0x80; } // Handle pregap between audio->data track { int32 pg_offset = (int32)lba - Tracks[track].LBA; // If we're more than 2 seconds(150 sectors) from the real "start" of the track/INDEX 01, and the track is a data track, // and the preceding track is an audio track, encode it as audio(by taking the SubQ control field from the preceding track). // // TODO: Look into how we're supposed to handle subq control field in the four combinations of track types(data/audio). // if(pg_offset < -150) { if((Tracks[track].subq_control & SUBQ_CTRLF_DATA) && (FirstTrack < track) && !(Tracks[track - 1].subq_control & SUBQ_CTRLF_DATA)) { //printf("Pregap part 1 audio->data: lba=%d track_lba=%d\n", lba, Tracks[track].LBA); control = Tracks[track - 1].subq_control; } } } memset(buf, 0, 0xC); buf[0] = (adr << 0) | (control << 4); buf[1] = U8_to_BCD(track); if(lba < Tracks[track].LBA) // Index is 00 in pregap buf[2] = U8_to_BCD(0x00); else buf[2] = U8_to_BCD(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(int i = 0; i < 96; i++) SubPWBuf[i] |= (((buf[i >> 3] >> (7 - (i & 0x7))) & 1) ? 0x40 : 0x00) | pause_or; } void CDAccess_Image::Read_TOC(TOC *toc) { toc->Clear(); toc->first_track = FirstTrack; toc->last_track = FirstTrack + NumTracks - 1; toc->disc_type = disc_type; for(int i = toc->first_track; i <= toc->last_track; i++) { toc->tracks[i].lba = Tracks[i].LBA; toc->tracks[i].adr = ADR_CURPOS; toc->tracks[i].control = Tracks[i].subq_control; } toc->tracks[100].lba = total_sectors; toc->tracks[100].adr = ADR_CURPOS; toc->tracks[100].control = toc->tracks[toc->last_track].control & 0x4; // Convenience leadout track duplication. if(toc->last_track < 99) toc->tracks[toc->last_track + 1] = toc->tracks[100]; } bool CDAccess_Image::Is_Physical(void) throw() { return(false); } void CDAccess_Image::Eject(bool eject_status) { } mednafen/pce_fast/huc.h000664 001750 001750 00000000462 12726204343 016200 0ustar00sergiosergio000000 000000 int HuCLoad(const uint8 *data, uint32 len, uint32 crc32) MDFN_COLD; int HuCLoadCD(const char *bios_path) MDFN_COLD; void HuC_Close(void) MDFN_COLD; int HuC_StateAction(StateMem *sm, int load, int data_only); void HuC_Power(void) MDFN_COLD; DECLFR(PCE_ACRead); DECLFW(PCE_ACWrite); extern bool PCE_IsCD; libretro-common/include/boolean.h000664 001750 001750 00000003250 12726204343 020230 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2015 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (boolean.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_BOOLEAN_H #define __LIBRETRO_SDK_BOOLEAN_H #ifndef __cplusplus #if defined(_MSC_VER) && !defined(SN_TARGET_PS3) /* Hack applied for MSVC when compiling in C89 mode as it isn't C99 compliant. */ #define bool unsigned char #define true 1 #define false 0 #else #include #endif #endif #endif mednafen/include/blargg_common.h000664 001750 001750 00000011103 12726204343 020060 0ustar00sergiosergio000000 000000 // Sets up common environment for Shay Green's libraries. // To change configuration options, modify blargg_config.h, not this file. #ifndef BLARGG_COMMON_H #define BLARGG_COMMON_H #include #include #include #include #undef BLARGG_COMMON_H // allow blargg_config.h to #include blargg_common.h #include "blargg_config.h" #ifndef BLARGG_COMMON_H #define BLARGG_COMMON_H // STATIC_CAST(T,expr): Used in place of static_cast (expr) #ifndef STATIC_CAST #define STATIC_CAST(T,expr) ((T) (expr)) #endif // blargg_err_t (0 on success, otherwise error string) #ifndef blargg_err_t typedef const char* blargg_err_t; #endif // blargg_vector - very lightweight vector of POD types (no constructor/destructor) template class blargg_vector { T* begin_; size_t size_; public: blargg_vector() : begin_( 0 ), size_( 0 ) { } ~blargg_vector() { free( begin_ ); } size_t size() const { return size_; } T* begin() const { return begin_; } T* end() const { return begin_ + size_; } blargg_err_t resize( size_t n ) { void* p = realloc( begin_, n * sizeof (T) ); if ( !p && n ) return "Out of memory"; begin_ = (T*) p; size_ = n; return 0; } void clear() { void* p = begin_; begin_ = 0; size_ = 0; free( p ); } T& operator [] ( size_t n ) const { assert( n <= size_ ); // <= to allow past-the-end value return begin_ [n]; } }; #ifndef BLARGG_DISABLE_NOTHROW #if __cplusplus < 199711 #define BLARGG_THROWS( spec ) #else #define BLARGG_THROWS( spec ) throw spec #endif #define BLARGG_DISABLE_NOTHROW \ void* operator new ( size_t s ) BLARGG_THROWS(()) { return malloc( s ); }\ void operator delete ( void* p ) { free( p ); } #define BLARGG_NEW new #else #include #define BLARGG_NEW new (std::nothrow) #endif #define BLARGG_4CHAR( a, b, c, d ) \ ((a&0xFF)*0x1000000L + (b&0xFF)*0x10000L + (c&0xFF)*0x100L + (d&0xFF)) // BOOST_STATIC_ASSERT( expr ): Generates compile error if expr is 0. #ifndef BOOST_STATIC_ASSERT #ifdef _MSC_VER // MSVC6 (_MSC_VER < 1300) fails for use of __LINE__ when /Zl is specified #define BOOST_STATIC_ASSERT( expr ) \ void blargg_failed_( int (*arg) [2 / (int) !!(expr) - 1] ) #else // Some other compilers fail when declaring same function multiple times in class, // so differentiate them by line #define BOOST_STATIC_ASSERT( expr ) \ void blargg_failed_( int (*arg) [2 / !!(expr) - 1] [__LINE__] ) #endif #endif // BLARGG_COMPILER_HAS_BOOL: If 0, provides bool support for old compiler. If 1, // compiler is assumed to support bool. If undefined, availability is determined. #ifndef BLARGG_COMPILER_HAS_BOOL #if defined (__MWERKS__) #if !__option(bool) #define BLARGG_COMPILER_HAS_BOOL 0 #endif #elif defined (_MSC_VER) #if _MSC_VER < 1100 #define BLARGG_COMPILER_HAS_BOOL 0 #endif #elif defined (__GNUC__) // supports bool #elif __cplusplus < 199711 #define BLARGG_COMPILER_HAS_BOOL 0 #endif #endif #if defined (BLARGG_COMPILER_HAS_BOOL) && !BLARGG_COMPILER_HAS_BOOL // If you get errors here, modify your blargg_config.h file typedef int bool; const bool true = 1; const bool false = 0; #endif // blargg_long/blargg_ulong = at least 32 bits, int if it's big enough #include #if INT_MAX >= 0x7FFFFFFF typedef int blargg_long; #else typedef long blargg_long; #endif #if UINT_MAX >= 0xFFFFFFFF typedef unsigned blargg_ulong; #else typedef unsigned long blargg_ulong; #endif // BOOST::int8_t etc. // HAVE_STDINT_H: If defined, use for int8_t etc. #if defined (HAVE_STDINT_H) #include #define BOOST // HAVE_INTTYPES_H: If defined, use for int8_t etc. #elif defined (HAVE_INTTYPES_H) #include #define BOOST #else struct BOOST { #if UCHAR_MAX == 0xFF && SCHAR_MAX == 0x7F typedef signed char int8_t; typedef unsigned char uint8_t; #else // No suitable 8-bit type available typedef struct see_blargg_common_h int8_t; typedef struct see_blargg_common_h uint8_t; #endif #if USHRT_MAX == 0xFFFF typedef short int16_t; typedef unsigned short uint16_t; #else // No suitable 16-bit type available typedef struct see_blargg_common_h int16_t; typedef struct see_blargg_common_h uint16_t; #endif #if ULONG_MAX == 0xFFFFFFFF typedef long int32_t; typedef unsigned long uint32_t; #elif UINT_MAX == 0xFFFFFFFF typedef int int32_t; typedef unsigned int uint32_t; #else // No suitable 32-bit type available typedef struct see_blargg_common_h int32_t; typedef struct see_blargg_common_h uint32_t; #endif }; #endif #endif #endif msvc/msvc-2010/libretro.def000664 001750 001750 00000001011 12726204343 016500 0ustar00sergiosergio000000 000000 LIBRARY "msvc-2010" EXPORTS retro_set_environment retro_set_video_refresh retro_set_audio_sample retro_set_audio_sample_batch retro_set_input_poll retro_set_input_state retro_init retro_deinit retro_api_version retro_get_system_info retro_get_system_av_info retro_set_controller_port_device retro_reset retro_run retro_serialize_size retro_serialize retro_unserialize retro_cheat_reset retro_cheat_set retro_load_game retro_load_game_special retro_unload_game retro_get_region retro_get_memory_data retro_get_memory_size libretro-common/streams/000700 001750 001750 00000000000 12727366154 016471 5ustar00sergiosergio000000 000000 libretro-common/queues/000700 001750 001750 00000000000 12727366154 016322 5ustar00sergiosergio000000 000000 mednafen/pce_fast/vdc.cpp000664 001750 001750 00000106227 12726204343 016536 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 */ /* VDC and VCE emulation */ /* "Tonight I hooked up my Turbo Duo(with no games or CDs in it)'s video output to my PC sound card, recorded it, and did a FFT and looked at the spectrum(around the line rate, 15-16KHz), and I also counted the number of samples between the ~60Hz peaks(just to verify that the math shown below is remotely accurate). The spectrum peaked at 15734 Hz. 21477272.727272... / 3 / 15734 = 455.00(CPU cycles per scanline)" */ #include "pce.h" #include "../video.h" #include "vdc.h" #include "huc.h" #include "pcecd.h" #include "../FileStream.h" #include static uint32 userle; // User layer enable. static uint32 disabled_layer_color; static bool unlimited_sprites; static bool correct_aspect; #define ULE_BG0 1 #define ULE_SPR0 2 #define ULE_BG1 4 #define ULE_SPR1 8 static const uint8 bat_width_shift_tab[4] = { 5, 6, 7, 7 }; static const uint8 bat_height_mask_tab[2] = { 32 - 1, 64 - 1 }; static unsigned int VDS; static unsigned int VSW; static unsigned int VDW; static unsigned int VCR; static unsigned int VBlankFL; vce_t vce; vdc_t *vdc = NULL; #define MAKECOLOR_PCE(val) ((((val & 0x038) >> 3) << 13)|(((((val & 0x038) >> 3) & 0x6) << 10) | (((val & 0x1c0) >> 6) << 8) | (((val & 0x1c0) >> 6) << 5) | ((val & 0x007) << 2) | ((val & 0x007) >> 1))) static INLINE void MDFN_FastU32MemsetM8(uint32_t *array, uint32_t value_32, unsigned int u32len) { uint32_t *ai; for(ai = array; ai < array + u32len; ai += 2) { ai[0] = value_32; ai[1] = value_32; } } static INLINE void FixPCache(int entry) { if(!(entry & 0xFF)) { uint16_t color0 = MAKECOLOR_PCE(vce.color_table[entry & 0x100]); for(int x = 0; x < 16; x++) vce.color_table_cache[entry + (x << 4)] = color0 ; return; } if(entry & 0xF) vce.color_table_cache[entry] = MAKECOLOR_PCE(vce.color_table[entry]); } static INLINE void FixTileCache(vdc_t *which_vdc, uint16 A) { uint32 charname = (A >> 4); uint32 y = (A & 0x7); uint64 *tc = &which_vdc->bg_tile_cache[charname][y]; uint32 bitplane01 = which_vdc->VRAM[y + charname * 16]; uint32 bitplane23 = which_vdc->VRAM[y+ 8 + charname * 16]; *tc = 0; for(int x = 0; x < 8; x++) { uint32 raw_pixel = ((bitplane01 >> x) & 1); raw_pixel |= ((bitplane01 >> (x + 8)) & 1) << 1; raw_pixel |= ((bitplane23 >> x) & 1) << 2; raw_pixel |= ((bitplane23 >> (x + 8)) & 1) << 3; #ifdef MSB_FIRST *tc |= (uint64)raw_pixel << ((x) * 8); #else *tc |= (uint64)raw_pixel << ((7 - x) * 8); #endif } } static INLINE void CheckFixSpriteTileCache(vdc_t *which_vdc, uint16 no, uint32 special) { if(special != 0x4 && special != 0x5) special = 0; if((special | 0x80) == which_vdc->spr_tile_clean[no]) return; //printf("Oops: %d, %d, %d\n", no, special | 0x100, which_vdc->spr_tile_clean[no]); if((no * 64) >= VRAM_Size) { //printf("Unmapped: %d\n", no); //VDC_UNDEFINED("Unmapped VRAM sprite tile read"); // Unnecessary, since we reset the sprite tile cache to 0 on reset/init anyway. //memset(which_vdc->spr_tile_cache[no], 0x00, 16 * 16 * sizeof(uint16)); } else if(special) { for(int y = 0; y < 16; y++) { uint8 *tc = which_vdc->spr_tile_cache[no][y]; uint32 bitplane0 = which_vdc->VRAM[y + 0x00 + no * 0x40 + ((special & 1) << 5)]; uint32 bitplane1 = which_vdc->VRAM[y + 0x10 + no * 0x40 + ((special & 1) << 5)]; for(int x = 0; x < 16; x++) { uint32 raw_pixel; raw_pixel = ((bitplane0 >> x) & 1) << 0; raw_pixel |= ((bitplane1 >> x) & 1) << 1; tc[x] = raw_pixel; } } } else { for(int y = 0; y < 16; y++) { uint8 *tc = which_vdc->spr_tile_cache[no][y]; uint32 bitplane0 = which_vdc->VRAM[y + 0x00 + no * 0x40]; uint32 bitplane1 = which_vdc->VRAM[y + 0x10 + no * 0x40]; uint32 bitplane2 = which_vdc->VRAM[y + 0x20 + no * 0x40]; uint32 bitplane3 = which_vdc->VRAM[y + 0x30 + no * 0x40]; for(int x = 0; x < 16; x++) { uint32 raw_pixel; raw_pixel = ((bitplane0 >> x) & 1) << 0; raw_pixel |= ((bitplane1 >> x) & 1) << 1; raw_pixel |= ((bitplane2 >> x) & 1) << 2; raw_pixel |= ((bitplane3 >> x) & 1) << 3; tc[x] = raw_pixel; } } } which_vdc->spr_tile_clean[no] = special | 0x80; } static INLINE void SetVCECR(uint8 V) { if(((V & 0x80) >> 7) != vce.bw) { vce.bw = V & 0x80; for(int x = 0; x < 512; x++) FixPCache(x); } vce.lc263 = (V & 0x04); vce.dot_clock = V & 1; if(V & 2) vce.dot_clock = 2; vce.CR = V; } static unsigned int frame_counter; static int32 need_vbi[2] = { 0, 0 }; static int32 line_leadin1 = 0; static int32 magical, cyc_tot; vpc_t vpc; // Some virtual vdc macros to make code simpler to read #define M_vdc_HSW (vdc->HSR & 0x1F) // Horizontal Synchro Width #define M_vdc_HDS ((vdc->HSR >> 8) & 0x7F) // Horizontal Display Start #define M_vdc_HDW (vdc->HDR & 0x7F) // Horizontal Display Width #define M_vdc_HDE ((vdc->HDR >> 8) & 0x7F) // Horizontal Display End #define M_vdc_VSW (vdc->VSR & 0x1F) // Vertical synchro width #define M_vdc_VDS ((vdc->VSR >> 8) & 0xFF) // Vertical Display Start #define M_vdc_VDW (vdc->VDR & 0x1FF) // Vertical Display Width(Height? :b) #define M_vdc_VCR (vdc->VCR & 0xFF) #define VDCS_CR 0x01 // Sprite #0 collision interrupt occurred #define VDCS_OR 0x02 // sprite overflow "" "" #define VDCS_RR 0x04 // RCR "" "" #define VDCS_DS 0x08 // VRAM to SAT DMA completion interrupt occurred #define VDCS_DV 0x10 // VRAM to VRAM DMA completion interrupt occurred #define VDCS_VD 0x20 // Vertical blank interrupt occurred #define VDCS_BSY 0x40 // VDC is waiting for a CPU access slot during the active display area?? void VDC_SetPixelFormat(void) { // I know the temptation is there, but don't combine these two loops just // because they loop 512 times ;) for(int x = 0; x < 512; x++) FixPCache(x); disabled_layer_color = MAKECOLOR(0x00, 0xFE, 0x00, 0); } DECLFR(VCE_Read) { switch(A & 0x7) { case 4: return (vce.color_table[vce.ctaddress & 0x1FF]); case 5: { uint8 ret = vce.color_table[vce.ctaddress & 0x1FF] >> 8; ret &= 1; ret |= 0xFE; vce.ctaddress++; return(ret); } } return(0xFF); } DECLFW(VCE_Write) { //printf("%04x %02x, %04x\n", A, V, HuCPU.PC); switch(A&0x7) { case 0: SetVCECR(V); break; case 2: vce.ctaddress &= 0x100; vce.ctaddress |= V; break; case 3: vce.ctaddress &= 0x0FF; vce.ctaddress |= (V & 1) << 8; break; case 4: vce.color_table[vce.ctaddress & 0x1FF] &= 0x100; vce.color_table[vce.ctaddress & 0x1FF] |= V; FixPCache(vce.ctaddress & 0x1FF); break; case 5: vce.color_table[vce.ctaddress & 0x1FF] &= 0xFF; vce.color_table[vce.ctaddress & 0x1FF] |= (V & 1) << 8; FixPCache(vce.ctaddress & 0x1FF); vce.ctaddress++; break; } } void VDC_SetLayerEnableMask(uint64 mask) { userle = mask; } DECLFW(VDC_Write_ST) { //printf("WriteST: %04x %02x\n", A, V); VDC_Write(A, V); } static void DoDMA(vdc_t *vdc) { // Assuming one cycle for reads, one cycle for write, with DMA? for(int i = 0; i < 455; i++) { if(!vdc->DMAReadWrite) { if(vdc->SOUR >= VRAM_Size) VDC_UNDEFINED("Unmapped VRAM DMA read"); vdc->DMAReadBuffer = vdc->VRAM[vdc->SOUR]; } else { if(vdc->DESR < VRAM_Size) { vdc->VRAM[vdc->DESR] = vdc->DMAReadBuffer; FixTileCache(vdc, vdc->DESR); vdc->spr_tile_clean[vdc->DESR >> 6] = 0; } //if(vdc->DCR & 0xC) //printf("Pllal: %02x\n", vdc->DCR); vdc->SOUR += (((vdc->DCR & 0x4) >> 1) ^ 2) - 1; vdc->DESR += (((vdc->DCR & 0x8) >> 2) ^ 2) - 1; vdc->LENR--; if(vdc->LENR == 0xFFFF) // DMA is done. { vdc->DMARunning = 0; if(vdc->DCR & 0x02) { vdc->status |= VDCS_DV; HuC6280_IRQBegin(MDFN_IQIRQ1); VDC_DEBUG("DMA IRQ"); } break; } } vdc->DMAReadWrite ^= 1; } // for() } DECLFW(VDC_Write) { int msb = A & 1; int chip = 0; A &= 0x3; //if((A == 0x2 || A == 0x3) && ((vdc->select & 0x1f) >= 0x09) && ((vdc->select & 0x1f) <= 0x13)) //printf("%04x, %02x: %02x, %d\n", A, vdc->select, V, vdc->display_counter); switch(A) { case 0x0: vdc->select = V & 0x1F; break; case 0x2: case 0x3: switch(vdc->select & 0x1F) { case 0x00: REGSETP(vdc->MAWR, V, msb); break; case 0x01: REGSETP(vdc->MARR, V, msb); if(msb) { if(vdc->MARR >= VRAM_Size) VDC_UNDEFINED("Unmapped VRAM VRR(MARR set) read"); vdc->read_buffer = vdc->VRAM[vdc->MARR]; } break; case 0x02: if(!msb) vdc->write_latch = V; else { if(vdc->MAWR < VRAM_Size) { // A hack to fix Crest of Wolf, and maybe others. while(vdc->DMARunning) DoDMA(vdc); vdc->VRAM[vdc->MAWR] = (V << 8) | vdc->write_latch; FixTileCache(vdc, vdc->MAWR); vdc->spr_tile_clean[vdc->MAWR >> 6] = 0; } else { //VDC_UNDEFINED("Unmapped VRAM write"); //printf("VROOM: %04x, %02x\n", vdc->MAWR, (vdc->CR >> 11) & 0x3); } vdc->MAWR += vram_inc_tab[(vdc->CR >> 11) & 0x3]; } break; case 0x05: REGSETP(vdc->CR, V, msb); break; case 0x06: REGSETP(vdc->RCR, V, msb); vdc->RCR &= 0x3FF; break; case 0x07: REGSETP(vdc->BXR, V, msb); vdc->BXR &= 0x3FF; break; case 0x08: REGSETP(vdc->BYR, V, msb); vdc->BYR &= 0x1FF; vdc->BG_YOffset = vdc->BYR; // Set it on LSB and MSB writes(only changing on MSB breaks Youkai Douchuuki) //printf("%04x\n", HuCPU.PC); break; case 0x09: REGSETP(vdc->MWR, V, msb); break; case 0x0a: REGSETP(vdc->HSR, V, msb); break; case 0x0b: REGSETP(vdc->HDR, V, msb); break; case 0x0c: REGSETP(vdc->VSR, V, msb); break; case 0x0d: REGSETP(vdc->VDR, V, msb); break; case 0x0e: REGSETP(vdc->VCR, V, msb); break; case 0x0f: REGSETP(vdc->DCR, V, msb); break; case 0x10: REGSETP(vdc->SOUR, V, msb); break; case 0x11: REGSETP(vdc->DESR, V, msb); break; case 0x12: REGSETP(vdc->LENR, V, msb); if(msb) { vdc->DMARunning = 1; vdc->DMAReadWrite = 0; if(vdc->burst_mode && !(vdc->DCR & 0x02)) DoDMA(vdc); // Do one line's worth of DMA transfers // because Cosmic Fantasy 4 is evil // and uses timed writes to the DMA // start register, rather than waiting until // the machine says we're done, // which would require cycle-accurate VDC emulation...like that's // going to happen when I don't even have accurate values // for HuC6280 instruction timings. :b } break; case 0x13: REGSETP(vdc->SATB, V, msb); vdc->SATBPending = 1; break; // default: printf("Oops 2: %04x %02x\n", vdc->select, V);break; } break; } } // 682 + 8 + 128 = 818. static INLINE void CalcStartEnd(const vdc_t *vdc, uint32 &start, uint32 &end) { //static const unsigned int ClockModeWidths[3] = { 288, 384, 576 }; static const unsigned int ClockPixelWidths[3] = { 341, 455, 682 }; start = (M_vdc_HDS + 1) * 8; // Semi-hack for Asuka 120% if(vce.dot_clock == 1 && M_vdc_HDS == 5 && M_vdc_HDE == 6 && M_vdc_HDW == 43 && M_vdc_HSW == 2) start -= 8; else if(vce.dot_clock == 0 && M_vdc_HDS == 2 && M_vdc_HDE == 3 && M_vdc_HDW == 33 && M_vdc_HSW == 2) start -= 4; // and for Addams Family else if(vce.dot_clock == 1 && M_vdc_HDS == 4 && M_vdc_HDE == 4 && M_vdc_HDW == 43 && M_vdc_HSW == 9) start -= 4; end = start + (M_vdc_HDW + 1) * 8; if(start > (ClockPixelWidths[vce.dot_clock])) start = ClockPixelWidths[vce.dot_clock]; if(end > (ClockPixelWidths[vce.dot_clock])) end = ClockPixelWidths[vce.dot_clock]; if(start == end) // In case HDS is way off-screen, REMOVE when we confirm the rest of the code won't flip out start = end - 8; // when start == end; // For: start - (vdc->BG_XOffset & 7) end += 8; start += 8; // For: alignment space when correct_aspect == 0 end += 128; start += 128; } #define CB_EXL(n) (((n) << 4) | ((n) << 12) | ((n) << 20) | ((n) << 28) | ((n) << 36) | ((n) << 44) | ((n) << 52) | ((n) << 60)) static const uint64 cblock_exlut[16] = { CB_EXL(0ULL), CB_EXL(1ULL), CB_EXL(2ULL), CB_EXL(3ULL), CB_EXL(4ULL), CB_EXL(5ULL), CB_EXL(6ULL), CB_EXL(7ULL), CB_EXL(8ULL), CB_EXL(9ULL), CB_EXL(10ULL), CB_EXL(11ULL), CB_EXL(12ULL), CB_EXL(13ULL), CB_EXL(14ULL), CB_EXL(15ULL) }; static void DrawBG(const vdc_t *vdc, const uint32 count, uint8 *target) NO_INLINE; static void DrawBG(const vdc_t *vdc, const uint32 count, uint8 *target) { int bat_width_shift = bat_width_shift_tab[(vdc->MWR >> 4) & 3]; int bat_width_mask = (1U << bat_width_shift) - 1; int bat_height_mask = bat_height_mask_tab[(vdc->MWR >> 6) & 1]; uint64 *target64 = (uint64 *)target; { int bat_y = ((vdc->BG_YOffset >> 3) & bat_height_mask) << bat_width_shift; int bat_boom = (vdc->BG_XOffset >> 3) & bat_width_mask; int line_sub = vdc->BG_YOffset & 7; const uint16 *BAT_Base = &vdc->VRAM[bat_y]; const uint64 *CG_Base = &vdc->bg_tile_cache[0][line_sub]; uint64_t cg_mask = 0xFFFFFFFFFFFFFFFFULL; if((vdc->MWR & 0x3) == 0x3) cg_mask = (vdc->MWR & 0x80) ? 0xCCCCCCCCCCCCCCCCULL : 0x3333333333333333ULL; for(int x = count - 1; x >= 0; x -= 8) { const uint16 bat = BAT_Base[bat_boom]; const uint64 color_or = cblock_exlut[bat >> 12]; *target64 = (CG_Base[(bat & 0xFFF) * 8] & cg_mask) | color_or; bat_boom = (bat_boom + 1) & bat_width_mask; target64++; } } } #define SPRF_PRIORITY 0x00080 #define SPRF_HFLIP 0x00800 #define SPRF_VFLIP 0x08000 #define SPRF_SPRITE0 0x10000 static const unsigned int sprite_height_tab[4] = { 16, 32, 64, 64 }; static const unsigned int sprite_height_no_mask[4] = { ~0U, ~2U, ~6U, ~6U }; static INLINE void RebuildSATCache(vdc_t *vdc) { unsigned i; SAT_Cache_t *sat_ptr = (SAT_Cache_t*)vdc->SAT_Cache; vdc->SAT_Cache_Valid = 0; for(i = 0; i < 64; i++) { uint16 height; const uint16 SATR0 = vdc->SAT[i * 4 + 0x0]; const uint16 SATR1 = vdc->SAT[i * 4 + 0x1]; const uint16 SATR2 = vdc->SAT[i * 4 + 0x2]; const uint16 SATR3 = vdc->SAT[i * 4 + 0x3]; int16 y = (int16)(SATR0 & 0x3FF) - 0x40; uint16 x = SATR1 & 0x3FF; uint16 no = (SATR2 >> 1) & 0x3FF; uint16 flags = (SATR3); bool cgmode = SATR2 & 0x1; uint32 width = ((flags >> 8) & 1); flags &= ~0x100; height = sprite_height_tab[(flags >> 12) & 3]; no &= sprite_height_no_mask[(flags >> 12) & 3]; no = ((no & ~width) | 0) ^ ((flags & SPRF_HFLIP) ? width : 0); sat_ptr->y = y; sat_ptr->height = height; sat_ptr->x = x; sat_ptr->no = no; sat_ptr->flags = flags; sat_ptr->cgmode = cgmode; sat_ptr++; vdc->SAT_Cache_Valid++; if(width) { no = ((no & ~width) | 1) ^ ((flags & SPRF_HFLIP) ? width : 0); x += 16; *sat_ptr = *(sat_ptr - 1); sat_ptr->no = no; sat_ptr->x = x; sat_ptr++; vdc->SAT_Cache_Valid++; } } } static INLINE void DoSATDMA(vdc_t *vdc) { unsigned i; if(vdc->SATB > (VRAM_Size - 0x100)) VDC_UNDEFINED("Unmapped VRAM SATB DMA read"); for(i = 0; i < 256; i++) vdc->SAT[i] = vdc->VRAM[(vdc->SATB + i) & 0xFFFF]; RebuildSATCache(vdc); } typedef struct { uint32 x; uint32 flags; uint8 palette_index; uint16 no; uint16 sub_y; } SPRLE; #define SPR_HPMASK 0x8000 // High priority bit mask // DrawSprites will write up to 0x20 units before the start of the pointer it's passed. static void DrawSprites(vdc_t *vdc, const int32 end, uint16 *spr_linebuf) NO_INLINE; static void DrawSprites(vdc_t *vdc, const int32 end, uint16 *spr_linebuf) { int active_sprites = 0; SPRLE SpriteList[64 * 2]; // (see unlimited_sprites option, *2 to accomodate 32-pixel-width sprites ) //16]; // First, grab the up to 16(or 128 for unlimited_sprites) sprite units(16xWHATEVER; each 32xWHATEVER sprite counts as 2 sprite units when // rendering a scanline) for this scanline. for(int i = 0; i < vdc->SAT_Cache_Valid; i++) { const SAT_Cache_t *SATR = &vdc->SAT_Cache[i]; int16 y = SATR->y; uint16 x = SATR->x; uint16 no = SATR->no; const uint16 flags = SATR->flags; const uint8 cgmode = SATR->cgmode; const uint16 height = SATR->height; const uint32 palette_index = (flags & 0xF) << 4; uint32 y_offset = vdc->RCRCount - y; if(y_offset < height) { if(active_sprites == 16) { if(vdc->CR & 0x2) { vdc->status |= VDCS_OR; HuC6280_IRQBegin(MDFN_IQIRQ1); VDC_DEBUG("Overflow IRQ"); } if(!unlimited_sprites) break; } if(flags & SPRF_VFLIP) y_offset = height - 1 - y_offset; no |= (y_offset & 0x30) >> 3; SpriteList[active_sprites].flags = flags; //printf("Found: %d %d\n", vdc->RCRCount, x); SpriteList[active_sprites].x = x; SpriteList[active_sprites].palette_index = palette_index; SpriteList[active_sprites].no = no; SpriteList[active_sprites].sub_y = (y_offset & 15); CheckFixSpriteTileCache(vdc, no, (vdc->MWR & 0xC) | cgmode); SpriteList[active_sprites].flags |= i ? 0 : SPRF_SPRITE0; active_sprites++; } } //if(!active_sprites) // return; #if 0 memset(spr_linebuf, 0, sizeof(uint16) * end); #else MDFN_FastU32MemsetM8((uint32 *)spr_linebuf, 0, ((end + 3) >> 1) & ~1); #endif if(!active_sprites) return; for(int i = (active_sprites - 1) ; i >= 0; i--) { int32 pos = SpriteList[i].x - 0x20; uint32 prio_or; uint16 *dest_pix; if(pos > end) continue; dest_pix = &spr_linebuf[pos]; prio_or = 0x100 | SpriteList[i].palette_index; if(SpriteList[i].flags & SPRF_PRIORITY) prio_or |= SPR_HPMASK; const uint8 *pix_source = vdc->spr_tile_cache[SpriteList[i].no][SpriteList[i].sub_y]; int increment = -1; int32 x_second = 15; if(SpriteList[i].flags & SPRF_HFLIP) { increment = 1; x_second = 0; } if((SpriteList[i].flags & SPRF_SPRITE0) && (vdc->CR & 0x01)) { for(int32 x = 0; x < 16; x++, x_second += increment) { const uint32 raw_pixel = pix_source[x_second]; if(raw_pixel) { if(((uint32)pos + x) >= (uint32)end) // Covers negative and overflowing the right side(to prevent spurious sprite hits) continue; if(dest_pix[x] & 0x100) { vdc->status |= VDCS_CR; VDC_DEBUG("Sprite hit IRQ"); HuC6280_IRQBegin(MDFN_IQIRQ1); } dest_pix[x] = raw_pixel | prio_or; } } } // End sprite0 handling else // No sprite0 hit: { // x must be signed, for "pos + x" to not be promoted to unsigned, which will cause a stack overflow. // for(int32 x = 0; x < 16; x++, x_second += increment) { const uint32 raw_pixel = pix_source[x_second]; if(raw_pixel) dest_pix[x] = raw_pixel | prio_or; } } // End no sprite0 hit } } static INLINE void MixBGSPR(const uint32 count_in, const uint8 *bg_linebuf_in, const uint16 *spr_linebuf_in, uint16_t *target_in) { for(unsigned int x = 0; x < count_in; x++) { const uint32 bg_pixel = bg_linebuf_in[x]; const uint32 spr_pixel = spr_linebuf_in[x]; uint32 pixel = bg_pixel; if ((spr_pixel & SPR_HPMASK) || !(bg_pixel & 0x0F)) pixel = spr_pixel; target_in[x] = vce.color_table_cache[pixel & 0x1FF]; } } static void MixBGOnly(const uint32 count, const uint8 *bg_linebuf, uint16_t *target) { unsigned x; for(x = 0; x < count; x++) target[x] = vce.color_table_cache[bg_linebuf[x]]; } static void MixSPROnly(const uint32 count, const uint16 *spr_linebuf, uint16_t *target) { unsigned x; for(x = 0; x < count; x++) target[x] = vce.color_table_cache[(spr_linebuf[x] | 0x100) & 0x1FF]; } static void MixNone(const uint32 count, uint16_t *target) { unsigned x; uint32 bg_color = vce.color_table_cache[0x000]; for(x = 0; x < count; x++) target[x] = bg_color; } void DrawOverscan(const vdc_t *vdc, uint16_t *target, const MDFN_Rect *lw, const bool full = true, const int32 vpl = 0, const int32 vpr = 0) { uint32 os_color = vce.color_table_cache[0x100]; //printf("%d %d\n", lw->x, lw->w); int x = lw->x; if(!full) { for(; x < vpl; x++) target[x] = os_color; x = vpr; } for(; x < lw->x + lw->w; x++) target[x] = os_color; } void VDC_RunFrame(EmulateSpecStruct *espec, bool IsHES) { int max_dc = 0; MDFN_Surface *surface = espec->surface; MDFN_Rect *DisplayRect = &espec->DisplayRect; int32 *LineWidths = espec->LineWidths; bool skip = espec->skip || IsHES; // x and w should be overwritten in the big loop if(!skip) { DisplayRect->x = 0; DisplayRect->w = 256; DisplayRect->y = MDFN_GetSettingUI("pce_fast.slstart"); DisplayRect->h = MDFN_GetSettingUI("pce_fast.slend") - DisplayRect->y + 1; } do { const bool SHOULD_DRAW = (!skip && (int)frame_counter >= (DisplayRect->y + 14) && (int)frame_counter < (DisplayRect->y + DisplayRect->h + 14)); if(frame_counter == 0) { VDS = M_vdc_VDS; VSW = M_vdc_VSW; VDW = M_vdc_VDW; VCR = M_vdc_VCR; VBlankFL = VDS + VSW + VDW + 1; if(VBlankFL > 261) VBlankFL = 261; } need_vbi[0] = need_vbi[1] = 0; #if 1 line_leadin1 = 0; magical = M_vdc_HDS + (M_vdc_HDW + 1) + M_vdc_HDE; magical = (magical + 2) & ~1; magical -= M_vdc_HDW + 1; cyc_tot = magical * 8; //ClockPixelWidths[vce.dot_clock] - magical * 8; cyc_tot-=2; switch(vce.dot_clock) { case 0: cyc_tot = 4 * cyc_tot / 3; break; case 1: break; case 2: cyc_tot = 2 * cyc_tot / 3; break; } if(cyc_tot < 0) cyc_tot = 0; line_leadin1 = cyc_tot; #endif #if 0 { int vdc_to_master = 4; line_leadin1 = 1365 - ((M_vdc_HDW + 1) * 8 - 4 + 6) * vdc_to_master; if(line_leadin1 < 0) { line_leadin1 = 0; puts("Eep"); } if(M_vdc_HDS > 2) line_leadin1 += 2; line_leadin1 = line_leadin1 / 3; } if(line_leadin1 < 0) line_leadin1 = 0; else if(line_leadin1 > 400) line_leadin1 = 400; #endif //printf("%d\n", line_leadin1); if(max_dc < vce.dot_clock) max_dc = vce.dot_clock; if(!skip) { static const int ws[2][3] = { { 341, 341, 682 }, { 256, 341, 512 } }; DisplayRect->x = 0; DisplayRect->w = ws[correct_aspect][vce.dot_clock]; } int chip = 0; { if(frame_counter == 0) { vdc->display_counter = 0; vdc->burst_mode = !(vdc->CR & 0xC0); } if(vdc->display_counter == (VDS + VSW)) { vdc->burst_mode = !(vdc->CR & 0xC0); vdc->RCRCount = 0; } int have_free_time = 1; if(!vdc->burst_mode && vdc->display_counter >= (VDS + VSW) && vdc->display_counter < (VDS + VSW + VDW + 1)) have_free_time = 0; if(have_free_time) // We're outside of the active display area. Weehee { if(vdc->DMARunning) DoDMA(vdc); } if(vdc->display_counter == VBlankFL) { need_vbi[0] = 1; if(vdc->SATBPending || (vdc->DCR & 0x10)) { vdc->SATBPending = 0; vdc->sat_dma_slcounter = 2; DoSATDMA(vdc); } } if((int)vdc->RCRCount == ((int)vdc->RCR - 0x40) && (vdc->CR & 0x04)) { VDC_DEBUG("RCR IRQ"); vdc->status |= VDCS_RR; HuC6280_IRQBegin(MDFN_IQIRQ1); } } HuC6280_Run(line_leadin1); const bool fc_vrm = (frame_counter >= 14 && frame_counter < (14 + 242)); chip = 0; { MDFN_ALIGN(8) uint8 bg_linebuf[8 + 1024]; MDFN_ALIGN(8) uint16 spr_linebuf[16 + 1024]; uint16 *target_ptr16 = surface->pixels + (frame_counter - 14) * surface->pitch; if(fc_vrm && !skip) LineWidths[frame_counter - 14] = DisplayRect->w; if(vdc->burst_mode) { if(fc_vrm && SHOULD_DRAW) { DrawOverscan(vdc, target_ptr16, DisplayRect); } } else if(vdc->display_counter >= (VDS + VSW) && vdc->display_counter < (VDS + VSW + VDW + 1)) { if(vdc->display_counter == (VDS + VSW)) vdc->BG_YOffset = vdc->BYR; else vdc->BG_YOffset++; vdc->BG_XOffset = vdc->BXR; if(fc_vrm) { uint32 start, end; CalcStartEnd(vdc, start, end); if((vdc->CR & 0x80) && SHOULD_DRAW) { if(userle & (ULE_BG0)) DrawBG(vdc, end - start + (vdc->BG_XOffset & 7), bg_linebuf); else memset(bg_linebuf, 0, end - start + (vdc->BG_XOffset & 7)); } if((vdc->CR & 0x40) && (SHOULD_DRAW || (vdc->CR & 0x03))) // Don't skip sprite drawing if we can generate sprite #0 or sprite overflow IRQs. { if((userle & (ULE_SPR0)) || (vdc->CR & 0x03)) DrawSprites(vdc, end - start, spr_linebuf + 0x20); if(!(userle & (ULE_SPR0))) memset(spr_linebuf + 0x20, 0, sizeof(uint16) * (end - start)); } if(SHOULD_DRAW) { static const int xs[2][3] = { { 24 - 43, 38, 96 - 43 * 2 }, { 24, 38, 96 } }; int32 width = end - start; int32 source_offset = 0; int32 target_offset = start - (128 + 8 + xs[correct_aspect][vce.dot_clock]); if(target_offset < 0) { width += target_offset; source_offset += 0 - target_offset; target_offset = 0; } if((target_offset + width) > DisplayRect->w) width = (int32)DisplayRect->w - target_offset; //if(vdc->display_counter == 50) // MDFN_DispMessage("soffset=%d, toffset=%d, width=%d", source_offset, target_offset, width); if(width > 0) { //else if(target_ptr16) { switch(vdc->CR & 0xC0) { case 0xC0: MixBGSPR(width, bg_linebuf + (vdc->BG_XOffset & 7) + source_offset, spr_linebuf + 0x20 + source_offset, target_ptr16 + target_offset); break; case 0x80: MixBGOnly(width, bg_linebuf + (vdc->BG_XOffset & 7) + source_offset, target_ptr16 + target_offset); break; case 0x40: MixSPROnly(width, spr_linebuf + 0x20 + source_offset, target_ptr16 + target_offset); break; case 0x00: MixNone(width, target_ptr16 + target_offset); break; } } } //else if(target_ptr16) DrawOverscan(vdc, target_ptr16, DisplayRect, false, target_offset, target_offset + width); } // end if(SHOULD_DRAW) } } else if(SHOULD_DRAW && fc_vrm) // Hmm, overscan... { //else if(target_ptr16) DrawOverscan(vdc, target_ptr16, DisplayRect); } } if(SHOULD_DRAW && fc_vrm) { MDFN_MidLineUpdate(espec, frame_counter - 14); } if((vdc->CR & 0x08) && need_vbi[0]) vdc->status |= VDCS_VD; HuC6280_Run(2); if(vdc->status & VDCS_VD) { VDC_DEBUG("VBlank IRQ"); HuC6280_IRQBegin(MDFN_IQIRQ1); } HuC6280_Run(455 - line_leadin1 - 2); if(PCE_IsCD) { PCECD_Run(HuCPU.timestamp * 3); } { vdc->RCRCount++; //vdc->BG_YOffset = (vdc->BG_YOffset + 1); vdc->display_counter++; if(vdc->sat_dma_slcounter) { vdc->sat_dma_slcounter--; if(!vdc->sat_dma_slcounter) { if(vdc->DCR & 0x01) { VDC_DEBUG("Sprite DMA IRQ"); vdc->status |= VDCS_DS; HuC6280_IRQBegin(MDFN_IQIRQ1); } } } if(vdc->display_counter == (VDS + VSW + VDW + VCR + 3)) { vdc->display_counter = 0; } } frame_counter = (frame_counter + 1) % (vce.lc263 ? 263 : 262); //printf("%d\n", vce.lc263); } while(frame_counter != VBlankFL); // big frame loop! } void VDC_Reset(void) { vdc->read_buffer = 0xFFFF; vpc.priority[0] = vpc.priority[1] = 0x11; vdc->HSR = vdc->HDR = vdc->VSR = vdc->VDR = vdc->VCR = 0xFF; // Needed for Body Conquest 2 frame_counter = 0; } void VDC_Power(void) { memset(vdc, 0, sizeof(vdc_t)); VDC_Reset(); } void VDC_Init(int sgx) { unlimited_sprites = MDFN_GetSettingB("pce_fast.nospritelimit"); correct_aspect = MDFN_GetSettingB("pce_fast.correct_aspect"); userle = ~0; vdc = (vdc_t *)malloc(sizeof(vdc_t)); } void VDC_Close(void) { if(vdc) free(vdc); vdc = NULL; } int VDC_StateAction(StateMem *sm, int load, int data_only) { SFORMAT VCE_StateRegs[] = { SFVARN(vce.CR, "VCECR"), SFVARN(vce.lc263, "lc263"), SFVARN(vce.bw, "bw"), SFVARN(vce.dot_clock, "dot clock"), SFVARN(vce.ctaddress, "ctaddress"), SFARRAY16N(vce.color_table, 0x200, "color_table"), SFEND }; int ret = MDFNSS_StateAction(sm, load, data_only, VCE_StateRegs, "VCE"); int chip = 0; { SFORMAT VDC_StateRegs[] = { SFVARN(vdc->display_counter, "display_counter"), SFVARN(vdc->sat_dma_slcounter, "sat_dma_slcounter"), SFVARN(vdc->select, "select"), SFVARN(vdc->MAWR, "MAWR"), SFVARN(vdc->MARR, "MARR"), SFVARN(vdc->CR, "CR"), SFVARN(vdc->RCR, "RCR"), SFVARN(vdc->BXR, "BXR"), SFVARN(vdc->BYR, "BYR"), SFVARN(vdc->MWR, "MWR"), SFVARN(vdc->HSR, "HSR"), SFVARN(vdc->HDR, "HDR"), SFVARN(vdc->VSR, "VSR"), SFVARN(vdc->VDR, "VDR"), SFVARN(vdc->VCR, "VCR"), SFVARN(vdc->DCR, "DCR"), SFVARN(vdc->SOUR, "SOUR"), SFVARN(vdc->DESR, "DESR"), SFVARN(vdc->LENR, "LENR"), SFVARN(vdc->SATB, "SATB"), SFVARN(vdc->RCRCount, "RCRCount"), SFVARN(vdc->read_buffer, "read_buffer"), SFVARN(vdc->write_latch, "write_latch"), SFVARN(vdc->status, "status"), SFARRAY16N(vdc->SAT, 0x100, "SAT"), SFARRAY16N(vdc->VRAM, VRAM_Size, "VRAM"), SFVARN(vdc->DMAReadBuffer, "DMAReadBuffer"), SFVARN(vdc->DMAReadWrite, "DMAReadWrite"), SFVARN(vdc->DMARunning, "DMARunning"), SFVARN(vdc->SATBPending, "SATBPending"), SFVARN(vdc->burst_mode, "burst_mode"), SFVARN(vdc->BG_YOffset, "BG_YOffset"), SFVARN(vdc->BG_XOffset, "BG_XOffset"), SFVAR(frame_counter), SFVARN(VDS, "VDS_cache"), SFVARN(VSW, "VSW_cache"), SFVARN(VDW, "VDW_cache"), SFVARN(VCR, "VCR_cache"), SFVARN(VBlankFL, "VBlankFL_cache"), SFARRAY32(need_vbi, 2), SFVAR(line_leadin1), SFVAR(magical), SFVAR(cyc_tot), SFEND }; ret &= MDFNSS_StateAction(sm, load, data_only, VDC_StateRegs, "VDC0"); if(load) { for(int x = 0; x < VRAM_Size; x++) { FixTileCache(vdc, x); vdc->spr_tile_clean[x >> 6] = 0; } for(int x = 0; x < 512; x++) FixPCache(x); RebuildSATCache(vdc); } } return(ret); } mednafen/tremor/asm_arm.h000664 001750 001750 00000014606 12726204343 016571 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: arm7 and later wide math functions ********************************************************************/ #ifdef _ARM_ASSEM_ #if !defined(_V_WIDE_MATH) && !defined(_LOW_ACCURACY_) #define _V_WIDE_MATH static inline ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) { int lo,hi; asm volatile("smull\t%0, %1, %2, %3" : "=&r"(lo),"=&r"(hi) : "%r"(x),"r"(y) : "cc"); return(hi); } static inline ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) { return MULT32(x,y)<<1; } static inline ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) { int lo,hi; asm volatile("smull %0, %1, %2, %3\n\t" "movs %0, %0, lsr #15\n\t" "adc %1, %0, %1, lsl #17\n\t" : "=&r"(lo),"=&r"(hi) : "%r"(x),"r"(y) : "cc"); return(hi); } #define MB() asm volatile ("" : : : "memory") static inline void XPROD32(ogg_int32_t a, ogg_int32_t b, ogg_int32_t t, ogg_int32_t v, ogg_int32_t *x, ogg_int32_t *y) { int x1, y1, l; asm( "smull %0, %1, %4, %6\n\t" "smlal %0, %1, %5, %7\n\t" "rsb %3, %4, #0\n\t" "smull %0, %2, %5, %6\n\t" "smlal %0, %2, %3, %7" : "=&r" (l), "=&r" (x1), "=&r" (y1), "=r" (a) : "3" (a), "r" (b), "r" (t), "r" (v) : "cc" ); *x = x1; MB(); *y = y1; } static inline void XPROD31(ogg_int32_t a, ogg_int32_t b, ogg_int32_t t, ogg_int32_t v, ogg_int32_t *x, ogg_int32_t *y) { int x1, y1, l; asm( "smull %0, %1, %4, %6\n\t" "smlal %0, %1, %5, %7\n\t" "rsb %3, %4, #0\n\t" "smull %0, %2, %5, %6\n\t" "smlal %0, %2, %3, %7" : "=&r" (l), "=&r" (x1), "=&r" (y1), "=r" (a) : "3" (a), "r" (b), "r" (t), "r" (v) : "cc" ); *x = x1 << 1; MB(); *y = y1 << 1; } static inline void XNPROD31(ogg_int32_t a, ogg_int32_t b, ogg_int32_t t, ogg_int32_t v, ogg_int32_t *x, ogg_int32_t *y) { int x1, y1, l; asm( "rsb %2, %4, #0\n\t" "smull %0, %1, %3, %5\n\t" "smlal %0, %1, %2, %6\n\t" "smull %0, %2, %4, %5\n\t" "smlal %0, %2, %3, %6" : "=&r" (l), "=&r" (x1), "=&r" (y1) : "r" (a), "r" (b), "r" (t), "r" (v) : "cc" ); *x = x1 << 1; MB(); *y = y1 << 1; } #endif #ifndef _V_CLIP_MATH #define _V_CLIP_MATH static inline ogg_int32_t CLIP_TO_15(ogg_int32_t x) { int tmp; asm volatile("subs %1, %0, #32768\n\t" "movpl %0, #0x7f00\n\t" "orrpl %0, %0, #0xff\n" "adds %1, %0, #32768\n\t" "movmi %0, #0x8000" : "+r"(x),"=r"(tmp) : : "cc"); return(x); } #endif #ifndef _V_LSP_MATH_ASM #define _V_LSP_MATH_ASM static inline void lsp_loop_asm(ogg_uint32_t *qip,ogg_uint32_t *pip, ogg_int32_t *qexpp, ogg_int32_t *ilsp,ogg_int32_t wi, ogg_int32_t m){ ogg_uint32_t qi=*qip,pi=*pip; ogg_int32_t qexp=*qexpp; asm("mov r0,%3;" "movs r1,%5,asr#1;" "add r0,r0,r1,lsl#3;" "beq 2f;\n" "1:" "ldmdb r0!,{r1,r3};" "subs r1,r1,%4;" //ilsp[j]-wi "rsbmi r1,r1,#0;" //labs(ilsp[j]-wi) "umull %0,r2,r1,%0;" //qi*=labs(ilsp[j]-wi) "subs r1,r3,%4;" //ilsp[j+1]-wi "rsbmi r1,r1,#0;" //labs(ilsp[j+1]-wi) "umull %1,r3,r1,%1;" //pi*=labs(ilsp[j+1]-wi) "cmn r2,r3;" // shift down 16? "beq 0f;" "add %2,%2,#16;" "mov %0,%0,lsr #16;" "orr %0,%0,r2,lsl #16;" "mov %1,%1,lsr #16;" "orr %1,%1,r3,lsl #16;" "0:" "cmp r0,%3;\n" "bhi 1b;\n" "2:" // odd filter assymetry "ands r0,%5,#1;\n" "beq 3f;\n" "add r0,%3,%5,lsl#2;\n" "ldr r1,[r0,#-4];\n" "mov r0,#0x4000;\n" "subs r1,r1,%4;\n" //ilsp[j]-wi "rsbmi r1,r1,#0;\n" //labs(ilsp[j]-wi) "umull %0,r2,r1,%0;\n" //qi*=labs(ilsp[j]-wi) "umull %1,r3,r0,%1;\n" //pi*=labs(ilsp[j+1]-wi) "cmn r2,r3;\n" // shift down 16? "beq 3f;\n" "add %2,%2,#16;\n" "mov %0,%0,lsr #16;\n" "orr %0,%0,r2,lsl #16;\n" "mov %1,%1,lsr #16;\n" "orr %1,%1,r3,lsl #16;\n" //qi=(pi>>shift)*labs(ilsp[j]-wi); //pi=(qi>>shift)*labs(ilsp[j+1]-wi); //qexp+=shift; //} /* normalize to max 16 sig figs */ "3:" "mov r2,#0;" "orr r1,%0,%1;" "tst r1,#0xff000000;" "addne r2,r2,#8;" "movne r1,r1,lsr #8;" "tst r1,#0x00f00000;" "addne r2,r2,#4;" "movne r1,r1,lsr #4;" "tst r1,#0x000c0000;" "addne r2,r2,#2;" "movne r1,r1,lsr #2;" "tst r1,#0x00020000;" "addne r2,r2,#1;" "movne r1,r1,lsr #1;" "tst r1,#0x00010000;" "addne r2,r2,#1;" "mov %0,%0,lsr r2;" "mov %1,%1,lsr r2;" "add %2,%2,r2;" : "+r"(qi),"+r"(pi),"+r"(qexp) : "r"(ilsp),"r"(wi),"r"(m) : "r0","r1","r2","r3","cc"); *qip=qi; *pip=pi; *qexpp=qexp; } static inline void lsp_norm_asm(ogg_uint32_t *qip,ogg_int32_t *qexpp){ ogg_uint32_t qi=*qip; ogg_int32_t qexp=*qexpp; asm("tst %0,#0x0000ff00;" "moveq %0,%0,lsl #8;" "subeq %1,%1,#8;" "tst %0,#0x0000f000;" "moveq %0,%0,lsl #4;" "subeq %1,%1,#4;" "tst %0,#0x0000c000;" "moveq %0,%0,lsl #2;" "subeq %1,%1,#2;" "tst %0,#0x00008000;" "moveq %0,%0,lsl #1;" "subeq %1,%1,#1;" : "+r"(qi),"+r"(qexp) : : "cc"); *qip=qi; *qexpp=qexp; } #endif #endif mednafen/cdrom/galois.cpp000664 001750 001750 00000010655 12726204343 016557 0ustar00sergiosergio000000 000000 /* dvdisaster: Additional error correction for optical media. * Copyright (C) 2004-2007 Carsten Gnoerlich. * Project home page: http://www.dvdisaster.com * Email: carsten@dvdisaster.com -or- cgnoerlich@fsfe.org * * The Reed-Solomon error correction draws a lot of inspiration - and even code - * from Phil Karn's excellent Reed-Solomon library: http://www.ka9q.net/code/fec/ * * 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, * or direct your browser at http://www.gnu.org. */ #include "dvdisaster.h" #include "galois-inlines.h" /*** *** Galois field arithmetic. *** * Calculations are done over the extension field GF(2**n). * Be careful not to overgeneralize these arithmetics; * they only work for the case of GF(p**n) with p being prime. */ /* Initialize the Galois field tables */ GaloisTables* CreateGaloisTables(int32 gf_generator) { GaloisTables *gt = (GaloisTables *)calloc(1, sizeof(GaloisTables)); int32 b,log; /* Allocate the tables. The encoder uses a special version of alpha_to which has the mod_fieldmax() folded into the table. */ gt->gfGenerator = gf_generator; gt->indexOf = (int32 *)calloc(GF_FIELDSIZE, sizeof(int32)); gt->alphaTo = (int32 *)calloc(GF_FIELDSIZE, sizeof(int32)); gt->encAlphaTo = (int32 *)calloc(2*GF_FIELDSIZE, sizeof(int32)); /* create the log/ilog values */ for(b=1, log=0; logindexOf[b] = log; gt->alphaTo[log] = b; b = b << 1; if(b & GF_FIELDSIZE) b = b ^ gf_generator; } if(b!=1) { printf("Failed to create the Galois field log tables!\n"); exit(1); } /* we're even closed using infinity (makes things easier) */ gt->indexOf[0] = GF_ALPHA0; /* log(0) = inf */ gt->alphaTo[GF_ALPHA0] = 0; /* and the other way around */ for(b=0; b<2*GF_FIELDSIZE; b++) gt->encAlphaTo[b] = gt->alphaTo[mod_fieldmax(b)]; return gt; } void FreeGaloisTables(GaloisTables *gt) { if(gt->indexOf) free(gt->indexOf); if(gt->alphaTo) free(gt->alphaTo); if(gt->encAlphaTo) free(gt->encAlphaTo); free(gt); } /*** *** Create the the Reed-Solomon generator polynomial *** and some auxiliary data structures. */ ReedSolomonTables *CreateReedSolomonTables(GaloisTables *gt, int32 first_consecutive_root, int32 prim_elem, int nroots_in) { ReedSolomonTables *rt = (ReedSolomonTables *)calloc(1, sizeof(ReedSolomonTables)); int32 i,j,root; rt->gfTables = gt; rt->fcr = first_consecutive_root; rt->primElem = prim_elem; rt->nroots = nroots_in; rt->ndata = GF_FIELDMAX - rt->nroots; rt->gpoly = (int32 *)calloc((rt->nroots+1), sizeof(int32)); /* Create the RS code generator polynomial */ rt->gpoly[0] = 1; for(i=0, root=first_consecutive_root*prim_elem; inroots; i++, root+=prim_elem) { rt->gpoly[i+1] = 1; /* Multiply gpoly by alpha**(root+x) */ for(j=i; j>0; j--) { if(rt->gpoly[j] != 0) rt->gpoly[j] = rt->gpoly[j-1] ^ gt->alphaTo[mod_fieldmax(gt->indexOf[rt->gpoly[j]] + root)]; else rt->gpoly[j] = rt->gpoly[j-1]; } rt->gpoly[0] = gt->alphaTo[mod_fieldmax(gt->indexOf[rt->gpoly[0]] + root)]; } /* Store the polynomials index for faster encoding */ for(i=0; i<=rt->nroots; i++) rt->gpoly[i] = gt->indexOf[rt->gpoly[i]]; #if 0 /* for the precalculated unrolled loops only */ for(i=gt->nroots-1; i>0; i--) PrintCLI( " par_idx[((++spk)&%d)] ^= enc_alpha_to[feedback + %3d];\n", nroots-1,gt->gpoly[i]); PrintCLI(" par_idx[sp] = enc_alpha_to[feedback + %3d];\n", gt->gpoly[0]); #endif return rt; } void FreeReedSolomonTables(ReedSolomonTables *rt) { if(rt->gpoly) free(rt->gpoly); free(rt); } libretro-common/rthreads/xenon_sdl_threads.c000664 001750 001750 00000004064 12726204343 022504 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2015 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (xenon_sdl_threads.c). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ // libSDLxenon doesn't implement this yet :[. Implement it very stupidly for now. ;) #include "SDL_thread.h" #include "SDL_mutex.h" #include #include SDL_cond *SDL_CreateCond(void) { bool *sleeping = calloc(1, sizeof(*sleeping)); return (SDL_cond*)sleeping; } void SDL_DestroyCond(SDL_cond *sleeping) { free(sleeping); } int SDL_CondWait(SDL_cond *cond, SDL_mutex *lock) { (void)lock; volatile bool *sleeping = (volatile bool*)cond; SDL_mutexV(lock); *sleeping = true; while (*sleeping); /* Yeah, we all love busyloops don't we? ._. */ SDL_mutexP(lock); return 0; } int SDL_CondSignal(SDL_cond *cond) { *(volatile bool*)cond = false; return 0; } mednafen/pce_fast/vdc.h000664 001750 001750 00000010112 12726204343 016166 0ustar00sergiosergio000000 000000 #ifndef _PCE_VDC_H #define _PCE_VDC_H #define REGSETP(_reg, _data, _msb) { _reg &= 0xFF << ((_msb) ? 0 : 8); _reg |= (_data) << ((_msb) ? 8 : 0); } #define REGGETP(_reg, _msb) ((_reg >> ((_msb) ? 8 : 0)) & 0xFF) #define VDC_DEBUG(x) //printf("%s: %d\n", x, vdc->display_counter); #define VDC_UNDEFINED(x) { } //{ printf("%s: %d\n", x, vdc->display_counter); } static const uint8 vram_inc_tab[4] = { 1, 32, 64, 128 }; typedef struct { uint8 priority[2]; uint16 winwidths[2]; uint8 st_mode; } vpc_t; extern vpc_t vpc; static const int VRAM_Size = 0x8000; static const int VRAM_SizeMask = VRAM_Size - 1; //0x7FFF; static const int VRAM_BGTileNoMask = VRAM_SizeMask / 16; //0x7FF; typedef struct { uint8 CR; bool lc263; // 263 line count if set, 262 if not bool bw; // Black and White uint8 dot_clock; // Dot Clock(5, 7, or 10 MHz = 0, 1, 2) uint16 color_table[0x200]; uint16 color_table_cache[0x200]; uint16 ctaddress; } vce_t; extern vce_t vce; typedef struct { int16 y; uint16 height; uint16 x; uint16 no; uint16 flags; bool cgmode; } SAT_Cache_t; typedef struct { uint32 display_counter; int32 sat_dma_slcounter; uint8 select; uint16 MAWR; // Memory Address Write Register uint16 MARR; // Memory Address Read Register uint16 CR; // Control Register uint16 RCR; // Raster Compare Register uint16 BXR; // Background X-Scroll Register uint16 BYR; // Background Y-Scroll Register uint16 MWR; // Memory Width Register uint16 HSR; // Horizontal Sync Register uint16 HDR; // Horizontal Display Register uint16 VSR; uint16 VDR; uint16 VCR; uint16 DCR; uint16 SOUR; uint16 DESR; uint16 LENR; uint16 SATB; uint32 RCRCount; uint16 read_buffer; uint8 write_latch; uint8 status; uint16 DMAReadBuffer; bool DMAReadWrite; bool DMARunning; bool SATBPending; bool burst_mode; uint32 BG_YOffset; uint32 BG_XOffset; int SAT_Cache_Valid; // 64 through 128, depending on the number of 32-pixel-wide sprites. SAT_Cache_t SAT_Cache[128]; //64]; uint16 SAT[0x100]; uint16 VRAM[65536]; //VRAM_Size]; uint64 bg_tile_cache[65536][8]; // Tile, y, x uint8 spr_tile_cache[1024][16][16]; // Tile, y, x uint8 spr_tile_clean[1024]; //VRAM_Size / 64]; } vdc_t; extern vdc_t *vdc; void VDC_SetPixelFormat(void); void VDC_RunFrame(EmulateSpecStruct *espec, bool IsHES); void VDC_SetLayerEnableMask(uint64 mask); DECLFW(VDC_Write); DECLFW(VDC_Write_ST); DECLFR(VCE_Read); static INLINE uint8 VDC_Read(unsigned int A, bool SGX) { uint8 ret = 0; int msb = A & 1; int chip = 0; { A &= 0x3; } switch(A) { case 0x0: ret = vdc->status; vdc->status &= ~0x3F; HuC6280_IRQEnd(MDFN_IQIRQ1); // Clear VDC IRQ line break; case 0x2: case 0x3: ret = REGGETP(vdc->read_buffer, msb); if(vdc->select == 0x2) // VRR - VRAM Read Register { if(msb) { vdc->MARR += vram_inc_tab[(vdc->CR >> 11) & 0x3]; if(vdc->MARR >= VRAM_Size) VDC_UNDEFINED("Unmapped VRAM VRR read"); vdc->read_buffer = vdc->VRAM[vdc->MARR & VRAM_SizeMask]; } } break; } //if(HuCPU.isopread && (A == 1 || A == 3)) //(A == 2 || A == 3)) // && A == 1) if(A == 1) { //if(vdc->display_counter >= (VDS + VSW) && vdc->display_counter < (VDS + VSW + VDW + 1) && vce.dot_clock > 0) if(vce.dot_clock > 0) ret = 0x40; //printf("%d %d %02x\n", vdc->display_counter, vce.dot_clock, ret); //ret = 0x40; } return(ret); } DECLFW(VCE_Write); void VDC_Init(int sgx) MDFN_COLD; void VDC_Close(void) MDFN_COLD; void VDC_Reset(void) MDFN_COLD; void VDC_Power(void) MDFN_COLD; int VDC_StateAction(StateMem *sm, int load, int data_only); #endif mednafen/tremor/res012.c000664 001750 001750 00000024020 12726204343 016150 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: residue backend 0, 1 and 2 implementation ********************************************************************/ #include #include #include #include "ogg.h" #include "ivorbiscodec.h" #include "codec_internal.h" #include "registry.h" #include "codebook.h" #include "misc.h" #include "os.h" #include "block.h" typedef struct { vorbis_info_residue0 *info; int map; int parts; int stages; codebook *fullbooks; codebook *phrasebook; codebook ***partbooks; int partvals; int **decodemap; } vorbis_look_residue0; void res0_free_info(vorbis_info_residue *i){ vorbis_info_residue0 *info=(vorbis_info_residue0 *)i; if(info){ memset(info,0,sizeof(*info)); _ogg_free(info); } } void res0_free_look(vorbis_look_residue *i){ int j; if(i){ vorbis_look_residue0 *look=(vorbis_look_residue0 *)i; for(j=0;jparts;j++) if(look->partbooks[j])_ogg_free(look->partbooks[j]); _ogg_free(look->partbooks); for(j=0;jpartvals;j++) _ogg_free(look->decodemap[j]); _ogg_free(look->decodemap); memset(look,0,sizeof(*look)); _ogg_free(look); } } static int ilog(unsigned int v){ int ret=0; while(v){ ret++; v>>=1; } return(ret); } static int icount(unsigned int v){ int ret=0; while(v){ ret+=v&1; v>>=1; } return(ret); } /* vorbis_info is for range checking */ vorbis_info_residue *res0_unpack(vorbis_info *vi,oggpack_buffer *opb){ int j,acc=0; vorbis_info_residue0 *info=(vorbis_info_residue0 *)_ogg_calloc(1,sizeof(*info)); codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; info->begin=oggpack_read(opb,24); info->end=oggpack_read(opb,24); info->grouping=oggpack_read(opb,24)+1; info->partitions=oggpack_read(opb,6)+1; info->groupbook=oggpack_read(opb,8); /* check for premature EOP */ if(info->groupbook<0)goto errout; for(j=0;jpartitions;j++){ int cascade=oggpack_read(opb,3); int cflag=oggpack_read(opb,1); if(cflag<0) goto errout; if(cflag){ int c=oggpack_read(opb,5); if(c<0) goto errout; cascade|=(c<<3); } info->secondstages[j]=cascade; acc+=icount(cascade); } for(j=0;jbooklist[j]=book; } if(info->groupbook>=ci->books)goto errout; for(j=0;jbooklist[j]>=ci->books)goto errout; if(ci->book_param[info->booklist[j]]->maptype==0)goto errout; } /* verify the phrasebook is not specifying an impossible or inconsistent partitioning scheme. */ /* modify the phrasebook ranging check from r16327; an early beta encoder had a bug where it used an oversized phrasebook by accident. These files should continue to be playable, but don't allow an exploit */ { int entries = ci->book_param[info->groupbook]->entries; int dim = ci->book_param[info->groupbook]->dim; int partvals = 1; if (dim<1) goto errout; while(dim>0){ partvals *= info->partitions; if(partvals > entries) goto errout; dim--; } info->partvals = partvals; } return(info); errout: res0_free_info(info); return(NULL); } vorbis_look_residue *res0_look(vorbis_dsp_state *vd,vorbis_info_mode *vm, vorbis_info_residue *vr){ vorbis_info_residue0 *info=(vorbis_info_residue0 *)vr; vorbis_look_residue0 *look=(vorbis_look_residue0 *)_ogg_calloc(1,sizeof(*look)); codec_setup_info *ci=(codec_setup_info *)vd->vi->codec_setup; int j,k,acc=0; int dim; int maxstage=0; look->info=info; look->map=vm->mapping; look->parts=info->partitions; look->fullbooks=ci->fullbooks; look->phrasebook=ci->fullbooks+info->groupbook; dim=look->phrasebook->dim; look->partbooks=(codebook ***)_ogg_calloc(look->parts,sizeof(*look->partbooks)); for(j=0;jparts;j++){ int stages=ilog(info->secondstages[j]); if(stages){ if(stages>maxstage)maxstage=stages; look->partbooks[j]=(codebook **)_ogg_calloc(stages,sizeof(*look->partbooks[j])); for(k=0;ksecondstages[j]&(1<partbooks[j][k]=ci->fullbooks+info->booklist[acc++]; #ifdef TRAIN_RES look->training_data[k][j]=calloc(look->partbooks[j][k]->entries, sizeof(***look->training_data)); #endif } } } look->partvals=look->parts; for(j=1;jpartvals*=look->parts; look->stages=maxstage; look->decodemap=(int **)_ogg_malloc(look->partvals*sizeof(*look->decodemap)); for(j=0;jpartvals;j++){ long val=j; long mult=look->partvals/look->parts; look->decodemap[j]=(int *)_ogg_malloc(dim*sizeof(*look->decodemap[j])); for(k=0;kparts; look->decodemap[j][k]=deco; } } return(look); } /* a truncated packet here just means 'stop working'; it's not an error */ static int _01inverse(vorbis_block *vb,vorbis_look_residue *vl, ogg_int32_t **in,int ch, long (*decodepart)(codebook *, ogg_int32_t *, oggpack_buffer *,int,int)){ long i,j,k,l,s; vorbis_look_residue0 *look=(vorbis_look_residue0 *)vl; vorbis_info_residue0 *info=look->info; /* move all this setup out later */ int samples_per_partition=info->grouping; int partitions_per_word=look->phrasebook->dim; int max=vb->pcmend>>1; int end=(info->endend:max); int n=end-info->begin; if(n>0){ int partvals=n/samples_per_partition; int partwords=(partvals+partitions_per_word-1)/partitions_per_word; int ***partword=(int ***)alloca(ch*sizeof(*partword)); for(j=0;jstages;s++){ /* each loop decodes on partition codeword containing partitions_pre_word partitions */ for(i=0,l=0;iphrasebook,&vb->opb); if(temp==-1 || temp>=info->partvals)goto eopbreak; partword[j][l]=look->decodemap[temp]; if(partword[j][l]==NULL)goto errout; } } /* now we decode residual values for the partitions */ for(k=0;kbegin+i*samples_per_partition; if(info->secondstages[partword[j][l][k]]&(1<partbooks[partword[j][l][k]][s]; if(stagebook){ if(decodepart(stagebook,in[j]+offset,&vb->opb, samples_per_partition,-8)==-1)goto eopbreak; } } } } } } errout: eopbreak: return(0); } int res0_inverse(vorbis_block *vb,vorbis_look_residue *vl, ogg_int32_t **in,int *nonzero,int ch){ int i,used=0; for(i=0;iinfo; /* move all this setup out later */ int samples_per_partition=info->grouping; int partitions_per_word=look->phrasebook->dim; int max=(vb->pcmend*ch)>>1; int end=(info->endend:max); int n=end-info->begin; if(n>0){ int partvals=n/samples_per_partition; int partwords=(partvals+partitions_per_word-1)/partitions_per_word; int **partword=(int **)_vorbis_block_alloc(vb,partwords*sizeof(*partword)); int beginoff=info->begin/ch; for(i=0;istages;s++){ for(i=0,l=0;iphrasebook,&vb->opb); if(temp==-1 || temp>=info->partvals)goto eopbreak; partword[l]=look->decodemap[temp]; if(partword[l]==NULL)goto errout; } /* now we decode residual values for the partitions */ for(k=0;ksecondstages[partword[l][k]]&(1<partbooks[partword[l][k]][s]; if(stagebook){ if(vorbis_book_decodevv_add(stagebook,in, i*samples_per_partition+beginoff,ch, &vb->opb, samples_per_partition,-8)==-1) goto eopbreak; } } } } } errout: eopbreak: return(0); } vorbis_func_residue residue0_exportbundle={ &res0_unpack, &res0_look, &res0_free_info, &res0_free_look, &res0_inverse }; vorbis_func_residue residue1_exportbundle={ &res0_unpack, &res0_look, &res0_free_info, &res0_free_look, &res1_inverse }; vorbis_func_residue residue2_exportbundle={ &res0_unpack, &res0_look, &res0_free_info, &res0_free_look, &res2_inverse }; mednafen/general.cpp000664 001750 001750 00000011276 12726204343 015612 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "mednafen.h" #include #include #include #include #include "general.h" #include "state.h" using namespace std; static bool IsAbsolutePath(const char *path) { if (path[0] == '\\' || path[0] == '/') return(TRUE); #if defined(WIN32) || defined(DOS) if((path[0] >= 'a' && path[0] <= 'z') || (path[0] >= 'A' && path[0] <= 'Z')) { if(path[1] == ':') return(TRUE); } #endif return(FALSE); } bool MDFN_IsFIROPSafe(const std::string &path) { // We could make this more OS-specific, but it shouldn't hurt to try to weed out usage of characters that are path // separators in one OS but not in another, and we'd also run more of a risk of missing a special path separator case // in some OS. if(!MDFN_GetSettingB("filesys.untrusted_fip_check")) return(true); if(path.find('\0') != string::npos) return(false); if(path.find(':') != string::npos) return(false); if(path.find('\\') != string::npos) return(false); if(path.find('/') != string::npos) return(false); return(true); } void MDFN_GetFilePathComponents(const std::string &file_path, std::string *dir_path_out, std::string *file_base_out, std::string *file_ext_out) { size_t final_ds; // in file_path string file_name; size_t fn_final_dot; // in local var file_name string dir_path, file_base, file_ext; // Temporary output #ifdef _WIN32 final_ds = file_path.find_last_of('\\'); size_t alt_final_ds = file_path.find_last_of('/'); if(final_ds == string::npos || (alt_final_ds != string::npos && alt_final_ds > final_ds)) final_ds = alt_final_ds; #else final_ds = file_path.find_last_of('/'); #endif if(final_ds == string::npos) { dir_path = string("."); file_name = file_path; } else { dir_path = file_path.substr(0, final_ds); file_name = file_path.substr(final_ds + 1); } fn_final_dot = file_name.find_last_of('.'); if(fn_final_dot != string::npos) { file_base = file_name.substr(0, fn_final_dot); file_ext = file_name.substr(fn_final_dot); } else { file_base = file_name; file_ext = string(""); } if(dir_path_out) *dir_path_out = dir_path; if(file_base_out) *file_base_out = file_base; if(file_ext_out) *file_ext_out = file_ext; } std::string MDFN_EvalFIP(const std::string &dir_path, const std::string &rel_path, bool skip_safety_check) { char slash; #ifdef _WIN32 slash = '\\'; #else slash = '/'; #endif if(!skip_safety_check && !MDFN_IsFIROPSafe(rel_path)) throw MDFN_Error(0, _("Referenced path \"%s\" is potentially unsafe. See \"filesys.untrusted_fip_check\" setting.\n"), rel_path.c_str()); if(IsAbsolutePath(rel_path.c_str())) return(rel_path); else return(dir_path + slash + rel_path); } const char * GetFNComponent(const char *str) { const char *tp1; #ifdef _WIN32 tp1 = ((char *)strrchr(str,'\\')); const char *tp3; tp3 = ((char *)strrchr(str,'/')); if (tp1 #include "os_types.h" typedef struct { void *iov_base; size_t iov_len; } ogg_iovec_t; typedef struct { long endbyte; int endbit; unsigned char *buffer; unsigned char *ptr; long storage; } oggpack_buffer; /* ogg_page is used to encapsulate the data in one Ogg bitstream page *****/ typedef struct { unsigned char *header; long header_len; unsigned char *body; long body_len; } ogg_page; /* ogg_stream_state contains the current encode/decode state of a logical Ogg bitstream **********************************************************/ typedef struct { unsigned char *body_data; /* bytes from packet bodies */ long body_storage; /* storage elements allocated */ long body_fill; /* elements stored; fill mark */ long body_returned; /* elements of fill returned */ int *lacing_vals; /* The values that will go to the segment table */ ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact this way, but it is simple coupled to the lacing fifo */ long lacing_storage; long lacing_fill; long lacing_packet; long lacing_returned; unsigned char header[282]; /* working space for header encode */ int header_fill; int e_o_s; /* set when we have buffered the last packet in the logical bitstream */ int b_o_s; /* set after we've written the initial page of a logical bitstream */ long serialno; long pageno; ogg_int64_t packetno; /* sequence number for decode; the framing knows where there's a hole in the data, but we need coupling so that the codec (which is in a separate abstraction layer) also knows about the gap */ ogg_int64_t granulepos; } ogg_stream_state; /* ogg_packet is used to encapsulate the data and metadata belonging to a single raw Ogg/Vorbis packet *************************************/ typedef struct { unsigned char *packet; long bytes; long b_o_s; long e_o_s; ogg_int64_t granulepos; ogg_int64_t packetno; /* sequence number for decode; the framing knows where there's a hole in the data, but we need coupling so that the codec (which is in a separate abstraction layer) also knows about the gap */ } ogg_packet; typedef struct { unsigned char *data; int storage; int fill; int returned; int unsynced; int headerbytes; int bodybytes; } ogg_sync_state; /* Ogg BITSTREAM PRIMITIVES: bitstream ************************/ extern void oggpack_writeinit(oggpack_buffer *b); extern int oggpack_writecheck(oggpack_buffer *b); extern void oggpack_writetrunc(oggpack_buffer *b,long bits); extern void oggpack_writealign(oggpack_buffer *b); extern void oggpack_writecopy(oggpack_buffer *b,void *source,long bits); extern void oggpack_reset(oggpack_buffer *b); extern void oggpack_writeclear(oggpack_buffer *b); extern void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes); extern void oggpack_write(oggpack_buffer *b,unsigned long value,int bits); extern long oggpack_look(oggpack_buffer *b,int bits); extern long oggpack_look1(oggpack_buffer *b); extern void oggpack_adv(oggpack_buffer *b,int bits); extern void oggpack_adv1(oggpack_buffer *b); extern long oggpack_read(oggpack_buffer *b,int bits); extern long oggpack_read1(oggpack_buffer *b); extern long oggpack_bytes(oggpack_buffer *b); extern long oggpack_bits(oggpack_buffer *b); extern unsigned char *oggpack_get_buffer(oggpack_buffer *b); extern void oggpackB_writeinit(oggpack_buffer *b); extern int oggpackB_writecheck(oggpack_buffer *b); extern void oggpackB_writetrunc(oggpack_buffer *b,long bits); extern void oggpackB_writealign(oggpack_buffer *b); extern void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits); extern void oggpackB_reset(oggpack_buffer *b); extern void oggpackB_writeclear(oggpack_buffer *b); extern void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes); extern void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits); extern long oggpackB_look(oggpack_buffer *b,int bits); extern long oggpackB_look1(oggpack_buffer *b); extern void oggpackB_adv(oggpack_buffer *b,int bits); extern void oggpackB_adv1(oggpack_buffer *b); extern long oggpackB_read(oggpack_buffer *b,int bits); extern long oggpackB_read1(oggpack_buffer *b); extern long oggpackB_bytes(oggpack_buffer *b); extern long oggpackB_bits(oggpack_buffer *b); extern unsigned char *oggpackB_get_buffer(oggpack_buffer *b); /* Ogg BITSTREAM PRIMITIVES: encoding **************************/ extern int ogg_stream_packetin(ogg_stream_state *os, ogg_packet *op); extern int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov, int count, long e_o_s, ogg_int64_t granulepos); extern int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og); extern int ogg_stream_pageout_fill(ogg_stream_state *os, ogg_page *og, int nfill); extern int ogg_stream_flush(ogg_stream_state *os, ogg_page *og); extern int ogg_stream_flush_fill(ogg_stream_state *os, ogg_page *og, int nfill); /* Ogg BITSTREAM PRIMITIVES: decoding **************************/ extern int ogg_sync_init(ogg_sync_state *oy); extern int ogg_sync_clear(ogg_sync_state *oy); extern int ogg_sync_reset(ogg_sync_state *oy); extern int ogg_sync_destroy(ogg_sync_state *oy); extern int ogg_sync_check(ogg_sync_state *oy); extern char *ogg_sync_buffer(ogg_sync_state *oy, long size); extern int ogg_sync_wrote(ogg_sync_state *oy, long bytes); extern long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og); extern int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og); extern int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og); extern int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op); extern int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op); /* Ogg BITSTREAM PRIMITIVES: general ***************************/ extern int ogg_stream_init(ogg_stream_state *os,int serialno); extern int ogg_stream_clear(ogg_stream_state *os); extern int ogg_stream_reset(ogg_stream_state *os); extern int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno); extern int ogg_stream_destroy(ogg_stream_state *os); extern int ogg_stream_check(ogg_stream_state *os); extern int ogg_stream_eos(ogg_stream_state *os); extern void ogg_page_checksum_set(ogg_page *og); extern int ogg_page_version(const ogg_page *og); extern int ogg_page_continued(const ogg_page *og); extern int ogg_page_bos(const ogg_page *og); extern int ogg_page_eos(const ogg_page *og); extern ogg_int64_t ogg_page_granulepos(const ogg_page *og); extern int ogg_page_serialno(const ogg_page *og); extern long ogg_page_pageno(const ogg_page *og); extern int ogg_page_packets(const ogg_page *og); extern void ogg_packet_clear(ogg_packet *op); #ifdef __cplusplus } #endif #endif /* _OGG_H */ mednafen/pce_fast/pcecd_drive.h000664 001750 001750 00000006325 12726204343 017674 0ustar00sergiosergio000000 000000 #ifndef __PCEFAST_PCECD_Drive_H #define __PCEFAST_PCECD_Drive_H #include "../include/blip/Blip_Buffer.h" typedef int32 pcecd_drive_timestamp_t; struct pcecd_drive_bus_t { // Data bus(FIXME: we should have a variable for the target and the initiator, and OR them together to be truly accurate). uint8 DB; uint32 signals; }; extern pcecd_drive_bus_t cd_bus; // Don't access this structure directly by name outside of pcecd_drive.c, but use the macros below. // Signals under our(the "target") control. #define PCECD_Drive_IO_mask 0x001 #define PCECD_Drive_CD_mask 0x002 #define PCECD_Drive_MSG_mask 0x004 #define PCECD_Drive_REQ_mask 0x008 #define PCECD_Drive_BSY_mask 0x010 // Signals under the control of the initiator(not us!) #define PCECD_Drive_kingRST_mask 0x020 #define PCECD_Drive_kingACK_mask 0x040 #define PCECD_Drive_kingSEL_mask 0x100 #define BSY_signal ((const bool)(cd_bus.signals & PCECD_Drive_BSY_mask)) #define ACK_signal ((const bool)(cd_bus.signals & PCECD_Drive_kingACK_mask)) #define RST_signal ((const bool)(cd_bus.signals & PCECD_Drive_kingRST_mask)) #define MSG_signal ((const bool)(cd_bus.signals & PCECD_Drive_MSG_mask)) #define SEL_signal ((const bool)(cd_bus.signals & PCECD_Drive_kingSEL_mask)) #define REQ_signal ((const bool)(cd_bus.signals & PCECD_Drive_REQ_mask)) #define IO_signal ((const bool)(cd_bus.signals & PCECD_Drive_IO_mask)) #define CD_signal ((const bool)(cd_bus.signals & PCECD_Drive_CD_mask)) #define DB_signal ((const uint8)cd_bus.DB) #define PCECD_Drive_GetDB() DB_signal #define PCECD_Drive_GetBSY() BSY_signal #define PCECD_Drive_GetIO() IO_signal #define PCECD_Drive_GetCD() CD_signal #define PCECD_Drive_GetMSG() MSG_signal #define PCECD_Drive_GetREQ() REQ_signal // Should we phase out getting these initiator-driven signals like this(the initiator really should keep track of them itself)? #define PCECD_Drive_GetACK() ACK_signal #define PCECD_Drive_GetRST() RST_signal #define PCECD_Drive_GetSEL() SEL_signal void PCECD_Drive_Power(pcecd_drive_timestamp_t system_timestamp); void PCECD_Drive_SetDB(uint8 data); // These PCECD_Drive_Set* functions are kind of misnomers, at least in comparison to the PCECD_Drive_Get* functions... // They will set/clear the bits corresponding to the KING's side of the bus. void PCECD_Drive_SetACK(bool set); void PCECD_Drive_SetSEL(bool set); void PCECD_Drive_SetRST(bool set); uint32 PCECD_Drive_Run(pcecd_drive_timestamp_t); void PCECD_Drive_ResetTS(void); enum { PCECD_Drive_IRQ_DATA_TRANSFER_DONE = 1, PCECD_Drive_IRQ_DATA_TRANSFER_READY, PCECD_Drive_IRQ_MAGICAL_REQ, }; void PCECD_Drive_GetCDDAValues(int16 &left, int16 &right); void PCECD_Drive_SetLog(void (*logfunc)(const char *, const char *, ...)) MDFN_COLD; void PCECD_Drive_Init(int CDDATimeDiv, Blip_Buffer *leftbuf, Blip_Buffer *rightbuf, uint32 TransferRate, uint32 SystemClock, void (*IRQFunc)(int), void (*SSCFunc)(uint8, int)) MDFN_COLD; void PCECD_Drive_Close(void) MDFN_COLD; void PCECD_Drive_SetTransferRate(uint32 TransferRate); void PCECD_Drive_SetCDDAVolume(unsigned vol); // vol of 65536 = 1.0 = maximum. int PCECD_Drive_StateAction(StateMem *sm, int load, int data_only, const char *sname); void PCECD_Drive_SetDisc(bool tray_open, CDIF *cdif, bool no_emu_side_effects = false) MDFN_COLD; #endif mednafen/tremor/README000664 001750 001750 00000003625 12726204343 015660 0ustar00sergiosergio000000 000000 This README covers the Ogg Vorbis 'Tremor' integer playback codec source as of date 2002 09 02, version 1.0.0. ****** The C source in this package will build on any ANSI C compiler and function completely and properly on any platform. The included build system assumes GNU build system and make tools (m4, automake, autoconf, libtool and gmake). GCC is not required, although GCC is the most tested compiler. To build using GNU tools, type in the source directory: ./autogen.sh make Currently, the source implements playback in pure C on all platforms except ARM, where a [currently] small amount of assembly (see asm_arm.h) is used to implement 64 bit math operations and fast LSP computation. If building on ARM without the benefit of GNU build system tools, be sure that '_ARM_ASSEM_' is #defined by the build system if this assembly is desired, else the resulting library will use whatever 64 bit math builtins the compiler implements. No math library is required by this source. No floating point operations are used at any point in either setup or decode. This decoder library will properly decode any past, current or future Vorbis I file or stream. ******** The build system produces a static and [when supported by the OS] dynamic library named 'libvorbisidec'. This library exposes an API nearly identical to the BSD reference library's 'libvorbisfile', including all the features familiar to users of vorbisfile. This API is similar enough that the proper header file to include is named 'ivorbisfile.h' [included in the source build directory]. Lower level libvorbis-style headers and structures are in 'ivorbiscodec.h' [included in the source build directory]. A simple example program, ivorbisfile_example.c, can be built with 'make example'. ******** Detailed Tremor API Documentation begins at doc/index.html Monty xiph.org mednafen/include/blargg_config.h000664 001750 001750 00000001501 12726204343 020036 0ustar00sergiosergio000000 000000 // Library configuration. Modify this file as necessary. #ifndef BLARGG_CONFIG_H #define BLARGG_CONFIG_H // Uncomment to use zlib for transparent decompression of gzipped files //#define HAVE_ZLIB_H // Uncomment to support only the listed game music types. See gme_type_list.cpp // for a list of all types. //#define GME_TYPE_LIST gme_nsf_type, gme_gbs_type // Uncomment to enable platform-specific optimizations //#define BLARGG_NONPORTABLE 1 // Uncomment to use faster, lower quality sound synthesis //#define BLIP_BUFFER_FAST 1 // Uncomment if automatic byte-order determination doesn't work //#define BLARGG_BIG_ENDIAN 1 // Uncomment if you get errors in the bool section of blargg_common.h //#define BLARGG_COMPILER_HAS_BOOL 1 // Use standard config.h if present #ifdef HAVE_CONFIG_H #include "config.h" #endif #endif mednafen/tremor/config_types.h000664 001750 001750 00000000353 12726204343 017635 0ustar00sergiosergio000000 000000 #ifndef __CONFIG_TYPES_H__ #define __CONFIG_TYPES_H__ #include typedef int16_t ogg_int16_t; typedef uint16_t ogg_uint16_t; typedef int32_t ogg_int32_t; typedef uint32_t ogg_uint32_t; typedef int64_t ogg_int64_t; #endif mednafen/cdrom/CDAccess_CCD.h000664 001750 001750 00000002536 12726204343 017026 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "../FileStream.h" #include "../MemoryStream.h" #include "CDAccess.h" #include class CDAccess_CCD : public CDAccess { public: CDAccess_CCD(const char *path, bool image_memcache); virtual ~CDAccess_CCD(); virtual void Read_Raw_Sector(uint8 *buf, int32 lba); virtual void Read_TOC(CDUtility::TOC *toc); virtual bool Is_Physical(void) throw(); virtual void Eject(bool eject_status); private: void Load(const char *path, bool image_memcache); void Cleanup(void); void CheckSubQSanity(void); Stream* img_stream; Stream* sub_stream; size_t img_numsectors; CDUtility::TOC tocd; }; libretro-common/string/stdstring.c000664 001750 001750 00000010272 12726204343 020512 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (stdstring.c). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include #include #include bool string_is_empty(const char *data) { return data==NULL || *data=='\0'; } bool string_is_equal(const char *a, const char *b) { if (!a || !b) return false; return (strcmp(a, b) == 0); } bool string_is_equal_noncase(const char *a, const char *b) { if (!a || !b) return false; return (strcasecmp(a, b) == 0); } char *string_to_upper(char *s) { char *cs = (char *)s; for ( ; *cs != '\0'; cs++) *cs = toupper(*cs); return s; } char *string_to_lower(char *s) { char *cs = (char *)s; for ( ; *cs != '\0'; cs++) *cs = tolower(*cs); return s; } char *string_ucwords(char *s) { char *cs = (char *)s; for ( ; *cs != '\0'; cs++) { if (*cs == ' ') { *(cs+1) = toupper(*(cs+1)); } } s[0] = toupper(s[0]); return s; } char *string_replace_substring(const char *in, const char *pattern, const char *replacement) { size_t numhits, pattern_len, replacement_len, outlen; const char *inat; const char *inprev; char *out, *outat; /* if either pattern or replacement is NULL, * duplicate in and let caller handle it. */ if (!pattern || !replacement) return strdup(in); pattern_len = strlen(pattern); replacement_len = strlen(replacement); numhits = 0; inat = in; while ((inat = strstr(inat, pattern))) { inat += pattern_len; numhits++; } outlen = strlen(in) - pattern_len*numhits + replacement_len*numhits; out = (char *)malloc(outlen+1); outat = out; inat = in; inprev = in; while ((inat = strstr(inat, pattern))) { memcpy(outat, inprev, inat-inprev); outat += inat-inprev; memcpy(outat, replacement, replacement_len); outat += replacement_len; inat += pattern_len; inprev = inat; } strcpy(outat, inprev); return out; } /* Non-GPL licensed versions of whitespace trimming: * http://stackoverflow.com/questions/656542/trim-a-string-in-c */ /* Remove leading whitespaces */ char *string_trim_whitespace_left(char *const s) { if(s && *s) { size_t len = strlen(s); char *cur = s; while(*cur && isspace(*cur)) ++cur, --len; if(s != cur) memmove(s, cur, len + 1); } return s; } /* Remove trailing whitespaces */ char *string_trim_whitespace_right(char *const s) { if(s && *s) { size_t len = strlen(s); char *cur = s + len - 1; while(cur != s && isspace(*cur)) --cur, --len; cur[isspace(*cur) ? 0 : 1] = '\0'; } return s; } /* Remove leading and trailing whitespaces */ char *string_trim_whitespace(char *const s) { string_trim_whitespace_right(s); /* order matters */ string_trim_whitespace_left(s); return s; } mednafen/tremor/info.c000664 001750 001750 00000026466 12726204343 016107 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2003 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: maintain the info structure, info <-> header packets ********************************************************************/ /* general handling of the header and the vorbis_info structure (and substructures) */ #include #include #include #include #include "ogg.h" #include "ivorbiscodec.h" #include "codec_internal.h" #include "codebook.h" #include "registry.h" #include "window.h" #include "misc.h" /* helpers */ static void _v_readstring(oggpack_buffer *o,char *buf,int bytes){ while(bytes--){ *buf++=oggpack_read(o,8); } } void vorbis_comment_init(vorbis_comment *vc){ memset(vc,0,sizeof(*vc)); } /* This is more or less the same as strncasecmp - but that doesn't exist * everywhere, and this is a fairly trivial function, so we include it */ static int tagcompare(const char *s1, const char *s2, int n){ int c=0; while(c < n){ if(toupper(s1[c]) != toupper(s2[c])) return !0; c++; } return 0; } char *vorbis_comment_query(vorbis_comment *vc, char *tag, int count){ long i; int found = 0; int taglen = strlen(tag)+1; /* +1 for the = we append */ char *fulltag = (char *)alloca(taglen+ 1); strcpy(fulltag, tag); strcat(fulltag, "="); for(i=0;icomments;i++){ if(!tagcompare(vc->user_comments[i], fulltag, taglen)){ if(count == found) /* We return a pointer to the data, not a copy */ return vc->user_comments[i] + taglen; else found++; } } return NULL; /* didn't find anything */ } int vorbis_comment_query_count(vorbis_comment *vc, char *tag){ int i,count=0; int taglen = strlen(tag)+1; /* +1 for the = we append */ char *fulltag = (char *)alloca(taglen+1); strcpy(fulltag,tag); strcat(fulltag, "="); for(i=0;icomments;i++){ if(!tagcompare(vc->user_comments[i], fulltag, taglen)) count++; } return count; } void vorbis_comment_clear(vorbis_comment *vc){ if(vc){ long i; if(vc->user_comments){ for(i=0;icomments;i++) if(vc->user_comments[i])_ogg_free(vc->user_comments[i]); _ogg_free(vc->user_comments); } if(vc->comment_lengths)_ogg_free(vc->comment_lengths); if(vc->vendor)_ogg_free(vc->vendor); memset(vc,0,sizeof(*vc)); } } /* blocksize 0 is guaranteed to be short, 1 is guarantted to be long. They may be equal, but short will never ge greater than long */ int vorbis_info_blocksize(vorbis_info *vi,int zo){ codec_setup_info *ci = (codec_setup_info *)vi->codec_setup; return ci ? ci->blocksizes[zo] : -1; } /* used by synthesis, which has a full, alloced vi */ void vorbis_info_init(vorbis_info *vi){ memset(vi,0,sizeof(*vi)); vi->codec_setup=(codec_setup_info *)_ogg_calloc(1,sizeof(codec_setup_info)); } void vorbis_info_clear(vorbis_info *vi){ codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; int i; if(ci){ for(i=0;imodes;i++) if(ci->mode_param[i])_ogg_free(ci->mode_param[i]); for(i=0;imaps;i++) /* unpack does the range checking */ if(ci->map_param[i]) _mapping_P[ci->map_type[i]]->free_info(ci->map_param[i]); for(i=0;ifloors;i++) /* unpack does the range checking */ if(ci->floor_param[i]) _floor_P[ci->floor_type[i]]->free_info(ci->floor_param[i]); for(i=0;iresidues;i++) /* unpack does the range checking */ if(ci->residue_param[i]) _residue_P[ci->residue_type[i]]->free_info(ci->residue_param[i]); for(i=0;ibooks;i++){ if(ci->book_param[i]){ /* knows if the book was not alloced */ vorbis_staticbook_destroy(ci->book_param[i]); } if(ci->fullbooks) vorbis_book_clear(ci->fullbooks+i); } if(ci->fullbooks) _ogg_free(ci->fullbooks); _ogg_free(ci); } memset(vi,0,sizeof(*vi)); } /* Header packing/unpacking ********************************************/ static int _vorbis_unpack_info(vorbis_info *vi,oggpack_buffer *opb){ codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; if(!ci)return(OV_EFAULT); vi->version=oggpack_read(opb,32); if(vi->version!=0)return(OV_EVERSION); vi->channels=oggpack_read(opb,8); vi->rate=oggpack_read(opb,32); vi->bitrate_upper=oggpack_read(opb,32); vi->bitrate_nominal=oggpack_read(opb,32); vi->bitrate_lower=oggpack_read(opb,32); ci->blocksizes[0]=1<blocksizes[1]=1<rate<1)goto err_out; if(vi->channels<1)goto err_out; if(ci->blocksizes[0]<64)goto err_out; if(ci->blocksizes[1]blocksizes[0])goto err_out; if(ci->blocksizes[1]>8192)goto err_out; if(oggpack_read(opb,1)!=1)goto err_out; /* EOP check */ return(0); err_out: vorbis_info_clear(vi); return(OV_EBADHEADER); } static int _vorbis_unpack_comment(vorbis_comment *vc,oggpack_buffer *opb){ int i; int vendorlen; vendorlen=oggpack_read(opb,32); if(vendorlen<0)goto err_out; if(vendorlen>opb->storage-oggpack_bytes(opb))goto err_out; vc->vendor=(char *)_ogg_calloc(vendorlen+1,1); if(vc->vendor==NULL)goto err_out; _v_readstring(opb,vc->vendor,vendorlen); i=oggpack_read(opb,32); if(i<0||i>=INT_MAX||i>(opb->storage-oggpack_bytes(opb))>>2)goto err_out; vc->user_comments=(char **)_ogg_calloc(i+1,sizeof(*vc->user_comments)); vc->comment_lengths=(int *)_ogg_calloc(i+1, sizeof(*vc->comment_lengths)); if(vc->user_comments==NULL||vc->comment_lengths==NULL)goto err_out; vc->comments=i; for(i=0;icomments;i++){ int len=oggpack_read(opb,32); if(len<0||len>opb->storage-oggpack_bytes(opb))goto err_out; vc->comment_lengths[i]=len; vc->user_comments[i]=(char *)_ogg_calloc(len+1,1); if(vc->user_comments[i]==NULL){ vc->comments=i; goto err_out; } _v_readstring(opb,vc->user_comments[i],len); } if(oggpack_read(opb,1)!=1)goto err_out; /* EOP check */ return(0); err_out: vorbis_comment_clear(vc); return(OV_EBADHEADER); } /* all of the real encoding details are here. The modes, books, everything */ static int _vorbis_unpack_books(vorbis_info *vi,oggpack_buffer *opb){ codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; int i; if(!ci)return(OV_EFAULT); /* codebooks */ ci->books=oggpack_read(opb,8)+1; if(ci->books<=0)goto err_out; for(i=0;ibooks;i++){ ci->book_param[i]=vorbis_staticbook_unpack(opb); if(!ci->book_param[i])goto err_out; } /* time backend settings */ ci->times=oggpack_read(opb,6)+1; if(ci->times<=0)goto err_out; for(i=0;itimes;i++){ ci->time_type[i]=oggpack_read(opb,16); if(ci->time_type[i]<0 || ci->time_type[i]>=VI_TIMEB)goto err_out; /* ci->time_param[i]=_time_P[ci->time_type[i]]->unpack(vi,opb); Vorbis I has no time backend */ /*if(!ci->time_param[i])goto err_out;*/ } /* floor backend settings */ ci->floors=oggpack_read(opb,6)+1; if(ci->floors<=0)goto err_out; for(i=0;ifloors;i++){ ci->floor_type[i]=oggpack_read(opb,16); if(ci->floor_type[i]<0 || ci->floor_type[i]>=VI_FLOORB)goto err_out; ci->floor_param[i]=_floor_P[ci->floor_type[i]]->unpack(vi,opb); if(!ci->floor_param[i])goto err_out; } /* residue backend settings */ ci->residues=oggpack_read(opb,6)+1; if(ci->residues<=0)goto err_out; for(i=0;iresidues;i++){ ci->residue_type[i]=oggpack_read(opb,16); if(ci->residue_type[i]<0 || ci->residue_type[i]>=VI_RESB)goto err_out; ci->residue_param[i]=_residue_P[ci->residue_type[i]]->unpack(vi,opb); if(!ci->residue_param[i])goto err_out; } /* map backend settings */ ci->maps=oggpack_read(opb,6)+1; if(ci->maps<=0)goto err_out; for(i=0;imaps;i++){ ci->map_type[i]=oggpack_read(opb,16); if(ci->map_type[i]<0 || ci->map_type[i]>=VI_MAPB)goto err_out; ci->map_param[i]=_mapping_P[ci->map_type[i]]->unpack(vi,opb); if(!ci->map_param[i])goto err_out; } /* mode settings */ ci->modes=oggpack_read(opb,6)+1; if(ci->modes<=0)goto err_out; for(i=0;imodes;i++){ ci->mode_param[i]=(vorbis_info_mode *)_ogg_calloc(1,sizeof(*ci->mode_param[i])); ci->mode_param[i]->blockflag=oggpack_read(opb,1); ci->mode_param[i]->windowtype=oggpack_read(opb,16); ci->mode_param[i]->transformtype=oggpack_read(opb,16); ci->mode_param[i]->mapping=oggpack_read(opb,8); if(ci->mode_param[i]->windowtype>=VI_WINDOWB)goto err_out; if(ci->mode_param[i]->transformtype>=VI_WINDOWB)goto err_out; if(ci->mode_param[i]->mapping>=ci->maps)goto err_out; if(ci->mode_param[i]->mapping<0)goto err_out; } if(oggpack_read(opb,1)!=1)goto err_out; /* top level EOP check */ return(0); err_out: vorbis_info_clear(vi); return(OV_EBADHEADER); } /* Is this packet a vorbis ID header? */ int vorbis_synthesis_idheader(ogg_packet *op){ oggpack_buffer opb; char buffer[6]; if(op){ oggpack_readinit(&opb,op->packet,op->bytes); if(!op->b_o_s) return(0); /* Not the initial packet */ if(oggpack_read(&opb,8) != 1) return 0; /* not an ID header */ memset(buffer,0,6); _v_readstring(&opb,buffer,6); if(memcmp(buffer,"vorbis",6)) return 0; /* not vorbis */ return 1; } return 0; } /* The Vorbis header is in three packets; the initial small packet in the first page that identifies basic parameters, a second packet with bitstream comments and a third packet that holds the codebook. */ int vorbis_synthesis_headerin(vorbis_info *vi,vorbis_comment *vc,ogg_packet *op){ oggpack_buffer opb; if(op){ oggpack_readinit(&opb,op->packet,op->bytes); /* Which of the three types of header is this? */ /* Also verify header-ness, vorbis */ { char buffer[6]; int packtype=oggpack_read(&opb,8); memset(buffer,0,6); _v_readstring(&opb,buffer,6); if(memcmp(buffer,"vorbis",6)){ /* not a vorbis header */ return(OV_ENOTVORBIS); } switch(packtype){ case 0x01: /* least significant *bit* is read first */ if(!op->b_o_s){ /* Not the initial packet */ return(OV_EBADHEADER); } if(vi->rate!=0){ /* previously initialized info header */ return(OV_EBADHEADER); } return(_vorbis_unpack_info(vi,&opb)); case 0x03: /* least significant *bit* is read first */ if(vi->rate==0){ /* um... we didn't get the initial header */ return(OV_EBADHEADER); } return(_vorbis_unpack_comment(vc,&opb)); case 0x05: /* least significant *bit* is read first */ if(vi->rate==0 || vc->vendor==NULL){ /* um... we didn;t get the initial header or comments yet */ return(OV_EBADHEADER); } return(_vorbis_unpack_books(vi,&opb)); default: /* Not a valid vorbis header type */ return(OV_EBADHEADER); break; } } } return(OV_EBADHEADER); } mednafen/settings-common.h000664 001750 001750 00000005373 12726204343 016771 0ustar00sergiosergio000000 000000 #ifndef _MDFN_SETTINGS_COMMON_H #define _MDFN_SETTINGS_COMMON_H typedef enum { // Actual base types MDFNST_INT = 0, // (signed), int8, int16, int32, int64(saved as) MDFNST_UINT, // uint8, uint16, uint32, uint64(saved as) MDFNST_BOOL, // bool. bool. bool! MDFNST_FLOAT, // float, double(saved as). MDFNST_STRING, MDFNST_ENUM, // Handled like a string, but validated against the enumeration list, and MDFN_GetSettingUI() returns the number in the enumeration list. MDFNST_ALIAS } MDFNSettingType; //#define MDFNST_EX_DRIVER = (1 << 16), // If this is not set, the setting is assumed to be internal. This...should probably be set automatically? #define MDFNSF_NOFLAGS 0 // Always 0, makes setting definitions prettier...maybe. // TODO(cats) #define MDFNSF_CAT_INPUT (1 << 8) #define MDFNSF_CAT_SOUND (1 << 9) #define MDFNSF_CAT_VIDEO (1 << 10) #define MDFNSF_EMU_STATE (1 << 17) // If the setting affects emulation from the point of view of the emulated program #define MDFNSF_UNTRUSTED_SAFE (1 << 18) // If it's safe for an untrusted source to modify it, probably only used in conjunction with // MDFNST_EX_EMU_STATE and network play #define MDFNSF_SUPPRESS_DOC (1 << 19) // Suppress documentation generation for this setting. #define MDFNSF_COMMON_TEMPLATE (1 << 20) // Auto-generated common template setting(like nes.xscale, pce.xscale, vb.xscale, nes.enable, pce.enable, vb.enable) // TODO: // #define MDFNSF_WILL_BREAK_GAMES (1 << ) // If changing the value of the setting from the default value will break games/programs that would otherwise work. // TODO(in progress): #define MDFNSF_REQUIRES_RELOAD (1 << 24) // If a game reload is required for the setting to take effect. #define MDFNSF_REQUIRES_RESTART (1 << 25) // If Mednafen restart is required for the setting to take effect. typedef struct { const char *string; int number; const char *description; // Short const char *description_extra; // Extra verbose text appended to the short description. } MDFNSetting_EnumList; typedef struct { const char *name; uint32 flags; const char *description; // Short const char *description_extra; MDFNSettingType type; const char *default_value; const char *minimum; const char *maximum; bool (*validate_func)(const char *name, const char *value); void (*ChangeNotification)(const char *name); const MDFNSetting_EnumList *enum_list; } MDFNSetting; typedef struct __MDFNCS { char *name; char *value; char *game_override; // per-game setting override(netplay_override > game_override > value, in precedence) const MDFNSetting *desc; void (*ChangeNotification)(const char *name); uint32 name_hash; } MDFNCS; #endif libretro-common/include/retro_common_api.h000664 001750 001750 00000006413 12726204343 022151 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (retro_common_api.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef _LIBRETRO_COMMON_RETRO_COMMON_API_H #define _LIBRETRO_COMMON_RETRO_COMMON_API_H /* This file is designed to normalize the libretro-common compiling environment for public API headers. This should be leaner than a normal compiling environment, since it gets #included into other project's sources. */ /* ------------------------------------ */ /* Ordinarily we want to put #ifdef __cplusplus extern "C" in C library headers to enable them to get used by c++ sources. However, we want to support building this library as C++ as well, so a special technique is called for. */ #define RETRO_BEGIN_DECLS #define RETRO_END_DECLS #ifdef __cplusplus #ifdef CXX_BUILD /* build wants everything to be built as c++, so no extern "C" */ #else #undef RETRO_BEGIN_DECLS #undef RETRO_END_DECLS #define RETRO_BEGIN_DECLS extern "C" { #define RETRO_END_DECLS } #endif #else /* header is included by a C source file, so no extern "C" */ #endif /* IMO, this non-standard ssize_t should not be used. However, it's a good example of how to handle something like this. */ #ifdef _MSC_VER #ifndef HAVE_SSIZE_T #define HAVE_SSIZE_T #if defined(_WIN64) typedef __int64 ssize_t; #elif defined(_WIN32) typedef int ssize_t; #endif #endif #elif defined(__MACH__) #include #endif /* I would like to see retro_inline.h moved in here; possibly boolean too. rationale: these are used in public APIs, and it is easier to find problems and write code that works the first time portably when theyre included uniformly than to do the analysis from scratch each time you think you need it, for each feature. Moreover it helps force you to make hard decisions: if you EVER bring in boolean.h, then you should pay the price everywhere, so you can see how much grief it will cause. Of course, another school of thought is that you should do as little damage as possible in as few places as possible... */ /* _LIBRETRO_COMMON_RETRO_COMMON_API_H */ #endif libretro-common/include/000700 001750 001750 00000000000 12727366154 016436 5ustar00sergiosergio000000 000000 link.T000664 001750 001750 00000000047 12726204343 012770 0ustar00sergiosergio000000 000000 { global: retro_*; local: *; }; mednafen/error.cpp000664 001750 001750 00000005442 12726204343 015324 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "mednafen.h" #include "error.h" #include #include #include "../libretro.h" extern retro_log_printf_t log_cb; MDFN_Error::MDFN_Error() throw() { abort(); } MDFN_Error::MDFN_Error(int errno_code_new, const char *format, ...) throw() { errno_code = errno_code_new; va_list ap; va_start(ap, format); vsnprintf(error_message, 4096, format, ap); va_end(ap); if (log_cb) log_cb(RETRO_LOG_ERROR, "%s\n", error_message); } MDFN_Error::MDFN_Error(const ErrnoHolder &enh) { errno_code = enh.Errno(); error_message = strdup(enh.StrError()); } MDFN_Error::~MDFN_Error() throw() { if(error_message) { free(error_message); error_message = NULL; } } MDFN_Error::MDFN_Error(const MDFN_Error &ze_error) throw() { if(ze_error.error_message) error_message = strdup(ze_error.error_message); else error_message = NULL; errno_code = ze_error.errno_code; } MDFN_Error& MDFN_Error::operator=(const MDFN_Error &ze_error) throw() { char *new_error_message = ze_error.error_message ? strdup(ze_error.error_message) : NULL; int new_errno_code = ze_error.errno_code; if(error_message) free(error_message); error_message = new_error_message; errno_code = new_errno_code; return(*this); } const char * MDFN_Error::what(void) const throw() { if(!error_message) return("Error allocating memory for the error message!"); return(error_message); } int MDFN_Error::GetErrno(void) const throw() { return(errno_code); } static const char *srr_wrap(int ret, const char *local_strerror) { if(ret == -1) return("ERROR IN strerror_r()!!!"); return(local_strerror); } static const char *srr_wrap(const char *ret, const char *local_strerror) { if(ret == NULL) return("ERROR IN strerror_r()!!!"); return(ret); } void ErrnoHolder::SetErrno(int the_errno) { local_errno = the_errno; if(the_errno == 0) local_strerror[0] = 0; else { strncpy(local_strerror, strerror(the_errno), 255); local_strerror[255] = 0; } } mednafen/git.h000664 001750 001750 00000034043 12726204343 014422 0ustar00sergiosergio000000 000000 #ifndef _GIT_H #define _GIT_H #include #include "video.h" typedef struct { const char *extension; // Example ".nes" const char *description; // Example "iNES Format ROM Image" } FileExtensionSpecStruct; #include "file.h" enum { MDFN_ROTATE0 = 0, MDFN_ROTATE90, MDFN_ROTATE180, MDFN_ROTATE270 }; typedef enum { VIDSYS_NONE, // Can be used internally in system emulation code, but it is an error condition to let it continue to be // after the Load() or LoadCD() function returns! VIDSYS_PAL, VIDSYS_PAL_M, // Same timing as NTSC, but uses PAL-style colour encoding VIDSYS_NTSC, VIDSYS_SECAM } VideoSystems; typedef enum { GMT_CART, // Self-explanatory! GMT_ARCADE, // VS Unisystem, PC-10... GMT_DISK, // Famicom Disk System, mostly GMT_CDROM, // PC Engine CD, PC-FX GMT_PLAYER // Music player(NSF, HES, GSF) } GameMediumTypes; #include "state.h" #include "settings-common.h" typedef enum { IDIT_BUTTON, // 1-bit IDIT_BUTTON_CAN_RAPID, // 1-bit IDIT_BUTTON_BYTE, // 8-bits, Button as a byte instead of a bit. IDIT_X_AXIS, // (mouse) 32-bits, signed, fixed-point: 1.15.16 - in-screen/window range: [0.0, nominal_width) IDIT_Y_AXIS, // (mouse) 32-bits, signed, fixed-point: 1.15.16 - in-screen/window range: [0.0, nominal_height) IDIT_X_AXIS_REL, // (mouse) 32-bits, signed IDIT_Y_AXIS_REL, // (mouse) 32-bits, signed IDIT_BYTE_SPECIAL, IDIT_BUTTON_ANALOG, // 32-bits, 0 - 32767 IDIT_RUMBLE, // 32-bits, lower 8 bits are weak rumble(0-255), next 8 bits are strong rumble(0-255), 0=no rumble, 255=max rumble. Somewhat subjective, too... // May extend to 16-bit each in the future. // It's also rather a special case of game module->driver code communication. } InputDeviceInputType; typedef struct { const char *SettingName; // No spaces, shouldbe all a-z0-9 and _. Definitely no ~! const char *Name; /*const InputDeviceInputVB VirtButton;*/ const int ConfigOrder; // Configuration order during in-game config process, -1 for no config. const InputDeviceInputType Type; const char *ExcludeName; // SettingName of a button that can't be pressed at the same time as this button // due to physical limitations. const char *RotateName[3]; // 90, 180, 270 //const char *Rotate180Name; //const char *Rotate270Name; } InputDeviceInputInfoStruct; typedef struct { const char *ShortName; const char *FullName; const char *Description; //struct InputPortInfoStruct *PortExpanderDeviceInfo; const void *PortExpanderDeviceInfo; // DON'T USE, IT'S NOT IMPLEMENTED PROPERLY CURRENTLY. int NumInputs; // Usually just the number of buttons....OR if PortExpanderDeviceInfo is non-NULL, it's the number of input // ports this port expander device provides. const InputDeviceInputInfoStruct *IDII; } InputDeviceInfoStruct; typedef struct { const char *ShortName; const char *FullName; int NumTypes; // Number of unique input devices available for this input port InputDeviceInfoStruct *DeviceInfo; const char *DefaultDevice; // Default device for this port. } InputPortInfoStruct; typedef struct { int InputPorts; const InputPortInfoStruct *Types; } InputInfoStruct; struct MemoryPatch; struct CheatFormatStruct { const char *FullName; //"Game Genie", "GameShark", "Pro Action Catplay", etc. const char *Description; // Whatever? bool (*DecodeCheat)(const std::string& cheat_string, MemoryPatch* patch); // *patch should be left as initialized by MemoryPatch::MemoryPatch(), unless this is the // second(or third or whatever) part of a multipart cheat. // // Will throw an std::exception(or derivative) on format error. // // Will return true if this is part of a multipart cheat. }; struct CheatFormatInfoStruct { unsigned NumFormats; CheatFormatStruct *Formats; }; // Miscellaneous system/simple commands(power, reset, dip switch toggles, coin insert, etc.) // (for DoSimpleCommand() ) enum { MDFN_MSC_RESET = 0x01, MDFN_MSC_POWER = 0x02, MDFN_MSC_INSERT_COIN = 0x07, // If we ever support arcade systems, we'll abstract DIP switches differently...maybe. MDFN_MSC_TOGGLE_DIP0 = 0x10, MDFN_MSC_TOGGLE_DIP1, MDFN_MSC_TOGGLE_DIP2, MDFN_MSC_TOGGLE_DIP3, MDFN_MSC_TOGGLE_DIP4, MDFN_MSC_TOGGLE_DIP5, MDFN_MSC_TOGGLE_DIP6, MDFN_MSC_TOGGLE_DIP7, MDFN_MSC_TOGGLE_DIP8, MDFN_MSC_TOGGLE_DIP9, MDFN_MSC_TOGGLE_DIP10, MDFN_MSC_TOGGLE_DIP11, MDFN_MSC_TOGGLE_DIP12, MDFN_MSC_TOGGLE_DIP13, MDFN_MSC_TOGGLE_DIP14, MDFN_MSC_TOGGLE_DIP15, // n of DISKn translates to is emulation module specific. MDFN_MSC_INSERT_DISK0 = 0x20, MDFN_MSC_INSERT_DISK1, MDFN_MSC_INSERT_DISK2, MDFN_MSC_INSERT_DISK3, MDFN_MSC_INSERT_DISK4, MDFN_MSC_INSERT_DISK5, MDFN_MSC_INSERT_DISK6, MDFN_MSC_INSERT_DISK7, MDFN_MSC_INSERT_DISK8, MDFN_MSC_INSERT_DISK9, MDFN_MSC_INSERT_DISK10, MDFN_MSC_INSERT_DISK11, MDFN_MSC_INSERT_DISK12, MDFN_MSC_INSERT_DISK13, MDFN_MSC_INSERT_DISK14, MDFN_MSC_INSERT_DISK15, MDFN_MSC_INSERT_DISK = 0x30, MDFN_MSC_EJECT_DISK = 0x31, // This command should select the next disk or disk side in the set and use MDFN_DispMessage() to show which disk is selected. // (If it's only allowed while a disk is ejected, or not, is emulation module specific. MDFN_MSC_SELECT_DISK = 0x32, MDFN_MSC__LAST = 0x3F // WARNING: Increasing(or having the enum'd value of a command greater than this :b) this will necessitate a change to the netplay protocol. }; typedef struct { // Pitch(32-bit) must be equal to width and >= the "fb_width" specified in the MDFNGI struct for the emulated system. // Height must be >= to the "fb_height" specified in the MDFNGI struct for the emulated system. // The framebuffer pointed to by surface->pixels is written to by the system emulation code. MDFN_Surface *surface; // Will be set to TRUE if the video pixel format has changed since the last call to Emulate(), FALSE otherwise. // Will be set to TRUE on the first call to the Emulate() function/method bool VideoFormatChanged; // Set by the system emulation code every frame, to denote the horizontal and vertical offsets of the image, and the size // of the image. If the emulated system sets the elements of LineWidths, then the horizontal offset(x) and width(w) of this structure // are ignored while drawing the image. MDFN_Rect DisplayRect; // Pointer to an array of MDFN_Rect, number of elements = fb_height, set by the driver code. Individual MDFN_Rect structs written // to by system emulation code. If the emulated system doesn't support multiple screen widths per frame, or if you handle // such a situation by outputting at a constant width-per-frame that is the least-common-multiple of the screen widths, then // you can ignore this. If you do wish to use this, you must set all elements every frame. int32_t *LineWidths; // TODO bool *IsFMV; // Set(optionally) by emulation code. If InterlaceOn is true, then assume field height is 1/2 DisplayRect.h, and // only every other line in surface (with the start line defined by InterlacedField) has valid data // (it's up to internal Mednafen code to deinterlace it). bool InterlaceOn; bool InterlaceField; // Skip rendering this frame if true. Set by the driver code. int skip; // // If sound is disabled, the driver code must set SoundRate to false, SoundBuf to NULL, SoundBufMaxSize to 0. // Will be set to TRUE if the sound format(only rate for now, at least) has changed since the last call to Emulate(), FALSE otherwise. // Will be set to TRUE on the first call to the Emulate() function/method bool SoundFormatChanged; // Sound rate. Set by driver side. double SoundRate; // Pointer to sound buffer, set by the driver code, that the emulation code should render sound to. // Guaranteed to be at least 500ms in length, but emulation code really shouldn't exceed 40ms or so. Additionally, if emulation code // generates >= 100ms, // DEPRECATED: Emulation code may set this pointer to a sound buffer internal to the emulation module. int16 *SoundBuf; // Maximum size of the sound buffer, in frames. Set by the driver code. int32 SoundBufMaxSize; // Number of frames currently in internal sound buffer. Set by the system emulation code, to be read by the driver code. int32 SoundBufSize; int32 SoundBufSizeALMS; // SoundBufSize value at last MidSync(), 0 // if mid sync isn't implemented for the emulation module in use. // Number of cycles that this frame consumed, using MDFNGI::MasterClock as a time base. // Set by emulation code. int64 MasterCycles; int64 MasterCyclesALMS; // MasterCycles value at last MidSync(), 0 // if mid sync isn't implemented for the emulation module in use. // Current sound volume(0.000...<=volume<=1.000...). If, after calling Emulate(), it is still != 1, Mednafen will handle it internally. // Emulation modules can handle volume themselves if they like, for speed reasons. If they do, afterwards, they should set its value to 1. double SoundVolume; // Current sound speed multiplier. Set by the driver code. If, after calling Emulate(), it is still != 1, Mednafen will handle it internally // by resampling the audio. This means that emulation modules can handle(and set the value to 1 after handling it) it if they want to get the most // performance possible. HOWEVER, emulation modules must make sure the value is in a range(with minimum and maximum) that their code can handle // before they try to handle it. double soundmultiplier; // True if we want to rewind one frame. Set by the driver code. bool NeedRewind; // Sound reversal during state rewinding is normally done in mednafen.cpp, but // individual system emulation code can also do it if this is set, and clear it after it's done. // (Also, the driver code shouldn't touch this variable) bool NeedSoundReverse; } EmulateSpecStruct; typedef enum { MODPRIO_INTERNAL_EXTRA_LOW = 0, // For "cdplay" module, mostly. MODPRIO_INTERNAL_LOW = 10, MODPRIO_EXTERNAL_LOW = 20, MODPRIO_INTERNAL_HIGH = 30, MODPRIO_EXTERNAL_HIGH = 40 } ModPrio; class CDIF; typedef struct { /* Private functions to Mednafen. Do not call directly from the driver code, or else bad things shall happen. Maybe. Probably not, but don't do it(yet)! */ // Short system name, lowercase a-z, 0-9, and _ are the only allowable characters! const char *shortname; // Full system name. Preferably English letters, but can be UTF8 const char *fullname; // Pointer to an array of FileExtensionSpecStruct, with the last entry being { NULL, NULL } to terminate the list. // This list is used to make best-guess choices, when calling the TestMagic*() functions would be unreasonable, such // as when scanning a ZIP archive for a file to load. The list may also be used in the future for GUI file open windows. const FileExtensionSpecStruct *FileExtensions; ModPrio ModulePriority; void *Debugger; InputInfoStruct *InputInfo; // Returns 1 on successful load, 0 on fatal error(deprecated: -1 on unrecognized format) int (*Load)(const char *name, MDFNFILE *fp); // Return TRUE if the file is a recognized type, FALSE if not. bool (*TestMagic)(const char *name, MDFNFILE *fp); // // (*CDInterfaces).size() is guaranteed to be >= 1. int (*LoadCD)(std::vector *CDInterfaces); bool (*TestMagicCD)(std::vector *CDInterfaces); void (*CloseGame)(void); void (*SetLayerEnableMask)(uint64 mask); // Video const char *LayerNames; void (*SetChanEnableMask)(uint64 mask); // Audio(TODO, placeholder) const char *ChanNames; void (*InstallReadPatch)(uint32 address); void (*RemoveReadPatches)(void); uint8 (*MemRead)(uint32 addr); #ifdef WANT_NEW_API CheatFormatInfoStruct *CheatFormatInfo; #endif bool SaveStateAltersState; // true for bsnes and some libco-style emulators, false otherwise. // Main save state routine, called by the save state code in state.cpp. // When saving, load is set to 0. When loading, load is set to the version field of the save state being loaded. // data_only is true when the save state data is temporary, such as being saved into memory for state rewinding. int (*StateAction)(StateMem *sm, int load, int data_only); void (*Emulate)(EmulateSpecStruct *espec); void (*SetInput)(int port, const char *type, void *ptr); void (*DoSimpleCommand)(int cmd); const MDFNSetting *Settings; // Time base for EmulateSpecStruct::MasterCycles #define MDFN_MASTERCLOCK_FIXED(n) ((int64)((double)(n) * (1LL << 32))) int64 MasterClock; uint32 fps; // frames per second * 65536 * 256, truncated // multires is a hint that, if set, indicates that the system has fairly programmable video modes(particularly, the ability // to display multiple horizontal resolutions, such as the PCE, PC-FX, or Genesis). In practice, it will cause the driver // code to set the linear interpolation on by default. // // lcm_width and lcm_height are the least common multiples of all possible // resolutions in the frame buffer as specified by DisplayRect/LineWidths(Ex for PCE: widths of 256, 341.333333, 512, // lcm = 1024) // // nominal_width and nominal_height specify the resolution that Mednafen should display // the framebuffer image in at 1x scaling, scaled from the dimensions of DisplayRect, and optionally the LineWidths array // passed through espec to the Emulate() function. // bool multires; int lcm_width; int lcm_height; void *dummy_separator; // int nominal_width; int nominal_height; int fb_width; // Width of the framebuffer(not necessarily width of the image). MDFN_Surface width should be >= this. int fb_height; // Height of the framebuffer passed to the Emulate() function(not necessarily height of the image) int soundchan; // Number of output sound channels. int rotated; uint8 *name; /* Game name, UTF8 encoding */ int soundrate; /* For Ogg Vorbis expansion sound wacky support. 0 for default. */ VideoSystems VideoSystem; GameMediumTypes GameType; //int DiskLogicalCount; // A single double-sided disk would be 2 here. //const char *DiskNames; // Null-terminated. const char *cspecial; /* Special cart expansion: DIP switches, barcode reader, etc. */ std::vectorDesiredInput; // Desired input device for the input ports, NULL for don't care double mouse_sensitivity; } MDFNGI; #endif mednafen/cdrom/audioreader_opus.h000664 001750 001750 00000000544 12726204343 020274 0ustar00sergiosergio000000 000000 #ifndef __MDFN_AUDIOREADER_OPUS_H #define __MDFN_AUDIOREADER_OPUS_H #include class OggOpusReader : public AudioReader { public: OggOpusReader(Stream *fp); ~OggOpusReader(); int64 Read_(int16 *buffer, int64 frames); bool Seek_(int64 frame_offset); int64 FrameCount(void); private: OggOpus_File *opfile; Stream *fw; }; #endif mednafen/cdrom/cdromif.cpp000664 001750 001750 00000041546 12726204343 016727 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "../mednafen.h" #include #include #include "cdromif.h" #include "CDAccess.h" #include "../general.h" #include #include "../../libretro.h" extern retro_log_printf_t log_cb; using namespace CDUtility; enum { // Status/Error messages CDIF_MSG_DONE = 0, // Read -> emu. args: No args. CDIF_MSG_INFO, // Read -> emu. args: str_message CDIF_MSG_FATAL_ERROR, // Read -> emu. args: *TODO ARGS* // // Command messages. // CDIF_MSG_DIEDIEDIE, // Emu -> read CDIF_MSG_READ_SECTOR, /* Emu -> read args[0] = lba */ CDIF_MSG_EJECT, // Emu -> read, args[0]; 0=insert, 1=eject }; class CDIF_Message { public: CDIF_Message(); CDIF_Message(unsigned int message_, uint32 arg0 = 0, uint32 arg1 = 0, uint32 arg2 = 0, uint32 arg3 = 0); CDIF_Message(unsigned int message_, const std::string &str); ~CDIF_Message(); unsigned int message; uint32 args[4]; void *parg; std::string str_message; }; class CDIF_Queue { public: CDIF_Queue(); ~CDIF_Queue(); bool Read(CDIF_Message *message, bool blocking = TRUE); void Write(const CDIF_Message &message); private: std::queue ze_queue; MDFN_Mutex *ze_mutex; MDFN_Cond *ze_cond; }; typedef struct { bool valid; bool error; uint32 lba; uint8 data[2352 + 96]; } CDIF_Sector_Buffer; // TODO: prohibit copy constructor class CDIF_MT : public CDIF { public: CDIF_MT(CDAccess *cda); virtual ~CDIF_MT(); virtual void HintReadSector(uint32 lba); virtual bool ReadRawSector(uint8 *buf, uint32 lba); // Return true if operation succeeded or it was a NOP(either due to not being implemented, or the current status matches eject_status). // Returns false on failure(usually drive error of some kind; not completely fatal, can try again). virtual bool Eject(bool eject_status); // FIXME: Semi-private: int ReadThreadStart(void); private: CDAccess *disc_cdaccess; MDFN_Thread *CDReadThread; // Queue for messages to the read thread. CDIF_Queue ReadThreadQueue; // Queue for messages to the emu thread. CDIF_Queue EmuThreadQueue; enum { SBSize = 256 }; CDIF_Sector_Buffer SectorBuffers[SBSize]; uint32 SBWritePos; MDFN_Mutex *SBMutex; MDFN_Cond *SBCond; // // Read-thread-only: // void RT_EjectDisc(bool eject_status, bool skip_actual_eject = false); uint32 ra_lba; int ra_count; uint32 last_read_lba; }; // TODO: prohibit copy constructor class CDIF_ST : public CDIF { public: CDIF_ST(CDAccess *cda); virtual ~CDIF_ST(); virtual void HintReadSector(uint32 lba); virtual bool ReadRawSector(uint8 *buf, uint32 lba); virtual bool Eject(bool eject_status); private: CDAccess *disc_cdaccess; }; CDIF::CDIF() : UnrecoverableError(false), is_phys_cache(false), DiscEjected(false) { } CDIF::~CDIF() { } CDIF_Message::CDIF_Message() { message = 0; memset(args, 0, sizeof(args)); } CDIF_Message::CDIF_Message(unsigned int message_, uint32 arg0, uint32 arg1, uint32 arg2, uint32 arg3) { message = message_; args[0] = arg0; args[1] = arg1; args[2] = arg2; args[3] = arg3; } CDIF_Message::CDIF_Message(unsigned int message_, const std::string &str) { message = message_; str_message = str; } CDIF_Message::~CDIF_Message() { } CDIF_Queue::CDIF_Queue() { ze_mutex = MDFND_CreateMutex(); ze_cond = MDFND_CreateCond(); } CDIF_Queue::~CDIF_Queue() { MDFND_DestroyMutex(ze_mutex); MDFND_DestroyCond(ze_cond); } // Returns FALSE if message not read, TRUE if it was read. Will always return TRUE if "blocking" is set. // Will throw MDFN_Error if the read message code is CDIF_MSG_FATAL_ERROR bool CDIF_Queue::Read(CDIF_Message *message, bool blocking) { bool ret = true; // // // MDFND_LockMutex(ze_mutex); if(blocking) { while(ze_queue.size() == 0) // while, not just if. MDFND_WaitCond(ze_cond, ze_mutex); } if(ze_queue.size() == 0) ret = false; else { *message = ze_queue.front(); ze_queue.pop(); } MDFND_UnlockMutex(ze_mutex); // // // if(ret && message->message == CDIF_MSG_FATAL_ERROR) throw MDFN_Error(0, "%s", message->str_message.c_str()); return(ret); } void CDIF_Queue::Write(const CDIF_Message &message) { MDFND_LockMutex(ze_mutex); ze_queue.push(message); MDFND_SignalCond(ze_cond); // Signal while the mutex is held to prevent icky race conditions MDFND_UnlockMutex(ze_mutex); } void CDIF_MT::RT_EjectDisc(bool eject_status, bool skip_actual_eject) { int32 old_de = DiscEjected; DiscEjected = eject_status; if(old_de != DiscEjected) { if(!skip_actual_eject) disc_cdaccess->Eject(eject_status); if(!eject_status) // Re-read the TOC { disc_cdaccess->Read_TOC(&disc_toc); if(disc_toc.first_track < 1 || disc_toc.last_track > 99 || disc_toc.first_track > disc_toc.last_track) { throw(MDFN_Error(0, _("TOC first(%d)/last(%d) track numbers bad."), disc_toc.first_track, disc_toc.last_track)); } } SBWritePos = 0; ra_lba = 0; ra_count = 0; last_read_lba = ~0U; memset(SectorBuffers, 0, SBSize * sizeof(CDIF_Sector_Buffer)); } } struct RTS_Args { CDIF_MT *cdif_ptr; }; static int ReadThreadStart_C(void *v_arg) { RTS_Args *args = (RTS_Args *)v_arg; return args->cdif_ptr->ReadThreadStart(); } int CDIF_MT::ReadThreadStart() { bool Running = TRUE; DiscEjected = true; SBWritePos = 0; ra_lba = 0; ra_count = 0; last_read_lba = ~0U; try { RT_EjectDisc(false, true); } catch(std::exception &e) { EmuThreadQueue.Write(CDIF_Message(CDIF_MSG_FATAL_ERROR, std::string(e.what()))); return(0); } is_phys_cache = false; EmuThreadQueue.Write(CDIF_Message(CDIF_MSG_DONE)); while(Running) { CDIF_Message msg; // Only do a blocking-wait for a message if we don't have any sectors to read-ahead. // MDFN_DispMessage("%d %d %d\n", last_read_lba, ra_lba, ra_count); if(ReadThreadQueue.Read(&msg, ra_count ? FALSE : TRUE)) { switch(msg.message) { case CDIF_MSG_DIEDIEDIE: Running = FALSE; break; case CDIF_MSG_EJECT: try { RT_EjectDisc(msg.args[0]); EmuThreadQueue.Write(CDIF_Message(CDIF_MSG_DONE)); } catch(std::exception &e) { EmuThreadQueue.Write(CDIF_Message(CDIF_MSG_FATAL_ERROR, std::string(e.what()))); } break; case CDIF_MSG_READ_SECTOR: { static const int max_ra = 16; static const int initial_ra = 1; static const int speedmult_ra = 2; uint32 new_lba = msg.args[0]; assert((unsigned int)max_ra < (SBSize / 4)); if(last_read_lba != ~0U && new_lba == (last_read_lba + 1)) { int how_far_ahead = ra_lba - new_lba; if(how_far_ahead <= max_ra) ra_count = std::min(speedmult_ra, 1 + max_ra - how_far_ahead); else ra_count++; } else if(new_lba != last_read_lba) { ra_lba = new_lba; ra_count = initial_ra; } last_read_lba = new_lba; } break; } } // Don't read >= the "end" of the disc, silly snake. Slither. if(ra_count && ra_lba == disc_toc.tracks[100].lba) { ra_count = 0; //printf("Ephemeral scarabs: %d!\n", ra_lba); } if(ra_count) { uint8 tmpbuf[2352 + 96]; bool error_condition = false; try { disc_cdaccess->Read_Raw_Sector(tmpbuf, ra_lba); } catch(std::exception &e) { if (log_cb) log_cb(RETRO_LOG_ERROR, "Sector %u read error: %s\n", ra_lba, e.what()); memset(tmpbuf, 0, sizeof(tmpbuf)); error_condition = true; } MDFND_LockMutex(SBMutex); SectorBuffers[SBWritePos].lba = ra_lba; memcpy(SectorBuffers[SBWritePos].data, tmpbuf, 2352 + 96); SectorBuffers[SBWritePos].valid = TRUE; SectorBuffers[SBWritePos].error = error_condition; SBWritePos = (SBWritePos + 1) % SBSize; MDFND_SignalCond(SBCond); MDFND_UnlockMutex(SBMutex); ra_lba++; ra_count--; } } return(1); } CDIF_MT::CDIF_MT(CDAccess *cda) : disc_cdaccess(cda), CDReadThread(NULL), SBMutex(NULL), SBCond(NULL) { try { CDIF_Message msg; RTS_Args s; SBMutex = MDFND_CreateMutex(); SBCond = MDFND_CreateCond(); UnrecoverableError = false; s.cdif_ptr = this; CDReadThread = MDFND_CreateThread(ReadThreadStart_C, &s); EmuThreadQueue.Read(&msg); } catch(...) { if(CDReadThread) { MDFND_WaitThread(CDReadThread, NULL); CDReadThread = NULL; } if(SBMutex) { MDFND_DestroyMutex(SBMutex); SBMutex = NULL; } if(SBCond) { MDFND_DestroyCond(SBCond); SBCond = NULL; } if(disc_cdaccess) { delete disc_cdaccess; disc_cdaccess = NULL; } throw; } } CDIF_MT::~CDIF_MT() { bool thread_deaded_failed = false; try { ReadThreadQueue.Write(CDIF_Message(CDIF_MSG_DIEDIEDIE)); } catch(std::exception &e) { if (log_cb) log_cb(RETRO_LOG_ERROR, "%s.\n", e.what()); thread_deaded_failed = true; } if(!thread_deaded_failed) MDFND_WaitThread(CDReadThread, NULL); if(SBMutex) { MDFND_DestroyMutex(SBMutex); SBMutex = NULL; } if(disc_cdaccess) { delete disc_cdaccess; disc_cdaccess = NULL; } } bool CDIF::ValidateRawSector(uint8 *buf) { int mode = buf[12 + 3]; if(mode != 0x1 && mode != 0x2) return(false); if(!edc_lec_check_and_correct(buf, mode == 2)) return(false); return(true); } bool CDIF_MT::ReadRawSector(uint8 *buf, uint32 lba) { bool found = FALSE; bool error_condition = false; if(UnrecoverableError) { memset(buf, 0, 2352 + 96); return(false); } // This shouldn't happen, the emulated-system-specific CDROM emulation code should make sure the emulated program doesn't try // to read past the last "real" sector of the disc. if(lba >= disc_toc.tracks[100].lba) { printf("Attempt to read LBA %d, >= LBA %d\n", lba, disc_toc.tracks[100].lba); return(FALSE); } ReadThreadQueue.Write(CDIF_Message(CDIF_MSG_READ_SECTOR, lba)); MDFND_LockMutex(SBMutex); do { for(int i = 0; i < SBSize; i++) { if(SectorBuffers[i].valid && SectorBuffers[i].lba == lba) { error_condition = SectorBuffers[i].error; memcpy(buf, SectorBuffers[i].data, 2352 + 96); found = TRUE; } } if(!found) { //int32 swt = MDFND_GetTime(); MDFND_WaitCond(SBCond, SBMutex); //printf("SB Waited: %d\n", MDFND_GetTime() - swt); } } while(!found); MDFND_UnlockMutex(SBMutex); return(!error_condition); } void CDIF_MT::HintReadSector(uint32 lba) { if(UnrecoverableError) return; ReadThreadQueue.Write(CDIF_Message(CDIF_MSG_READ_SECTOR, lba)); } int CDIF::ReadSector(uint8* pBuf, uint32 lba, uint32 nSectors) { int ret = 0; if(UnrecoverableError) return(false); while(nSectors--) { uint8 tmpbuf[2352 + 96]; if(!ReadRawSector(tmpbuf, lba)) { puts("CDIF Raw Read error"); return(FALSE); } if(!ValidateRawSector(tmpbuf)) { if (log_cb) { log_cb(RETRO_LOG_ERROR, "Uncorrectable data at sector %d\n", lba); log_cb(RETRO_LOG_ERROR, "Uncorrectable data at sector %d\n", lba); } return(false); } const int mode = tmpbuf[12 + 3]; if(!ret) ret = mode; if(mode == 1) { memcpy(pBuf, &tmpbuf[12 + 4], 2048); } else if(mode == 2) { memcpy(pBuf, &tmpbuf[12 + 4 + 8], 2048); } else { printf("CDIF_ReadSector() invalid sector type at LBA=%u\n", (unsigned int)lba); return(false); } pBuf += 2048; lba++; } return(ret); } bool CDIF_MT::Eject(bool eject_status) { if(UnrecoverableError) return(false); try { CDIF_Message msg; ReadThreadQueue.Write(CDIF_Message(CDIF_MSG_EJECT, eject_status)); EmuThreadQueue.Read(&msg); } catch(std::exception &e) { log_cb(RETRO_LOG_ERROR, "Error on eject/insert attempt: %s\n", e.what()); return(false); } return(true); } // // // Single-threaded implementation follows. // // CDIF_ST::CDIF_ST(CDAccess *cda) : disc_cdaccess(cda) { //puts("***WARNING USING SINGLE-THREADED CD READER***"); is_phys_cache = false; UnrecoverableError = false; DiscEjected = false; disc_cdaccess->Read_TOC(&disc_toc); if(disc_toc.first_track < 1 || disc_toc.last_track > 99 || disc_toc.first_track > disc_toc.last_track) { throw(MDFN_Error(0, _("TOC first(%d)/last(%d) track numbers bad."), disc_toc.first_track, disc_toc.last_track)); } } CDIF_ST::~CDIF_ST() { if(disc_cdaccess) { delete disc_cdaccess; disc_cdaccess = NULL; } } void CDIF_ST::HintReadSector(uint32 lba) { // TODO: disc_cdaccess seek hint? (probably not, would require asynchronousitycamel) } bool CDIF_ST::ReadRawSector(uint8 *buf, uint32 lba) { if(UnrecoverableError) { memset(buf, 0, 2352 + 96); return(false); } try { disc_cdaccess->Read_Raw_Sector(buf, lba); } catch(std::exception &e) { if (log_cb) log_cb(RETRO_LOG_ERROR, "Sector %u read error: %s\n", lba, e.what()); memset(buf, 0, 2352 + 96); return(false); } return(true); } bool CDIF_ST::Eject(bool eject_status) { if(UnrecoverableError) return(false); try { int32 old_de = DiscEjected; DiscEjected = eject_status; if(old_de != DiscEjected) { disc_cdaccess->Eject(eject_status); if(!eject_status) // Re-read the TOC { disc_cdaccess->Read_TOC(&disc_toc); if(disc_toc.first_track < 1 || disc_toc.last_track > 99 || disc_toc.first_track > disc_toc.last_track) { throw(MDFN_Error(0, _("TOC first(%d)/last(%d) track numbers bad."), disc_toc.first_track, disc_toc.last_track)); } } } } catch(std::exception &e) { if (log_cb) log_cb(RETRO_LOG_ERROR, "%s\n", e.what()); return(false); } return(true); } class CDIF_Stream_Thing : public Stream { public: CDIF_Stream_Thing(CDIF *cdintf_arg, uint32 lba_arg, uint32 sector_count_arg); ~CDIF_Stream_Thing(); virtual uint64 attributes(void); virtual uint8 *map(void); virtual void unmap(void); virtual uint64 read(void *data, uint64 count, bool error_on_eos = true); virtual void write(const void *data, uint64 count); virtual void seek(int64 offset, int whence); virtual int64 tell(void); virtual int64 size(void); virtual void close(void); private: CDIF *cdintf; const uint32 start_lba; const uint32 sector_count; int64 position; }; CDIF_Stream_Thing::CDIF_Stream_Thing(CDIF *cdintf_arg, uint32 start_lba_arg, uint32 sector_count_arg) : cdintf(cdintf_arg), start_lba(start_lba_arg), sector_count(sector_count_arg) { } CDIF_Stream_Thing::~CDIF_Stream_Thing() { } uint64 CDIF_Stream_Thing::attributes(void) { return(ATTRIBUTE_READABLE | ATTRIBUTE_SEEKABLE); } uint8 *CDIF_Stream_Thing::map(void) { return NULL; } void CDIF_Stream_Thing::unmap(void) { } uint64 CDIF_Stream_Thing::read(void *data, uint64 count, bool error_on_eos) { if(count > (((uint64)sector_count * 2048) - position)) { if(error_on_eos) { throw MDFN_Error(0, "EOF"); } count = ((uint64)sector_count * 2048) - position; } if(!count) return(0); for(uint64 rp = position; rp < (position + count); rp = (rp &~ 2047) + 2048) { uint8 buf[2048]; if(!cdintf->ReadSector(buf, start_lba + (rp / 2048), 1)) { throw MDFN_Error(ErrnoHolder(EIO)); } //::printf("Meow: %08llx -- %08llx\n", count, (rp - position) + std::min(2048 - (rp & 2047), count - (rp - position))); memcpy((uint8*)data + (rp - position), buf + (rp & 2047), std::min(2048 - (rp & 2047), count - (rp - position))); } position += count; return count; } void CDIF_Stream_Thing::write(const void *data, uint64 count) { throw MDFN_Error(ErrnoHolder(EBADF)); } void CDIF_Stream_Thing::seek(int64 offset, int whence) { int64 new_position; switch(whence) { default: throw MDFN_Error(ErrnoHolder(EINVAL)); break; case SEEK_SET: new_position = offset; break; case SEEK_CUR: new_position = position + offset; break; case SEEK_END: new_position = ((int64)sector_count * 2048) + offset; break; } if(new_position < 0 || new_position > ((int64)sector_count * 2048)) throw MDFN_Error(ErrnoHolder(EINVAL)); position = new_position; } int64 CDIF_Stream_Thing::tell(void) { return position; } int64 CDIF_Stream_Thing::size(void) { return(sector_count * 2048); } void CDIF_Stream_Thing::close(void) { } Stream *CDIF::MakeStream(uint32 lba, uint32 sector_count) { return new CDIF_Stream_Thing(this, lba, sector_count); } CDIF *CDIF_Open(const char *path, const bool is_device, bool image_memcache) { CDAccess *cda = cdaccess_open_image(path, image_memcache); if(!image_memcache) return new CDIF_MT(cda); else return new CDIF_ST(cda); } README.md000664 001750 001750 00000000036 12726204343 013163 0ustar00sergiosergio000000 000000 # Mednafen PC-Engine libretro libretro-common/include/streams/file_stream.h000664 001750 001750 00000004706 12726204343 022570 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (file_stream.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_FILE_STREAM_H #define __LIBRETRO_SDK_FILE_STREAM_H #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif typedef struct RFILE RFILE; enum { RFILE_MODE_READ = 0, RFILE_MODE_WRITE, RFILE_MODE_READ_WRITE, /* There is no garantee these requests will be attended. */ RFILE_HINT_UNBUFFERED = 1<<8, RFILE_HINT_MMAP = 1<<9 /* requires RFILE_MODE_READ */ }; RFILE *filestream_open(const char *path, unsigned mode, ssize_t len); ssize_t filestream_seek(RFILE *stream, ssize_t offset, int whence); ssize_t filestream_read(RFILE *stream, void *data, size_t len); ssize_t filestream_write(RFILE *stream, const void *data, size_t len); ssize_t filestream_tell(RFILE *stream); void filestream_rewind(RFILE *stream); int filestream_close(RFILE *stream); int filestream_read_file(const char *path, void **buf, ssize_t *len); bool filestream_write_file(const char *path, const void *data, ssize_t size); int filestream_get_fd(RFILE *stream); #ifdef __cplusplus } #endif #endif mednafen/cdrom/dvdisaster.h000664 001750 001750 00000011627 12726204343 017116 0ustar00sergiosergio000000 000000 /* dvdisaster: Additional error correction for optical media. * Copyright (C) 2004-2007 Carsten Gnoerlich. * Project home page: http://www.dvdisaster.com * Email: carsten@dvdisaster.com -or- cgnoerlich@fsfe.org * * 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, * or direct your browser at http://www.gnu.org. */ #ifndef DVDISASTER_H #define DVDISASTER_H /* "Dare to be gorgeous and unique. * But don't ever be cryptic or otherwise unfathomable. * Make it unforgettably great." * * From "A Final Note on Style", * Amiga Intuition Reference Manual, 1986, p. 231 */ /*** *** I'm too lazy to mess with #include dependencies. *** Everything #includeable is rolled up herein... */ #include "../mednafen-types.h" #include #include #include #include #include #include #include #include #include #include #ifdef _WIN32 #include #else #include #endif /*** *** dvdisaster.c ***/ void PrepareDeadSector(void); void CreateEcc(void); void FixEcc(void); void Verify(void); uint32 EDCCrc32(const unsigned char*, int); /*** *** galois.c *** * This is currently the hardcoded GF(2**8). * int32 gives abundant space for the GF. * Squeezing it down to uint8 won't probably gain much, * so we implement this defensively here. * * Note that some performance critical stuff needs to * be #included from galois-inlines.h */ /* Galois field parameters for 8bit symbol Reed-Solomon code */ #define GF_SYMBOLSIZE 8 #define GF_FIELDSIZE (1< #include FileStream::FileStream(const char *path, const int mode): OpenedMode(mode) { fp = filestream_open(path, (mode == MODE_WRITE) ? RFILE_MODE_WRITE : RFILE_MODE_READ, -1); if (!fp) { ErrnoHolder ene(errno); throw(MDFN_Error(ene.Errno(), "Error opening file %s", ene.StrError())); } original_path = strdup(path); } FileStream::~FileStream() { if (original_path) free(original_path); original_path = NULL; } uint64_t FileStream::attributes(void) { uint64_t ret = ATTRIBUTE_SEEKABLE; switch(OpenedMode) { case MODE_READ: ret |= ATTRIBUTE_READABLE; break; case MODE_WRITE_SAFE: case MODE_WRITE: ret |= ATTRIBUTE_WRITEABLE; break; } return ret; } uint64_t FileStream::read(void *data, uint64_t count, bool error_on_eos) { if (!fp) return 0; return filestream_read(fp, data, count); } void FileStream::write(const void *data, uint64_t count) { if (!fp) return; filestream_write(fp, data, count); } void FileStream::seek(int64_t offset, int whence) { if (!fp) return; filestream_seek(fp, offset, whence); } int64_t FileStream::tell(void) { if (!fp) return -1; return filestream_tell(fp); } int64_t FileStream::size(void) { if (!original_path) return -1; return path_get_size(original_path); } void FileStream::close(void) { if (!fp) return; filestream_close(fp); } mednafen/cdrom/CDUtility.cpp000664 001750 001750 00000020604 12726204343 017146 0ustar00sergiosergio000000 000000 /* 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 "../mednafen.h" #include "CDUtility.h" #include "dvdisaster.h" #include "lec.h" #include // Kill_LEC_Correct(); namespace CDUtility { // lookup table for crc calculation static uint16 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 scramble_table[2352 - 12]; static bool CDUtility_Inited = false; static void InitScrambleTable(void) { unsigned cv = 1; for(unsigned i = 12; i < 2352; i++) { unsigned char z = 0; for(int b = 0; b < 8; b++) { z |= (cv & 1) << b; int feedback = ((cv >> 1) & 1) ^ (cv & 1); cv = (cv >> 1) | (feedback << 14); } scramble_table[i - 12] = z; } //for(int i = 0; i < 2352 - 12; i++) // printf("0x%02x, ", scramble_table[i]); } void CDUtility_Init(void) { if(!CDUtility_Inited) { Init_LEC_Correct(); InitScrambleTable(); CDUtility_Inited = true; } } void encode_mode0_sector(uint32 aba, uint8 *sector_data) { CDUtility_Init(); lec_encode_mode0_sector(aba, sector_data); } void encode_mode1_sector(uint32 aba, uint8 *sector_data) { CDUtility_Init(); lec_encode_mode1_sector(aba, sector_data); } void encode_mode2_sector(uint32 aba, uint8 *sector_data) { CDUtility_Init(); lec_encode_mode2_sector(aba, sector_data); } void encode_mode2_form1_sector(uint32 aba, uint8 *sector_data) { CDUtility_Init(); lec_encode_mode2_form1_sector(aba, sector_data); } void encode_mode2_form2_sector(uint32 aba, uint8 *sector_data) { CDUtility_Init(); lec_encode_mode2_form2_sector(aba, sector_data); } bool edc_check(const uint8 *sector_data, bool xa) { CDUtility_Init(); return(CheckEDC(sector_data, xa)); } bool edc_lec_check_and_correct(uint8 *sector_data, bool xa) { CDUtility_Init(); return(ValidateRawSector(sector_data, xa)); } bool subq_check_checksum(const uint8 *SubQBuf) { uint16 crc = 0; uint16 stored_crc = 0; stored_crc = SubQBuf[0xA] << 8; stored_crc |= SubQBuf[0xB]; for(int 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 *buf) { uint16 crc = 0; for(int 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 *SubPWBuf, uint8 *qbuf) { memset(qbuf, 0, 0xC); for(int 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 *in_buf, uint8 *out_buf) { assert(in_buf != out_buf); memset(out_buf, 0, 96); for(unsigned ch = 0; ch < 8; ch++) { for(unsigned 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 *in_buf, uint8 *out_buf) { assert(in_buf != out_buf); for(unsigned d = 0; d < 12; d++) { for(unsigned bitpoodle = 0; bitpoodle < 8; bitpoodle++) { uint8 rawb = 0; for(unsigned 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 TOC& toc, const int32 lba, uint8* SubPWBuf) { uint8 buf[0xC]; uint32 lba_relative; uint32 ma, sa, fa; uint32 m, s, f; lba_relative = lba - toc.tracks[100].lba; f = (lba_relative % 75); s = ((lba_relative / 75) % 60); m = (lba_relative / 75 / 60); fa = (lba + 150) % 75; sa = ((lba + 150) / 75) % 60; ma = ((lba + 150) / 75 / 60); uint8 adr = 0x1; // Q channel data encodes position uint8 control = (toc.tracks[toc.last_track].control & 0x4) | toc.tracks[100].control; 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(int i = 0; i < 96; i++) SubPWBuf[i] = (((buf[i >> 3] >> (7 - (i & 0x7))) & 1) ? 0x40 : 0x00) | 0x80; } void synth_leadout_sector_lba(const uint8 mode, const TOC& toc, const int32 lba, uint8* out_buf) { memset(out_buf, 0, 2352 + 96); subpw_synth_leadout_lba(toc, lba, out_buf + 2352); if((toc.tracks[toc.last_track].control | toc.tracks[100].control) & 0x4) { 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[18] = 0x20; encode_mode2_form2_sector(LBA_to_ABA(lba), out_buf); break; } } } #if 0 bool subq_extrapolate(const uint8 *subq_input, int32 position_delta, uint8 *subq_output) { assert(subq_check_checksum(subq_input)); subq_generate_checksum(subq_output); } #endif void scrambleize_data_sector(uint8 *sector_data) { for(unsigned i = 12; i < 2352; i++) sector_data[i] ^= scramble_table[i - 12]; } } mednafen/pce_fast/input.h000664 001750 001750 00000000636 12726204343 016563 0ustar00sergiosergio000000 000000 #ifndef __PCE_INPUT_H #define __PCE_INPUT_H void PCEINPUT_Init(void); void PCEINPUT_SettingChanged(const char *name); void PCEINPUT_SetInput(int port, const char *type, void *ptr); uint8 INPUT_Read(unsigned int A); void INPUT_Write(unsigned int A, uint8 V); void INPUT_Frame(void); int INPUT_StateAction(StateMem *sm, int load, int data_only); extern InputInfoStruct PCEInputInfo; void INPUT_FixTS(void); #endif mednafen/cdrom/CDAccess.cpp000664 001750 001750 00000002732 12726204343 016706 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "../mednafen.h" #include "CDAccess.h" #include "CDAccess_Image.h" #include "CDAccess_CCD.h" #ifdef HAVE_LIBCDIO #include "CDAccess_Physical.h" #endif using namespace CDUtility; CDAccess::CDAccess() { } CDAccess::~CDAccess() { } CDAccess *cdaccess_open_image(const char *path, bool image_memcache) { CDAccess *ret = NULL; if(strlen(path) >= 4 && !strcasecmp(path + strlen(path) - 4, ".ccd")) ret = new CDAccess_CCD(path, image_memcache); else ret = new CDAccess_Image(path, image_memcache); return ret; } CDAccess *cdaccess_open_phys(const char *devicename) { #ifdef HAVE_LIBCDIO return new CDAccess_Physical(devicename); #else throw MDFN_Error(0, _("Physical CD access support not compiled in.")); #endif } mednafen/tremor/mdct.c000664 001750 001750 00000033065 12726204343 016074 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: normalized modified discrete cosine transform power of two length transform only [64 <= n ] last mod: $Id: mdct.c,v 1.9 2002/10/16 09:17:39 xiphmont Exp $ Original algorithm adapted long ago from _The use of multirate filter banks for coding of high quality digital audio_, by T. Sporer, K. Brandenburg and B. Edler, collection of the European Signal Processing Conference (EUSIPCO), Amsterdam, June 1992, Vol.1, pp 211-214 The below code implements an algorithm that no longer looks much like that presented in the paper, but the basic structure remains if you dig deep enough to see it. This module DOES NOT INCLUDE code to generate/apply the window function. Everybody has their own weird favorite including me... I happen to like the properties of y=sin(.5PI*sin^2(x)), but others may vehemently disagree. ********************************************************************/ #include "ivorbiscodec.h" #include "codebook.h" #include "misc.h" #include "mdct.h" #include "mdct_lookup.h" /* 8 point butterfly (in place) */ STIN void mdct_butterfly_8(DATA_TYPE *x){ REG_TYPE r0 = x[4] + x[0]; REG_TYPE r1 = x[4] - x[0]; REG_TYPE r2 = x[5] + x[1]; REG_TYPE r3 = x[5] - x[1]; REG_TYPE r4 = x[6] + x[2]; REG_TYPE r5 = x[6] - x[2]; REG_TYPE r6 = x[7] + x[3]; REG_TYPE r7 = x[7] - x[3]; x[0] = r5 + r3; x[1] = r7 - r1; x[2] = r5 - r3; x[3] = r7 + r1; x[4] = r4 - r0; x[5] = r6 - r2; x[6] = r4 + r0; x[7] = r6 + r2; MB(); } /* 16 point butterfly (in place, 4 register) */ STIN void mdct_butterfly_16(DATA_TYPE *x){ REG_TYPE r0, r1; r0 = x[ 0] - x[ 8]; x[ 8] += x[ 0]; r1 = x[ 1] - x[ 9]; x[ 9] += x[ 1]; x[ 0] = MULT31((r0 + r1) , cPI2_8); x[ 1] = MULT31((r1 - r0) , cPI2_8); MB(); r0 = x[10] - x[ 2]; x[10] += x[ 2]; r1 = x[ 3] - x[11]; x[11] += x[ 3]; x[ 2] = r1; x[ 3] = r0; MB(); r0 = x[12] - x[ 4]; x[12] += x[ 4]; r1 = x[13] - x[ 5]; x[13] += x[ 5]; x[ 4] = MULT31((r0 - r1) , cPI2_8); x[ 5] = MULT31((r0 + r1) , cPI2_8); MB(); r0 = x[14] - x[ 6]; x[14] += x[ 6]; r1 = x[15] - x[ 7]; x[15] += x[ 7]; x[ 6] = r0; x[ 7] = r1; MB(); mdct_butterfly_8(x); mdct_butterfly_8(x+8); } /* 32 point butterfly (in place, 4 register) */ STIN void mdct_butterfly_32(DATA_TYPE *x){ REG_TYPE r0, r1; r0 = x[30] - x[14]; x[30] += x[14]; r1 = x[31] - x[15]; x[31] += x[15]; x[14] = r0; x[15] = r1; MB(); r0 = x[28] - x[12]; x[28] += x[12]; r1 = x[29] - x[13]; x[29] += x[13]; XNPROD31( r0, r1, cPI1_8, cPI3_8, &x[12], &x[13] ); MB(); r0 = x[26] - x[10]; x[26] += x[10]; r1 = x[27] - x[11]; x[27] += x[11]; x[10] = MULT31((r0 - r1) , cPI2_8); x[11] = MULT31((r0 + r1) , cPI2_8); MB(); r0 = x[24] - x[ 8]; x[24] += x[ 8]; r1 = x[25] - x[ 9]; x[25] += x[ 9]; XNPROD31( r0, r1, cPI3_8, cPI1_8, &x[ 8], &x[ 9] ); MB(); r0 = x[22] - x[ 6]; x[22] += x[ 6]; r1 = x[ 7] - x[23]; x[23] += x[ 7]; x[ 6] = r1; x[ 7] = r0; MB(); r0 = x[ 4] - x[20]; x[20] += x[ 4]; r1 = x[ 5] - x[21]; x[21] += x[ 5]; XPROD31 ( r0, r1, cPI3_8, cPI1_8, &x[ 4], &x[ 5] ); MB(); r0 = x[ 2] - x[18]; x[18] += x[ 2]; r1 = x[ 3] - x[19]; x[19] += x[ 3]; x[ 2] = MULT31((r1 + r0) , cPI2_8); x[ 3] = MULT31((r1 - r0) , cPI2_8); MB(); r0 = x[ 0] - x[16]; x[16] += x[ 0]; r1 = x[ 1] - x[17]; x[17] += x[ 1]; XPROD31 ( r0, r1, cPI1_8, cPI3_8, &x[ 0], &x[ 1] ); MB(); mdct_butterfly_16(x); mdct_butterfly_16(x+16); } /* N/stage point generic N stage butterfly (in place, 2 register) */ STIN void mdct_butterfly_generic(DATA_TYPE *x,int points,int step){ LOOKUP_T *T = sincos_lookup0; DATA_TYPE *x1 = x + points - 8; DATA_TYPE *x2 = x + (points>>1) - 8; REG_TYPE r0; REG_TYPE r1; do{ r0 = x1[6] - x2[6]; x1[6] += x2[6]; r1 = x2[7] - x1[7]; x1[7] += x2[7]; XPROD31( r1, r0, T[0], T[1], &x2[6], &x2[7] ); T+=step; r0 = x1[4] - x2[4]; x1[4] += x2[4]; r1 = x2[5] - x1[5]; x1[5] += x2[5]; XPROD31( r1, r0, T[0], T[1], &x2[4], &x2[5] ); T+=step; r0 = x1[2] - x2[2]; x1[2] += x2[2]; r1 = x2[3] - x1[3]; x1[3] += x2[3]; XPROD31( r1, r0, T[0], T[1], &x2[2], &x2[3] ); T+=step; r0 = x1[0] - x2[0]; x1[0] += x2[0]; r1 = x2[1] - x1[1]; x1[1] += x2[1]; XPROD31( r1, r0, T[0], T[1], &x2[0], &x2[1] ); T+=step; x1-=8; x2-=8; }while(Tsincos_lookup0); do{ r0 = x2[6] - x1[6]; x1[6] += x2[6]; r1 = x2[7] - x1[7]; x1[7] += x2[7]; XPROD31( r0, r1, T[0], T[1], &x2[6], &x2[7] ); T+=step; r0 = x2[4] - x1[4]; x1[4] += x2[4]; r1 = x2[5] - x1[5]; x1[5] += x2[5]; XPROD31( r0, r1, T[0], T[1], &x2[4], &x2[5] ); T+=step; r0 = x2[2] - x1[2]; x1[2] += x2[2]; r1 = x2[3] - x1[3]; x1[3] += x2[3]; XPROD31( r0, r1, T[0], T[1], &x2[2], &x2[3] ); T+=step; r0 = x2[0] - x1[0]; x1[0] += x2[0]; r1 = x2[1] - x1[1]; x1[1] += x2[1]; XPROD31( r0, r1, T[0], T[1], &x2[0], &x2[1] ); T+=step; x1-=8; x2-=8; }while(Tsincos_lookup0); } STIN void mdct_butterflies(DATA_TYPE *x,int points,int shift){ int stages=8-shift; int i,j; for(i=0;--stages>0;i++){ for(j=0;j<(1<>i)*j,points>>i,4<<(i+shift)); } for(j=0;j>8]|(bitrev[(x&0x0f0)>>4]<<4)|(((int)bitrev[x&0x00f])<<8); } STIN void mdct_bitreverse(DATA_TYPE *x,int n,int step,int shift){ int bit = 0; DATA_TYPE *w0 = x; DATA_TYPE *w1 = x = w0+(n>>1); LOOKUP_T *T = (step>=4)?(sincos_lookup0+(step>>1)):sincos_lookup1; LOOKUP_T *Ttop = T+1024; DATA_TYPE r2; do{ DATA_TYPE r3 = bitrev12(bit++); DATA_TYPE *x0 = x + ((r3 ^ 0xfff)>>shift) -1; DATA_TYPE *x1 = x + (r3>>shift); REG_TYPE r0 = x0[0] + x1[0]; REG_TYPE r1 = x1[1] - x0[1]; XPROD32( r0, r1, T[1], T[0], &r2, &r3 ); T+=step; w1 -= 4; r0 = (x0[1] + x1[1])>>1; r1 = (x0[0] - x1[0])>>1; w0[0] = r0 + r2; w0[1] = r1 + r3; w1[2] = r0 - r2; w1[3] = r3 - r1; r3 = bitrev12(bit++); x0 = x + ((r3 ^ 0xfff)>>shift) -1; x1 = x + (r3>>shift); r0 = x0[0] + x1[0]; r1 = x1[1] - x0[1]; XPROD32( r0, r1, T[1], T[0], &r2, &r3 ); T+=step; r0 = (x0[1] + x1[1])>>1; r1 = (x0[0] - x1[0])>>1; w0[2] = r0 + r2; w0[3] = r1 + r3; w1[0] = r0 - r2; w1[1] = r3 - r1; w0 += 4; }while(T>shift) -1; DATA_TYPE *x1 = x + (r3>>shift); REG_TYPE r0 = x0[0] + x1[0]; REG_TYPE r1 = x1[1] - x0[1]; T-=step; XPROD32( r0, r1, T[0], T[1], &r2, &r3 ); w1 -= 4; r0 = (x0[1] + x1[1])>>1; r1 = (x0[0] - x1[0])>>1; w0[0] = r0 + r2; w0[1] = r1 + r3; w1[2] = r0 - r2; w1[3] = r3 - r1; r3 = bitrev12(bit++); x0 = x + ((r3 ^ 0xfff)>>shift) -1; x1 = x + (r3>>shift); r0 = x0[0] + x1[0]; r1 = x1[1] - x0[1]; T-=step; XPROD32( r0, r1, T[0], T[1], &r2, &r3 ); r0 = (x0[1] + x1[1])>>1; r1 = (x0[0] - x1[0])>>1; w0[2] = r0 + r2; w0[3] = r1 + r3; w1[0] = r0 - r2; w1[1] = r3 - r1; w0 += 4; }while(w0>1; int n4=n>>2; DATA_TYPE *iX; DATA_TYPE *oX; LOOKUP_T *T; LOOKUP_T *V; int shift; int step; for (shift=6;!(n&(1<=in+n4); do{ oX-=4; XPROD31( iX[4], iX[6], T[1], T[0], &oX[2], &oX[3] ); T-=step; XPROD31( iX[0], iX[2], T[1], T[0], &oX[0], &oX[1] ); T-=step; iX-=8; }while(iX>=in); iX = in+n2-8; oX = out+n2+n4; T = sincos_lookup0; do{ T+=step; XNPROD31( iX[6], iX[4], T[0], T[1], &oX[0], &oX[1] ); T+=step; XNPROD31( iX[2], iX[0], T[0], T[1], &oX[2], &oX[3] ); iX-=8; oX+=4; }while(iX>=in+n4); do{ T-=step; XNPROD31( iX[6], iX[4], T[1], T[0], &oX[0], &oX[1] ); T-=step; XNPROD31( iX[2], iX[0], T[1], T[0], &oX[2], &oX[3] ); iX-=8; oX+=4; }while(iX>=in); mdct_butterflies(out+n2,n2,shift); mdct_bitreverse(out,n,step,shift); /* rotate + window */ step>>=2; { DATA_TYPE *oX1=out+n2+n4; DATA_TYPE *oX2=out+n2+n4; DATA_TYPE *iX =out; switch(step) { default: { T=(step>=4)?(sincos_lookup0+(step>>1)):sincos_lookup1; do{ oX1-=4; XPROD31( iX[0], -iX[1], T[0], T[1], &oX1[3], &oX2[0] ); T+=step; XPROD31( iX[2], -iX[3], T[0], T[1], &oX1[2], &oX2[1] ); T+=step; XPROD31( iX[4], -iX[5], T[0], T[1], &oX1[1], &oX2[2] ); T+=step; XPROD31( iX[6], -iX[7], T[0], T[1], &oX1[0], &oX2[3] ); T+=step; oX2+=4; iX+=8; }while(iX>1; t1 = (*T++)>>1; do{ oX1-=4; t0 += (v0 = (*V++)>>1); t1 += (v1 = (*V++)>>1); XPROD31( iX[0], -iX[1], t0, t1, &oX1[3], &oX2[0] ); v0 += (t0 = (*T++)>>1); v1 += (t1 = (*T++)>>1); XPROD31( iX[2], -iX[3], v0, v1, &oX1[2], &oX2[1] ); t0 += (v0 = (*V++)>>1); t1 += (v1 = (*V++)>>1); XPROD31( iX[4], -iX[5], t0, t1, &oX1[1], &oX2[2] ); v0 += (t0 = (*T++)>>1); v1 += (t1 = (*T++)>>1); XPROD31( iX[6], -iX[7], v0, v1, &oX1[0], &oX2[3] ); oX2+=4; iX+=8; }while(iX>2); t1 += (q1 = (v1-t1)>>2); XPROD31( iX[0], -iX[1], t0, t1, &oX1[3], &oX2[0] ); t0 = v0-q0; t1 = v1-q1; XPROD31( iX[2], -iX[3], t0, t1, &oX1[2], &oX2[1] ); t0 = *T++; t1 = *T++; v0 += (q0 = (t0-v0)>>2); v1 += (q1 = (t1-v1)>>2); XPROD31( iX[4], -iX[5], v0, v1, &oX1[1], &oX2[2] ); v0 = t0-q0; v1 = t1-q1; XPROD31( iX[6], -iX[7], v0, v1, &oX1[0], &oX2[3] ); oX2+=4; iX+=8; }while(iXoX2); } } mednafen/pce_fast/huc6280_ops.inc000664 001750 001750 00000030406 12726204343 017724 0ustar00sergiosergio000000 000000 /* Mednafen - NES/Famicom Emulator * * Copyright notice for this file: * Copyright (C) 2002 Xodnizel * * 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 */ #define TEST_WEIRD_TFLAG(n) { if(HU_P & T_FLAG) puts("RAWR" n); } case 0x00: /* BRK */ IncPC(); HU_P &= ~T_FLAG; PUSH_PC(); COMPRESS_FLAGS(); PUSH(HU_P|B_FLAG); HU_P|=I_FLAG; HU_P &= ~D_FLAG; HU_PI|=I_FLAG; { unsigned int npc; npc=RdOp(0xFFF6); npc|=RdOp(0xFFF7)<<8; SetPC(npc); } break; case 0x40: /* RTI */ HU_P = POP(); EXPAND_FLAGS(); /* HU_PI=HU_P; This is probably incorrect, so it's commented out. */ HU_PI = HU_P; POP_PC(); // T-flag handling here: TEST_WEIRD_TFLAG("RTI"); break; case 0x60: /* RTS */ POP_PC_AP(); break; case 0x48: /* PHA */ PUSH(HU_A); break; case 0x08: /* PHP */ HU_P &= ~T_FLAG; COMPRESS_FLAGS(); PUSH(HU_P|B_FLAG); break; case 0xDA: // PHX 65C02 PUSH(HU_X); break; case 0x5A: // PHY 65C02 PUSH(HU_Y); break; case 0x68: /* PLA */ HU_A = POP(); X_ZN(HU_A); break; case 0xFA: // PLX 65C02 HU_X = POP(); X_ZN(HU_X); break; case 0x7A: // PLY 65C02 HU_Y = POP(); X_ZN(HU_Y); break; case 0x28: /* PLP */ HU_P = POP(); EXPAND_FLAGS(); // T-flag handling here: TEST_WEIRD_TFLAG("PLP"); break; case 0x4C: { unsigned int npc; npc = RdAtPC(); IncPC(); npc|=RdAtPC() << 8; SetPC(npc); } break; /* JMP ABSOLUTE */ case 0x6C: /* JMP Indirect */ { uint32 tmp; unsigned int npc; GetAB(tmp); npc=RdMem(tmp); npc|=RdMem(tmp + 1)<<8; SetPC(npc); } break; case 0x7C: // JMP Indirect X - 65C02 { uint32 tmp; unsigned int npc; GetAB(tmp); tmp += HU_X; npc=RdMem(tmp); npc|=RdMem(tmp + 1)<<8; SetPC(npc); } break; case 0x20: /* JSR */ { unsigned int npc; npc = RdAtPC(); IncPC(); PUSH_PC(); npc |= RdAtPC() <<8; SetPC(npc); } break; case 0xAA: /* TAX */ HU_X=HU_A; X_ZN(HU_A); break; case 0x8A: /* TXA */ HU_A=HU_X; X_ZN(HU_A); break; case 0xA8: /* TAY */ HU_Y=HU_A; X_ZN(HU_A); break; case 0x98: /* TYA */ HU_A=HU_Y; X_ZN(HU_A); break; case 0xBA: /* TSX */ HU_X=HU_S; X_ZN(HU_X); break; case 0x9A: /* TXS */ HU_S=HU_X; break; case 0xCA: /* DEX */ HU_X--; X_ZN(HU_X); break; case 0x88: /* DEY */ HU_Y--; X_ZN(HU_Y); break; case 0xE8: /* INX */ HU_X++; X_ZN(HU_X); break; case 0xC8: /* INY */ HU_Y++; X_ZN(HU_Y); break; case 0x54: CSL; break; case 0xD4: CSH; break; case 0x62: HU_A = 0; break; // CLA case 0x82: HU_X = 0; break; // CLX case 0xC2: HU_Y = 0; break; // CLY case 0x18: /* CLC */ HU_P&=~C_FLAG; break; case 0xD8: /* CLD */ HU_P&=~D_FLAG; break; case 0x58: /* CLI */ if((HU_P & I_FLAG) && (HU_IRQlow & MDFN_IQIRQ1)) { uint8 moo_op = RdAtPC(); if((moo_op == 0xAC || moo_op == 0xAD || moo_op == 0xAE) && ((RdOp(GetRealPC() + 1) & 0x3) == 0) && ((RdOp(GetRealPC() + 2) & 0xFC) == 0)) { HU_IRQlow |= 0x200; //puts("CLI/LDA madness!"); } } HU_P&=~I_FLAG; break; case 0xB8: /* CLV */ HU_P&=~V_FLAG; break; case 0x38: /* SEC */ HU_P|=C_FLAG; break; case 0xF8: /* SED */ HU_P|=D_FLAG; break; case 0x78: /* SEI */ HU_P|=I_FLAG; break; case 0xEA: /* NOP */ break; case 0x0A: RMW_A(ASL); case 0x06: RMW_ZP(ASL); case 0x16: RMW_ZPX(ASL); case 0x0E: RMW_AB(ASL); case 0x1E: RMW_ABX(ASL); case 0x3A: RMW_A(DEC); case 0xC6: RMW_ZP(DEC); case 0xD6: RMW_ZPX(DEC); case 0xCE: RMW_AB(DEC); case 0xDE: RMW_ABX(DEC); case 0x1A: RMW_A(INC); // 65C02 case 0xE6: RMW_ZP(INC); case 0xF6: RMW_ZPX(INC); case 0xEE: RMW_AB(INC); case 0xFE: RMW_ABX(INC); case 0x4A: RMW_A(LSR); case 0x46: RMW_ZP(LSR); case 0x56: RMW_ZPX(LSR); case 0x4E: RMW_AB(LSR); case 0x5E: RMW_ABX(LSR); case 0x2A: RMW_A(ROL); case 0x26: RMW_ZP(ROL); case 0x36: RMW_ZPX(ROL); case 0x2E: RMW_AB(ROL); case 0x3E: RMW_ABX(ROL); case 0x6A: RMW_A(ROR); case 0x66: RMW_ZP(ROR); case 0x76: RMW_ZPX(ROR); case 0x6E: RMW_AB(ROR); case 0x7E: RMW_ABX(ROR); case 0x69: LD_IM(ADC); case 0x65: LD_ZP(ADC); case 0x75: LD_ZPX(ADC); case 0x6D: LD_AB(ADC); case 0x7D: LD_ABX(ADC); case 0x79: LD_ABY(ADC); case 0x72: LD_IND(ADC); case 0x61: LD_IX(ADC); case 0x71: LD_IY(ADC); case 0x29: LD_IM(AND); case 0x25: LD_ZP(AND); case 0x35: LD_ZPX(AND); case 0x2D: LD_AB(AND); case 0x3D: LD_ABX(AND); case 0x39: LD_ABY(AND); case 0x32: LD_IND(AND); case 0x21: LD_IX(AND); case 0x31: LD_IY(AND); case 0x89: LD_IM(BIT); case 0x24: LD_ZP(BIT); case 0x34: LD_ZPX(BIT); case 0x2C: LD_AB(BIT); case 0x3C: LD_ABX(BIT); case 0xC9: LD_IM(CMP); case 0xC5: LD_ZP(CMP); case 0xD5: LD_ZPX(CMP); case 0xCD: LD_AB(CMP); case 0xDD: LD_ABX(CMP); case 0xD9: LD_ABY(CMP); case 0xD2: LD_IND(CMP); case 0xC1: LD_IX(CMP); case 0xD1: LD_IY(CMP); case 0xE0: LD_IM(CPX); case 0xE4: LD_ZP(CPX); case 0xEC: LD_AB(CPX); case 0xC0: LD_IM(CPY); case 0xC4: LD_ZP(CPY); case 0xCC: LD_AB(CPY); case 0x49: LD_IM(EOR); case 0x45: LD_ZP(EOR); case 0x55: LD_ZPX(EOR); case 0x4D: LD_AB(EOR); case 0x5D: LD_ABX(EOR); case 0x59: LD_ABY(EOR); case 0x52: LD_IND(EOR); case 0x41: LD_IX(EOR); case 0x51: LD_IY(EOR); case 0xA9: LD_IM(LDA); case 0xA5: LD_ZP(LDA); case 0xB5: LD_ZPX(LDA); case 0xAD: LD_AB(LDA); case 0xBD: LD_ABX(LDA); case 0xB9: LD_ABY(LDA); case 0xB2: LD_IND(LDA); case 0xA1: LD_IX(LDA); case 0xB1: LD_IY(LDA); case 0xA2: LD_IM(LDX); case 0xA6: LD_ZP(LDX); case 0xB6: LD_ZPY(LDX); case 0xAE: LD_AB(LDX); case 0xBE: LD_ABY(LDX); case 0xA0: LD_IM(LDY); case 0xA4: LD_ZP(LDY); case 0xB4: LD_ZPX(LDY); case 0xAC: LD_AB(LDY); case 0xBC: LD_ABX(LDY); case 0x09: LD_IM(ORA); case 0x05: LD_ZP(ORA); case 0x15: LD_ZPX(ORA); case 0x0D: LD_AB(ORA); case 0x1D: LD_ABX(ORA); case 0x19: LD_ABY(ORA); case 0x12: LD_IND(ORA); case 0x01: LD_IX(ORA); case 0x11: LD_IY(ORA); case 0xE9: LD_IM(SBC); case 0xE5: LD_ZP(SBC); case 0xF5: LD_ZPX(SBC); case 0xED: LD_AB(SBC); case 0xFD: LD_ABX(SBC); case 0xF9: LD_ABY(SBC); case 0xF2: LD_IND(SBC); case 0xE1: LD_IX(SBC); case 0xF1: LD_IY(SBC); case 0x85: ST_ZP(HU_A); case 0x95: ST_ZPX(HU_A); case 0x8D: ST_AB(HU_A); case 0x9D: ST_ABX(HU_A); case 0x99: ST_ABY(HU_A); case 0x92: ST_IND(HU_A); case 0x81: ST_IX(HU_A); case 0x91: ST_IY(HU_A); case 0x86: ST_ZP(HU_X); case 0x96: ST_ZPY(HU_X); case 0x8E: ST_AB(HU_X); case 0x84: ST_ZP(HU_Y); case 0x94: ST_ZPX(HU_Y); case 0x8C: ST_AB(HU_Y); /* BBRi */ case 0x0F: LD_ZP(BBRi(0)); case 0x1F: LD_ZP(BBRi(1)); case 0x2F: LD_ZP(BBRi(2)); case 0x3F: LD_ZP(BBRi(3)); case 0x4F: LD_ZP(BBRi(4)); case 0x5F: LD_ZP(BBRi(5)); case 0x6F: LD_ZP(BBRi(6)); case 0x7F: LD_ZP(BBRi(7)); /* BBSi */ case 0x8F: LD_ZP(BBSi(0)); case 0x9F: LD_ZP(BBSi(1)); case 0xAF: LD_ZP(BBSi(2)); case 0xBF: LD_ZP(BBSi(3)); case 0xCF: LD_ZP(BBSi(4)); case 0xDF: LD_ZP(BBSi(5)); case 0xEF: LD_ZP(BBSi(6)); case 0xFF: LD_ZP(BBSi(7)); /* BRA */ case 0x80: BRA; break; /* BSR */ case 0x44: { PUSH_PC(); BRA; } break; /* BCC */ case 0x90: JR(!(HU_P&C_FLAG)); break; /* BCS */ case 0xB0: JR(HU_P&C_FLAG); break; /* BVC */ case 0x50: JR(!(HU_P&V_FLAG)); break; /* BVS */ case 0x70: JR(HU_P&V_FLAG); break; #ifdef HUC6280_LAZY_FLAGS /* BEQ */ case 0xF0: JR(!(HU_ZNFlags & 0xFF)); break; /* BNE */ case 0xD0: JR((HU_ZNFlags & 0xFF)); break; /* BMI */ case 0x30: JR((HU_ZNFlags & 0x80000000)); break; /* BPL */ case 0x10: JR(!(HU_ZNFlags & 0x80000000)); break; #else /* BEQ */ case 0xF0: JR(HU_P&Z_FLAG); break; /* BNE */ case 0xD0: JR(!(HU_P&Z_FLAG)); break; /* BMI */ case 0x30: JR(HU_P&N_FLAG); break; /* BPL */ case 0x10: JR(!(HU_P&N_FLAG)); break; #endif // RMB 65SC02 case 0x07: RMW_ZP(RMB(0)); case 0x17: RMW_ZP(RMB(1)); case 0x27: RMW_ZP(RMB(2)); case 0x37: RMW_ZP(RMB(3)); case 0x47: RMW_ZP(RMB(4)); case 0x57: RMW_ZP(RMB(5)); case 0x67: RMW_ZP(RMB(6)); case 0x77: RMW_ZP(RMB(7)); // SMB 65SC02 case 0x87: RMW_ZP(SMB(0)); case 0x97: RMW_ZP(SMB(1)); case 0xa7: RMW_ZP(SMB(2)); case 0xb7: RMW_ZP(SMB(3)); case 0xc7: RMW_ZP(SMB(4)); case 0xd7: RMW_ZP(SMB(5)); case 0xe7: RMW_ZP(SMB(6)); case 0xf7: RMW_ZP(SMB(7)); // STZ 65C02 case 0x64: ST_ZP(0); case 0x74: ST_ZPX(0); case 0x9C: ST_AB(0); case 0x9E: ST_ABX(0); // TRB 65SC02 case 0x14: RMW_ZP(TRB); case 0x1C: RMW_AB(TRB); // TSB 65SC02 case 0x04: RMW_ZP(TSB); case 0x0C: RMW_AB(TSB); // TST case 0x83: { uint8 zoomhack=RdAtPC(); IncPC(); LD_ZP(TST); } case 0xA3: { uint8 zoomhack=RdAtPC(); IncPC(); LD_ZPX(TST); } case 0x93: { uint8 zoomhack=RdAtPC(); IncPC(); LD_AB(TST); } case 0xB3: { uint8 zoomhack=RdAtPC(); IncPC(); LD_ABX(TST); } case 0x22: // SAX(amaphone!) { uint8 tmp = HU_X; HU_X = HU_A; HU_A = tmp; } break; case 0x42: // SAY(what?) { uint8 tmp = HU_Y; HU_Y = HU_A; HU_A = tmp; } break; case 0x02: // SXY { uint8 tmp = HU_X; HU_X = HU_Y; HU_Y = tmp; } break; case 0x73: // TII LD_BMT(BMT_TII); case 0xC3: // TDD LD_BMT(BMT_TDD); case 0xD3: // TIN LD_BMT(BMT_TIN); case 0xE3: // TIA LD_BMT(BMT_TIA); case 0xF3: // TAI LD_BMT(BMT_TAI); case 0x43: // TMAi LD_IM(TMA); case 0x53: // TAMi LD_IM(TAM); case 0x03: // ST0 LD_IM(ST0); case 0x13: // ST1 LD_IM(ST1); case 0x23: // ST2 LD_IM(ST2); case 0xF4: /* SET */ { // AND, EOR, ORA, ADC uint8 Abackup = HU_A; ADDCYC(3); HU_A = HU_Page1[HU_X]; //PAGE1_R[HU_X]; switch(RdAtPC()) { default: //puts("Bad SET"); break; case 0x69: IncPC(); LD_IM(ADC); case 0x65: IncPC(); LD_ZP(ADC); case 0x75: IncPC(); LD_ZPX(ADC); case 0x6D: IncPC(); LD_AB(ADC); case 0x7D: IncPC(); LD_ABX(ADC); case 0x79: IncPC(); LD_ABY(ADC); case 0x72: IncPC(); LD_IND(ADC); case 0x61: IncPC(); LD_IX(ADC); case 0x71: IncPC(); LD_IY(ADC); case 0x29: IncPC(); LD_IM(AND); case 0x25: IncPC(); LD_ZP(AND); case 0x35: IncPC(); LD_ZPX(AND); case 0x2D: IncPC(); LD_AB(AND); case 0x3D: IncPC(); LD_ABX(AND); case 0x39: IncPC(); LD_ABY(AND); case 0x32: IncPC(); LD_IND(AND); case 0x21: IncPC(); LD_IX(AND); case 0x31: IncPC(); LD_IY(AND); case 0x49: IncPC(); LD_IM(EOR); case 0x45: IncPC(); LD_ZP(EOR); case 0x55: IncPC(); LD_ZPX(EOR); case 0x4D: IncPC(); LD_AB(EOR); case 0x5D: IncPC(); LD_ABX(EOR); case 0x59: IncPC(); LD_ABY(EOR); case 0x52: IncPC(); LD_IND(EOR); case 0x41: IncPC(); LD_IX(EOR); case 0x51: IncPC(); LD_IY(EOR); case 0x09: IncPC(); LD_IM(ORA); case 0x05: IncPC(); LD_ZP(ORA); case 0x15: IncPC(); LD_ZPX(ORA); case 0x0D: IncPC(); LD_AB(ORA); case 0x1D: IncPC(); LD_ABX(ORA); case 0x19: IncPC(); LD_ABY(ORA); case 0x12: IncPC(); LD_IND(ORA); case 0x01: IncPC(); LD_IX(ORA); case 0x11: IncPC(); LD_IY(ORA); } HU_Page1[HU_X] /*PAGE1_W[HU_X]*/ = HU_A; HU_A = Abackup; } break; case 0xFC: { int32 ec_tmp; ec_tmp = next_event - HuCPU.timestamp; if(ec_tmp > 0) { ADDCYC(ec_tmp); } } break; default: //MDFN_printf("Bad %02x at $%04x\n", b1, GetRealPC()); break; mednafen/tremor/misc.h000664 001750 001750 00000013617 12726204343 016106 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: miscellaneous math and prototypes ********************************************************************/ #ifndef _V_RANDOM_H_ #define _V_RANDOM_H_ #include "ivorbiscodec.h" #include "os.h" #ifdef _LOW_ACCURACY_ # define X(n) (((((n)>>22)+1)>>1) - ((((n)>>22)+1)>>9)) # define LOOKUP_T const unsigned char #else # define X(n) (n) # define LOOKUP_T const ogg_int32_t #endif #include "asm_arm.h" #include /* for abs() */ #ifndef _V_WIDE_MATH #define _V_WIDE_MATH #ifndef _LOW_ACCURACY_ /* 64 bit multiply */ #if !(defined WIN32 && defined WINCE) #include #endif #if BYTE_ORDER==LITTLE_ENDIAN union magic { struct { ogg_int32_t lo; ogg_int32_t hi; } halves; ogg_int64_t whole; }; #endif #if BYTE_ORDER==BIG_ENDIAN union magic { struct { ogg_int32_t hi; ogg_int32_t lo; } halves; ogg_int64_t whole; }; #endif STIN ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) { union magic magic; magic.whole = (ogg_int64_t)x * y; return magic.halves.hi; } STIN ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) { return MULT32(x,y)<<1; } STIN ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) { union magic magic; magic.whole = (ogg_int64_t)x * y; return ((ogg_uint32_t)(magic.halves.lo)>>15) | ((magic.halves.hi)<<17); } #else /* 32 bit multiply, more portable but less accurate */ /* * Note: Precision is biased towards the first argument therefore ordering * is important. Shift values were chosen for the best sound quality after * many listening tests. */ /* * For MULT32 and MULT31: The second argument is always a lookup table * value already preshifted from 31 to 8 bits. We therefore take the * opportunity to save on text space and use unsigned char for those * tables in this case. */ STIN ogg_int32_t MULT32(ogg_int32_t x, ogg_int32_t y) { return (x >> 9) * y; /* y preshifted >>23 */ } STIN ogg_int32_t MULT31(ogg_int32_t x, ogg_int32_t y) { return (x >> 8) * y; /* y preshifted >>23 */ } STIN ogg_int32_t MULT31_SHIFT15(ogg_int32_t x, ogg_int32_t y) { return (x >> 6) * y; /* y preshifted >>9 */ } #endif /* * This should be used as a memory barrier, forcing all cached values in * registers to wr writen back to memory. Might or might not be beneficial * depending on the architecture and compiler. */ #define MB() /* * The XPROD functions are meant to optimize the cross products found all * over the place in mdct.c by forcing memory operation ordering to avoid * unnecessary register reloads as soon as memory is being written to. * However this is only beneficial on CPUs with a sane number of general * purpose registers which exclude the Intel x86. On Intel, better let the * compiler actually reload registers directly from original memory by using * macros. */ #ifdef __i386__ #define XPROD32(_a, _b, _t, _v, _x, _y) \ { *(_x)=MULT32(_a,_t)+MULT32(_b,_v); \ *(_y)=MULT32(_b,_t)-MULT32(_a,_v); } #define XPROD31(_a, _b, _t, _v, _x, _y) \ { *(_x)=MULT31(_a,_t)+MULT31(_b,_v); \ *(_y)=MULT31(_b,_t)-MULT31(_a,_v); } #define XNPROD31(_a, _b, _t, _v, _x, _y) \ { *(_x)=MULT31(_a,_t)-MULT31(_b,_v); \ *(_y)=MULT31(_b,_t)+MULT31(_a,_v); } #else STIN void XPROD32(ogg_int32_t a, ogg_int32_t b, ogg_int32_t t, ogg_int32_t v, ogg_int32_t *x, ogg_int32_t *y) { *x = MULT32(a, t) + MULT32(b, v); *y = MULT32(b, t) - MULT32(a, v); } STIN void XPROD31(ogg_int32_t a, ogg_int32_t b, ogg_int32_t t, ogg_int32_t v, ogg_int32_t *x, ogg_int32_t *y) { *x = MULT31(a, t) + MULT31(b, v); *y = MULT31(b, t) - MULT31(a, v); } STIN void XNPROD31(ogg_int32_t a, ogg_int32_t b, ogg_int32_t t, ogg_int32_t v, ogg_int32_t *x, ogg_int32_t *y) { *x = MULT31(a, t) - MULT31(b, v); *y = MULT31(b, t) + MULT31(a, v); } #endif #endif #ifndef _V_CLIP_MATH #define _V_CLIP_MATH STIN ogg_int32_t CLIP_TO_15(ogg_int32_t x) { int ret=x; ret-= ((x<=32767)-1)&(x-32767); ret-= ((x>=-32768)-1)&(x+32768); return(ret); } #endif STIN ogg_int32_t VFLOAT_MULT(ogg_int32_t a,ogg_int32_t ap, ogg_int32_t b,ogg_int32_t bp, ogg_int32_t *p){ if(a && b){ #ifndef _LOW_ACCURACY_ *p=ap+bp+32; return MULT32(a,b); #else *p=ap+bp+31; return (a>>15)*(b>>16); #endif }else return 0; } int _ilog(unsigned int); STIN ogg_int32_t VFLOAT_MULTI(ogg_int32_t a,ogg_int32_t ap, ogg_int32_t i, ogg_int32_t *p){ int ip=_ilog(abs(i))-31; return VFLOAT_MULT(a,ap,i<<-ip,ip,p); } STIN ogg_int32_t VFLOAT_ADD(ogg_int32_t a,ogg_int32_t ap, ogg_int32_t b,ogg_int32_t bp, ogg_int32_t *p){ if(!a){ *p=bp; return b; }else if(!b){ *p=ap; return a; } /* yes, this can leak a bit. */ if(ap>bp){ int shift=ap-bp+1; *p=ap+1; a>>=1; if(shift<32){ b=(b+(1<<(shift-1)))>>shift; }else{ b=0; } }else{ int shift=bp-ap+1; *p=bp+1; b>>=1; if(shift<32){ a=(a+(1<<(shift-1)))>>shift; }else{ a=0; } } a+=b; if((a&0xc0000000)==0xc0000000 || (a&0xc0000000)==0){ a<<=1; (*p)--; } return(a); } #endif libretro-common/include/compat/strl.h000664 001750 001750 00000004022 12726204343 021056 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (strl.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_COMPAT_STRL_H #define __LIBRETRO_SDK_COMPAT_STRL_H #include #include #ifdef HAVE_CONFIG_H #include "../../../config.h" #endif #ifdef __cplusplus extern "C" { #endif #ifdef __MACH__ #ifndef HAVE_STRL #define HAVE_STRL #endif #endif #ifndef HAVE_STRL /* Avoid possible naming collisions during link since * we prefer to use the actual name. */ #define strlcpy(dst, src, size) strlcpy_retro__(dst, src, size) #define strlcat(dst, src, size) strlcat_retro__(dst, src, size) size_t strlcpy(char *dest, const char *source, size_t size); size_t strlcat(char *dest, const char *source, size_t size); #endif #ifdef __cplusplus } #endif #endif mednafen/tremor/CHANGELOG000664 001750 001750 00000000723 12726204343 016206 0ustar00sergiosergio000000 000000 *** 20020517: 1.0.2 *** Playback bugfix to floor1; mode mistakenly used for sizing instead of blockflag *** 20020515: 1.0.1 *** Added complete API documentation to source tarball. No code changes. *** 20020412: 1.0.1 *** Fixed a clipping bug that affected ARM processors; negative overflows were being properly clipped, but then clobbered to positive by the positive overflow chec (asm_arm.h:CLIP_TO_15) *** 20020403: 1.0.0 *** Initial versionmednafen/cdrom/crc32.cpp000664 001750 001750 00000013676 12726204343 016223 0ustar00sergiosergio000000 000000 /* dvdisaster: Additional error correction for optical media. * Copyright (C) 2004-2007 Carsten Gnoerlich. * Project home page: http://www.dvdisaster.com * Email: carsten@dvdisaster.com -or- cgnoerlich@fsfe.org * * CRC32 code based upon public domain code by Ross Williams (see notes below) * * 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, * or direct your browser at http://www.gnu.org. */ #include "dvdisaster.h" /*** *** EDC checksum used in CDROM sectors ***/ /*****************************************************************/ /* */ /* CRC LOOKUP TABLE */ /* ================ */ /* The following CRC lookup table was generated automagically */ /* by the Rocksoft^tm Model CRC Algorithm Table Generation */ /* Program V1.0 using the following model parameters: */ /* */ /* Width : 4 bytes. */ /* Poly : 0x8001801BL */ /* Reverse : TRUE. */ /* */ /* For more information on the Rocksoft^tm Model CRC Algorithm, */ /* see the document titled "A Painless Guide to CRC Error */ /* Detection Algorithms" by Ross Williams */ /* (ross@guest.adelaide.edu.au.). This document is likely to be */ /* in the FTP archive "ftp.adelaide.edu.au/pub/rocksoft". */ /* */ /*****************************************************************/ unsigned long edctable[256] = { 0x00000000L, 0x90910101L, 0x91210201L, 0x01B00300L, 0x92410401L, 0x02D00500L, 0x03600600L, 0x93F10701L, 0x94810801L, 0x04100900L, 0x05A00A00L, 0x95310B01L, 0x06C00C00L, 0x96510D01L, 0x97E10E01L, 0x07700F00L, 0x99011001L, 0x09901100L, 0x08201200L, 0x98B11301L, 0x0B401400L, 0x9BD11501L, 0x9A611601L, 0x0AF01700L, 0x0D801800L, 0x9D111901L, 0x9CA11A01L, 0x0C301B00L, 0x9FC11C01L, 0x0F501D00L, 0x0EE01E00L, 0x9E711F01L, 0x82012001L, 0x12902100L, 0x13202200L, 0x83B12301L, 0x10402400L, 0x80D12501L, 0x81612601L, 0x11F02700L, 0x16802800L, 0x86112901L, 0x87A12A01L, 0x17302B00L, 0x84C12C01L, 0x14502D00L, 0x15E02E00L, 0x85712F01L, 0x1B003000L, 0x8B913101L, 0x8A213201L, 0x1AB03300L, 0x89413401L, 0x19D03500L, 0x18603600L, 0x88F13701L, 0x8F813801L, 0x1F103900L, 0x1EA03A00L, 0x8E313B01L, 0x1DC03C00L, 0x8D513D01L, 0x8CE13E01L, 0x1C703F00L, 0xB4014001L, 0x24904100L, 0x25204200L, 0xB5B14301L, 0x26404400L, 0xB6D14501L, 0xB7614601L, 0x27F04700L, 0x20804800L, 0xB0114901L, 0xB1A14A01L, 0x21304B00L, 0xB2C14C01L, 0x22504D00L, 0x23E04E00L, 0xB3714F01L, 0x2D005000L, 0xBD915101L, 0xBC215201L, 0x2CB05300L, 0xBF415401L, 0x2FD05500L, 0x2E605600L, 0xBEF15701L, 0xB9815801L, 0x29105900L, 0x28A05A00L, 0xB8315B01L, 0x2BC05C00L, 0xBB515D01L, 0xBAE15E01L, 0x2A705F00L, 0x36006000L, 0xA6916101L, 0xA7216201L, 0x37B06300L, 0xA4416401L, 0x34D06500L, 0x35606600L, 0xA5F16701L, 0xA2816801L, 0x32106900L, 0x33A06A00L, 0xA3316B01L, 0x30C06C00L, 0xA0516D01L, 0xA1E16E01L, 0x31706F00L, 0xAF017001L, 0x3F907100L, 0x3E207200L, 0xAEB17301L, 0x3D407400L, 0xADD17501L, 0xAC617601L, 0x3CF07700L, 0x3B807800L, 0xAB117901L, 0xAAA17A01L, 0x3A307B00L, 0xA9C17C01L, 0x39507D00L, 0x38E07E00L, 0xA8717F01L, 0xD8018001L, 0x48908100L, 0x49208200L, 0xD9B18301L, 0x4A408400L, 0xDAD18501L, 0xDB618601L, 0x4BF08700L, 0x4C808800L, 0xDC118901L, 0xDDA18A01L, 0x4D308B00L, 0xDEC18C01L, 0x4E508D00L, 0x4FE08E00L, 0xDF718F01L, 0x41009000L, 0xD1919101L, 0xD0219201L, 0x40B09300L, 0xD3419401L, 0x43D09500L, 0x42609600L, 0xD2F19701L, 0xD5819801L, 0x45109900L, 0x44A09A00L, 0xD4319B01L, 0x47C09C00L, 0xD7519D01L, 0xD6E19E01L, 0x46709F00L, 0x5A00A000L, 0xCA91A101L, 0xCB21A201L, 0x5BB0A300L, 0xC841A401L, 0x58D0A500L, 0x5960A600L, 0xC9F1A701L, 0xCE81A801L, 0x5E10A900L, 0x5FA0AA00L, 0xCF31AB01L, 0x5CC0AC00L, 0xCC51AD01L, 0xCDE1AE01L, 0x5D70AF00L, 0xC301B001L, 0x5390B100L, 0x5220B200L, 0xC2B1B301L, 0x5140B400L, 0xC1D1B501L, 0xC061B601L, 0x50F0B700L, 0x5780B800L, 0xC711B901L, 0xC6A1BA01L, 0x5630BB00L, 0xC5C1BC01L, 0x5550BD00L, 0x54E0BE00L, 0xC471BF01L, 0x6C00C000L, 0xFC91C101L, 0xFD21C201L, 0x6DB0C300L, 0xFE41C401L, 0x6ED0C500L, 0x6F60C600L, 0xFFF1C701L, 0xF881C801L, 0x6810C900L, 0x69A0CA00L, 0xF931CB01L, 0x6AC0CC00L, 0xFA51CD01L, 0xFBE1CE01L, 0x6B70CF00L, 0xF501D001L, 0x6590D100L, 0x6420D200L, 0xF4B1D301L, 0x6740D400L, 0xF7D1D501L, 0xF661D601L, 0x66F0D700L, 0x6180D800L, 0xF111D901L, 0xF0A1DA01L, 0x6030DB00L, 0xF3C1DC01L, 0x6350DD00L, 0x62E0DE00L, 0xF271DF01L, 0xEE01E001L, 0x7E90E100L, 0x7F20E200L, 0xEFB1E301L, 0x7C40E400L, 0xECD1E501L, 0xED61E601L, 0x7DF0E700L, 0x7A80E800L, 0xEA11E901L, 0xEBA1EA01L, 0x7B30EB00L, 0xE8C1EC01L, 0x7850ED00L, 0x79E0EE00L, 0xE971EF01L, 0x7700F000L, 0xE791F101L, 0xE621F201L, 0x76B0F300L, 0xE541F401L, 0x75D0F500L, 0x7460F600L, 0xE4F1F701L, 0xE381F801L, 0x7310F900L, 0x72A0FA00L, 0xE231FB01L, 0x71C0FC00L, 0xE151FD01L, 0xE0E1FE01L, 0x7070FF00L }; /* * CDROM EDC calculation */ uint32 EDCCrc32(const unsigned char *data, int len) { uint32 crc = 0; while(len--) crc = edctable[(crc ^ *data++) & 0xFF] ^ (crc >> 8); return crc; } mednafen/pce_fast/pcecd.cpp000664 001750 001750 00000057473 12726204343 017050 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * Copyright notice for this file: * Copyright (C) 2004 Ki * Copyright (C) 2007-2011 Mednafen Team * * 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 */ /* PCE_FAST(less accurate, faster, etc.) fork from PCE module "pcecd.cpp". */ #include "../mednafen.h" #include "../cdrom/cdromif.h" #include "pcecd_drive.h" #include "../okiadpcm.h" #include "pcecd.h" #include "../cdrom/SimpleFIFO.h" //#define PCECD_DEBUG static unsigned int OC_Multiplier; static void (*IRQCB)(bool asserted); static float CDDAVolumeSetting; // User setting! static bool bBRAMEnabled; static uint8 _Port[15]; static uint8 ACKStatus; static SimpleFIFO SubChannelFIFO(16); static Blip_Buffer *sbuf[2]; static int16 RawPCMVolumeCache[2]; static int32 ClearACKDelay; static int32 lastts; static int32 pcecd_drive_ne = 0; // ADPCM variables and whatnot static inline void ADPCM_DEBUG(const char *format, ...) { /*printf("[Half=%d, End=%d, Playing=%d] "x, ADPCM.HalfReached, ADPCM.EndReached, ADPCM.Playing, ## __VA_ARGS__);*/ } typedef Blip_Synth ADSynth; static ADSynth ADPCMSynth; static OKIADPCM_Decoder MSM5205; static bool ADPCMLP; typedef struct { uint8 *RAM; // = NULL; //0x10000; uint16 Addr; uint16 ReadAddr; uint16 WriteAddr; uint16 LengthCount; bool HalfReached; bool EndReached; bool Playing; uint8 LastCmd; uint32 SampleFreq; uint32 LPF_SampleFreq; uint8 PlayBuffer; uint8 ReadBuffer; int32 ReadPending; int32 WritePending; uint8 WritePendingValue; uint32 PlayNibble; int64 bigdivacc; int64 bigdiv; int32 last_pcm; } ADPCM_t; static ADPCM_t ADPCM; typedef struct { uint8 Command; int32 Volume; int32 CycleCounter; uint32 CountValue; // What to reload CycleCounter with when it expires. bool Clocked; } FADE_t; static FADE_t Fader; static int32 ADPCMFadeVolume, CDDAFadeVolume; static INLINE void Fader_SyncWhich(void) { if(Fader.Command & 0x2) // ADPCM fade { ADPCMFadeVolume = Fader.Volume; CDDAFadeVolume = 65536; } else // CD-DA Fade { CDDAFadeVolume = Fader.Volume; ADPCMFadeVolume = 65536; } ADPCMFadeVolume >>= 6; PCECD_Drive_SetCDDAVolume(0.50f * CDDAFadeVolume * CDDAVolumeSetting); } static void RedoLPF(int f) { if(sbuf[0] && sbuf[1]) { if(ADPCMLP) { if(f >= 14) { int rolloff = (int)((((double)32087.5 / (16 - f)) / 2) * 0.70); ADPCMSynth.treble_eq( blip_eq_t(-1000, rolloff, sbuf[0]->sample_rate())); } else { int rolloff = (int)((((double)32087.5 / (16 - f)) / 2) * 0.80); ADPCMSynth.treble_eq( blip_eq_t(-1000, rolloff, sbuf[0]->sample_rate())); } } else ADPCMSynth.treble_eq(-8.0); } } static INLINE int32 ADPCM_ClocksToNextEvent(void) { int32 ret = (ADPCM.bigdiv + 65535) >> 16; if(ADPCM.WritePending && ret > ADPCM.WritePending) ret = ADPCM.WritePending; if(ADPCM.ReadPending && ret > ADPCM.ReadPending) ret = ADPCM.ReadPending; return(ret); } static int32 CalcNextEvent(int32 base) { int32 next_event = base; int32 ADPCM_ctne = ADPCM_ClocksToNextEvent(); if(next_event > ADPCM_ctne) next_event = ADPCM_ctne; if(ClearACKDelay > 0 && next_event > ClearACKDelay) next_event = ClearACKDelay; if(next_event > pcecd_drive_ne) next_event = pcecd_drive_ne; if(Fader.Clocked && next_event > Fader.CycleCounter) next_event = Fader.CycleCounter; return(next_event); } static void update_irq_state() { uint8 irq = _Port[2] & _Port[0x3] & (0x4|0x8|0x10|0x20|0x40); IRQCB((bool)irq); } static void StuffSubchannel(uint8 meow, int subindex) { uint8 tmp_data = meow & 0x7F; if(subindex == -2) tmp_data = 0x00; else if(subindex == -1) tmp_data = 0x80; if(SubChannelFIFO.CanWrite()) SubChannelFIFO.Write(&tmp_data, 1); _Port[0x3] |= 0x10; update_irq_state(); } static void CDIRQ(int type) { #ifdef PCECD_DEBUG if(type != 0x8000 || _Port[0x3] & 0x60) printf("CDIRQ: %d\n", type); #endif if(type & 0x8000) { type &= 0x7FFF; if(type == PCECD_Drive_IRQ_DATA_TRANSFER_DONE) _Port[0x3] &= ~0x20; else if(type == PCECD_Drive_IRQ_DATA_TRANSFER_READY) _Port[0x3] &= ~0x40; } else if(type == PCECD_Drive_IRQ_DATA_TRANSFER_DONE) { _Port[0x3] |= 0x20; } else if(type == PCECD_Drive_IRQ_DATA_TRANSFER_READY) { _Port[0x3] |= 0x40; } update_irq_state(); } static void UpdateADPCMIRQState(void) { _Port[0x3] &= ~0xC; _Port[0x3] |= ADPCM.HalfReached ? 0x4 : 0x0; _Port[0x3] |= ADPCM.EndReached ? 0x8 : 0x0; update_irq_state(); } static INLINE uint8 read_1808(int32 timestamp) { uint8 ret = PCECD_Drive_GetDB(); if(PCECD_Drive_GetREQ() && !PCECD_Drive_GetACK() && !PCECD_Drive_GetCD()) { if(PCECD_Drive_GetIO()) { PCECD_Drive_SetACK(TRUE); ACKStatus = TRUE; pcecd_drive_ne = PCECD_Drive_Run(timestamp); ClearACKDelay = 15 * 3; } } return(ret); } bool PCECD_SetSettings(const PCECD_Settings *settings) { if(settings) { assert(settings->CDDA_Volume <= 2.0); assert(settings->ADPCM_Volume <= 2.0); } CDDAVolumeSetting = settings ? settings->CDDA_Volume : 1.0; Fader_SyncWhich(); ADPCMSynth.volume(0.42735f * (settings ? settings->ADPCM_Volume : 1.0)); ADPCMLP = settings ? settings->ADPCM_LPF : 0; PCECD_Drive_SetTransferRate(126000 * (settings ? settings->CD_Speed : 1)); return true; } bool PCECD_Init(const PCECD_Settings *settings, void (*irqcb)(bool), double master_clock, unsigned int ocm, Blip_Buffer *soundbuf_l, Blip_Buffer *soundbuf_r) { lastts = 0; OC_Multiplier = ocm; IRQCB = irqcb; sbuf[0] = soundbuf_l; sbuf[1] = soundbuf_r; // Warning: magic number 126000 in PCECD_SetSettings() too PCECD_Drive_Init(3 * OC_Multiplier, sbuf[0], sbuf[1], 126000 * (settings ? settings->CD_Speed : 1), master_clock * OC_Multiplier, CDIRQ, StuffSubchannel); if(!(ADPCM.RAM = (uint8 *)malloc(0x10000))) { return(0); } PCECD_SetSettings(settings); ADPCM.bigdivacc = (int64)((double)master_clock * OC_Multiplier * 65536 / 32087.5); return(TRUE); } void PCECD_Close(void) { if(ADPCM.RAM) free(ADPCM.RAM); ADPCM.RAM = NULL; PCECD_Drive_Close(); } void PCECD_Power(uint32 timestamp) { if((int32)timestamp != lastts) (void)PCECD_Run(timestamp); IRQCB(0); PCECD_Drive_Power(timestamp); pcecd_drive_ne = 0x7fffffff; bBRAMEnabled = FALSE; memset(_Port, 0, sizeof(_Port)); ACKStatus = 0; ClearACKDelay = 0; memset(ADPCM.RAM, 0x00, 65536); ADPCM.ReadPending = ADPCM.WritePending = 0; ADPCM.ReadBuffer = 0; ADPCM.PlayBuffer = 0; ADPCM.LastCmd = 0; MSM5205.SetSample(0x800); MSM5205.SetSSI(0); ADPCM.SampleFreq = 0; ADPCM.LPF_SampleFreq = 0; ADPCM.bigdiv = ADPCM.bigdivacc * (16 - ADPCM.SampleFreq); RedoLPF(ADPCM.LPF_SampleFreq); ADPCM.Addr = 0; ADPCM.ReadAddr = 0; ADPCM.WriteAddr = 0; ADPCM.LengthCount = 0; ADPCM.LastCmd = 0; ADPCM.HalfReached = false; ADPCM.EndReached = false; ADPCM.Playing = false; ADPCM.PlayNibble = 0; UpdateADPCMIRQState(); Fader.Command = 0x00; Fader.Volume = 0; Fader.CycleCounter = 0; Fader.CountValue = 0; Fader.Clocked = FALSE; } bool PCECD_IsBRAMEnabled(void) { return bBRAMEnabled; } uint8 PCECD_Read(uint32 timestamp, uint32 A) { uint8 ret = 0; if((A & 0x18c0) == 0x18c0) { switch (A & 0x18cf) { case 0x18c1: ret = 0xaa; break; case 0x18c2: ret = 0x55; break; case 0x18c3: ret = 0x00; break; case 0x18c5: ret = 0xaa; break; case 0x18c6: ret = 0x55; break; case 0x18c7: ret = 0x03; break; } } else { PCECD_Run(timestamp); switch(A & 0xf) { case 0x0: ret = 0; ret |= PCECD_Drive_GetBSY() ? 0x80 : 0x00; ret |= PCECD_Drive_GetREQ() ? 0x40 : 0x00; ret |= PCECD_Drive_GetMSG() ? 0x20 : 0x00; ret |= PCECD_Drive_GetCD() ? 0x10 : 0x00; ret |= PCECD_Drive_GetIO() ? 0x08 : 0x00; break; case 0x1: ret = PCECD_Drive_GetDB(); break; case 0x2: ret = _Port[2]; break; case 0x3: bBRAMEnabled = FALSE; /* switch left/right of digitized cd playback */ ret = _Port[0x3]; _Port[0x3] ^= 2; break; case 0x4: ret = _Port[4]; break; case 0x5: if(_Port[0x3] & 0x2) ret = RawPCMVolumeCache[1] & 0xff; // Right else ret = RawPCMVolumeCache[0] & 0xff; // Left break; case 0x6: if(_Port[0x3] & 0x2) ret = ((uint16)RawPCMVolumeCache[1]) >> 8; // Right else ret = ((uint16)RawPCMVolumeCache[0]) >> 8; // Left break; case 0x7: if(SubChannelFIFO.CanRead() > 0) ret = SubChannelFIFO.ReadByte(); else ret = 0x00; // Not sure if it's 0, 0xFF, the last byte read, or something else. if(SubChannelFIFO.CanRead() == 0) { _Port[0x3] &= ~0x10; update_irq_state(); } break; case 0x8: ret = read_1808(timestamp); break; case 0xa: ADPCM_DEBUG("ReadBuffer\n"); ADPCM.ReadPending = 19 * 3; //24 * 3; ret = ADPCM.ReadBuffer; break; case 0xb: ret = _Port[0xb]; break; case 0xc: //printf("ADPCM Status Read: %d\n", timestamp); ret = 0x00; ret |= (ADPCM.EndReached) ? 0x01 : 0x00; ret |= (ADPCM.Playing) ? 0x08 : 0x00; ret |= (ADPCM.WritePending > 0) ? 0x04 : 0x00; ret |= (ADPCM.ReadPending > 0) ? 0x80 : 0x00; break; case 0xd: ret = ADPCM.LastCmd; break; } } #ifdef PCECD_DEBUG printf("Read: %04x %02x, %d\n", A, ret, timestamp); #endif return(ret); } static INLINE void Fader_Run(const int32 clocks) { if(Fader.Clocked) { Fader.CycleCounter -= clocks; while(Fader.CycleCounter <= 0) { if(Fader.Volume) Fader.Volume--; Fader_SyncWhich(); Fader.CycleCounter += Fader.CountValue; } } } void PCECD_Write(uint32 timestamp, uint32 physAddr, uint8 data) { const uint8 V = data; #ifdef PCECD_DEBUG printf("Write: (PC=%04x, t=%6d) %04x %02x; MSG: %d, REQ: %d, ACK: %d, CD: %d, IO: %d, BSY: %d, SEL: %d\n", HuCPU.PC, timestamp, physAddr, data, PCECD_Drive_GetMSG(), PCECD_Drive_GetREQ(), PCECD_Drive_GetACK(), PCECD_Drive_GetCD(), PCECD_Drive_GetIO(), PCECD_Drive_GetBSY(), PCECD_Drive_GetSEL()); #endif PCECD_Run(timestamp); switch (physAddr & 0xf) { case 0x0: PCECD_Drive_SetSEL(1); PCECD_Drive_Run(timestamp); PCECD_Drive_SetSEL(0); pcecd_drive_ne = PCECD_Drive_Run(timestamp); /* reset irq status */ _Port[0x3] &= ~(0x20 | 0x40); // TODO: Confirm writing this register really reset these bits. update_irq_state(); break; case 0x1: // $1801 _Port[1] = data; PCECD_Drive_SetDB(data); pcecd_drive_ne = PCECD_Drive_Run(timestamp); break; case 0x2: // $1802 #ifdef PCECD_DEBUG if(!(_Port[0x3] & _Port[2] & 0x40) && (_Port[0x3] & data & 0x40)) puts("IRQ on waah 0x40"); if(!(_Port[0x3] & _Port[2] & 0x20) && (_Port[0x3] & data & 0x20)) puts("IRQ on waah 0x20"); #endif PCECD_Drive_SetACK(data & 0x80); pcecd_drive_ne = PCECD_Drive_Run(timestamp); _Port[2] = data; ACKStatus = (bool)(data & 0x80); update_irq_state(); break; case 0x3: // read only break; case 0x4: PCECD_Drive_SetRST(data & 0x2); pcecd_drive_ne = PCECD_Drive_Run(timestamp); if(data & 0x2) { _Port[0x3] &= ~0x70; update_irq_state(); } _Port[4] = data; break; case 0x5: case 0x6: { int16 left, right; PCECD_Drive_GetCDDAValues(left, right); RawPCMVolumeCache[0] = ((int64)abs(left) * CDDAFadeVolume) >> 16; RawPCMVolumeCache[1] = ((int64)abs(right) * CDDAFadeVolume) >> 16; } break; case 0x7: // $1807: D7=1 enables backup ram if (data & 0x80) { bBRAMEnabled = TRUE; } break; case 0x8: // Set ADPCM address low if(ADPCM.LastCmd & 0x80) break; ADPCM.Addr &= 0xFF00; ADPCM.Addr |= V; ADPCM_DEBUG("SAL: %02x, %d\n", V, timestamp); // Length appears to be constantly latched when D4 is set(tested on a real system) if(ADPCM.LastCmd & 0x10) { ADPCM_DEBUG("Set length(crazy way L): %04x\n", ADPCM.Addr); ADPCM.LengthCount = ADPCM.Addr; } break; case 0x9: // Set ADPCM address high if(ADPCM.LastCmd & 0x80) break; ADPCM.Addr &= 0x00FF; ADPCM.Addr |= V << 8; ADPCM_DEBUG("SAH: %02x, %d\n", V, timestamp); // Length appears to be constantly latched when D4 is set(tested on a real system) if(ADPCM.LastCmd & 0x10) { ADPCM_DEBUG("Set length(crazy way H): %04x\n", ADPCM.Addr); ADPCM.LengthCount = ADPCM.Addr; } break; case 0xa: //ADPCM_DEBUG("Write: %02x, %d\n", V, timestamp); ADPCM.WritePending = 3 * 11; ADPCM.WritePendingValue = data; break; case 0xb: // adpcm dma ADPCM_DEBUG("DMA: %02x\n", V); _Port[0xb] = data; break; case 0xc: // read-only break; case 0xd: ADPCM_DEBUG("Write180D: %02x\n", V); if(data & 0x80) { ADPCM.Addr = 0; ADPCM.ReadAddr = 0; ADPCM.WriteAddr = 0; ADPCM.LengthCount = 0; ADPCM.LastCmd = 0; ADPCM.Playing = false; ADPCM.HalfReached = false; ADPCM.EndReached = false; ADPCM.PlayNibble = 0; UpdateADPCMIRQState(); MSM5205.SetSample(0x800); MSM5205.SetSSI(0); break; } if(ADPCM.Playing && !(data & 0x20)) ADPCM.Playing = false; if(!ADPCM.Playing && (data & 0x20)) { ADPCM.bigdiv = ADPCM.bigdivacc * (16 - ADPCM.SampleFreq); ADPCM.Playing = true; ADPCM.HalfReached = false; // Not sure about this. ADPCM.PlayNibble = 0; MSM5205.SetSample(0x800); MSM5205.SetSSI(0); } // Length appears to be constantly latched when D4 is set(tested on a real system) if(data & 0x10) { ADPCM_DEBUG("Set length: %04x\n", ADPCM.Addr); ADPCM.LengthCount = ADPCM.Addr; ADPCM.EndReached = false; } // D2 and D3 control read address if(!(ADPCM.LastCmd & 0x8) && (data & 0x08)) { if(data & 0x4) ADPCM.ReadAddr = ADPCM.Addr; else ADPCM.ReadAddr = (ADPCM.Addr - 1) & 0xFFFF; ADPCM_DEBUG("Set ReadAddr: %04x, %06x\n", ADPCM.Addr, ADPCM.ReadAddr); } // D0 and D1 control write address if(!(ADPCM.LastCmd & 0x2) && (data & 0x2)) { ADPCM.WriteAddr = ADPCM.Addr; if(!(data & 0x1)) ADPCM.WriteAddr = (ADPCM.WriteAddr - 1) & 0xFFFF; ADPCM_DEBUG("Set WriteAddr: %04x, %06x\n", ADPCM.Addr, ADPCM.WriteAddr); } ADPCM.LastCmd = data; UpdateADPCMIRQState(); break; case 0xe: // Set ADPCM playback rate { uint8 freq = V & 0x0F; ADPCM.SampleFreq = freq; ADPCM_DEBUG("Freq: %02x\n", freq); } break; case 0xf: Fader.Command = V; #ifdef PCECD_DEBUG printf("Fade: %02x\n", data); #endif // Cancel fade if(!(V & 0x8)) { Fader.Volume = 65536; Fader.CycleCounter = 0; Fader.CountValue = 0; Fader.Clocked = FALSE; } else { Fader.CountValue = OC_Multiplier * 3 * ((V & 0x4) ? 273 : 655); // 2.500s : 6.000s; if(!Fader.Clocked) Fader.CycleCounter = Fader.CountValue; Fader.Clocked = TRUE; } Fader_SyncWhich(); break; } } static INLINE void ADPCM_PB_Run(int32 basetime, int32 run_time) { ADPCM.bigdiv -= run_time * 65536; while(ADPCM.bigdiv <= 0) { ADPCM.bigdiv += ADPCM.bigdivacc * (16 - ADPCM.SampleFreq); if(ADPCM.Playing && !ADPCM.PlayNibble) // Do playback sample buffer fetch. { ADPCM.HalfReached = (ADPCM.LengthCount < 32768); if(!ADPCM.LengthCount && !(ADPCM.LastCmd & 0x10)) { if(ADPCM.EndReached) ADPCM.HalfReached = false; ADPCM.EndReached = true; if(ADPCM.LastCmd & 0x40) ADPCM.Playing = false; } ADPCM.PlayBuffer = ADPCM.RAM[ADPCM.ReadAddr]; ADPCM.ReadAddr = (ADPCM.ReadAddr + 1) & 0xFFFF; if(ADPCM.LengthCount && !(ADPCM.LastCmd & 0x10)) ADPCM.LengthCount--; } if(ADPCM.Playing) { int32 pcm; uint8 nibble; nibble = (ADPCM.PlayBuffer >> (ADPCM.PlayNibble ^ 4)) & 0x0F; pcm = MSM5205.Decode(nibble) - 2048; ADPCM.PlayNibble ^= 4; pcm = (pcm * ADPCMFadeVolume) >> 8; uint32 synthtime = ((basetime + (ADPCM.bigdiv >> 16))) / (3 * OC_Multiplier); if(sbuf[0] && sbuf[1]) { ADPCMSynth.offset(synthtime, pcm - ADPCM.last_pcm, sbuf[0]); ADPCMSynth.offset(synthtime, pcm - ADPCM.last_pcm, sbuf[1]); } ADPCM.last_pcm = pcm; } } } static INLINE void ADPCM_Run(const int32 clocks, const int32 timestamp) { //printf("ADPCM Run: %d\n", clocks); ADPCM_PB_Run(timestamp, clocks); if(ADPCM.WritePending) { ADPCM.WritePending -= clocks; if(ADPCM.WritePending <= 0) { ADPCM.HalfReached = (ADPCM.LengthCount < 32768); if(!(ADPCM.LastCmd & 0x10) && ADPCM.LengthCount < 0xFFFF) ADPCM.LengthCount++; ADPCM.RAM[ADPCM.WriteAddr++] = ADPCM.WritePendingValue; ADPCM.WritePending = 0; } } if(!ADPCM.WritePending) { if(_Port[0xb] & 0x3) { // Run PCECD_Drive before we examine the signals. pcecd_drive_ne = PCECD_Drive_Run(timestamp); if(!PCECD_Drive_GetCD() && PCECD_Drive_GetIO() && PCECD_Drive_GetREQ() && !PCECD_Drive_GetACK()) { ADPCM.WritePendingValue = read_1808(timestamp); ADPCM.WritePending = 10 * 3; } } } if(ADPCM.ReadPending) { ADPCM.ReadPending -= clocks; if(ADPCM.ReadPending <= 0) { ADPCM.ReadBuffer = ADPCM.RAM[ADPCM.ReadAddr]; ADPCM.ReadAddr = (ADPCM.ReadAddr + 1) & 0xFFFF; ADPCM.ReadPending = 0; ADPCM.HalfReached = (ADPCM.LengthCount < 32768); if(!(ADPCM.LastCmd & 0x10)) { if(ADPCM.LengthCount) ADPCM.LengthCount--; else { ADPCM.EndReached = true; ADPCM.HalfReached = false; if(ADPCM.LastCmd & 0x40) ADPCM.Playing = false; } } } } UpdateADPCMIRQState(); } void PCECD_Run(uint32 in_timestamp) { int32 clocks = in_timestamp - lastts; int32 running_ts = lastts; //printf("Run Begin: Clocks=%d(%d - %d), cl=%d\n", clocks, in_timestamp, lastts, CalcNextEvent); //fflush(stdout); while(clocks > 0) { int32 chunk_clocks = CalcNextEvent(clocks); running_ts += chunk_clocks; if(ClearACKDelay > 0) { ClearACKDelay -= chunk_clocks; if(ClearACKDelay <= 0) { ACKStatus = FALSE; PCECD_Drive_SetACK(FALSE); PCECD_Drive_Run(running_ts); if(PCECD_Drive_GetCD()) { _Port[0xb] &= ~1; #ifdef PCECD_DEBUG puts("DMA End"); #endif } } } Fader_Run(chunk_clocks); ADPCM_Run(chunk_clocks, running_ts); pcecd_drive_ne = PCECD_Drive_Run(running_ts); clocks -= chunk_clocks; } lastts = in_timestamp; } void PCECD_ResetTS(void) { if(ADPCM.SampleFreq != ADPCM.LPF_SampleFreq) { ADPCM.LPF_SampleFreq = ADPCM.SampleFreq; RedoLPF(ADPCM.LPF_SampleFreq); } PCECD_Drive_ResetTS(); lastts = 0; } static int ADPCM_StateAction(StateMem *sm, int load, int data_only) { uint32 ad_sample = MSM5205.GetSample(); int32 ad_ref_index = MSM5205.GetSSI(); SFORMAT StateRegs[] = { SFARRAY(ADPCM.RAM, 0x10000), SFVAR(ADPCM.bigdiv), SFVAR(ADPCM.Addr), SFVAR(ADPCM.ReadAddr), SFVAR(ADPCM.WriteAddr), SFVAR(ADPCM.LengthCount), SFVAR(ADPCM.LastCmd), SFVAR(ADPCM.SampleFreq), SFVAR(ADPCM.ReadPending), SFVAR(ADPCM.ReadBuffer), SFVAR(ADPCM.PlayBuffer), SFVAR(ADPCM.WritePending), SFVAR(ADPCM.WritePendingValue), SFVAR(ADPCM.HalfReached), SFVAR(ADPCM.EndReached), SFVAR(ADPCM.Playing), SFVAR(ADPCM.PlayNibble), SFVAR(ad_sample), SFVAR(ad_ref_index), SFEND }; int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, "APCM"); if(load) { MSM5205.SetSample(ad_sample); MSM5205.SetSSI(ad_ref_index); RedoLPF(ADPCM.SampleFreq); } return(ret); } int PCECD_StateAction(StateMem *sm, int load, int data_only) { SFORMAT StateRegs[] = { SFVAR(bBRAMEnabled), SFVAR(ACKStatus), SFVAR(ClearACKDelay), SFARRAY16(RawPCMVolumeCache, 2), SFARRAY(_Port, sizeof(_Port)), SFVAR(Fader.Command), SFVAR(Fader.Volume), SFVAR(Fader.CycleCounter), SFVAR(Fader.CountValue), SFVAR(Fader.Clocked), SFARRAY(&SubChannelFIFO.data[0], SubChannelFIFO.data.size()), SFVAR(SubChannelFIFO.read_pos), SFVAR(SubChannelFIFO.write_pos), SFVAR(SubChannelFIFO.in_count), SFEND }; int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, "PECD"); ret &= PCECD_Drive_StateAction(sm, load, data_only, "CDRM"); ret &= ADPCM_StateAction(sm, load, data_only); if(load) { Fader_SyncWhich(); //PCECD_Drive_SetDB(_Port[1]); PCECD_Drive_SetACK(ACKStatus); PCECD_Drive_SetRST(_Port[4] & 0x2); SubChannelFIFO.read_pos %= SubChannelFIFO.size; SubChannelFIFO.write_pos %= SubChannelFIFO.size; } return(ret); } mednafen/pce_fast/psg.cpp000664 001750 001750 00000044436 12726204343 016556 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "../mednafen.h" #include "psg.h" #include #include void PCEFast_PSG::SetVolume(double new_volume) { OutputVolume = new_volume; Synth.volume(OutputVolume / 6); } void PCEFast_PSG::UpdateOutput_Norm(const int32 timestamp, psg_channel *ch) { int32 samp[2]; int sv = ch->dda; samp[0] = dbtable[ch->vl[0]][sv]; samp[1] = dbtable[ch->vl[1]][sv]; Synth.offset_inline(timestamp, samp[0] - ch->blip_prev_samp[0], sbuf[0]); Synth.offset_inline(timestamp, samp[1] - ch->blip_prev_samp[1], sbuf[1]); ch->blip_prev_samp[0] = samp[0]; ch->blip_prev_samp[1] = samp[1]; } void PCEFast_PSG::UpdateOutput_Noise(const int32 timestamp, psg_channel *ch) { int32 samp[2]; int sv = ((ch->lfsr & 1) << 5) - (ch->lfsr & 1); //(ch->lfsr & 0x1) ? 0x1F : 0; samp[0] = dbtable[ch->vl[0]][sv]; samp[1] = dbtable[ch->vl[1]][sv]; Synth.offset_inline(timestamp, samp[0] - ch->blip_prev_samp[0], sbuf[0]); Synth.offset_inline(timestamp, samp[1] - ch->blip_prev_samp[1], sbuf[1]); ch->blip_prev_samp[0] = samp[0]; ch->blip_prev_samp[1] = samp[1]; } void PCEFast_PSG::UpdateOutput_Off(const int32 timestamp, psg_channel *ch) { int32 samp[2]; samp[0] = samp[1] = 0; Synth.offset_inline(timestamp, samp[0] - ch->blip_prev_samp[0], sbuf[0]); Synth.offset_inline(timestamp, samp[1] - ch->blip_prev_samp[1], sbuf[1]); ch->blip_prev_samp[0] = samp[0]; ch->blip_prev_samp[1] = samp[1]; } void PCEFast_PSG::UpdateOutput_Accum(const int32 timestamp, psg_channel *ch) { int32 samp[2]; samp[0] = ((int32)dbtable_volonly[ch->vl[0]] * ((int32)ch->samp_accum - 496)) >> (8 + 5); samp[1] = ((int32)dbtable_volonly[ch->vl[1]] * ((int32)ch->samp_accum - 496)) >> (8 + 5); Synth.offset_inline(timestamp, samp[0] - ch->blip_prev_samp[0], sbuf[0]); Synth.offset_inline(timestamp, samp[1] - ch->blip_prev_samp[1], sbuf[1]); ch->blip_prev_samp[0] = samp[0]; ch->blip_prev_samp[1] = samp[1]; } // This function should always be called after RecalcFreqCache() (it's not called from RecalcFreqCache to avoid redundant code) void PCEFast_PSG::RecalcUOFunc(int chnum) { psg_channel *ch = &channel[chnum]; //printf("UO Update: %d, %02x\n", chnum, ch->control); if(!(ch->control & 0xC0)) ch->UpdateOutput = &PCEFast_PSG::UpdateOutput_Off; else if(ch->noisectrl & ch->control & 0x80) ch->UpdateOutput = &PCEFast_PSG::UpdateOutput_Noise; // If the control for the channel is in waveform play mode, and the (real) playback frequency is too high, and the channel is either not the LFO modulator channel or // if the LFO trigger bit(which halts the LFO modulator channel's waveform incrementing when set) is clear else if((ch->control & 0xC0) == 0x80 && ch->freq_cache <= 0xA && (chnum != 1 || !(lfoctrl & 0x80)) ) ch->UpdateOutput = &PCEFast_PSG::UpdateOutput_Accum; else ch->UpdateOutput = &PCEFast_PSG::UpdateOutput_Norm; } void PCEFast_PSG::RecalcFreqCache(int chnum) { psg_channel *ch = &channel[chnum]; if(chnum == 0 && (lfoctrl & 0x03)) { const uint32 shift = (((lfoctrl & 0x3) - 1) << 1); uint8 la = channel[1].dda; int32 tmp_freq = ((int32)ch->frequency + ((la - 0x10) << shift)) & 0xFFF; ch->freq_cache = (tmp_freq ? tmp_freq : 4096) << 1; } else { ch->freq_cache = (ch->frequency ? ch->frequency : 4096) << 1; if(chnum == 1 && (lfoctrl & 0x03)) ch->freq_cache *= lfofreq ? lfofreq : 256; } } void PCEFast_PSG::RecalcNoiseFreqCache(int chnum) { psg_channel *ch = &channel[chnum]; int32 freq = 0x1F - (ch->noisectrl & 0x1F); if(!freq) freq = 0x20; else freq <<= 6; freq <<= 1; ch->noise_freq_cache = freq; } PCEFast_PSG::PCEFast_PSG(Blip_Buffer *bb_l, Blip_Buffer *bb_r) { //printf("Test: %u, %u\n", sizeof(psg_channel), (uint8*)&channel[0].balance - (uint8*)&channel[0].waveform[0]); Synth.treble_eq(-2.0); sbuf[0] = bb_l; sbuf[1] = bb_r; lastts = 0; for(int ch = 0; ch < 6; ch++) { channel[ch].blip_prev_samp[0] = 0; channel[ch].blip_prev_samp[1] = 0; channel[ch].lastts = 0; } SetVolume(1.0); for(int vl = 0; vl < 32; vl++) { double flub = 1; if(vl) flub /= powf(2, (double)1 / 4 * vl); // ~1.5dB reduction per increment of vl if(vl == 0x1F) flub = 0; for(int samp = 0; samp < 32; samp++) { int eff_samp = samp * 2 - 0x1F; dbtable[vl][samp] = (int32)(flub * eff_samp * 128); dbtable_volonly[vl] = (int32)(flub * 65536); } } Power(0); } PCEFast_PSG::~PCEFast_PSG() { } int32 PCEFast_PSG::GetVL(const int chnum, const int lr) { // Note: Changing the 0x1F(not that there should be) would require changing the channel pseudo-off volume check logic later on. static const uint8 scale_tab[] = { 0x00, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D, 0x0F, 0x10, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F }; psg_channel *ch = &channel[chnum]; const int gbal = 0x1F - scale_tab[(globalbalance >> (lr ? 0 : 4)) & 0xF]; const int bal = 0x1F - scale_tab[(ch->balance >> (lr ? 0 : 4)) & 0xF]; const int al = 0x1F - (ch->control & 0x1F); int vol_reduction; vol_reduction = gbal + bal + al; if(vol_reduction > 0x1F) vol_reduction = 0x1F; return(vol_reduction); } void PCEFast_PSG::Write(int32 timestamp, uint8 A, uint8 V) { A &= 0x0F; if(A == 0x00) { select = (V & 0x07); return; } Update(timestamp); psg_channel *ch = &channel[select]; //if(A == 0x01 || select == 5) // printf("Write Ch: %d %04x %02x, %d\n", select, A, V, timestamp); switch(A) { default: break; case 0x01: /* Global sound balance */ globalbalance = V; vol_pending = true; break; case 0x02: /* Channel frequency (LSB) */ if(select > 5) return; // no more than 6 channels, silly game. ch->frequency = (ch->frequency & 0x0F00) | V; RecalcFreqCache(select); RecalcUOFunc(select); break; case 0x03: /* Channel frequency (MSB) */ if(select > 5) return; // no more than 6 channels, silly game. ch->frequency = (ch->frequency & 0x00FF) | ((V & 0x0F) << 8); RecalcFreqCache(select); RecalcUOFunc(select); break; case 0x04: /* Channel enable, DDA, volume */ if(select > 5) return; // no more than 6 channels, silly game. if((ch->control & 0x40) && !(V & 0x40)) { ch->waveform_index = 0; ch->dda = ch->waveform[ch->waveform_index]; ch->counter = ch->freq_cache; } if(!(ch->control & 0x80) && (V & 0x80)) { if(!(V & 0x40)) { ch->waveform_index = (ch->waveform_index + 1) & 0x1F; ch->dda = ch->waveform[ch->waveform_index]; } } ch->control = V; RecalcFreqCache(select); RecalcUOFunc(select); vol_pending = true; break; case 0x05: /* Channel balance */ if(select > 5) return; // no more than 6 channels, silly game. ch->balance = V; vol_pending = true; break; case 0x06: /* Channel waveform data */ if(select > 5) return; // no more than 6 channels, silly game. V &= 0x1F; if(!(ch->control & 0x40)) { ch->samp_accum -= ch->waveform[ch->waveform_index]; ch->waveform[ch->waveform_index] = V; ch->samp_accum += ch->waveform[ch->waveform_index]; } if((ch->control & 0xC0) == 0x00) ch->waveform_index = ((ch->waveform_index + 1) & 0x1F); if(ch->control & 0x80) { // According to my tests(on SuperGrafx), writing to this channel // will update the waveform value cache/latch regardless of DDA mode being enabled. ch->dda = V; } break; case 0x07: /* Noise enable and frequency */ if(select > 5) return; // no more than 6 channels, silly game. if(select >= 4) { ch->noisectrl = V; RecalcNoiseFreqCache(select); RecalcUOFunc(select); } break; case 0x08: /* LFO frequency */ lfofreq = V & 0xFF; //printf("LFO Freq: %02x\n", V); break; case 0x09: /* LFO trigger and control */ //printf("LFO Ctrl: %02x\n", V); if(V & 0x80) { channel[1].waveform_index = 0; channel[1].dda = channel[1].waveform[channel[1].waveform_index]; channel[1].counter = channel[1].freq_cache; } lfoctrl = V; RecalcFreqCache(0); RecalcUOFunc(0); RecalcFreqCache(1); RecalcUOFunc(1); break; } } // Don't use INLINE, which has always_inline in it, due to gcc's inability to cope with the type of recursion // used in this function. template void PCEFast_PSG::RunChannel(int chc, int32 timestamp) { psg_channel *ch = &channel[chc]; int32 running_timestamp = ch->lastts; int32 run_time = timestamp - ch->lastts; ch->lastts = timestamp; if(!run_time) return; (this->*ch->UpdateOutput)(running_timestamp, ch); if(chc >= 4) { int32 freq = ch->noise_freq_cache; ch->noisecount -= run_time; #define CLOCK_LFSR(lfsr) { unsigned int newbit = ((lfsr >> 0) ^ (lfsr >> 1) ^ (lfsr >> 11) ^ (lfsr >> 12) ^ (lfsr >> 17)) & 1; lfsr = (lfsr >> 1) | (newbit << 17); } if(&PCEFast_PSG::UpdateOutput_Noise == ch->UpdateOutput) { while(ch->noisecount <= 0) { CLOCK_LFSR(ch->lfsr); UpdateOutput_Noise(timestamp + ch->noisecount, ch); ch->noisecount += freq; } } else { while(ch->noisecount <= 0) { CLOCK_LFSR(ch->lfsr); ch->noisecount += freq; } } #undef CLOCK_LFSR } // D7 of control is 0, don't clock the counter at all. // D7 of lfocontrol is 1(and chc == 1), don't clock the counter at all(not sure about this) // In DDA mode, don't clock the counter. // (Noise being enabled isn't handled here since AFAIK it doesn't disable clocking of the waveform portion, its sound just overrides the sound from // the waveform portion when the noise enable bit is set, which is handled in our RecalcUOFunc). if(!(ch->control & 0x80) || (chc == 1 && (lfoctrl & 0x80)) || (ch->control & 0x40)) return; ch->counter -= run_time; if(!LFO_On && ch->freq_cache <= 0xA) { if(ch->counter <= 0) { const int32 inc_count = ((0 - ch->counter) / ch->freq_cache) + 1; ch->counter += inc_count * ch->freq_cache; ch->waveform_index = (ch->waveform_index + inc_count) & 0x1F; ch->dda = ch->waveform[ch->waveform_index]; } } while(ch->counter <= 0) { ch->waveform_index = (ch->waveform_index + 1) & 0x1F; ch->dda = ch->waveform[ch->waveform_index]; (this->*ch->UpdateOutput)(timestamp + ch->counter, ch); if(LFO_On) { RunChannel(1, timestamp + ch->counter); RecalcFreqCache(0); RecalcUOFunc(0); ch->counter += (ch->freq_cache <= 0xA) ? 0xA : ch->freq_cache; // Not particularly accurate, but faster. } else ch->counter += ch->freq_cache; } } INLINE void PCEFast_PSG::UpdateSubLFO(int32 timestamp) { RunChannel(0, timestamp); for(int chc = 1; chc < 6; chc++) RunChannel(chc, timestamp); } INLINE void PCEFast_PSG::UpdateSubNonLFO(int32 timestamp) { for(int chc = 0; chc < 6; chc++) RunChannel(chc, timestamp); } //static int32 last_read; //static int32 last_apply; void PCEFast_PSG::Update(int32 timestamp) { int32 run_time = timestamp - lastts; if(vol_pending && !vol_update_counter && !vol_update_which) { vol_update_counter = 1; vol_pending = false; } bool lfo_on = (bool)(lfoctrl & 0x03); if(lfo_on) { if(!(channel[1].control & 0x80) || (lfoctrl & 0x80)) { lfo_on = 0; RecalcFreqCache(0); RecalcUOFunc(0); } } int32 clocks = run_time; int32 running_timestamp = lastts; while(clocks > 0) { int32 chunk_clocks = clocks; if(vol_update_counter > 0 && chunk_clocks > vol_update_counter) chunk_clocks = vol_update_counter; running_timestamp += chunk_clocks; clocks -= chunk_clocks; if(lfo_on) UpdateSubLFO(running_timestamp); else UpdateSubNonLFO(running_timestamp); if(vol_update_counter > 0) { vol_update_counter -= chunk_clocks; if(!vol_update_counter) { const int phase = vol_update_which & 1; const int lr = ((vol_update_which >> 1) & 1) ^ 1; const int chnum = vol_update_which >> 2; if(!phase) { //printf("Volume update(Read, %d since last): ch=%d, lr=%d, ts=%d\n", running_timestamp - last_read, chnum, lr, running_timestamp); if(chnum < 6) { vol_update_vllatch = GetVL(chnum, lr); } //last_read = running_timestamp; } else { // printf("Volume update(Apply): ch=%d, lr=%d, ts=%d\n", chnum, lr, running_timestamp); if(chnum < 6) { channel[chnum].vl[lr] = vol_update_vllatch; } //last_apply = running_timestamp; } vol_update_which = (vol_update_which + 1) & 0x1F; if(vol_update_which) vol_update_counter = phase ? 1 : 255; else if(vol_pending) { vol_update_counter = phase ? 1 : 255; vol_pending = false; } } } lastts = running_timestamp; } } void PCEFast_PSG::EndFrame(int32 timestamp) { Update(timestamp); lastts = 0; for(int chc = 0; chc < 6; chc++) channel[chc].lastts = 0; } void PCEFast_PSG::Power(const int32 timestamp) { // Not sure about power-on values, these are mostly just intuitive guesses(with some laziness thrown in). if(timestamp != lastts) Update(timestamp); memset(&channel, 0, sizeof(channel)); select = 0; globalbalance = 0; lfofreq = 0; lfoctrl = 0; for(int ch = 0; ch < 6; ch++) { channel[ch].frequency = 0; channel[ch].control = 0x00; channel[ch].balance = 0; memset(channel[ch].waveform, 0, 32); channel[ch].samp_accum = 0; channel[ch].waveform_index = 0; channel[ch].dda = 0x00; channel[ch].noisectrl = 0x00; channel[ch].vl[0] = 0x1F; channel[ch].vl[1] = 0x1F; channel[ch].samp_accum = 0; RecalcFreqCache(ch); RecalcUOFunc(ch); channel[ch].counter = channel[ch].freq_cache; if(ch >= 4) { RecalcNoiseFreqCache(ch); channel[ch].noisecount = 1; channel[ch].lfsr = 1; } } vol_pending = false; vol_update_counter = 0; vol_update_which = 0; } int PCEFast_PSG::StateAction(StateMem *sm, int load, int data_only) { int ret = 1; for(int ch = 0; ch < 6; ch++) { char tmpstr[5] = "SCHx"; psg_channel *pt = &channel[ch]; SFORMAT CH_StateRegs[] = { SFVARN(pt->counter, "counter"), SFVARN(pt->frequency, "frequency"), SFVARN(pt->control, "control"), SFVARN(pt->balance, "balance"), SFARRAYN(pt->waveform, 32, "waveform"), SFVARN(pt->waveform_index, "waveform_index"), SFVARN(pt->dda, "dda"), SFVARN(pt->noisectrl, "noisectrl"), SFVARN(pt->noisecount, "noisecount"), SFVARN(pt->lfsr, "lfsr"), SFARRAY32N(pt->vl, 2, "vl"), // TODO SFEND }; tmpstr[3] = '0' + ch; ret &= MDFNSS_StateAction(sm, load, data_only, CH_StateRegs, tmpstr); } SFORMAT PSG_StateRegs[] = { SFVAR(select), SFVAR(globalbalance), SFVAR(lfofreq), SFVAR(lfoctrl), SFVAR(vol_update_counter), SFVAR(vol_update_which), SFVAR(vol_pending), SFEND }; ret &= MDFNSS_StateAction(sm, load, data_only, PSG_StateRegs, "PSG"); if(load) { vol_update_which &= 0x1F; if(!channel[4].lfsr) channel[4].lfsr = 1; if(!channel[5].lfsr) channel[5].lfsr = 1; for(int ch = 0; ch < 6; ch++) { channel[ch].samp_accum = 0; for(int wi = 0; wi < 32; wi++) { channel[ch].waveform[wi] &= 0x1F; channel[ch].samp_accum += channel[ch].waveform[wi]; } for(int lr = 0; lr < 2; lr++) channel[ch].vl[lr] &= 0x1F; if(!channel[ch].noisecount && ch >= 4) { printf("ch=%d, noisecount == 0\n", ch); channel[ch].noisecount = 1; } if(channel[ch].counter <= 0) { printf("ch=%d, counter <= 0\n", ch); channel[ch].counter = 1; } if(ch >= 4) RecalcNoiseFreqCache(ch); RecalcFreqCache(ch); RecalcUOFunc(ch); } } return(ret); } libretro-common/include/retro_common.h000664 001750 001750 00000003510 12726204343 021313 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (retro_common.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef _LIBRETRO_COMMON_RETRO_COMMON_H #define _LIBRETRO_COMMON_RETRO_COMMON_H /* This file is designed to normalize the libretro-common compiling environment. It is not to be used in public API headers, as they should be designed as leanly as possible. Nonetheless.. in the meantime, if you do something like use ssize_t, which is not fully portable, in a public API, you may need this. */ /* conditional compilation is handled inside here */ #include #endif libretro-common/include/compat/fnmatch.h000664 001750 001750 00000003040 12726204343 021511 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (compat_fnmatch.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_COMPAT_FNMATCH_H__ #define __LIBRETRO_SDK_COMPAT_FNMATCH_H__ #define FNM_NOMATCH 1 int rl_fnmatch(const char *pattern, const char *string, int flags); #endif mednafen/pce_fast/pcecd_drive.cpp000664 001750 001750 00000076127 12726204343 020236 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "../mednafen.h" #include #include "pcecd_drive.h" #include "../cdrom/cdromif.h" #include "../cdrom/SimpleFIFO.h" #include "../msvc_compat.h" static inline void SCSIDBG(const char *format, ...) { //printf("SCSI: " format "\n", ## __VA_ARGS__); } //#define SCSIDBG(format, ...) { } using namespace CDUtility; static uint32 CD_DATA_TRANSFER_RATE; static uint32 System_Clock; static void (*CDIRQCallback)(int); static void (*CDStuffSubchannels)(uint8, int); static Blip_Buffer *sbuf[2]; static CDIF *Cur_CDIF; // Internal operation to the SCSI CD unit. Only pass 1 or 0 to these macros! #define SetIOP(mask, set) { cd_bus.signals &= ~mask; if(set) cd_bus.signals |= mask; } #define SetBSY(set) SetIOP(PCECD_Drive_BSY_mask, set) #define SetIO(set) SetIOP(PCECD_Drive_IO_mask, set) #define SetCD(set) SetIOP(PCECD_Drive_CD_mask, set) #define SetMSG(set) SetIOP(PCECD_Drive_MSG_mask, set) static INLINE void SetREQ(bool set) { if(set && !REQ_signal) CDIRQCallback(PCECD_Drive_IRQ_MAGICAL_REQ); SetIOP(PCECD_Drive_REQ_mask, set); } #define SetkingACK(set) SetIOP(PCECD_Drive_kingACK_mask, set) #define SetkingRST(set) SetIOP(PCECD_Drive_kingRST_mask, set) #define SetkingSEL(set) SetIOP(PCECD_Drive_kingSEL_mask, set) enum { QMode_Zero = 0, QMode_Time = 1, QMode_MCN = 2, // Media Catalog Number QMode_ISRC = 3 // International Standard Recording Code }; typedef struct { bool last_RST_signal; // The pending message to send(in the message phase) uint8 message_pending; bool status_sent, message_sent; // Pending error codes uint8 key_pending, asc_pending, ascq_pending, fru_pending; uint8 command_buffer[256]; uint8 command_buffer_pos; uint8 command_size_left; // FALSE if not all pending data is in the FIFO, TRUE if it is. // Used for multiple sector CD reads. bool data_transfer_done; bool TrayOpen; bool DiscChanged; uint8 SubQBuf[4][0xC]; // One for each of the 4 most recent q-Modes. uint8 SubQBuf_Last[0xC]; // The most recent q subchannel data, regardless of q-mode. uint8 SubPWBuf[96]; } pcecd_drive_t; typedef Blip_Synth < blip_good_quality, 1> CDSynth; enum { CDDASTATUS_PAUSED = -1, CDDASTATUS_STOPPED = 0, CDDASTATUS_PLAYING = 1, }; enum { PLAYMODE_SILENT = 0x00, PLAYMODE_NORMAL, PLAYMODE_INTERRUPT, PLAYMODE_LOOP, }; typedef struct { int32 CDDADivAcc; uint32 scan_sec_end; uint8 PlayMode; CDSynth CDDASynth; int32 CDDAVolume; int16 last_sample[2]; int16 CDDASectorBuffer[1176]; uint32 CDDAReadPos; int8 CDDAStatus; uint8 ScanMode; int32 CDDADiv; int CDDATimeDiv; } cdda_t; static INLINE void MakeSense(uint8 target[18], uint8 key, uint8 asc, uint8 ascq, uint8 fru) { memset(target, 0, 18); target[0] = 0x70; // Current errors and sense data is not SCSI compliant target[2] = key; target[7] = 0x0A; target[12] = asc; // Additional Sense Code target[13] = ascq; // Additional Sense Code Qualifier target[14] = fru; // Field Replaceable Unit code } static void (*SCSILog)(const char *, const char *format, ...); static pcecd_drive_timestamp_t lastts; static int64 monotonic_timestamp; static int64 pce_lastsapsp_timestamp; static pcecd_drive_t cd; pcecd_drive_bus_t cd_bus; static cdda_t cdda; static SimpleFIFO din(2048); static CDUtility::TOC toc; static uint32 read_sec_start; static uint32 read_sec; static uint32 read_sec_end; static int32 CDReadTimer; static uint32 SectorAddr; static uint32 SectorCount; enum { PHASE_BUS_FREE = 0, PHASE_COMMAND, PHASE_DATA_IN, PHASE_STATUS, PHASE_MESSAGE_IN, }; static unsigned int CurrentPhase; static void ChangePhase(const unsigned int new_phase); static void VirtualReset(void) { din.Flush(); cdda.CDDADivAcc = (int64)System_Clock * 65536 / 44100; CDReadTimer = 0; pce_lastsapsp_timestamp = monotonic_timestamp; SectorAddr = SectorCount = 0; read_sec_start = read_sec = 0; read_sec_end = ~0; cdda.PlayMode = PLAYMODE_SILENT; cdda.CDDAReadPos = 0; cdda.CDDAStatus = CDDASTATUS_STOPPED; cdda.CDDADiv = 0; cdda.ScanMode = 0; cdda.scan_sec_end = 0; ChangePhase(PHASE_BUS_FREE); } void PCECD_Drive_Power(pcecd_drive_timestamp_t system_timestamp) { memset(&cd, 0, sizeof(pcecd_drive_t)); memset(&cd_bus, 0, sizeof(pcecd_drive_bus_t)); monotonic_timestamp = system_timestamp; cd.DiscChanged = false; if(Cur_CDIF && !cd.TrayOpen) Cur_CDIF->ReadTOC(&toc); CurrentPhase = PHASE_BUS_FREE; VirtualReset(); } void PCECD_Drive_SetDB(uint8 data) { cd_bus.DB = data; //printf("Set DB: %02x\n", data); } void PCECD_Drive_SetACK(bool set) { SetkingACK(set); //printf("Set ACK: %d\n", set); } void PCECD_Drive_SetSEL(bool set) { SetkingSEL(set); //printf("Set SEL: %d\n", set); } void PCECD_Drive_SetRST(bool set) { SetkingRST(set); //printf("Set RST: %d\n", set); } static void GenSubQFromSubPW(void) { uint8 SubQBuf[0xC]; subq_deinterleave(cd.SubPWBuf, SubQBuf); //printf("Real %d/ SubQ %d - ", read_sec, BCD_to_U8(SubQBuf[7]) * 75 * 60 + BCD_to_U8(SubQBuf[8]) * 75 + BCD_to_U8(SubQBuf[9]) - 150); // Debug code, remove me. //for(int i = 0; i < 0xC; i++) // printf("%02x ", SubQBuf[i]); //printf("\n"); if(!subq_check_checksum(SubQBuf)) { SCSIDBG("SubQ checksum error!"); } else { memcpy(cd.SubQBuf_Last, SubQBuf, 0xC); uint8 adr = SubQBuf[0] & 0xF; if(adr <= 0x3) memcpy(cd.SubQBuf[adr], SubQBuf, 0xC); //if(adr == 0x02) //for(int i = 0; i < 12; i++) // printf("%02x\n", cd.SubQBuf[0x2][i]); } } #define STATUS_GOOD 0 #define STATUS_CHECK_CONDITION 1 #define SENSEKEY_NO_SENSE 0x0 #define SENSEKEY_NOT_READY 0x2 #define SENSEKEY_MEDIUM_ERROR 0x3 #define SENSEKEY_HARDWARE_ERROR 0x4 #define SENSEKEY_ILLEGAL_REQUEST 0x5 #define SENSEKEY_UNIT_ATTENTION 0x6 #define SENSEKEY_ABORTED_COMMAND 0xB #define ASC_MEDIUM_NOT_PRESENT 0x3A // NEC sub-errors(ASC), no ASCQ. #define NSE_NO_DISC 0x0B // Used with SENSEKEY_NOT_READY - This condition occurs when tray is closed with no disc present. #define NSE_TRAY_OPEN 0x0D // Used with SENSEKEY_NOT_READY #define NSE_SEEK_ERROR 0x15 #define NSE_HEADER_READ_ERROR 0x16 // Used with SENSEKEY_MEDIUM_ERROR #define NSE_NOT_AUDIO_TRACK 0x1C // Used with SENSEKEY_MEDIUM_ERROR #define NSE_NOT_DATA_TRACK 0x1D // Used with SENSEKEY_MEDIUM_ERROR #define NSE_INVALID_COMMAND 0x20 #define NSE_INVALID_ADDRESS 0x21 #define NSE_INVALID_PARAMETER 0x22 #define NSE_END_OF_VOLUME 0x25 #define NSE_INVALID_REQUEST_IN_CDB 0x27 #define NSE_DISC_CHANGED 0x28 // Used with SENSEKEY_UNIT_ATTENTION #define NSE_AUDIO_NOT_PLAYING 0x2C // ASC, ASCQ pair #define AP_UNRECOVERED_READ_ERROR 0x11, 0x00 #define AP_LEC_UNCORRECTABLE_ERROR 0x11, 0x05 #define AP_CIRC_UNRECOVERED_ERROR 0x11, 0x06 #define AP_UNKNOWN_MEDIUM_FORMAT 0x30, 0x01 #define AP_INCOMPAT_MEDIUM_FORMAT 0x30, 0x02 static void ChangePhase(const unsigned int new_phase) { //printf("New phase: %d %lld\n", new_phase, monotonic_timestamp); switch(new_phase) { case PHASE_BUS_FREE: SetBSY(false); SetMSG(false); SetCD(false); SetIO(false); SetREQ(false); CDIRQCallback(0x8000 | PCECD_Drive_IRQ_DATA_TRANSFER_DONE); break; case PHASE_DATA_IN: // Us to them SetBSY(true); SetMSG(false); SetCD(false); SetIO(true); //SetREQ(true); SetREQ(false); break; case PHASE_STATUS: // Us to them SetBSY(true); SetMSG(false); SetCD(true); SetIO(true); SetREQ(true); break; case PHASE_MESSAGE_IN: // Us to them SetBSY(true); SetMSG(true); SetCD(true); SetIO(true); SetREQ(true); break; case PHASE_COMMAND: // Them to us SetBSY(true); SetMSG(false); SetCD(true); SetIO(false); SetREQ(true); break; } CurrentPhase = new_phase; } static void SendStatusAndMessage(uint8 status, uint8 message) { // This should never ever happen, but that doesn't mean it won't. ;) if(din.CanRead()) { printf("BUG: %d bytes still in SCSI CD FIFO\n", din.CanRead()); din.Flush(); } cd.message_pending = message; cd.status_sent = FALSE; cd.message_sent = FALSE; if(status == STATUS_GOOD) cd_bus.DB = 0x00; else cd_bus.DB = 0x01; ChangePhase(PHASE_STATUS); } static void DoSimpleDataIn(const uint8 *data_in, uint32 len) { din.Write(data_in, len); cd.data_transfer_done = true; ChangePhase(PHASE_DATA_IN); } void PCECD_Drive_SetDisc(bool tray_open, CDIF *cdif, bool no_emu_side_effects) { Cur_CDIF = cdif; // Closing the tray. if(cd.TrayOpen && !tray_open) { cd.TrayOpen = false; if(cdif) { cdif->ReadTOC(&toc); if(!no_emu_side_effects) { memset(cd.SubQBuf, 0, sizeof(cd.SubQBuf)); memset(cd.SubQBuf_Last, 0, sizeof(cd.SubQBuf_Last)); cd.DiscChanged = true; } } } else if(!cd.TrayOpen && tray_open) // Opening the tray { cd.TrayOpen = true; } } static void CommandCCError(int key, int asc = 0, int ascq = 0) { printf("CC Error: %02x %02x %02x\n", key, asc, ascq); cd.key_pending = key; cd.asc_pending = asc; cd.ascq_pending = ascq; cd.fru_pending = 0x00; SendStatusAndMessage(STATUS_CHECK_CONDITION, 0x00); } static bool ValidateRawDataSector(uint8 *data, const uint32 lba) { if(!edc_lec_check_and_correct(data, false)) { MDFN_DispMessage(_("Uncorrectable data at sector %u"), lba); MDFN_PrintError(_("Uncorrectable data at sector %u"), lba); din.Flush(); cd.data_transfer_done = false; CommandCCError(SENSEKEY_MEDIUM_ERROR, AP_LEC_UNCORRECTABLE_ERROR); return(false); } return(true); } static void DoREADBase(uint32 sa, uint32 sc) { if(sa > toc.tracks[100].lba) // Another one of those off-by-one PC-FX CD bugs. { CommandCCError(SENSEKEY_ILLEGAL_REQUEST, NSE_END_OF_VOLUME); return; } // Case for READ(10) and READ(12) where sc == 0, and sa == toc.tracks[100].lba if(!sc && sa == toc.tracks[100].lba) { CommandCCError(SENSEKEY_MEDIUM_ERROR, NSE_HEADER_READ_ERROR); return; } if(SCSILog) { int Track = toc.FindTrackByLBA(sa); uint32 Offset = sa - toc.tracks[Track].lba; //Cur_CDIF->GetTrackStartPositionLBA(Track); SCSILog("SCSI", "Read: start=0x%08x(track=%d, offs=0x%08x), cnt=0x%08x", sa, Track, Offset, sc); } SectorAddr = sa; SectorCount = sc; if(SectorCount) { Cur_CDIF->HintReadSector(sa); //, sa + sc); CDReadTimer = (uint64)3 * 2048 * System_Clock / CD_DATA_TRANSFER_RATE; } else { CDReadTimer = 0; SendStatusAndMessage(STATUS_GOOD, 0x00); } cdda.CDDAStatus = CDDASTATUS_STOPPED; } // // // static void DoTESTUNITREADY(const uint8 *cdb) { SendStatusAndMessage(STATUS_GOOD, 0x00); } static void DoREQUESTSENSE(const uint8 *cdb) { uint8 data_in[18]; MakeSense(data_in, cd.key_pending, cd.asc_pending, cd.ascq_pending, cd.fru_pending); DoSimpleDataIn(data_in, 18); cd.key_pending = 0; cd.asc_pending = 0; cd.ascq_pending = 0; cd.fru_pending = 0; } /******************************************************** * * * SCSI Command 0x08 - READ(6) * * * ********************************************************/ static void DoREAD6(const uint8 *cdb) { uint32 sa = ((cdb[1] & 0x1F) << 16) | (cdb[2] << 8) | (cdb[3] << 0); uint32 sc = cdb[4]; // TODO: confirm real PCE does this(PC-FX does at least). if(!sc) { SCSIDBG("READ(6) with count == 0.\n"); sc = 256; } DoREADBase(sa, sc); } /******************************************************** * * * PC Engine CD Command 0xD8 - SAPSP * * * ********************************************************/ static void DoNEC_PCE_SAPSP(const uint8 *cdb) { uint32 new_read_sec_start; //printf("Set audio start: %02x %02x %02x %02x %02x %02x %02x\n", cdb[9], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6]); switch (cdb[9] & 0xc0) { default: SCSIDBG("Unknown SAPSP 9: %02x\n", cdb[9]); case 0x00: new_read_sec_start = (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; break; case 0x40: new_read_sec_start = AMSF_to_LBA(BCD_to_U8(cdb[2]), BCD_to_U8(cdb[3]), BCD_to_U8(cdb[4])); break; case 0x80: { int track = BCD_to_U8(cdb[2]); if(!track) track = 1; else if(track >= toc.last_track + 1) track = 100; new_read_sec_start = toc.tracks[track].lba; } break; } //printf("%lld\n", (long long)(monotonic_timestamp - pce_lastsapsp_timestamp) * 1000 / System_Clock); if(cdda.CDDAStatus == CDDASTATUS_PLAYING && new_read_sec_start == read_sec_start && ((int64)(monotonic_timestamp - pce_lastsapsp_timestamp) * 1000 / System_Clock) < 190) { pce_lastsapsp_timestamp = monotonic_timestamp; SendStatusAndMessage(STATUS_GOOD, 0x00); CDIRQCallback(PCECD_Drive_IRQ_DATA_TRANSFER_DONE); return; } pce_lastsapsp_timestamp = monotonic_timestamp; read_sec = read_sec_start = new_read_sec_start; read_sec_end = toc.tracks[100].lba; cdda.CDDAReadPos = 588; cdda.CDDAStatus = CDDASTATUS_PAUSED; cdda.PlayMode = PLAYMODE_SILENT; if(cdb[1]) { cdda.PlayMode = PLAYMODE_NORMAL; cdda.CDDAStatus = CDDASTATUS_PLAYING; } if(read_sec < toc.tracks[100].lba) Cur_CDIF->HintReadSector(read_sec); SendStatusAndMessage(STATUS_GOOD, 0x00); CDIRQCallback(PCECD_Drive_IRQ_DATA_TRANSFER_DONE); } /******************************************************** * * * PC Engine CD Command 0xD9 - SAPEP * * * ********************************************************/ static void DoNEC_PCE_SAPEP(const uint8 *cdb) { uint32 new_read_sec_end; //printf("Set audio end: %02x %02x %02x %02x %02x %02x %02x\n", cdb[9], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6]); switch (cdb[9] & 0xc0) { default: SCSIDBG("Unknown SAPEP 9: %02x\n", cdb[9]); case 0x00: new_read_sec_end = (cdb[3] << 16) | (cdb[4] << 8) | cdb[5]; break; case 0x40: new_read_sec_end = BCD_to_U8(cdb[4]) + 75 * (BCD_to_U8(cdb[3]) + 60 * BCD_to_U8(cdb[2])); new_read_sec_end -= 150; break; case 0x80: { int track = BCD_to_U8(cdb[2]); if(!track) track = 1; else if(track >= toc.last_track + 1) track = 100; new_read_sec_end = toc.tracks[track].lba; } break; } read_sec_end = new_read_sec_end; switch(cdb[1]) // PCE CD(TODO: Confirm these, and check the mode mask): { default: case 0x03: cdda.PlayMode = PLAYMODE_NORMAL; cdda.CDDAStatus = CDDASTATUS_PLAYING; break; case 0x02: cdda.PlayMode = PLAYMODE_INTERRUPT; cdda.CDDAStatus = CDDASTATUS_PLAYING; break; case 0x01: cdda.PlayMode = PLAYMODE_LOOP; cdda.CDDAStatus = CDDASTATUS_PLAYING; break; case 0x00: cdda.PlayMode = PLAYMODE_SILENT; cdda.CDDAStatus = CDDASTATUS_STOPPED; break; } SendStatusAndMessage(STATUS_GOOD, 0x00); } /******************************************************** * * * PC Engine CD Command 0xDA - Pause * * * ********************************************************/ static void DoNEC_PCE_PAUSE(const uint8 *cdb) { if(cdda.CDDAStatus != CDDASTATUS_STOPPED) // Hmm, should we give an error if it tries to pause and it's already paused? { cdda.CDDAStatus = CDDASTATUS_PAUSED; SendStatusAndMessage(STATUS_GOOD, 0x00); } else // Definitely give an error if it tries to pause when no track is playing! { CommandCCError(SENSEKEY_ILLEGAL_REQUEST, NSE_AUDIO_NOT_PLAYING); } } /******************************************************** * * * PC Engine CD Command 0xDD - Read Subchannel Q * * * ********************************************************/ static void DoNEC_PCE_READSUBQ(const uint8 *cdb) { uint8 *SubQBuf = cd.SubQBuf[QMode_Time]; uint8 data_in[8192]; memset(data_in, 0x00, 10); data_in[2] = SubQBuf[1]; // Track data_in[3] = SubQBuf[2]; // Index data_in[4] = SubQBuf[3]; // M(rel) data_in[5] = SubQBuf[4]; // S(rel) data_in[6] = SubQBuf[5]; // F(rel) data_in[7] = SubQBuf[7]; // M(abs) data_in[8] = SubQBuf[8]; // S(abs) data_in[9] = SubQBuf[9]; // F(abs) if(cdda.CDDAStatus == CDDASTATUS_PAUSED) data_in[0] = 2; // Pause else if(cdda.CDDAStatus == CDDASTATUS_PLAYING) data_in[0] = 0; // Playing else data_in[0] = 3; // Stopped DoSimpleDataIn(data_in, 10); } /******************************************************** * * * PC Engine CD Command 0xDE - Get Directory Info * * * ********************************************************/ static void DoNEC_PCE_GETDIRINFO(const uint8 *cdb) { // Problems: // Returned data lengths on real PCE are not confirmed. // Mode 0x03 behavior not tested on real PCE uint8 data_in[2048]; uint32 data_in_size = 0; memset(data_in, 0, sizeof(data_in)); switch(cdb[1]) { default: MDFN_DispMessage("Unknown GETDIRINFO Mode: %02x", cdb[1]); printf("Unknown GETDIRINFO Mode: %02x", cdb[1]); case 0x0: data_in[0] = U8_to_BCD(toc.first_track); data_in[1] = U8_to_BCD(toc.last_track); data_in_size = 2; break; case 0x1: { uint8 m, s, f; LBA_to_AMSF(toc.tracks[100].lba, &m, &s, &f); data_in[0] = U8_to_BCD(m); data_in[1] = U8_to_BCD(s); data_in[2] = U8_to_BCD(f); data_in_size = 3; } break; case 0x2: { uint8 m, s, f; int track = BCD_to_U8(cdb[2]); if(!track) track = 1; else if(cdb[2] == 0xAA) { track = 100; } else if(track > 99) { CommandCCError(SENSEKEY_ILLEGAL_REQUEST, NSE_INVALID_PARAMETER); return; } LBA_to_AMSF(toc.tracks[track].lba, &m, &s, &f); data_in[0] = U8_to_BCD(m); data_in[1] = U8_to_BCD(s); data_in[2] = U8_to_BCD(f); data_in[3] = toc.tracks[track].control; data_in_size = 4; } break; } DoSimpleDataIn(data_in, data_in_size); } #define SCF_REQUIRES_MEDIUM 0x01 typedef struct { uint8 cmd; uint8 flags; void (*func)(const uint8 *cdb); const char *pretty_name; const char *format_string; } SCSICH; static const uint8 RequiredCDBLen[16] = { 6, // 0x0n 6, // 0x1n 10, // 0x2n 10, // 0x3n 10, // 0x4n 10, // 0x5n 10, // 0x6n 10, // 0x7n 10, // 0x8n 10, // 0x9n 12, // 0xAn 12, // 0xBn 10, // 0xCn 10, // 0xDn 10, // 0xEn 10, // 0xFn }; static SCSICH PCECommandDefs[] = { { 0x00, SCF_REQUIRES_MEDIUM, DoTESTUNITREADY, "Test Unit Ready" }, { 0x03, 0, DoREQUESTSENSE, "Request Sense" }, { 0x08, SCF_REQUIRES_MEDIUM, DoREAD6, "Read(6)" }, { 0xD8, SCF_REQUIRES_MEDIUM, DoNEC_PCE_SAPSP, "Set Audio Playback Start Position" }, { 0xD9, SCF_REQUIRES_MEDIUM, DoNEC_PCE_SAPEP, "Set Audio Playback End Position" }, { 0xDA, SCF_REQUIRES_MEDIUM, DoNEC_PCE_PAUSE, "Pause" }, { 0xDD, SCF_REQUIRES_MEDIUM, DoNEC_PCE_READSUBQ, "Read Subchannel Q" }, { 0xDE, SCF_REQUIRES_MEDIUM, DoNEC_PCE_GETDIRINFO, "Get Dir Info" }, { 0xFF, 0, 0, NULL, NULL }, }; void PCECD_Drive_ResetTS(void) { lastts = 0; } void PCECD_Drive_GetCDDAValues(int16 &left, int16 &right) { if(cdda.CDDAStatus) { left = cdda.CDDASectorBuffer[cdda.CDDAReadPos * 2]; right = cdda.CDDASectorBuffer[cdda.CDDAReadPos * 2 + 1]; } else left = right = 0; } static INLINE void RunCDDA(uint32 system_timestamp, int32 run_time) { if(cdda.CDDAStatus == CDDASTATUS_PLAYING) { int32 sample[2]; cdda.CDDADiv -= run_time << 16; while(cdda.CDDADiv <= 0) { const uint32 synthtime = ((system_timestamp + (cdda.CDDADiv >> 16))) / cdda.CDDATimeDiv; cdda.CDDADiv += cdda.CDDADivAcc; //MDFN_DispMessage("%d %d %d\n", read_sec_start, read_sec, read_sec_end); if(cdda.CDDAReadPos == 588) { if(read_sec >= read_sec_end) { switch(cdda.PlayMode) { case PLAYMODE_SILENT: case PLAYMODE_NORMAL: cdda.CDDAStatus = CDDASTATUS_STOPPED; break; case PLAYMODE_INTERRUPT: cdda.CDDAStatus = CDDASTATUS_STOPPED; CDIRQCallback(PCECD_Drive_IRQ_DATA_TRANSFER_DONE); break; case PLAYMODE_LOOP: read_sec = read_sec_start; break; } // If CDDA playback is stopped, break out of our while(CDDADiv ...) loop and don't play any more sound! if(cdda.CDDAStatus == CDDASTATUS_STOPPED) break; } // Don't play past the user area of the disc. if(read_sec >= toc.tracks[100].lba) { cdda.CDDAStatus = CDDASTATUS_STOPPED; break; } if(cd.TrayOpen) { cdda.CDDAStatus = CDDASTATUS_STOPPED; #if 0 cd.data_transfer_done = FALSE; cd.key_pending = SENSEKEY_NOT_READY; cd.asc_pending = ASC_MEDIUM_NOT_PRESENT; cd.ascq_pending = 0x00; cd.fru_pending = 0x00; SendStatusAndMessage(STATUS_CHECK_CONDITION, 0x00); #endif break; } cdda.CDDAReadPos = 0; { uint8 tmpbuf[2352 + 96]; Cur_CDIF->ReadRawSector(tmpbuf, read_sec); //, read_sec_end, read_sec_start); for(int i = 0; i < 588 * 2; i++) cdda.CDDASectorBuffer[i] = MDFN_de16lsb(&tmpbuf[i * 2]); memcpy(cd.SubPWBuf, tmpbuf + 2352, 96); } GenSubQFromSubPW(); read_sec++; } // End if(CDDAReadPos == 588) // If the last valid sub-Q data decoded indicate that the corresponding sector is a data sector, don't output the // current sector as audio. sample[0] = sample[1] = 0; if(!(cd.SubQBuf_Last[0] & 0x40) && cdda.PlayMode != PLAYMODE_SILENT) { sample[0] = (cdda.CDDASectorBuffer[cdda.CDDAReadPos * 2 + 0] * cdda.CDDAVolume) >> 16; sample[1] = (cdda.CDDASectorBuffer[cdda.CDDAReadPos * 2 + 1] * cdda.CDDAVolume) >> 16; } if(!(cdda.CDDAReadPos % 6)) { int subindex = cdda.CDDAReadPos / 6 - 2; if(subindex >= 0) CDStuffSubchannels(cd.SubPWBuf[subindex], subindex); else // The system-specific emulation code should handle what value the sync bytes are. CDStuffSubchannels(0x00, subindex); } if(sbuf[0] && sbuf[1]) { cdda.CDDASynth.offset_inline(synthtime, sample[0] - cdda.last_sample[0], sbuf[0]); cdda.CDDASynth.offset_inline(synthtime, sample[1] - cdda.last_sample[1], sbuf[1]); } cdda.last_sample[0] = sample[0]; cdda.last_sample[1] = sample[1]; cdda.CDDAReadPos++; } } } static INLINE void RunCDRead(uint32 system_timestamp, int32 run_time) { if(CDReadTimer > 0) { CDReadTimer -= run_time; if(CDReadTimer <= 0) { if(din.CanWrite() < 2048) { //printf("Carp: %d %d %d\n", din.CanWrite(), SectorCount, CDReadTimer); //CDReadTimer = (cd.data_in_size - cd.data_in_pos) * 10; CDReadTimer += (uint64) 1 * 2048 * System_Clock / CD_DATA_TRANSFER_RATE; //CDReadTimer += (uint64) 1 * 128 * System_Clock / CD_DATA_TRANSFER_RATE; } else { uint8 tmp_read_buf[2352 + 96]; if(cd.TrayOpen) { din.Flush(); cd.data_transfer_done = FALSE; CommandCCError(SENSEKEY_NOT_READY, NSE_TRAY_OPEN); } else if(SectorAddr >= toc.tracks[100].lba) { CommandCCError(SENSEKEY_ILLEGAL_REQUEST, NSE_END_OF_VOLUME); } else if(!Cur_CDIF->ReadRawSector(tmp_read_buf, SectorAddr)) //, SectorAddr + SectorCount)) { cd.data_transfer_done = FALSE; CommandCCError(SENSEKEY_ILLEGAL_REQUEST); } else if(ValidateRawDataSector(tmp_read_buf, SectorAddr)) { memcpy(cd.SubPWBuf, tmp_read_buf + 2352, 96); if(tmp_read_buf[12 + 3] == 0x2) din.Write(tmp_read_buf + 24, 2048); else din.Write(tmp_read_buf + 16, 2048); GenSubQFromSubPW(); CDIRQCallback(PCECD_Drive_IRQ_DATA_TRANSFER_READY); SectorAddr++; SectorCount--; if(CurrentPhase != PHASE_DATA_IN) ChangePhase(PHASE_DATA_IN); if(SectorCount) { cd.data_transfer_done = FALSE; CDReadTimer += (uint64) 1 * 2048 * System_Clock / CD_DATA_TRANSFER_RATE; } else { cd.data_transfer_done = TRUE; } } } // end else to if(!Cur_CDIF->ReadSector } } } uint32 PCECD_Drive_Run(pcecd_drive_timestamp_t system_timestamp) { int32 run_time = system_timestamp - lastts; if(system_timestamp < lastts) { fprintf(stderr, "Meow: %d %d\n", system_timestamp, lastts); assert(system_timestamp >= lastts); } monotonic_timestamp += run_time; lastts = system_timestamp; RunCDRead(system_timestamp, run_time); RunCDDA(system_timestamp, run_time); bool ResetNeeded = false; if(RST_signal && !cd.last_RST_signal) ResetNeeded = true; cd.last_RST_signal = RST_signal; if(ResetNeeded) { //puts("RST"); VirtualReset(); } else switch(CurrentPhase) { case PHASE_BUS_FREE: if(SEL_signal) { ChangePhase(PHASE_COMMAND); } break; case PHASE_COMMAND: if(REQ_signal && ACK_signal) // Data bus is valid nowww { //printf("Command Phase Byte I->T: %02x, %d\n", cd_bus.DB, cd.command_buffer_pos); cd.command_buffer[cd.command_buffer_pos++] = cd_bus.DB; SetREQ(FALSE); } if(!REQ_signal && !ACK_signal && cd.command_buffer_pos) // Received at least one byte, what should we do? { if(cd.command_buffer_pos == RequiredCDBLen[cd.command_buffer[0] >> 4]) { const SCSICH* cmd_info_ptr = PCECommandDefs; while(cmd_info_ptr->pretty_name && cmd_info_ptr->cmd != cd.command_buffer[0]) cmd_info_ptr++; if(SCSILog) { char log_buffer[1024]; int lb_pos; log_buffer[0] = 0; lb_pos = snprintf(log_buffer, 1024, "Command: %02x, %s ", cd.command_buffer[0], cmd_info_ptr->pretty_name ? cmd_info_ptr->pretty_name : "!!BAD COMMAND!!"); for(int i = 0; i < RequiredCDBLen[cd.command_buffer[0] >> 4]; i++) lb_pos += snprintf(log_buffer + lb_pos, 1024 - lb_pos, "%02x ", cd.command_buffer[i]); SCSILog("SCSI", "%s", log_buffer); //puts(log_buffer); } if(cmd_info_ptr->pretty_name == NULL) // Command not found! { CommandCCError(SENSEKEY_ILLEGAL_REQUEST, NSE_INVALID_COMMAND); SCSIDBG("Bad Command: %02x\n", cd.command_buffer[0]); if(SCSILog) SCSILog("SCSI", "Bad Command: %02x", cd.command_buffer[0]); cd.command_buffer_pos = 0; } else { if(cd.TrayOpen && (cmd_info_ptr->flags & SCF_REQUIRES_MEDIUM)) { CommandCCError(SENSEKEY_NOT_READY, NSE_TRAY_OPEN); } else if(!Cur_CDIF && (cmd_info_ptr->flags & SCF_REQUIRES_MEDIUM)) { CommandCCError(SENSEKEY_NOT_READY, NSE_NO_DISC); } else if(cd.DiscChanged && (cmd_info_ptr->flags & SCF_REQUIRES_MEDIUM)) { CommandCCError(SENSEKEY_UNIT_ATTENTION, NSE_DISC_CHANGED); cd.DiscChanged = false; } else { cmd_info_ptr->func(cd.command_buffer); } cd.command_buffer_pos = 0; } } // end if(cd.command_buffer_pos == RequiredCDBLen[cd.command_buffer[0] >> 4]) else // Otherwise, get more data for the command! SetREQ(TRUE); } break; case PHASE_STATUS: if(REQ_signal && ACK_signal) { SetREQ(FALSE); cd.status_sent = TRUE; } if(!REQ_signal && !ACK_signal && cd.status_sent) { // Status sent, so get ready to send the message! cd.status_sent = FALSE; cd_bus.DB = cd.message_pending; ChangePhase(PHASE_MESSAGE_IN); } break; case PHASE_DATA_IN: if(!REQ_signal && !ACK_signal) { //puts("REQ and ACK false"); if(din.CanRead() == 0) // aaand we're done! { CDIRQCallback(0x8000 | PCECD_Drive_IRQ_DATA_TRANSFER_READY); if(cd.data_transfer_done) { SendStatusAndMessage(STATUS_GOOD, 0x00); cd.data_transfer_done = FALSE; CDIRQCallback(PCECD_Drive_IRQ_DATA_TRANSFER_DONE); } } else { cd_bus.DB = din.ReadByte(); SetREQ(TRUE); } } if(REQ_signal && ACK_signal) { //puts("REQ and ACK true"); SetREQ(FALSE); } break; case PHASE_MESSAGE_IN: if(REQ_signal && ACK_signal) { SetREQ(FALSE); cd.message_sent = TRUE; } if(!REQ_signal && !ACK_signal && cd.message_sent) { cd.message_sent = FALSE; ChangePhase(PHASE_BUS_FREE); } break; } int32 next_time = 0x7fffffff; if(CDReadTimer > 0 && CDReadTimer < next_time) next_time = CDReadTimer; if(cdda.CDDAStatus == CDDASTATUS_PLAYING) { int32 cdda_div_sexytime = (cdda.CDDADiv + 0xFFFF) >> 16; if(cdda_div_sexytime > 0 && cdda_div_sexytime < next_time) next_time = cdda_div_sexytime; } assert(next_time >= 0); return(next_time); } void PCECD_Drive_SetLog(void (*logfunc)(const char *, const char *, ...)) { SCSILog = logfunc; } void PCECD_Drive_SetTransferRate(uint32 TransferRate) { CD_DATA_TRANSFER_RATE = TransferRate; } void PCECD_Drive_Close(void) { } void PCECD_Drive_Init(int cdda_time_div, Blip_Buffer *leftbuf, Blip_Buffer *rightbuf, uint32 TransferRate, uint32 SystemClock, void (*IRQFunc)(int), void (*SSCFunc)(uint8, int)) { Cur_CDIF = NULL; cd.TrayOpen = false; monotonic_timestamp = 0; lastts = 0; SCSILog = NULL; //din = new SimpleFIFO(2048); cdda.CDDATimeDiv = cdda_time_div; cdda.CDDAVolume = 65536; cdda.CDDASynth.volume(1.0f / 65536); cdda.CDDASynth.treble_eq(0); sbuf[0] = leftbuf; sbuf[1] = rightbuf; CD_DATA_TRANSFER_RATE = TransferRate; System_Clock = SystemClock; CDIRQCallback = IRQFunc; CDStuffSubchannels = SSCFunc; } void PCECD_Drive_SetCDDAVolume(unsigned vol) { cdda.CDDAVolume = vol; } int PCECD_Drive_StateAction(StateMem * sm, int load, int data_only, const char *sname) { SFORMAT StateRegs[] = { SFVARN(cd_bus.DB, "DB"), SFVARN(cd_bus.signals, "Signals"), SFVAR(CurrentPhase), SFVARN(cd.last_RST_signal, "last_RST"), SFVARN(cd.message_pending, "message_pending"), SFVARN(cd.status_sent, "status_sent"), SFVARN(cd.message_sent, "message_sent"), SFVARN(cd.key_pending, "key_pending"), SFVARN(cd.asc_pending, "asc_pending"), SFVARN(cd.ascq_pending, "ascq_pending"), SFVARN(cd.fru_pending, "fru_pending"), SFARRAYN(cd.command_buffer, 256, "command_buffer"), SFVARN(cd.command_buffer_pos, "command_buffer_pos"), SFVARN(cd.command_size_left, "command_size_left"), // Don't save the FIFO's write position, it will be reconstructed from read_pos and in_count SFARRAYN(&din.data[0], din.data.size(), "din_fifo"), SFVARN(din.read_pos, "din_read_pos"), SFVARN(din.in_count, "din_in_count"), SFVARN(cd.data_transfer_done, "data_transfer_done"), SFVARN(cd.TrayOpen, "TrayOpen"), SFVARN(cd.DiscChanged, "DiscChanged"), SFVAR(cdda.PlayMode), SFARRAY16(cdda.CDDASectorBuffer, 1176), SFVAR(cdda.CDDAReadPos), SFVAR(cdda.CDDAStatus), SFVAR(cdda.CDDADiv), SFVAR(read_sec_start), SFVAR(read_sec), SFVAR(read_sec_end), SFVAR(CDReadTimer), SFVAR(SectorAddr), SFVAR(SectorCount), SFVAR(cdda.ScanMode), SFVAR(cdda.scan_sec_end), SFARRAYN(&cd.SubQBuf[0][0], sizeof(cd.SubQBuf), "SubQBufs"), SFARRAYN(cd.SubQBuf_Last, sizeof(cd.SubQBuf_Last), "SubQBufLast"), SFARRAYN(cd.SubPWBuf, sizeof(cd.SubPWBuf), "SubPWBuf"), SFVAR(monotonic_timestamp), SFVAR(pce_lastsapsp_timestamp), SFEND }; int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, sname); if(load) { din.in_count &= din.size - 1; din.read_pos &= din.size - 1; din.write_pos = (din.read_pos + din.in_count) & (din.size - 1); if(cdda.CDDADiv <= 0) cdda.CDDADiv = 1; //printf("%d %d %d\n", din.in_count, din.read_pos, din.write_pos); } return (ret); } mednafen/pce_fast/pcecd.h000664 001750 001750 00000001532 12726204343 016476 0ustar00sergiosergio000000 000000 #ifndef __PCE_CDROM_H #define __PCE_CDROM_H #include "../include/blip/Blip_Buffer.h" typedef struct { float CDDA_Volume; // Max 2.000... float ADPCM_Volume; // Max 2.000... unsigned int CD_Speed; bool ADPCM_LPF; } PCECD_Settings; void PCECD_Run(uint32 in_timestamp); void PCECD_ResetTS(void); bool PCECD_Init(const PCECD_Settings *settings, void (*irqcb)(bool), double master_clock, unsigned int ocm, Blip_Buffer *soundbuf_l, Blip_Buffer *soundbuf_r) MDFN_COLD; bool PCECD_SetSettings(const PCECD_Settings *settings) MDFN_COLD; void PCECD_Close(void) MDFN_COLD; void PCECD_Power(uint32 timestamp) MDFN_COLD; uint8 PCECD_Read(uint32 timestamp, uint32); void PCECD_Write(uint32 timestamp, uint32, uint8 data); bool PCECD_IsBRAMEnabled(void); int PCECD_StateAction(StateMem *sm, int load, int data_only); #endif mednafen/cdrom/000700 001750 001750 00000000000 12727366154 014564 5ustar00sergiosergio000000 000000 mednafen/tremor/window_lookup.h000664 001750 001750 00000371447 12726204343 020063 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: window lookup tables ********************************************************************/ #include "os_types.h" static const LOOKUP_T vwin64[32] = { X(0x001f0003), X(0x01168c98), X(0x030333c8), X(0x05dfe3a4), X(0x09a49562), X(0x0e45df18), X(0x13b47ef2), X(0x19dcf676), X(0x20a74d83), X(0x27f7137c), X(0x2fabb05a), X(0x37a1105a), X(0x3fb0ab28), X(0x47b2dcd1), X(0x4f807bc6), X(0x56f48e70), X(0x5dedfc79), X(0x64511653), X(0x6a08cfff), X(0x6f079328), X(0x734796f4), X(0x76cab7f2), X(0x7999d6e8), X(0x7bc3cf9f), X(0x7d5c20c1), X(0x7e7961df), X(0x7f33a567), X(0x7fa2e1d0), X(0x7fdd78a5), X(0x7ff6ec6d), X(0x7ffed0e9), X(0x7ffffc3f), }; static const LOOKUP_T vwin128[64] = { X(0x0007c04d), X(0x0045bb89), X(0x00c18b87), X(0x017ae294), X(0x02714a4e), X(0x03a4217a), X(0x05129952), X(0x06bbb24f), X(0x089e38a1), X(0x0ab8c073), X(0x0d09a228), X(0x0f8ef6bd), X(0x12469488), X(0x152e0c7a), X(0x1842a81c), X(0x1b81686d), X(0x1ee705d9), X(0x226ff15d), X(0x26185705), X(0x29dc21cc), X(0x2db700fe), X(0x31a46f08), X(0x359fb9c1), X(0x39a40c0c), X(0x3dac78b6), X(0x41b40674), X(0x45b5bcb0), X(0x49acb109), X(0x4d94152b), X(0x516744bd), X(0x5521d320), X(0x58bf98a5), X(0x5c3cbef4), X(0x5f95cc5d), X(0x62c7add7), X(0x65cfbf64), X(0x68abd2ba), X(0x6b5a3405), X(0x6dd9acab), X(0x7029840d), X(0x72497e38), X(0x7439d8ac), X(0x75fb4532), X(0x778ee30a), X(0x78f6367e), X(0x7a331f1a), X(0x7b47cccd), X(0x7c36b416), X(0x7d028192), X(0x7dae0d18), X(0x7e3c4caa), X(0x7eb04763), X(0x7f0d08a7), X(0x7f5593b7), X(0x7f8cd7d5), X(0x7fb5a513), X(0x7fd2a1fc), X(0x7fe64212), X(0x7ff2bd4c), X(0x7ffa0890), X(0x7ffdcf39), X(0x7fff6dac), X(0x7fffed01), X(0x7fffffc4), }; static const LOOKUP_T vwin256[128] = { X(0x0001f018), X(0x00117066), X(0x00306e9e), X(0x005ee5f1), X(0x009ccf26), X(0x00ea208b), X(0x0146cdea), X(0x01b2c87f), X(0x022dfedf), X(0x02b85ced), X(0x0351cbbd), X(0x03fa317f), X(0x04b17167), X(0x05776b90), X(0x064bfcdc), X(0x072efedd), X(0x082047b4), X(0x091fa9f1), X(0x0a2cf477), X(0x0b47f25d), X(0x0c706ad2), X(0x0da620ff), X(0x0ee8d3ef), X(0x10383e75), X(0x11941716), X(0x12fc0ff6), X(0x146fd6c8), X(0x15ef14c2), X(0x17796e8e), X(0x190e844f), X(0x1aadf196), X(0x1c574d6e), X(0x1e0a2a62), X(0x1fc61688), X(0x218a9b9c), X(0x23573f12), X(0x252b823d), X(0x2706e269), X(0x28e8d913), X(0x2ad0dc0e), X(0x2cbe5dc1), X(0x2eb0cd60), X(0x30a79733), X(0x32a224d5), X(0x349fdd8b), X(0x36a02690), X(0x38a2636f), X(0x3aa5f65e), X(0x3caa409e), X(0x3eaea2df), X(0x40b27da6), X(0x42b531b8), X(0x44b62086), X(0x46b4ac99), X(0x48b03a05), X(0x4aa82ed5), X(0x4c9bf37d), X(0x4e8af349), X(0x50749ccb), X(0x52586246), X(0x5435ba1c), X(0x560c1f31), X(0x57db1152), X(0x59a21591), X(0x5b60b6a3), X(0x5d168535), X(0x5ec31839), X(0x60660d36), X(0x61ff0886), X(0x638db595), X(0x6511c717), X(0x668af734), X(0x67f907b0), X(0x695bc207), X(0x6ab2f787), X(0x6bfe815a), X(0x6d3e4090), X(0x6e721e16), X(0x6f9a0ab5), X(0x70b5fef8), X(0x71c5fb16), X(0x72ca06cd), X(0x73c2313d), X(0x74ae90b2), X(0x758f4275), X(0x76646a85), X(0x772e335c), X(0x77eccda0), X(0x78a06fd7), X(0x79495613), X(0x79e7c19c), X(0x7a7bf894), X(0x7b064596), X(0x7b86f757), X(0x7bfe6044), X(0x7c6cd615), X(0x7cd2b16e), X(0x7d304d71), X(0x7d860756), X(0x7dd43e06), X(0x7e1b51ad), X(0x7e5ba355), X(0x7e95947e), X(0x7ec986bb), X(0x7ef7db4a), X(0x7f20f2b9), X(0x7f452c7f), X(0x7f64e6a7), X(0x7f807d71), X(0x7f984aff), X(0x7faca700), X(0x7fbde662), X(0x7fcc5b04), X(0x7fd85372), X(0x7fe21a99), X(0x7fe9f791), X(0x7ff02d58), X(0x7ff4fa9e), X(0x7ff89990), X(0x7ffb3faa), X(0x7ffd1d8b), X(0x7ffe5ecc), X(0x7fff29e0), X(0x7fff9ff3), X(0x7fffdcd2), X(0x7ffff6d6), X(0x7ffffed0), X(0x7ffffffc), }; static const LOOKUP_T vwin512[256] = { X(0x00007c06), X(0x00045c32), X(0x000c1c62), X(0x0017bc4c), X(0x00273b7a), X(0x003a9955), X(0x0051d51c), X(0x006cede7), X(0x008be2a9), X(0x00aeb22a), X(0x00d55b0d), X(0x00ffdbcc), X(0x012e32b6), X(0x01605df5), X(0x01965b85), X(0x01d02939), X(0x020dc4ba), X(0x024f2b83), X(0x02945ae6), X(0x02dd5004), X(0x032a07d3), X(0x037a7f19), X(0x03ceb26e), X(0x04269e37), X(0x04823eab), X(0x04e18fcc), X(0x05448d6d), X(0x05ab3329), X(0x06157c68), X(0x0683645e), X(0x06f4e607), X(0x0769fc25), X(0x07e2a146), X(0x085ecfbc), X(0x08de819f), X(0x0961b0cc), X(0x09e856e3), X(0x0a726d46), X(0x0affed1d), X(0x0b90cf4c), X(0x0c250c79), X(0x0cbc9d0b), X(0x0d577926), X(0x0df598aa), X(0x0e96f337), X(0x0f3b8026), X(0x0fe3368f), X(0x108e0d42), X(0x113bfaca), X(0x11ecf56b), X(0x12a0f324), X(0x1357e9ac), X(0x1411ce70), X(0x14ce9698), X(0x158e3702), X(0x1650a444), X(0x1715d2aa), X(0x17ddb638), X(0x18a842aa), X(0x19756b72), X(0x1a4523b9), X(0x1b175e62), X(0x1bec0e04), X(0x1cc324f0), X(0x1d9c9532), X(0x1e78508a), X(0x1f564876), X(0x20366e2e), X(0x2118b2a2), X(0x21fd0681), X(0x22e35a37), X(0x23cb9dee), X(0x24b5c18e), X(0x25a1b4c0), X(0x268f66f1), X(0x277ec74e), X(0x286fc4cc), X(0x29624e23), X(0x2a5651d7), X(0x2b4bbe34), X(0x2c428150), X(0x2d3a8913), X(0x2e33c332), X(0x2f2e1d35), X(0x30298478), X(0x3125e62d), X(0x32232f61), X(0x33214cfc), X(0x34202bc2), X(0x351fb85a), X(0x361fdf4f), X(0x37208d10), X(0x3821adf7), X(0x39232e49), X(0x3a24fa3c), X(0x3b26fdf6), X(0x3c292593), X(0x3d2b5d29), X(0x3e2d90c8), X(0x3f2fac7f), X(0x40319c5f), X(0x41334c81), X(0x4234a905), X(0x43359e16), X(0x443617f3), X(0x453602eb), X(0x46354b65), X(0x4733dde1), X(0x4831a6ff), X(0x492e937f), X(0x4a2a9045), X(0x4b258a5f), X(0x4c1f6f06), X(0x4d182ba2), X(0x4e0fadce), X(0x4f05e35b), X(0x4ffaba53), X(0x50ee20fd), X(0x51e005e1), X(0x52d057ca), X(0x53bf05ca), X(0x54abff3b), X(0x559733c7), X(0x56809365), X(0x57680e62), X(0x584d955d), X(0x59311952), X(0x5a128b96), X(0x5af1dddd), X(0x5bcf023a), X(0x5ca9eb27), X(0x5d828b81), X(0x5e58d68d), X(0x5f2cbffc), X(0x5ffe3be9), X(0x60cd3edf), X(0x6199bdda), X(0x6263ae45), X(0x632b0602), X(0x63efbb66), X(0x64b1c53f), X(0x65711ad0), X(0x662db3d7), X(0x66e7888d), X(0x679e91a5), X(0x6852c84e), X(0x69042635), X(0x69b2a582), X(0x6a5e40dd), X(0x6b06f36c), X(0x6bacb8d2), X(0x6c4f8d30), X(0x6cef6d26), X(0x6d8c55d4), X(0x6e2644d4), X(0x6ebd3840), X(0x6f512ead), X(0x6fe2272e), X(0x7070214f), X(0x70fb1d17), X(0x71831b06), X(0x72081c16), X(0x728a21b5), X(0x73092dc8), X(0x738542a6), X(0x73fe631b), X(0x74749261), X(0x74e7d421), X(0x75582c72), X(0x75c59fd5), X(0x76303333), X(0x7697ebdd), X(0x76fccf85), X(0x775ee443), X(0x77be308a), X(0x781abb2e), X(0x78748b59), X(0x78cba88e), X(0x79201aa7), X(0x7971e9cd), X(0x79c11e79), X(0x7a0dc170), X(0x7a57dbc2), X(0x7a9f76c1), X(0x7ae49c07), X(0x7b27556b), X(0x7b67ad02), X(0x7ba5ad1b), X(0x7be1603a), X(0x7c1ad118), X(0x7c520a9e), X(0x7c8717e1), X(0x7cba0421), X(0x7ceadac3), X(0x7d19a74f), X(0x7d46756e), X(0x7d7150e5), X(0x7d9a4592), X(0x7dc15f69), X(0x7de6aa71), X(0x7e0a32c0), X(0x7e2c0479), X(0x7e4c2bc7), X(0x7e6ab4db), X(0x7e87abe9), X(0x7ea31d24), X(0x7ebd14be), X(0x7ed59edd), X(0x7eecc7a3), X(0x7f029b21), X(0x7f17255a), X(0x7f2a723f), X(0x7f3c8daa), X(0x7f4d835d), X(0x7f5d5f00), X(0x7f6c2c1b), X(0x7f79f617), X(0x7f86c83a), X(0x7f92ada2), X(0x7f9db146), X(0x7fa7ddf3), X(0x7fb13e46), X(0x7fb9dcb0), X(0x7fc1c36c), X(0x7fc8fc83), X(0x7fcf91c7), X(0x7fd58cd2), X(0x7fdaf702), X(0x7fdfd979), X(0x7fe43d1c), X(0x7fe82a8b), X(0x7febaa29), X(0x7feec412), X(0x7ff1801c), X(0x7ff3e5d6), X(0x7ff5fc86), X(0x7ff7cb29), X(0x7ff9586f), X(0x7ffaaaba), X(0x7ffbc81e), X(0x7ffcb660), X(0x7ffd7af3), X(0x7ffe1afa), X(0x7ffe9b42), X(0x7fff0047), X(0x7fff4e2f), X(0x7fff88c9), X(0x7fffb390), X(0x7fffd1a6), X(0x7fffe5d7), X(0x7ffff296), X(0x7ffff9fd), X(0x7ffffdcd), X(0x7fffff6d), X(0x7fffffed), X(0x7fffffff), }; static const LOOKUP_T vwin1024[512] = { X(0x00001f02), X(0x0001170e), X(0x00030724), X(0x0005ef40), X(0x0009cf59), X(0x000ea767), X(0x0014775e), X(0x001b3f2e), X(0x0022fec8), X(0x002bb618), X(0x00356508), X(0x00400b81), X(0x004ba968), X(0x00583ea0), X(0x0065cb0a), X(0x00744e84), X(0x0083c8ea), X(0x00943a14), X(0x00a5a1da), X(0x00b80010), X(0x00cb5488), X(0x00df9f10), X(0x00f4df76), X(0x010b1584), X(0x01224101), X(0x013a61b2), X(0x01537759), X(0x016d81b6), X(0x01888087), X(0x01a47385), X(0x01c15a69), X(0x01df34e6), X(0x01fe02b1), X(0x021dc377), X(0x023e76e7), X(0x02601ca9), X(0x0282b466), X(0x02a63dc1), X(0x02cab85d), X(0x02f023d6), X(0x03167fcb), X(0x033dcbd3), X(0x03660783), X(0x038f3270), X(0x03b94c29), X(0x03e4543a), X(0x04104a2e), X(0x043d2d8b), X(0x046afdd5), X(0x0499ba8c), X(0x04c9632d), X(0x04f9f734), X(0x052b7615), X(0x055ddf46), X(0x05913237), X(0x05c56e53), X(0x05fa9306), X(0x06309fb6), X(0x066793c5), X(0x069f6e93), X(0x06d82f7c), X(0x0711d5d9), X(0x074c60fe), X(0x0787d03d), X(0x07c422e4), X(0x0801583e), X(0x083f6f91), X(0x087e681f), X(0x08be4129), X(0x08fef9ea), X(0x0940919a), X(0x0983076d), X(0x09c65a92), X(0x0a0a8a38), X(0x0a4f9585), X(0x0a957b9f), X(0x0adc3ba7), X(0x0b23d4b9), X(0x0b6c45ee), X(0x0bb58e5a), X(0x0bffad0f), X(0x0c4aa11a), X(0x0c966982), X(0x0ce3054d), X(0x0d30737b), X(0x0d7eb308), X(0x0dcdc2eb), X(0x0e1da21a), X(0x0e6e4f83), X(0x0ebfca11), X(0x0f1210ad), X(0x0f652238), X(0x0fb8fd91), X(0x100da192), X(0x10630d11), X(0x10b93ee0), X(0x111035cb), X(0x1167f09a), X(0x11c06e13), X(0x1219acf5), X(0x1273abfb), X(0x12ce69db), X(0x1329e54a), X(0x13861cf3), X(0x13e30f80), X(0x1440bb97), X(0x149f1fd8), X(0x14fe3ade), X(0x155e0b40), X(0x15be8f92), X(0x161fc662), X(0x1681ae38), X(0x16e4459b), X(0x17478b0b), X(0x17ab7d03), X(0x181019fb), X(0x18756067), X(0x18db4eb3), X(0x1941e34a), X(0x19a91c92), X(0x1a10f8ea), X(0x1a7976af), X(0x1ae29439), X(0x1b4c4fda), X(0x1bb6a7e2), X(0x1c219a9a), X(0x1c8d2649), X(0x1cf9492e), X(0x1d660188), X(0x1dd34d8e), X(0x1e412b74), X(0x1eaf996a), X(0x1f1e959b), X(0x1f8e1e2f), X(0x1ffe3146), X(0x206ecd01), X(0x20dfef78), X(0x215196c2), X(0x21c3c0f0), X(0x22366c10), X(0x22a9962a), X(0x231d3d45), X(0x23915f60), X(0x2405fa7a), X(0x247b0c8c), X(0x24f09389), X(0x25668d65), X(0x25dcf80c), X(0x2653d167), X(0x26cb175e), X(0x2742c7d0), X(0x27bae09e), X(0x28335fa2), X(0x28ac42b3), X(0x292587a5), X(0x299f2c48), X(0x2a192e69), X(0x2a938bd1), X(0x2b0e4247), X(0x2b894f8d), X(0x2c04b164), X(0x2c806588), X(0x2cfc69b2), X(0x2d78bb9a), X(0x2df558f4), X(0x2e723f6f), X(0x2eef6cbb), X(0x2f6cde83), X(0x2fea9270), X(0x30688627), X(0x30e6b74e), X(0x31652385), X(0x31e3c86b), X(0x3262a39e), X(0x32e1b2b8), X(0x3360f352), X(0x33e06303), X(0x345fff5e), X(0x34dfc5f8), X(0x355fb462), X(0x35dfc82a), X(0x365ffee0), X(0x36e0560f), X(0x3760cb43), X(0x37e15c05), X(0x386205df), X(0x38e2c657), X(0x39639af5), X(0x39e4813e), X(0x3a6576b6), X(0x3ae678e3), X(0x3b678547), X(0x3be89965), X(0x3c69b2c1), X(0x3ceacedc), X(0x3d6beb37), X(0x3ded0557), X(0x3e6e1abb), X(0x3eef28e6), X(0x3f702d5a), X(0x3ff1259a), X(0x40720f29), X(0x40f2e789), X(0x4173ac3f), X(0x41f45ad0), X(0x4274f0c2), X(0x42f56b9a), X(0x4375c8e0), X(0x43f6061d), X(0x447620db), X(0x44f616a5), X(0x4575e509), X(0x45f58994), X(0x467501d6), X(0x46f44b62), X(0x477363cb), X(0x47f248a6), X(0x4870f78e), X(0x48ef6e1a), X(0x496da9e8), X(0x49eba897), X(0x4a6967c8), X(0x4ae6e521), X(0x4b641e47), X(0x4be110e5), X(0x4c5dbaa7), X(0x4cda193f), X(0x4d562a5f), X(0x4dd1ebbd), X(0x4e4d5b15), X(0x4ec87623), X(0x4f433aa9), X(0x4fbda66c), X(0x5037b734), X(0x50b16acf), X(0x512abf0e), X(0x51a3b1c5), X(0x521c40ce), X(0x52946a06), X(0x530c2b50), X(0x53838292), X(0x53fa6db8), X(0x5470eab3), X(0x54e6f776), X(0x555c91fc), X(0x55d1b844), X(0x56466851), X(0x56baa02f), X(0x572e5deb), X(0x57a19f98), X(0x58146352), X(0x5886a737), X(0x58f8696d), X(0x5969a81c), X(0x59da6177), X(0x5a4a93b4), X(0x5aba3d0f), X(0x5b295bcb), X(0x5b97ee30), X(0x5c05f28d), X(0x5c736738), X(0x5ce04a8d), X(0x5d4c9aed), X(0x5db856c1), X(0x5e237c78), X(0x5e8e0a89), X(0x5ef7ff6f), X(0x5f6159b0), X(0x5fca17d4), X(0x6032386e), X(0x6099ba15), X(0x61009b69), X(0x6166db11), X(0x61cc77b9), X(0x62317017), X(0x6295c2e7), X(0x62f96eec), X(0x635c72f1), X(0x63becdc8), X(0x64207e4b), X(0x6481835a), X(0x64e1dbde), X(0x654186c8), X(0x65a0830e), X(0x65fecfb1), X(0x665c6bb7), X(0x66b95630), X(0x67158e30), X(0x677112d7), X(0x67cbe34b), X(0x6825feb9), X(0x687f6456), X(0x68d81361), X(0x69300b1e), X(0x69874ada), X(0x69ddd1ea), X(0x6a339fab), X(0x6a88b382), X(0x6add0cdb), X(0x6b30ab2a), X(0x6b838dec), X(0x6bd5b4a6), X(0x6c271ee2), X(0x6c77cc36), X(0x6cc7bc3d), X(0x6d16ee9b), X(0x6d6562fb), X(0x6db31911), X(0x6e001099), X(0x6e4c4955), X(0x6e97c311), X(0x6ee27d9f), X(0x6f2c78d9), X(0x6f75b4a2), X(0x6fbe30e4), X(0x7005ed91), X(0x704ceaa1), X(0x70932816), X(0x70d8a5f8), X(0x711d6457), X(0x7161634b), X(0x71a4a2f3), X(0x71e72375), X(0x7228e500), X(0x7269e7c8), X(0x72aa2c0a), X(0x72e9b209), X(0x73287a12), X(0x73668476), X(0x73a3d18f), X(0x73e061bc), X(0x741c3566), X(0x74574cfa), X(0x7491a8ee), X(0x74cb49be), X(0x75042fec), X(0x753c5c03), X(0x7573ce92), X(0x75aa882f), X(0x75e08979), X(0x7615d313), X(0x764a65a7), X(0x767e41e5), X(0x76b16884), X(0x76e3da40), X(0x771597dc), X(0x7746a221), X(0x7776f9dd), X(0x77a69fe6), X(0x77d59514), X(0x7803da49), X(0x7831706a), X(0x785e5861), X(0x788a9320), X(0x78b6219c), X(0x78e104cf), X(0x790b3dbb), X(0x7934cd64), X(0x795db4d5), X(0x7985f51d), X(0x79ad8f50), X(0x79d48486), X(0x79fad5de), X(0x7a208478), X(0x7a45917b), X(0x7a69fe12), X(0x7a8dcb6c), X(0x7ab0fabb), X(0x7ad38d36), X(0x7af5841a), X(0x7b16e0a3), X(0x7b37a416), X(0x7b57cfb8), X(0x7b7764d4), X(0x7b9664b6), X(0x7bb4d0b0), X(0x7bd2aa14), X(0x7beff23b), X(0x7c0caa7f), X(0x7c28d43c), X(0x7c4470d2), X(0x7c5f81a5), X(0x7c7a081a), X(0x7c940598), X(0x7cad7b8b), X(0x7cc66b5e), X(0x7cded680), X(0x7cf6be64), X(0x7d0e247b), X(0x7d250a3c), X(0x7d3b711c), X(0x7d515a95), X(0x7d66c822), X(0x7d7bbb3c), X(0x7d903563), X(0x7da43814), X(0x7db7c4d0), X(0x7dcadd16), X(0x7ddd826a), X(0x7defb64d), X(0x7e017a44), X(0x7e12cfd3), X(0x7e23b87f), X(0x7e3435cc), X(0x7e444943), X(0x7e53f467), X(0x7e6338c0), X(0x7e7217d5), X(0x7e80932b), X(0x7e8eac49), X(0x7e9c64b7), X(0x7ea9bdf8), X(0x7eb6b994), X(0x7ec35910), X(0x7ecf9def), X(0x7edb89b6), X(0x7ee71de9), X(0x7ef25c09), X(0x7efd4598), X(0x7f07dc16), X(0x7f122103), X(0x7f1c15dc), X(0x7f25bc1f), X(0x7f2f1547), X(0x7f3822cd), X(0x7f40e62b), X(0x7f4960d6), X(0x7f519443), X(0x7f5981e7), X(0x7f612b31), X(0x7f689191), X(0x7f6fb674), X(0x7f769b45), X(0x7f7d416c), X(0x7f83aa51), X(0x7f89d757), X(0x7f8fc9df), X(0x7f958348), X(0x7f9b04ef), X(0x7fa0502e), X(0x7fa56659), X(0x7faa48c7), X(0x7faef8c7), X(0x7fb377a7), X(0x7fb7c6b3), X(0x7fbbe732), X(0x7fbfda67), X(0x7fc3a196), X(0x7fc73dfa), X(0x7fcab0ce), X(0x7fcdfb4a), X(0x7fd11ea0), X(0x7fd41c00), X(0x7fd6f496), X(0x7fd9a989), X(0x7fdc3bff), X(0x7fdead17), X(0x7fe0fdee), X(0x7fe32f9d), X(0x7fe54337), X(0x7fe739ce), X(0x7fe9146c), X(0x7fead41b), X(0x7fec79dd), X(0x7fee06b2), X(0x7fef7b94), X(0x7ff0d97b), X(0x7ff22158), X(0x7ff35417), X(0x7ff472a3), X(0x7ff57de0), X(0x7ff676ac), X(0x7ff75de3), X(0x7ff8345a), X(0x7ff8fae4), X(0x7ff9b24b), X(0x7ffa5b58), X(0x7ffaf6cd), X(0x7ffb8568), X(0x7ffc07e2), X(0x7ffc7eed), X(0x7ffceb38), X(0x7ffd4d6d), X(0x7ffda631), X(0x7ffdf621), X(0x7ffe3dd8), X(0x7ffe7dea), X(0x7ffeb6e7), X(0x7ffee959), X(0x7fff15c4), X(0x7fff3ca9), X(0x7fff5e80), X(0x7fff7bc0), X(0x7fff94d6), X(0x7fffaa2d), X(0x7fffbc29), X(0x7fffcb29), X(0x7fffd786), X(0x7fffe195), X(0x7fffe9a3), X(0x7fffeffa), X(0x7ffff4dd), X(0x7ffff889), X(0x7ffffb37), X(0x7ffffd1a), X(0x7ffffe5d), X(0x7fffff29), X(0x7fffffa0), X(0x7fffffdd), X(0x7ffffff7), X(0x7fffffff), X(0x7fffffff), }; static const LOOKUP_T vwin2048[1024] = { X(0x000007c0), X(0x000045c4), X(0x0000c1ca), X(0x00017bd3), X(0x000273de), X(0x0003a9eb), X(0x00051df9), X(0x0006d007), X(0x0008c014), X(0x000aee1e), X(0x000d5a25), X(0x00100428), X(0x0012ec23), X(0x00161216), X(0x001975fe), X(0x001d17da), X(0x0020f7a8), X(0x00251564), X(0x0029710c), X(0x002e0a9e), X(0x0032e217), X(0x0037f773), X(0x003d4ab0), X(0x0042dbca), X(0x0048aabe), X(0x004eb788), X(0x00550224), X(0x005b8a8f), X(0x006250c5), X(0x006954c1), X(0x0070967e), X(0x007815f9), X(0x007fd32c), X(0x0087ce13), X(0x009006a9), X(0x00987ce9), X(0x00a130cc), X(0x00aa224f), X(0x00b3516b), X(0x00bcbe1a), X(0x00c66856), X(0x00d0501a), X(0x00da755f), X(0x00e4d81f), X(0x00ef7853), X(0x00fa55f4), X(0x010570fc), X(0x0110c963), X(0x011c5f22), X(0x01283232), X(0x0134428c), X(0x01409027), X(0x014d1afb), X(0x0159e302), X(0x0166e831), X(0x01742a82), X(0x0181a9ec), X(0x018f6665), X(0x019d5fe5), X(0x01ab9663), X(0x01ba09d6), X(0x01c8ba34), X(0x01d7a775), X(0x01e6d18d), X(0x01f63873), X(0x0205dc1e), X(0x0215bc82), X(0x0225d997), X(0x02363350), X(0x0246c9a3), X(0x02579c86), X(0x0268abed), X(0x0279f7cc), X(0x028b801a), X(0x029d44c9), X(0x02af45ce), X(0x02c1831d), X(0x02d3fcaa), X(0x02e6b269), X(0x02f9a44c), X(0x030cd248), X(0x03203c4f), X(0x0333e255), X(0x0347c44b), X(0x035be225), X(0x03703bd5), X(0x0384d14d), X(0x0399a280), X(0x03aeaf5e), X(0x03c3f7d9), X(0x03d97be4), X(0x03ef3b6e), X(0x0405366a), X(0x041b6cc8), X(0x0431de78), X(0x04488b6c), X(0x045f7393), X(0x047696dd), X(0x048df53b), X(0x04a58e9b), X(0x04bd62ee), X(0x04d57223), X(0x04edbc28), X(0x050640ed), X(0x051f0060), X(0x0537fa70), X(0x05512f0a), X(0x056a9e1e), X(0x05844798), X(0x059e2b67), X(0x05b84978), X(0x05d2a1b8), X(0x05ed3414), X(0x06080079), X(0x062306d3), X(0x063e470f), X(0x0659c119), X(0x067574dd), X(0x06916247), X(0x06ad8941), X(0x06c9e9b8), X(0x06e68397), X(0x070356c8), X(0x07206336), X(0x073da8cb), X(0x075b2772), X(0x0778df15), X(0x0796cf9c), X(0x07b4f8f3), X(0x07d35b01), X(0x07f1f5b1), X(0x0810c8eb), X(0x082fd497), X(0x084f189e), X(0x086e94e9), X(0x088e495e), X(0x08ae35e6), X(0x08ce5a68), X(0x08eeb6cc), X(0x090f4af8), X(0x093016d3), X(0x09511a44), X(0x09725530), X(0x0993c77f), X(0x09b57115), X(0x09d751d8), X(0x09f969ae), X(0x0a1bb87c), X(0x0a3e3e26), X(0x0a60fa91), X(0x0a83eda2), X(0x0aa7173c), X(0x0aca7743), X(0x0aee0d9b), X(0x0b11da28), X(0x0b35dccc), X(0x0b5a156a), X(0x0b7e83e5), X(0x0ba3281f), X(0x0bc801fa), X(0x0bed1159), X(0x0c12561c), X(0x0c37d025), X(0x0c5d7f55), X(0x0c83638d), X(0x0ca97cae), X(0x0ccfca97), X(0x0cf64d2a), X(0x0d1d0444), X(0x0d43efc7), X(0x0d6b0f92), X(0x0d926383), X(0x0db9eb79), X(0x0de1a752), X(0x0e0996ee), X(0x0e31ba29), X(0x0e5a10e2), X(0x0e829af6), X(0x0eab5841), X(0x0ed448a2), X(0x0efd6bf4), X(0x0f26c214), X(0x0f504ade), X(0x0f7a062e), X(0x0fa3f3df), X(0x0fce13cd), X(0x0ff865d2), X(0x1022e9ca), X(0x104d9f8e), X(0x107886f9), X(0x10a39fe5), X(0x10ceea2c), X(0x10fa65a6), X(0x1126122d), X(0x1151ef9a), X(0x117dfdc5), X(0x11aa3c87), X(0x11d6abb6), X(0x12034b2c), X(0x12301ac0), X(0x125d1a48), X(0x128a499b), X(0x12b7a891), X(0x12e536ff), X(0x1312f4bb), X(0x1340e19c), X(0x136efd75), X(0x139d481e), X(0x13cbc16a), X(0x13fa692f), X(0x14293f40), X(0x14584371), X(0x14877597), X(0x14b6d585), X(0x14e6630d), X(0x15161e04), X(0x1546063b), X(0x15761b85), X(0x15a65db3), X(0x15d6cc99), X(0x16076806), X(0x16382fcd), X(0x166923bf), X(0x169a43ab), X(0x16cb8f62), X(0x16fd06b5), X(0x172ea973), X(0x1760776b), X(0x1792706e), X(0x17c49449), X(0x17f6e2cb), X(0x18295bc3), X(0x185bfeff), X(0x188ecc4c), X(0x18c1c379), X(0x18f4e452), X(0x19282ea4), X(0x195ba23c), X(0x198f3ee6), X(0x19c3046e), X(0x19f6f2a1), X(0x1a2b094a), X(0x1a5f4833), X(0x1a93af28), X(0x1ac83df3), X(0x1afcf460), X(0x1b31d237), X(0x1b66d744), X(0x1b9c034e), X(0x1bd15621), X(0x1c06cf84), X(0x1c3c6f40), X(0x1c72351e), X(0x1ca820e6), X(0x1cde3260), X(0x1d146953), X(0x1d4ac587), X(0x1d8146c3), X(0x1db7eccd), X(0x1deeb76c), X(0x1e25a667), X(0x1e5cb982), X(0x1e93f085), X(0x1ecb4b33), X(0x1f02c953), X(0x1f3a6aaa), X(0x1f722efb), X(0x1faa160b), X(0x1fe21f9e), X(0x201a4b79), X(0x2052995d), X(0x208b0910), X(0x20c39a53), X(0x20fc4cea), X(0x21352097), X(0x216e151c), X(0x21a72a3a), X(0x21e05fb5), X(0x2219b54d), X(0x22532ac3), X(0x228cbfd8), X(0x22c6744d), X(0x230047e2), X(0x233a3a58), X(0x23744b6d), X(0x23ae7ae3), X(0x23e8c878), X(0x242333ec), X(0x245dbcfd), X(0x24986369), X(0x24d326f1), X(0x250e0750), X(0x25490446), X(0x25841d90), X(0x25bf52ec), X(0x25faa417), X(0x263610cd), X(0x267198cc), X(0x26ad3bcf), X(0x26e8f994), X(0x2724d1d6), X(0x2760c451), X(0x279cd0c0), X(0x27d8f6e0), X(0x2815366a), X(0x28518f1b), X(0x288e00ac), X(0x28ca8ad8), X(0x29072d5a), X(0x2943e7eb), X(0x2980ba45), X(0x29bda422), X(0x29faa53c), X(0x2a37bd4a), X(0x2a74ec07), X(0x2ab2312b), X(0x2aef8c6f), X(0x2b2cfd8b), X(0x2b6a8437), X(0x2ba8202c), X(0x2be5d120), X(0x2c2396cc), X(0x2c6170e7), X(0x2c9f5f29), X(0x2cdd6147), X(0x2d1b76fa), X(0x2d599ff7), X(0x2d97dbf5), X(0x2dd62aab), X(0x2e148bcf), X(0x2e52ff16), X(0x2e918436), X(0x2ed01ae5), X(0x2f0ec2d9), X(0x2f4d7bc6), X(0x2f8c4562), X(0x2fcb1f62), X(0x300a097a), X(0x3049035f), X(0x30880cc6), X(0x30c72563), X(0x31064cea), X(0x3145830f), X(0x3184c786), X(0x31c41a03), X(0x32037a39), X(0x3242e7dc), X(0x3282629f), X(0x32c1ea36), X(0x33017e53), X(0x33411ea9), X(0x3380caec), X(0x33c082ce), X(0x34004602), X(0x34401439), X(0x347fed27), X(0x34bfd07e), X(0x34ffbdf0), X(0x353fb52e), X(0x357fb5ec), X(0x35bfbfda), X(0x35ffd2aa), X(0x363fee0f), X(0x368011b9), X(0x36c03d5a), X(0x370070a4), X(0x3740ab48), X(0x3780ecf7), X(0x37c13562), X(0x3801843a), X(0x3841d931), X(0x388233f7), X(0x38c2943d), X(0x3902f9b4), X(0x3943640d), X(0x3983d2f8), X(0x39c44626), X(0x3a04bd48), X(0x3a45380e), X(0x3a85b62a), X(0x3ac6374a), X(0x3b06bb20), X(0x3b47415c), X(0x3b87c9ae), X(0x3bc853c7), X(0x3c08df57), X(0x3c496c0f), X(0x3c89f99f), X(0x3cca87b6), X(0x3d0b1605), X(0x3d4ba43d), X(0x3d8c320e), X(0x3dccbf27), X(0x3e0d4b3a), X(0x3e4dd5f6), X(0x3e8e5f0c), X(0x3ecee62b), X(0x3f0f6b05), X(0x3f4fed49), X(0x3f906ca8), X(0x3fd0e8d2), X(0x40116177), X(0x4051d648), X(0x409246f6), X(0x40d2b330), X(0x41131aa7), X(0x41537d0c), X(0x4193da10), X(0x41d43162), X(0x421482b4), X(0x4254cdb7), X(0x4295121b), X(0x42d54f91), X(0x431585ca), X(0x4355b477), X(0x4395db49), X(0x43d5f9f1), X(0x44161021), X(0x44561d8a), X(0x449621dd), X(0x44d61ccc), X(0x45160e08), X(0x4555f544), X(0x4595d230), X(0x45d5a47f), X(0x46156be3), X(0x4655280e), X(0x4694d8b2), X(0x46d47d82), X(0x4714162f), X(0x4753a26d), X(0x479321ef), X(0x47d29466), X(0x4811f987), X(0x48515104), X(0x48909a91), X(0x48cfd5e1), X(0x490f02a7), X(0x494e2098), X(0x498d2f66), X(0x49cc2ec7), X(0x4a0b1e6f), X(0x4a49fe11), X(0x4a88cd62), X(0x4ac78c18), X(0x4b0639e6), X(0x4b44d683), X(0x4b8361a2), X(0x4bc1dafa), X(0x4c004241), X(0x4c3e972c), X(0x4c7cd970), X(0x4cbb08c5), X(0x4cf924e1), X(0x4d372d7a), X(0x4d752247), X(0x4db30300), X(0x4df0cf5a), X(0x4e2e870f), X(0x4e6c29d6), X(0x4ea9b766), X(0x4ee72f78), X(0x4f2491c4), X(0x4f61de02), X(0x4f9f13ec), X(0x4fdc333b), X(0x50193ba8), X(0x50562ced), X(0x509306c3), X(0x50cfc8e5), X(0x510c730d), X(0x514904f6), X(0x51857e5a), X(0x51c1def5), X(0x51fe2682), X(0x523a54bc), X(0x52766961), X(0x52b2642c), X(0x52ee44d9), X(0x532a0b26), X(0x5365b6d0), X(0x53a14793), X(0x53dcbd2f), X(0x54181760), X(0x545355e5), X(0x548e787d), X(0x54c97ee6), X(0x550468e1), X(0x553f362c), X(0x5579e687), X(0x55b479b3), X(0x55eeef70), X(0x5629477f), X(0x566381a1), X(0x569d9d97), X(0x56d79b24), X(0x57117a0a), X(0x574b3a0a), X(0x5784dae9), X(0x57be5c69), X(0x57f7be4d), X(0x5831005a), X(0x586a2254), X(0x58a32400), X(0x58dc0522), X(0x5914c57f), X(0x594d64de), X(0x5985e305), X(0x59be3fba), X(0x59f67ac3), X(0x5a2e93e9), X(0x5a668af2), X(0x5a9e5fa6), X(0x5ad611ce), X(0x5b0da133), X(0x5b450d9d), X(0x5b7c56d7), X(0x5bb37ca9), X(0x5bea7ede), X(0x5c215d41), X(0x5c58179d), X(0x5c8eadbe), X(0x5cc51f6f), X(0x5cfb6c7c), X(0x5d3194b2), X(0x5d6797de), X(0x5d9d75cf), X(0x5dd32e51), X(0x5e08c132), X(0x5e3e2e43), X(0x5e737551), X(0x5ea8962d), X(0x5edd90a7), X(0x5f12648e), X(0x5f4711b4), X(0x5f7b97ea), X(0x5faff702), X(0x5fe42ece), X(0x60183f20), X(0x604c27cc), X(0x607fe8a6), X(0x60b38180), X(0x60e6f22f), X(0x611a3a89), X(0x614d5a62), X(0x61805190), X(0x61b31fe9), X(0x61e5c545), X(0x62184179), X(0x624a945d), X(0x627cbdca), X(0x62aebd98), X(0x62e0939f), X(0x63123fba), X(0x6343c1c1), X(0x6375198f), X(0x63a646ff), X(0x63d749ec), X(0x64082232), X(0x6438cfad), X(0x64695238), X(0x6499a9b3), X(0x64c9d5f9), X(0x64f9d6ea), X(0x6529ac63), X(0x65595643), X(0x6588d46a), X(0x65b826b8), X(0x65e74d0e), X(0x6616474b), X(0x66451552), X(0x6673b704), X(0x66a22c44), X(0x66d074f4), X(0x66fe90f8), X(0x672c8033), X(0x675a428a), X(0x6787d7e1), X(0x67b5401f), X(0x67e27b27), X(0x680f88e1), X(0x683c6934), X(0x68691c05), X(0x6895a13e), X(0x68c1f8c7), X(0x68ee2287), X(0x691a1e68), X(0x6945ec54), X(0x69718c35), X(0x699cfdf5), X(0x69c8417f), X(0x69f356c0), X(0x6a1e3da3), X(0x6a48f615), X(0x6a738002), X(0x6a9ddb5a), X(0x6ac80808), X(0x6af205fd), X(0x6b1bd526), X(0x6b457575), X(0x6b6ee6d8), X(0x6b982940), X(0x6bc13c9f), X(0x6bea20e5), X(0x6c12d605), X(0x6c3b5bf1), X(0x6c63b29c), X(0x6c8bd9fb), X(0x6cb3d200), X(0x6cdb9aa0), X(0x6d0333d0), X(0x6d2a9d86), X(0x6d51d7b7), X(0x6d78e25a), X(0x6d9fbd67), X(0x6dc668d3), X(0x6dece498), X(0x6e1330ad), X(0x6e394d0c), X(0x6e5f39ae), X(0x6e84f68d), X(0x6eaa83a2), X(0x6ecfe0ea), X(0x6ef50e5e), X(0x6f1a0bfc), X(0x6f3ed9bf), X(0x6f6377a4), X(0x6f87e5a8), X(0x6fac23c9), X(0x6fd03206), X(0x6ff4105c), X(0x7017becc), X(0x703b3d54), X(0x705e8bf5), X(0x7081aaaf), X(0x70a49984), X(0x70c75874), X(0x70e9e783), X(0x710c46b2), X(0x712e7605), X(0x7150757f), X(0x71724523), X(0x7193e4f6), X(0x71b554fd), X(0x71d6953e), X(0x71f7a5bd), X(0x72188681), X(0x72393792), X(0x7259b8f5), X(0x727a0ab2), X(0x729a2cd2), X(0x72ba1f5d), X(0x72d9e25c), X(0x72f975d8), X(0x7318d9db), X(0x73380e6f), X(0x735713a0), X(0x7375e978), X(0x73949003), X(0x73b3074c), X(0x73d14f61), X(0x73ef684f), X(0x740d5222), X(0x742b0ce9), X(0x744898b1), X(0x7465f589), X(0x74832381), X(0x74a022a8), X(0x74bcf30e), X(0x74d994c3), X(0x74f607d8), X(0x75124c5f), X(0x752e6268), X(0x754a4a05), X(0x7566034b), X(0x75818e4a), X(0x759ceb16), X(0x75b819c4), X(0x75d31a66), X(0x75eded12), X(0x760891dc), X(0x762308da), X(0x763d5221), X(0x76576dc8), X(0x76715be4), X(0x768b1c8c), X(0x76a4afd9), X(0x76be15e0), X(0x76d74ebb), X(0x76f05a82), X(0x7709394d), X(0x7721eb35), X(0x773a7054), X(0x7752c8c4), X(0x776af49f), X(0x7782f400), X(0x779ac701), X(0x77b26dbd), X(0x77c9e851), X(0x77e136d8), X(0x77f8596f), X(0x780f5032), X(0x78261b3f), X(0x783cbab2), X(0x78532eaa), X(0x78697745), X(0x787f94a0), X(0x789586db), X(0x78ab4e15), X(0x78c0ea6d), X(0x78d65c03), X(0x78eba2f7), X(0x7900bf68), X(0x7915b179), X(0x792a7949), X(0x793f16fb), X(0x79538aaf), X(0x7967d488), X(0x797bf4a8), X(0x798feb31), X(0x79a3b846), X(0x79b75c0a), X(0x79cad6a1), X(0x79de282e), X(0x79f150d5), X(0x7a0450bb), X(0x7a172803), X(0x7a29d6d3), X(0x7a3c5d50), X(0x7a4ebb9f), X(0x7a60f1e6), X(0x7a73004a), X(0x7a84e6f2), X(0x7a96a604), X(0x7aa83da7), X(0x7ab9ae01), X(0x7acaf73a), X(0x7adc1979), X(0x7aed14e6), X(0x7afde9a8), X(0x7b0e97e8), X(0x7b1f1fcd), X(0x7b2f8182), X(0x7b3fbd2d), X(0x7b4fd2f9), X(0x7b5fc30f), X(0x7b6f8d98), X(0x7b7f32bd), X(0x7b8eb2a9), X(0x7b9e0d85), X(0x7bad437d), X(0x7bbc54b9), X(0x7bcb4166), X(0x7bda09ae), X(0x7be8adbc), X(0x7bf72dbc), X(0x7c0589d8), X(0x7c13c23d), X(0x7c21d716), X(0x7c2fc88f), X(0x7c3d96d5), X(0x7c4b4214), X(0x7c58ca78), X(0x7c66302d), X(0x7c737362), X(0x7c809443), X(0x7c8d92fc), X(0x7c9a6fbc), X(0x7ca72aaf), X(0x7cb3c404), X(0x7cc03be8), X(0x7ccc9288), X(0x7cd8c814), X(0x7ce4dcb9), X(0x7cf0d0a5), X(0x7cfca406), X(0x7d08570c), X(0x7d13e9e5), X(0x7d1f5cbf), X(0x7d2aafca), X(0x7d35e335), X(0x7d40f72e), X(0x7d4bebe4), X(0x7d56c188), X(0x7d617848), X(0x7d6c1054), X(0x7d7689db), X(0x7d80e50e), X(0x7d8b221b), X(0x7d954133), X(0x7d9f4286), X(0x7da92643), X(0x7db2ec9b), X(0x7dbc95bd), X(0x7dc621da), X(0x7dcf9123), X(0x7dd8e3c6), X(0x7de219f6), X(0x7deb33e2), X(0x7df431ba), X(0x7dfd13af), X(0x7e05d9f2), X(0x7e0e84b4), X(0x7e171424), X(0x7e1f8874), X(0x7e27e1d4), X(0x7e302074), X(0x7e384487), X(0x7e404e3c), X(0x7e483dc4), X(0x7e501350), X(0x7e57cf11), X(0x7e5f7138), X(0x7e66f9f4), X(0x7e6e6979), X(0x7e75bff5), X(0x7e7cfd9a), X(0x7e842298), X(0x7e8b2f22), X(0x7e922366), X(0x7e98ff97), X(0x7e9fc3e4), X(0x7ea6707f), X(0x7ead0598), X(0x7eb38360), X(0x7eb9ea07), X(0x7ec039bf), X(0x7ec672b7), X(0x7ecc9521), X(0x7ed2a12c), X(0x7ed8970a), X(0x7ede76ea), X(0x7ee440fd), X(0x7ee9f573), X(0x7eef947d), X(0x7ef51e4b), X(0x7efa930d), X(0x7efff2f2), X(0x7f053e2b), X(0x7f0a74e8), X(0x7f0f9758), X(0x7f14a5ac), X(0x7f19a013), X(0x7f1e86bc), X(0x7f2359d8), X(0x7f281995), X(0x7f2cc623), X(0x7f315fb1), X(0x7f35e66e), X(0x7f3a5a8a), X(0x7f3ebc33), X(0x7f430b98), X(0x7f4748e7), X(0x7f4b7450), X(0x7f4f8e01), X(0x7f539629), X(0x7f578cf5), X(0x7f5b7293), X(0x7f5f4732), X(0x7f630b00), X(0x7f66be2b), X(0x7f6a60df), X(0x7f6df34b), X(0x7f71759b), X(0x7f74e7fe), X(0x7f784aa0), X(0x7f7b9daf), X(0x7f7ee156), X(0x7f8215c3), X(0x7f853b22), X(0x7f88519f), X(0x7f8b5967), X(0x7f8e52a6), X(0x7f913d87), X(0x7f941a36), X(0x7f96e8df), X(0x7f99a9ad), X(0x7f9c5ccb), X(0x7f9f0265), X(0x7fa19aa5), X(0x7fa425b5), X(0x7fa6a3c1), X(0x7fa914f3), X(0x7fab7974), X(0x7fadd16f), X(0x7fb01d0d), X(0x7fb25c78), X(0x7fb48fd9), X(0x7fb6b75a), X(0x7fb8d323), X(0x7fbae35d), X(0x7fbce831), X(0x7fbee1c7), X(0x7fc0d047), X(0x7fc2b3d9), X(0x7fc48ca5), X(0x7fc65ad3), X(0x7fc81e88), X(0x7fc9d7ee), X(0x7fcb872a), X(0x7fcd2c63), X(0x7fcec7bf), X(0x7fd05966), X(0x7fd1e17c), X(0x7fd36027), X(0x7fd4d58d), X(0x7fd641d3), X(0x7fd7a51e), X(0x7fd8ff94), X(0x7fda5157), X(0x7fdb9a8e), X(0x7fdcdb5b), X(0x7fde13e2), X(0x7fdf4448), X(0x7fe06caf), X(0x7fe18d3b), X(0x7fe2a60e), X(0x7fe3b74b), X(0x7fe4c114), X(0x7fe5c38b), X(0x7fe6bed2), X(0x7fe7b30a), X(0x7fe8a055), X(0x7fe986d4), X(0x7fea66a7), X(0x7feb3ff0), X(0x7fec12cd), X(0x7fecdf5f), X(0x7feda5c5), X(0x7fee6620), X(0x7fef208d), X(0x7fefd52c), X(0x7ff0841c), X(0x7ff12d7a), X(0x7ff1d164), X(0x7ff26ff9), X(0x7ff30955), X(0x7ff39d96), X(0x7ff42cd9), X(0x7ff4b739), X(0x7ff53cd4), X(0x7ff5bdc5), X(0x7ff63a28), X(0x7ff6b217), X(0x7ff725af), X(0x7ff7950a), X(0x7ff80043), X(0x7ff86773), X(0x7ff8cab4), X(0x7ff92a21), X(0x7ff985d1), X(0x7ff9dddf), X(0x7ffa3262), X(0x7ffa8374), X(0x7ffad12c), X(0x7ffb1ba1), X(0x7ffb62ec), X(0x7ffba723), X(0x7ffbe85c), X(0x7ffc26b0), X(0x7ffc6233), X(0x7ffc9afb), X(0x7ffcd11e), X(0x7ffd04b1), X(0x7ffd35c9), X(0x7ffd647b), X(0x7ffd90da), X(0x7ffdbafa), X(0x7ffde2f0), X(0x7ffe08ce), X(0x7ffe2ca7), X(0x7ffe4e8e), X(0x7ffe6e95), X(0x7ffe8cce), X(0x7ffea94a), X(0x7ffec41b), X(0x7ffedd52), X(0x7ffef4ff), X(0x7fff0b33), X(0x7fff1ffd), X(0x7fff336e), X(0x7fff4593), X(0x7fff567d), X(0x7fff663a), X(0x7fff74d8), X(0x7fff8265), X(0x7fff8eee), X(0x7fff9a81), X(0x7fffa52b), X(0x7fffaef8), X(0x7fffb7f5), X(0x7fffc02d), X(0x7fffc7ab), X(0x7fffce7c), X(0x7fffd4a9), X(0x7fffda3e), X(0x7fffdf44), X(0x7fffe3c6), X(0x7fffe7cc), X(0x7fffeb60), X(0x7fffee8a), X(0x7ffff153), X(0x7ffff3c4), X(0x7ffff5e3), X(0x7ffff7b8), X(0x7ffff94b), X(0x7ffffaa1), X(0x7ffffbc1), X(0x7ffffcb2), X(0x7ffffd78), X(0x7ffffe19), X(0x7ffffe9a), X(0x7ffffeff), X(0x7fffff4e), X(0x7fffff89), X(0x7fffffb3), X(0x7fffffd2), X(0x7fffffe6), X(0x7ffffff3), X(0x7ffffffa), X(0x7ffffffe), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), }; static const LOOKUP_T vwin4096[2048] = { X(0x000001f0), X(0x00001171), X(0x00003072), X(0x00005ef5), X(0x00009cf8), X(0x0000ea7c), X(0x00014780), X(0x0001b405), X(0x0002300b), X(0x0002bb91), X(0x00035698), X(0x0004011e), X(0x0004bb25), X(0x000584ac), X(0x00065db3), X(0x0007463a), X(0x00083e41), X(0x000945c7), X(0x000a5ccc), X(0x000b8350), X(0x000cb954), X(0x000dfed7), X(0x000f53d8), X(0x0010b857), X(0x00122c55), X(0x0013afd1), X(0x001542ca), X(0x0016e541), X(0x00189735), X(0x001a58a7), X(0x001c2995), X(0x001e09ff), X(0x001ff9e6), X(0x0021f948), X(0x00240826), X(0x00262680), X(0x00285454), X(0x002a91a3), X(0x002cde6c), X(0x002f3aaf), X(0x0031a66b), X(0x003421a0), X(0x0036ac4f), X(0x00394675), X(0x003bf014), X(0x003ea92a), X(0x004171b7), X(0x004449bb), X(0x00473135), X(0x004a2824), X(0x004d2e8a), X(0x00504463), X(0x005369b2), X(0x00569e74), X(0x0059e2aa), X(0x005d3652), X(0x0060996d), X(0x00640bf9), X(0x00678df7), X(0x006b1f66), X(0x006ec045), X(0x00727093), X(0x00763051), X(0x0079ff7d), X(0x007dde16), X(0x0081cc1d), X(0x0085c991), X(0x0089d671), X(0x008df2bc), X(0x00921e71), X(0x00965991), X(0x009aa41a), X(0x009efe0c), X(0x00a36766), X(0x00a7e028), X(0x00ac6850), X(0x00b0ffde), X(0x00b5a6d1), X(0x00ba5d28), X(0x00bf22e4), X(0x00c3f802), X(0x00c8dc83), X(0x00cdd065), X(0x00d2d3a8), X(0x00d7e64a), X(0x00dd084c), X(0x00e239ac), X(0x00e77a69), X(0x00ecca83), X(0x00f229f9), X(0x00f798ca), X(0x00fd16f5), X(0x0102a479), X(0x01084155), X(0x010ded89), X(0x0113a913), X(0x011973f3), X(0x011f4e27), X(0x012537af), X(0x012b308a), X(0x013138b7), X(0x01375035), X(0x013d7702), X(0x0143ad1f), X(0x0149f289), X(0x01504741), X(0x0156ab44), X(0x015d1e92), X(0x0163a12a), X(0x016a330b), X(0x0170d433), X(0x017784a3), X(0x017e4458), X(0x01851351), X(0x018bf18e), X(0x0192df0d), X(0x0199dbcd), X(0x01a0e7cd), X(0x01a8030c), X(0x01af2d89), X(0x01b66743), X(0x01bdb038), X(0x01c50867), X(0x01cc6fd0), X(0x01d3e670), X(0x01db6c47), X(0x01e30153), X(0x01eaa593), X(0x01f25907), X(0x01fa1bac), X(0x0201ed81), X(0x0209ce86), X(0x0211beb8), X(0x0219be17), X(0x0221cca2), X(0x0229ea56), X(0x02321733), X(0x023a5337), X(0x02429e60), X(0x024af8af), X(0x02536220), X(0x025bdab3), X(0x02646267), X(0x026cf93a), X(0x02759f2a), X(0x027e5436), X(0x0287185d), X(0x028feb9d), X(0x0298cdf4), X(0x02a1bf62), X(0x02aabfe5), X(0x02b3cf7b), X(0x02bcee23), X(0x02c61bdb), X(0x02cf58a2), X(0x02d8a475), X(0x02e1ff55), X(0x02eb693e), X(0x02f4e230), X(0x02fe6a29), X(0x03080127), X(0x0311a729), X(0x031b5c2d), X(0x03252031), X(0x032ef334), X(0x0338d534), X(0x0342c630), X(0x034cc625), X(0x0356d512), X(0x0360f2f6), X(0x036b1fce), X(0x03755b99), X(0x037fa655), X(0x038a0001), X(0x0394689a), X(0x039ee020), X(0x03a9668f), X(0x03b3fbe6), X(0x03bea024), X(0x03c95347), X(0x03d4154d), X(0x03dee633), X(0x03e9c5f9), X(0x03f4b49b), X(0x03ffb219), X(0x040abe71), X(0x0415d9a0), X(0x042103a5), X(0x042c3c7d), X(0x04378428), X(0x0442daa2), X(0x044e3fea), X(0x0459b3fd), X(0x046536db), X(0x0470c880), X(0x047c68eb), X(0x0488181a), X(0x0493d60b), X(0x049fa2bc), X(0x04ab7e2a), X(0x04b76854), X(0x04c36137), X(0x04cf68d1), X(0x04db7f21), X(0x04e7a424), X(0x04f3d7d8), X(0x05001a3b), X(0x050c6b4a), X(0x0518cb04), X(0x05253966), X(0x0531b66e), X(0x053e421a), X(0x054adc68), X(0x05578555), X(0x05643cdf), X(0x05710304), X(0x057dd7c1), X(0x058abb15), X(0x0597acfd), X(0x05a4ad76), X(0x05b1bc7f), X(0x05beda14), X(0x05cc0635), X(0x05d940dd), X(0x05e68a0b), X(0x05f3e1bd), X(0x060147f0), X(0x060ebca1), X(0x061c3fcf), X(0x0629d176), X(0x06377194), X(0x06452027), X(0x0652dd2c), X(0x0660a8a2), X(0x066e8284), X(0x067c6ad1), X(0x068a6186), X(0x069866a1), X(0x06a67a1e), X(0x06b49bfc), X(0x06c2cc38), X(0x06d10acf), X(0x06df57bf), X(0x06edb304), X(0x06fc1c9d), X(0x070a9487), X(0x07191abe), X(0x0727af40), X(0x0736520b), X(0x0745031c), X(0x0753c270), X(0x07629004), X(0x07716bd6), X(0x078055e2), X(0x078f4e26), X(0x079e549f), X(0x07ad694b), X(0x07bc8c26), X(0x07cbbd2e), X(0x07dafc5f), X(0x07ea49b7), X(0x07f9a533), X(0x08090ed1), X(0x0818868c), X(0x08280c62), X(0x0837a051), X(0x08474255), X(0x0856f26b), X(0x0866b091), X(0x08767cc3), X(0x088656fe), X(0x08963f3f), X(0x08a63584), X(0x08b639c8), X(0x08c64c0a), X(0x08d66c45), X(0x08e69a77), X(0x08f6d69d), X(0x090720b3), X(0x091778b7), X(0x0927dea5), X(0x0938527a), X(0x0948d433), X(0x095963cc), X(0x096a0143), X(0x097aac94), X(0x098b65bb), X(0x099c2cb6), X(0x09ad0182), X(0x09bde41a), X(0x09ced47d), X(0x09dfd2a5), X(0x09f0de90), X(0x0a01f83b), X(0x0a131fa3), X(0x0a2454c3), X(0x0a359798), X(0x0a46e820), X(0x0a584656), X(0x0a69b237), X(0x0a7b2bc0), X(0x0a8cb2ec), X(0x0a9e47ba), X(0x0aafea24), X(0x0ac19a29), X(0x0ad357c3), X(0x0ae522ef), X(0x0af6fbab), X(0x0b08e1f1), X(0x0b1ad5c0), X(0x0b2cd712), X(0x0b3ee5e5), X(0x0b510234), X(0x0b632bfd), X(0x0b75633b), X(0x0b87a7eb), X(0x0b99fa08), X(0x0bac5990), X(0x0bbec67e), X(0x0bd140cf), X(0x0be3c87e), X(0x0bf65d89), X(0x0c08ffeb), X(0x0c1bafa1), X(0x0c2e6ca6), X(0x0c4136f6), X(0x0c540e8f), X(0x0c66f36c), X(0x0c79e588), X(0x0c8ce4e1), X(0x0c9ff172), X(0x0cb30b37), X(0x0cc6322c), X(0x0cd9664d), X(0x0ceca797), X(0x0cfff605), X(0x0d135193), X(0x0d26ba3d), X(0x0d3a2fff), X(0x0d4db2d5), X(0x0d6142ba), X(0x0d74dfac), X(0x0d8889a5), X(0x0d9c40a1), X(0x0db0049d), X(0x0dc3d593), X(0x0dd7b380), X(0x0deb9e60), X(0x0dff962f), X(0x0e139ae7), X(0x0e27ac85), X(0x0e3bcb05), X(0x0e4ff662), X(0x0e642e98), X(0x0e7873a2), X(0x0e8cc57d), X(0x0ea12423), X(0x0eb58f91), X(0x0eca07c2), X(0x0ede8cb1), X(0x0ef31e5b), X(0x0f07bcba), X(0x0f1c67cb), X(0x0f311f88), X(0x0f45e3ee), X(0x0f5ab4f7), X(0x0f6f92a0), X(0x0f847ce3), X(0x0f9973bc), X(0x0fae7726), X(0x0fc3871e), X(0x0fd8a39d), X(0x0fedcca1), X(0x10030223), X(0x1018441f), X(0x102d9291), X(0x1042ed74), X(0x105854c3), X(0x106dc879), X(0x10834892), X(0x1098d508), X(0x10ae6dd8), X(0x10c412fc), X(0x10d9c46f), X(0x10ef822d), X(0x11054c30), X(0x111b2274), X(0x113104f5), X(0x1146f3ac), X(0x115cee95), X(0x1172f5ab), X(0x118908e9), X(0x119f284a), X(0x11b553ca), X(0x11cb8b62), X(0x11e1cf0f), X(0x11f81ecb), X(0x120e7a90), X(0x1224e25a), X(0x123b5624), X(0x1251d5e9), X(0x126861a3), X(0x127ef94e), X(0x12959ce3), X(0x12ac4c5f), X(0x12c307bb), X(0x12d9cef2), X(0x12f0a200), X(0x130780df), X(0x131e6b8a), X(0x133561fa), X(0x134c642c), X(0x1363721a), X(0x137a8bbe), X(0x1391b113), X(0x13a8e214), X(0x13c01eba), X(0x13d76702), X(0x13eebae5), X(0x14061a5e), X(0x141d8567), X(0x1434fbfb), X(0x144c7e14), X(0x14640bae), X(0x147ba4c1), X(0x14934949), X(0x14aaf941), X(0x14c2b4a2), X(0x14da7b67), X(0x14f24d8a), X(0x150a2b06), X(0x152213d5), X(0x153a07f1), X(0x15520755), X(0x156a11fb), X(0x158227dd), X(0x159a48f5), X(0x15b2753d), X(0x15caacb1), X(0x15e2ef49), X(0x15fb3d01), X(0x161395d2), X(0x162bf9b6), X(0x164468a8), X(0x165ce2a1), X(0x1675679c), X(0x168df793), X(0x16a69280), X(0x16bf385c), X(0x16d7e922), X(0x16f0a4cc), X(0x17096b54), X(0x17223cb4), X(0x173b18e5), X(0x1753ffe2), X(0x176cf1a5), X(0x1785ee27), X(0x179ef562), X(0x17b80750), X(0x17d123eb), X(0x17ea4b2d), X(0x18037d10), X(0x181cb98d), X(0x1836009e), X(0x184f523c), X(0x1868ae63), X(0x1882150a), X(0x189b862c), X(0x18b501c4), X(0x18ce87c9), X(0x18e81836), X(0x1901b305), X(0x191b582f), X(0x193507ad), X(0x194ec17a), X(0x1968858f), X(0x198253e5), X(0x199c2c75), X(0x19b60f3a), X(0x19cffc2d), X(0x19e9f347), X(0x1a03f482), X(0x1a1dffd7), X(0x1a381540), X(0x1a5234b5), X(0x1a6c5e31), X(0x1a8691ac), X(0x1aa0cf21), X(0x1abb1687), X(0x1ad567da), X(0x1aefc311), X(0x1b0a2826), X(0x1b249712), X(0x1b3f0fd0), X(0x1b599257), X(0x1b741ea1), X(0x1b8eb4a7), X(0x1ba95462), X(0x1bc3fdcd), X(0x1bdeb0de), X(0x1bf96d91), X(0x1c1433dd), X(0x1c2f03bc), X(0x1c49dd27), X(0x1c64c017), X(0x1c7fac85), X(0x1c9aa269), X(0x1cb5a1be), X(0x1cd0aa7c), X(0x1cebbc9c), X(0x1d06d816), X(0x1d21fce4), X(0x1d3d2aff), X(0x1d586260), X(0x1d73a2fe), X(0x1d8eecd4), X(0x1daa3fda), X(0x1dc59c09), X(0x1de1015a), X(0x1dfc6fc5), X(0x1e17e743), X(0x1e3367cd), X(0x1e4ef15b), X(0x1e6a83e7), X(0x1e861f6a), X(0x1ea1c3da), X(0x1ebd7133), X(0x1ed9276b), X(0x1ef4e67c), X(0x1f10ae5e), X(0x1f2c7f0a), X(0x1f485879), X(0x1f643aa2), X(0x1f80257f), X(0x1f9c1908), X(0x1fb81536), X(0x1fd41a00), X(0x1ff02761), X(0x200c3d4f), X(0x20285bc3), X(0x204482b7), X(0x2060b221), X(0x207ce9fb), X(0x20992a3e), X(0x20b572e0), X(0x20d1c3dc), X(0x20ee1d28), X(0x210a7ebe), X(0x2126e895), X(0x21435aa6), X(0x215fd4ea), X(0x217c5757), X(0x2198e1e8), X(0x21b57493), X(0x21d20f51), X(0x21eeb21b), X(0x220b5ce7), X(0x22280fb0), X(0x2244ca6c), X(0x22618d13), X(0x227e579f), X(0x229b2a06), X(0x22b80442), X(0x22d4e649), X(0x22f1d015), X(0x230ec19d), X(0x232bbad9), X(0x2348bbc1), X(0x2365c44c), X(0x2382d474), X(0x239fec30), X(0x23bd0b78), X(0x23da3244), X(0x23f7608b), X(0x24149646), X(0x2431d36c), X(0x244f17f5), X(0x246c63da), X(0x2489b711), X(0x24a71193), X(0x24c47358), X(0x24e1dc57), X(0x24ff4c88), X(0x251cc3e2), X(0x253a425e), X(0x2557c7f4), X(0x2575549a), X(0x2592e848), X(0x25b082f7), X(0x25ce249e), X(0x25ebcd34), X(0x26097cb2), X(0x2627330e), X(0x2644f040), X(0x2662b441), X(0x26807f07), X(0x269e5089), X(0x26bc28c1), X(0x26da07a4), X(0x26f7ed2b), X(0x2715d94d), X(0x2733cc02), X(0x2751c540), X(0x276fc500), X(0x278dcb39), X(0x27abd7e2), X(0x27c9eaf3), X(0x27e80463), X(0x28062429), X(0x28244a3e), X(0x28427697), X(0x2860a92d), X(0x287ee1f7), X(0x289d20eb), X(0x28bb6603), X(0x28d9b134), X(0x28f80275), X(0x291659c0), X(0x2934b709), X(0x29531a49), X(0x29718378), X(0x298ff28b), X(0x29ae677b), X(0x29cce23e), X(0x29eb62cb), X(0x2a09e91b), X(0x2a287523), X(0x2a4706dc), X(0x2a659e3c), X(0x2a843b39), X(0x2aa2ddcd), X(0x2ac185ec), X(0x2ae0338f), X(0x2afee6ad), X(0x2b1d9f3c), X(0x2b3c5d33), X(0x2b5b208b), X(0x2b79e939), X(0x2b98b734), X(0x2bb78a74), X(0x2bd662ef), X(0x2bf5409d), X(0x2c142374), X(0x2c330b6b), X(0x2c51f87a), X(0x2c70ea97), X(0x2c8fe1b9), X(0x2caeddd6), X(0x2ccddee7), X(0x2cece4e1), X(0x2d0befbb), X(0x2d2aff6d), X(0x2d4a13ec), X(0x2d692d31), X(0x2d884b32), X(0x2da76de4), X(0x2dc69540), X(0x2de5c13d), X(0x2e04f1d0), X(0x2e2426f0), X(0x2e436095), X(0x2e629eb4), X(0x2e81e146), X(0x2ea1283f), X(0x2ec07398), X(0x2edfc347), X(0x2eff1742), X(0x2f1e6f80), X(0x2f3dcbf8), X(0x2f5d2ca0), X(0x2f7c916f), X(0x2f9bfa5c), X(0x2fbb675d), X(0x2fdad869), X(0x2ffa4d76), X(0x3019c67b), X(0x3039436f), X(0x3058c448), X(0x307848fc), X(0x3097d183), X(0x30b75dd3), X(0x30d6ede2), X(0x30f681a6), X(0x31161917), X(0x3135b42b), X(0x315552d8), X(0x3174f514), X(0x31949ad7), X(0x31b44417), X(0x31d3f0ca), X(0x31f3a0e6), X(0x32135462), X(0x32330b35), X(0x3252c555), X(0x327282b7), X(0x32924354), X(0x32b20720), X(0x32d1ce13), X(0x32f19823), X(0x33116546), X(0x33313573), X(0x3351089f), X(0x3370dec2), X(0x3390b7d1), X(0x33b093c3), X(0x33d0728f), X(0x33f05429), X(0x3410388a), X(0x34301fa7), X(0x34500977), X(0x346ff5ef), X(0x348fe506), X(0x34afd6b3), X(0x34cfcaeb), X(0x34efc1a5), X(0x350fbad7), X(0x352fb678), X(0x354fb47d), X(0x356fb4dd), X(0x358fb78e), X(0x35afbc86), X(0x35cfc3bc), X(0x35efcd25), X(0x360fd8b8), X(0x362fe66c), X(0x364ff636), X(0x3670080c), X(0x36901be5), X(0x36b031b7), X(0x36d04978), X(0x36f0631e), X(0x37107ea0), X(0x37309bf3), X(0x3750bb0e), X(0x3770dbe6), X(0x3790fe73), X(0x37b122aa), X(0x37d14881), X(0x37f16fee), X(0x381198e8), X(0x3831c365), X(0x3851ef5a), X(0x38721cbe), X(0x38924b87), X(0x38b27bac), X(0x38d2ad21), X(0x38f2dfde), X(0x391313d8), X(0x39334906), X(0x39537f5d), X(0x3973b6d4), X(0x3993ef60), X(0x39b428f9), X(0x39d46393), X(0x39f49f25), X(0x3a14dba6), X(0x3a35190a), X(0x3a555748), X(0x3a759657), X(0x3a95d62c), X(0x3ab616be), X(0x3ad65801), X(0x3af699ed), X(0x3b16dc78), X(0x3b371f97), X(0x3b576341), X(0x3b77a76c), X(0x3b97ec0d), X(0x3bb8311b), X(0x3bd8768b), X(0x3bf8bc55), X(0x3c19026d), X(0x3c3948ca), X(0x3c598f62), X(0x3c79d62b), X(0x3c9a1d1b), X(0x3cba6428), X(0x3cdaab48), X(0x3cfaf271), X(0x3d1b3999), X(0x3d3b80b6), X(0x3d5bc7be), X(0x3d7c0ea8), X(0x3d9c5569), X(0x3dbc9bf7), X(0x3ddce248), X(0x3dfd2852), X(0x3e1d6e0c), X(0x3e3db36c), X(0x3e5df866), X(0x3e7e3cf2), X(0x3e9e8106), X(0x3ebec497), X(0x3edf079b), X(0x3eff4a09), X(0x3f1f8bd7), X(0x3f3fccfa), X(0x3f600d69), X(0x3f804d1a), X(0x3fa08c02), X(0x3fc0ca19), X(0x3fe10753), X(0x400143a7), X(0x40217f0a), X(0x4041b974), X(0x4061f2da), X(0x40822b32), X(0x40a26272), X(0x40c29891), X(0x40e2cd83), X(0x41030140), X(0x412333bd), X(0x414364f1), X(0x416394d2), X(0x4183c355), X(0x41a3f070), X(0x41c41c1b), X(0x41e4464a), X(0x42046ef4), X(0x42249610), X(0x4244bb92), X(0x4264df72), X(0x428501a5), X(0x42a52222), X(0x42c540de), X(0x42e55dd0), X(0x430578ed), X(0x4325922d), X(0x4345a985), X(0x4365beeb), X(0x4385d255), X(0x43a5e3ba), X(0x43c5f30f), X(0x43e6004b), X(0x44060b65), X(0x44261451), X(0x44461b07), X(0x44661f7c), X(0x448621a7), X(0x44a6217d), X(0x44c61ef6), X(0x44e61a07), X(0x450612a6), X(0x452608ca), X(0x4545fc69), X(0x4565ed79), X(0x4585dbf1), X(0x45a5c7c6), X(0x45c5b0ef), X(0x45e59761), X(0x46057b15), X(0x46255bfe), X(0x46453a15), X(0x4665154f), X(0x4684eda2), X(0x46a4c305), X(0x46c4956e), X(0x46e464d3), X(0x4704312b), X(0x4723fa6c), X(0x4743c08d), X(0x47638382), X(0x47834344), X(0x47a2ffc9), X(0x47c2b906), X(0x47e26ef2), X(0x48022183), X(0x4821d0b1), X(0x48417c71), X(0x486124b9), X(0x4880c981), X(0x48a06abe), X(0x48c00867), X(0x48dfa272), X(0x48ff38d6), X(0x491ecb8a), X(0x493e5a84), X(0x495de5b9), X(0x497d6d22), X(0x499cf0b4), X(0x49bc7066), X(0x49dbec2e), X(0x49fb6402), X(0x4a1ad7db), X(0x4a3a47ad), X(0x4a59b370), X(0x4a791b1a), X(0x4a987ea1), X(0x4ab7ddfd), X(0x4ad73924), X(0x4af6900c), X(0x4b15e2ad), X(0x4b3530fc), X(0x4b547af1), X(0x4b73c082), X(0x4b9301a6), X(0x4bb23e53), X(0x4bd17681), X(0x4bf0aa25), X(0x4c0fd937), X(0x4c2f03ae), X(0x4c4e297f), X(0x4c6d4aa3), X(0x4c8c670f), X(0x4cab7eba), X(0x4cca919c), X(0x4ce99fab), X(0x4d08a8de), X(0x4d27ad2c), X(0x4d46ac8b), X(0x4d65a6f3), X(0x4d849c5a), X(0x4da38cb7), X(0x4dc27802), X(0x4de15e31), X(0x4e003f3a), X(0x4e1f1b16), X(0x4e3df1ba), X(0x4e5cc31e), X(0x4e7b8f3a), X(0x4e9a5603), X(0x4eb91771), X(0x4ed7d37b), X(0x4ef68a18), X(0x4f153b3f), X(0x4f33e6e7), X(0x4f528d08), X(0x4f712d97), X(0x4f8fc88e), X(0x4fae5de1), X(0x4fcced8a), X(0x4feb777f), X(0x5009fbb6), X(0x50287a28), X(0x5046f2cc), X(0x50656598), X(0x5083d284), X(0x50a23988), X(0x50c09a9a), X(0x50def5b1), X(0x50fd4ac7), X(0x511b99d0), X(0x5139e2c5), X(0x5158259e), X(0x51766251), X(0x519498d6), X(0x51b2c925), X(0x51d0f334), X(0x51ef16fb), X(0x520d3473), X(0x522b4b91), X(0x52495c4e), X(0x526766a2), X(0x52856a83), X(0x52a367e9), X(0x52c15ecd), X(0x52df4f24), X(0x52fd38e8), X(0x531b1c10), X(0x5338f892), X(0x5356ce68), X(0x53749d89), X(0x539265eb), X(0x53b02788), X(0x53cde257), X(0x53eb964f), X(0x54094369), X(0x5426e99c), X(0x544488df), X(0x5462212c), X(0x547fb279), X(0x549d3cbe), X(0x54babff4), X(0x54d83c12), X(0x54f5b110), X(0x55131ee7), X(0x5530858d), X(0x554de4fc), X(0x556b3d2a), X(0x55888e11), X(0x55a5d7a8), X(0x55c319e7), X(0x55e054c7), X(0x55fd883f), X(0x561ab447), X(0x5637d8d8), X(0x5654f5ea), X(0x56720b75), X(0x568f1971), X(0x56ac1fd7), X(0x56c91e9e), X(0x56e615c0), X(0x57030534), X(0x571fecf2), X(0x573cccf3), X(0x5759a530), X(0x577675a0), X(0x57933e3c), X(0x57affefd), X(0x57ccb7db), X(0x57e968ce), X(0x580611cf), X(0x5822b2d6), X(0x583f4bdd), X(0x585bdcdb), X(0x587865c9), X(0x5894e69f), X(0x58b15f57), X(0x58cdcfe9), X(0x58ea384e), X(0x5906987d), X(0x5922f071), X(0x593f4022), X(0x595b8788), X(0x5977c69c), X(0x5993fd57), X(0x59b02bb2), X(0x59cc51a6), X(0x59e86f2c), X(0x5a04843c), X(0x5a2090d0), X(0x5a3c94e0), X(0x5a589065), X(0x5a748359), X(0x5a906db4), X(0x5aac4f70), X(0x5ac82884), X(0x5ae3f8ec), X(0x5affc09f), X(0x5b1b7f97), X(0x5b3735cd), X(0x5b52e33a), X(0x5b6e87d8), X(0x5b8a239f), X(0x5ba5b689), X(0x5bc1408f), X(0x5bdcc1aa), X(0x5bf839d5), X(0x5c13a907), X(0x5c2f0f3b), X(0x5c4a6c6a), X(0x5c65c08d), X(0x5c810b9e), X(0x5c9c4d97), X(0x5cb78670), X(0x5cd2b623), X(0x5ceddcaa), X(0x5d08f9ff), X(0x5d240e1b), X(0x5d3f18f8), X(0x5d5a1a8f), X(0x5d7512da), X(0x5d9001d3), X(0x5daae773), X(0x5dc5c3b5), X(0x5de09692), X(0x5dfb6004), X(0x5e162004), X(0x5e30d68d), X(0x5e4b8399), X(0x5e662721), X(0x5e80c11f), X(0x5e9b518e), X(0x5eb5d867), X(0x5ed055a4), X(0x5eeac940), X(0x5f053334), X(0x5f1f937b), X(0x5f39ea0f), X(0x5f5436ea), X(0x5f6e7a06), X(0x5f88b35d), X(0x5fa2e2e9), X(0x5fbd08a6), X(0x5fd7248d), X(0x5ff13698), X(0x600b3ec2), X(0x60253d05), X(0x603f315b), X(0x60591bc0), X(0x6072fc2d), X(0x608cd29e), X(0x60a69f0b), X(0x60c06171), X(0x60da19ca), X(0x60f3c80f), X(0x610d6c3d), X(0x6127064d), X(0x6140963a), X(0x615a1bff), X(0x61739797), X(0x618d08fc), X(0x61a67029), X(0x61bfcd1a), X(0x61d91fc8), X(0x61f2682f), X(0x620ba64a), X(0x6224da13), X(0x623e0386), X(0x6257229d), X(0x62703754), X(0x628941a6), X(0x62a2418e), X(0x62bb3706), X(0x62d4220a), X(0x62ed0296), X(0x6305d8a3), X(0x631ea42f), X(0x63376533), X(0x63501bab), X(0x6368c793), X(0x638168e5), X(0x6399ff9e), X(0x63b28bb8), X(0x63cb0d2f), X(0x63e383ff), X(0x63fbf022), X(0x64145195), X(0x642ca853), X(0x6444f457), X(0x645d359e), X(0x64756c22), X(0x648d97e0), X(0x64a5b8d3), X(0x64bdcef6), X(0x64d5da47), X(0x64eddabf), X(0x6505d05c), X(0x651dbb19), X(0x65359af2), X(0x654d6fe3), X(0x656539e7), X(0x657cf8fb), X(0x6594ad1b), X(0x65ac5643), X(0x65c3f46e), X(0x65db8799), X(0x65f30fc0), X(0x660a8ce0), X(0x6621fef3), X(0x663965f7), X(0x6650c1e7), X(0x666812c1), X(0x667f5880), X(0x66969320), X(0x66adc29e), X(0x66c4e6f7), X(0x66dc0026), X(0x66f30e28), X(0x670a10fa), X(0x67210898), X(0x6737f4ff), X(0x674ed62b), X(0x6765ac19), X(0x677c76c5), X(0x6793362c), X(0x67a9ea4b), X(0x67c0931f), X(0x67d730a3), X(0x67edc2d6), X(0x680449b3), X(0x681ac538), X(0x68313562), X(0x68479a2d), X(0x685df396), X(0x6874419b), X(0x688a8438), X(0x68a0bb6a), X(0x68b6e72e), X(0x68cd0782), X(0x68e31c63), X(0x68f925cd), X(0x690f23be), X(0x69251633), X(0x693afd29), X(0x6950d89e), X(0x6966a88f), X(0x697c6cf8), X(0x699225d9), X(0x69a7d32d), X(0x69bd74f3), X(0x69d30b27), X(0x69e895c8), X(0x69fe14d2), X(0x6a138844), X(0x6a28f01b), X(0x6a3e4c54), X(0x6a539ced), X(0x6a68e1e4), X(0x6a7e1b37), X(0x6a9348e3), X(0x6aa86ae6), X(0x6abd813d), X(0x6ad28be7), X(0x6ae78ae2), X(0x6afc7e2b), X(0x6b1165c0), X(0x6b26419f), X(0x6b3b11c7), X(0x6b4fd634), X(0x6b648ee6), X(0x6b793bda), X(0x6b8ddd0e), X(0x6ba27281), X(0x6bb6fc31), X(0x6bcb7a1b), X(0x6bdfec3e), X(0x6bf45299), X(0x6c08ad29), X(0x6c1cfbed), X(0x6c313ee4), X(0x6c45760a), X(0x6c59a160), X(0x6c6dc0e4), X(0x6c81d493), X(0x6c95dc6d), X(0x6ca9d86f), X(0x6cbdc899), X(0x6cd1acea), X(0x6ce5855f), X(0x6cf951f7), X(0x6d0d12b1), X(0x6d20c78c), X(0x6d347087), X(0x6d480da0), X(0x6d5b9ed6), X(0x6d6f2427), X(0x6d829d94), X(0x6d960b1a), X(0x6da96cb9), X(0x6dbcc270), X(0x6dd00c3c), X(0x6de34a1f), X(0x6df67c16), X(0x6e09a221), X(0x6e1cbc3f), X(0x6e2fca6e), X(0x6e42ccaf), X(0x6e55c300), X(0x6e68ad60), X(0x6e7b8bd0), X(0x6e8e5e4d), X(0x6ea124d8), X(0x6eb3df70), X(0x6ec68e13), X(0x6ed930c3), X(0x6eebc77d), X(0x6efe5242), X(0x6f10d111), X(0x6f2343e9), X(0x6f35aacb), X(0x6f4805b5), X(0x6f5a54a8), X(0x6f6c97a2), X(0x6f7ecea4), X(0x6f90f9ae), X(0x6fa318be), X(0x6fb52bd6), X(0x6fc732f4), X(0x6fd92e19), X(0x6feb1d44), X(0x6ffd0076), X(0x700ed7ad), X(0x7020a2eb), X(0x7032622f), X(0x7044157a), X(0x7055bcca), X(0x70675821), X(0x7078e77e), X(0x708a6ae2), X(0x709be24c), X(0x70ad4dbd), X(0x70bead36), X(0x70d000b5), X(0x70e1483d), X(0x70f283cc), X(0x7103b363), X(0x7114d704), X(0x7125eead), X(0x7136fa60), X(0x7147fa1c), X(0x7158ede4), X(0x7169d5b6), X(0x717ab193), X(0x718b817d), X(0x719c4573), X(0x71acfd76), X(0x71bda988), X(0x71ce49a8), X(0x71deddd7), X(0x71ef6617), X(0x71ffe267), X(0x721052ca), X(0x7220b73e), X(0x72310fc6), X(0x72415c62), X(0x72519d14), X(0x7261d1db), X(0x7271faba), X(0x728217b1), X(0x729228c0), X(0x72a22dea), X(0x72b22730), X(0x72c21491), X(0x72d1f611), X(0x72e1cbaf), X(0x72f1956c), X(0x7301534c), X(0x7311054d), X(0x7320ab72), X(0x733045bc), X(0x733fd42d), X(0x734f56c5), X(0x735ecd86), X(0x736e3872), X(0x737d9789), X(0x738ceacf), X(0x739c3243), X(0x73ab6de7), X(0x73ba9dbe), X(0x73c9c1c8), X(0x73d8da08), X(0x73e7e67f), X(0x73f6e72e), X(0x7405dc17), X(0x7414c53c), X(0x7423a29f), X(0x74327442), X(0x74413a26), X(0x744ff44d), X(0x745ea2b9), X(0x746d456c), X(0x747bdc68), X(0x748a67ae), X(0x7498e741), X(0x74a75b23), X(0x74b5c356), X(0x74c41fdb), X(0x74d270b6), X(0x74e0b5e7), X(0x74eeef71), X(0x74fd1d57), X(0x750b3f9a), X(0x7519563c), X(0x75276140), X(0x753560a8), X(0x75435477), X(0x75513cae), X(0x755f1951), X(0x756cea60), X(0x757aafdf), X(0x758869d1), X(0x75961837), X(0x75a3bb14), X(0x75b1526a), X(0x75bede3c), X(0x75cc5e8d), X(0x75d9d35f), X(0x75e73cb5), X(0x75f49a91), X(0x7601ecf6), X(0x760f33e6), X(0x761c6f65), X(0x76299f74), X(0x7636c417), X(0x7643dd51), X(0x7650eb24), X(0x765ded93), X(0x766ae4a0), X(0x7677d050), X(0x7684b0a4), X(0x7691859f), X(0x769e4f45), X(0x76ab0d98), X(0x76b7c09c), X(0x76c46852), X(0x76d104bf), X(0x76dd95e6), X(0x76ea1bc9), X(0x76f6966b), X(0x770305d0), X(0x770f69fb), X(0x771bc2ef), X(0x772810af), X(0x7734533e), X(0x77408aa0), X(0x774cb6d7), X(0x7758d7e8), X(0x7764edd5), X(0x7770f8a2), X(0x777cf852), X(0x7788ece8), X(0x7794d668), X(0x77a0b4d5), X(0x77ac8833), X(0x77b85085), X(0x77c40dce), X(0x77cfc013), X(0x77db6756), X(0x77e7039b), X(0x77f294e6), X(0x77fe1b3b), X(0x7809969c), X(0x7815070e), X(0x78206c93), X(0x782bc731), X(0x783716ea), X(0x78425bc3), X(0x784d95be), X(0x7858c4e1), X(0x7863e92d), X(0x786f02a8), X(0x787a1156), X(0x78851539), X(0x78900e56), X(0x789afcb1), X(0x78a5e04d), X(0x78b0b92f), X(0x78bb875b), X(0x78c64ad4), X(0x78d1039e), X(0x78dbb1be), X(0x78e65537), X(0x78f0ee0e), X(0x78fb7c46), X(0x7905ffe4), X(0x791078ec), X(0x791ae762), X(0x79254b4a), X(0x792fa4a7), X(0x7939f380), X(0x794437d7), X(0x794e71b0), X(0x7958a111), X(0x7962c5fd), X(0x796ce078), X(0x7976f087), X(0x7980f62f), X(0x798af173), X(0x7994e258), X(0x799ec8e2), X(0x79a8a515), X(0x79b276f7), X(0x79bc3e8b), X(0x79c5fbd6), X(0x79cfaedc), X(0x79d957a2), X(0x79e2f62c), X(0x79ec8a7f), X(0x79f6149f), X(0x79ff9492), X(0x7a090a5a), X(0x7a1275fe), X(0x7a1bd781), X(0x7a252ee9), X(0x7a2e7c39), X(0x7a37bf77), X(0x7a40f8a7), X(0x7a4a27ce), X(0x7a534cf0), X(0x7a5c6813), X(0x7a65793b), X(0x7a6e806d), X(0x7a777dad), X(0x7a807100), X(0x7a895a6b), X(0x7a9239f4), X(0x7a9b0f9e), X(0x7aa3db6f), X(0x7aac9d6b), X(0x7ab55597), X(0x7abe03f9), X(0x7ac6a895), X(0x7acf4370), X(0x7ad7d48f), X(0x7ae05bf6), X(0x7ae8d9ac), X(0x7af14db5), X(0x7af9b815), X(0x7b0218d2), X(0x7b0a6ff2), X(0x7b12bd78), X(0x7b1b016a), X(0x7b233bce), X(0x7b2b6ca7), X(0x7b3393fc), X(0x7b3bb1d1), X(0x7b43c62c), X(0x7b4bd111), X(0x7b53d286), X(0x7b5bca90), X(0x7b63b935), X(0x7b6b9e78), X(0x7b737a61), X(0x7b7b4cf3), X(0x7b831634), X(0x7b8ad629), X(0x7b928cd8), X(0x7b9a3a45), X(0x7ba1de77), X(0x7ba97972), X(0x7bb10b3c), X(0x7bb893d9), X(0x7bc01350), X(0x7bc789a6), X(0x7bcef6e0), X(0x7bd65b03), X(0x7bddb616), X(0x7be5081c), X(0x7bec511c), X(0x7bf3911b), X(0x7bfac81f), X(0x7c01f62c), X(0x7c091b49), X(0x7c10377b), X(0x7c174ac7), X(0x7c1e5532), X(0x7c2556c4), X(0x7c2c4f80), X(0x7c333f6c), X(0x7c3a268e), X(0x7c4104ec), X(0x7c47da8a), X(0x7c4ea76f), X(0x7c556ba1), X(0x7c5c2724), X(0x7c62d9fe), X(0x7c698435), X(0x7c7025cf), X(0x7c76bed0), X(0x7c7d4f40), X(0x7c83d723), X(0x7c8a567f), X(0x7c90cd5a), X(0x7c973bb9), X(0x7c9da1a2), X(0x7ca3ff1b), X(0x7caa542a), X(0x7cb0a0d3), X(0x7cb6e51e), X(0x7cbd210f), X(0x7cc354ac), X(0x7cc97ffc), X(0x7ccfa304), X(0x7cd5bdc9), X(0x7cdbd051), X(0x7ce1daa3), X(0x7ce7dcc3), X(0x7cedd6b8), X(0x7cf3c888), X(0x7cf9b238), X(0x7cff93cf), X(0x7d056d51), X(0x7d0b3ec5), X(0x7d110830), X(0x7d16c99a), X(0x7d1c8306), X(0x7d22347c), X(0x7d27de00), X(0x7d2d7f9a), X(0x7d33194f), X(0x7d38ab24), X(0x7d3e351f), X(0x7d43b748), X(0x7d4931a2), X(0x7d4ea435), X(0x7d540f06), X(0x7d59721b), X(0x7d5ecd7b), X(0x7d64212a), X(0x7d696d2f), X(0x7d6eb190), X(0x7d73ee53), X(0x7d79237e), X(0x7d7e5117), X(0x7d837723), X(0x7d8895a9), X(0x7d8dacae), X(0x7d92bc3a), X(0x7d97c451), X(0x7d9cc4f9), X(0x7da1be39), X(0x7da6b017), X(0x7dab9a99), X(0x7db07dc4), X(0x7db5599e), X(0x7dba2e2f), X(0x7dbefb7b), X(0x7dc3c189), X(0x7dc8805e), X(0x7dcd3802), X(0x7dd1e879), X(0x7dd691ca), X(0x7ddb33fb), X(0x7ddfcf12), X(0x7de46315), X(0x7de8f00a), X(0x7ded75f8), X(0x7df1f4e3), X(0x7df66cd3), X(0x7dfaddcd), X(0x7dff47d7), X(0x7e03aaf8), X(0x7e080735), X(0x7e0c5c95), X(0x7e10ab1e), X(0x7e14f2d5), X(0x7e1933c1), X(0x7e1d6de8), X(0x7e21a150), X(0x7e25cdff), X(0x7e29f3fc), X(0x7e2e134c), X(0x7e322bf5), X(0x7e363dfd), X(0x7e3a496b), X(0x7e3e4e45), X(0x7e424c90), X(0x7e464454), X(0x7e4a3595), X(0x7e4e205a), X(0x7e5204aa), X(0x7e55e289), X(0x7e59b9ff), X(0x7e5d8b12), X(0x7e6155c7), X(0x7e651a24), X(0x7e68d831), X(0x7e6c8ff2), X(0x7e70416e), X(0x7e73ecac), X(0x7e7791b0), X(0x7e7b3082), X(0x7e7ec927), X(0x7e825ba6), X(0x7e85e804), X(0x7e896e48), X(0x7e8cee77), X(0x7e906899), X(0x7e93dcb2), X(0x7e974aca), X(0x7e9ab2e5), X(0x7e9e150b), X(0x7ea17141), X(0x7ea4c78e), X(0x7ea817f7), X(0x7eab6283), X(0x7eaea737), X(0x7eb1e61a), X(0x7eb51f33), X(0x7eb85285), X(0x7ebb8019), X(0x7ebea7f4), X(0x7ec1ca1d), X(0x7ec4e698), X(0x7ec7fd6d), X(0x7ecb0ea1), X(0x7ece1a3a), X(0x7ed1203f), X(0x7ed420b6), X(0x7ed71ba4), X(0x7eda110f), X(0x7edd00ff), X(0x7edfeb78), X(0x7ee2d081), X(0x7ee5b01f), X(0x7ee88a5a), X(0x7eeb5f36), X(0x7eee2eba), X(0x7ef0f8ed), X(0x7ef3bdd3), X(0x7ef67d73), X(0x7ef937d3), X(0x7efbecf9), X(0x7efe9ceb), X(0x7f0147ae), X(0x7f03ed4a), X(0x7f068dc4), X(0x7f092922), X(0x7f0bbf69), X(0x7f0e50a1), X(0x7f10dcce), X(0x7f1363f7), X(0x7f15e622), X(0x7f186355), X(0x7f1adb95), X(0x7f1d4ee9), X(0x7f1fbd57), X(0x7f2226e4), X(0x7f248b96), X(0x7f26eb74), X(0x7f294683), X(0x7f2b9cc9), X(0x7f2dee4d), X(0x7f303b13), X(0x7f328322), X(0x7f34c680), X(0x7f370533), X(0x7f393f40), X(0x7f3b74ad), X(0x7f3da581), X(0x7f3fd1c1), X(0x7f41f972), X(0x7f441c9c), X(0x7f463b43), X(0x7f48556d), X(0x7f4a6b21), X(0x7f4c7c64), X(0x7f4e893c), X(0x7f5091ae), X(0x7f5295c1), X(0x7f54957a), X(0x7f5690e0), X(0x7f5887f7), X(0x7f5a7ac5), X(0x7f5c6951), X(0x7f5e53a0), X(0x7f6039b8), X(0x7f621b9e), X(0x7f63f958), X(0x7f65d2ed), X(0x7f67a861), X(0x7f6979ba), X(0x7f6b46ff), X(0x7f6d1034), X(0x7f6ed560), X(0x7f709687), X(0x7f7253b1), X(0x7f740ce1), X(0x7f75c21f), X(0x7f777370), X(0x7f7920d8), X(0x7f7aca5f), X(0x7f7c7008), X(0x7f7e11db), X(0x7f7fafdd), X(0x7f814a13), X(0x7f82e082), X(0x7f847331), X(0x7f860224), X(0x7f878d62), X(0x7f8914f0), X(0x7f8a98d4), X(0x7f8c1912), X(0x7f8d95b0), X(0x7f8f0eb5), X(0x7f908425), X(0x7f91f605), X(0x7f93645c), X(0x7f94cf2f), X(0x7f963683), X(0x7f979a5d), X(0x7f98fac4), X(0x7f9a57bb), X(0x7f9bb14a), X(0x7f9d0775), X(0x7f9e5a41), X(0x7f9fa9b4), X(0x7fa0f5d3), X(0x7fa23ea4), X(0x7fa3842b), X(0x7fa4c66f), X(0x7fa60575), X(0x7fa74141), X(0x7fa879d9), X(0x7fa9af42), X(0x7faae182), X(0x7fac109e), X(0x7fad3c9a), X(0x7fae657d), X(0x7faf8b4c), X(0x7fb0ae0b), X(0x7fb1cdc0), X(0x7fb2ea70), X(0x7fb40420), X(0x7fb51ad5), X(0x7fb62e95), X(0x7fb73f64), X(0x7fb84d48), X(0x7fb95846), X(0x7fba6062), X(0x7fbb65a2), X(0x7fbc680c), X(0x7fbd67a3), X(0x7fbe646d), X(0x7fbf5e70), X(0x7fc055af), X(0x7fc14a31), X(0x7fc23bf9), X(0x7fc32b0d), X(0x7fc41773), X(0x7fc5012e), X(0x7fc5e844), X(0x7fc6ccba), X(0x7fc7ae94), X(0x7fc88dd8), X(0x7fc96a8a), X(0x7fca44af), X(0x7fcb1c4c), X(0x7fcbf167), X(0x7fccc403), X(0x7fcd9425), X(0x7fce61d3), X(0x7fcf2d11), X(0x7fcff5e3), X(0x7fd0bc4f), X(0x7fd1805a), X(0x7fd24207), X(0x7fd3015c), X(0x7fd3be5d), X(0x7fd47910), X(0x7fd53178), X(0x7fd5e79b), X(0x7fd69b7c), X(0x7fd74d21), X(0x7fd7fc8e), X(0x7fd8a9c8), X(0x7fd954d4), X(0x7fd9fdb5), X(0x7fdaa471), X(0x7fdb490b), X(0x7fdbeb89), X(0x7fdc8bef), X(0x7fdd2a42), X(0x7fddc685), X(0x7fde60be), X(0x7fdef8f0), X(0x7fdf8f20), X(0x7fe02353), X(0x7fe0b58d), X(0x7fe145d3), X(0x7fe1d428), X(0x7fe26091), X(0x7fe2eb12), X(0x7fe373b0), X(0x7fe3fa6f), X(0x7fe47f53), X(0x7fe50260), X(0x7fe5839b), X(0x7fe60308), X(0x7fe680ab), X(0x7fe6fc88), X(0x7fe776a4), X(0x7fe7ef02), X(0x7fe865a7), X(0x7fe8da97), X(0x7fe94dd6), X(0x7fe9bf68), X(0x7fea2f51), X(0x7fea9d95), X(0x7feb0a39), X(0x7feb7540), X(0x7febdeae), X(0x7fec4687), X(0x7fecaccf), X(0x7fed118b), X(0x7fed74be), X(0x7fedd66c), X(0x7fee3698), X(0x7fee9548), X(0x7feef27e), X(0x7fef4e3f), X(0x7fefa88e), X(0x7ff0016f), X(0x7ff058e7), X(0x7ff0aef8), X(0x7ff103a6), X(0x7ff156f6), X(0x7ff1a8eb), X(0x7ff1f988), X(0x7ff248d2), X(0x7ff296cc), X(0x7ff2e37a), X(0x7ff32edf), X(0x7ff378ff), X(0x7ff3c1de), X(0x7ff4097e), X(0x7ff44fe5), X(0x7ff49515), X(0x7ff4d911), X(0x7ff51bde), X(0x7ff55d7f), X(0x7ff59df7), X(0x7ff5dd4a), X(0x7ff61b7b), X(0x7ff6588d), X(0x7ff69485), X(0x7ff6cf65), X(0x7ff70930), X(0x7ff741eb), X(0x7ff77998), X(0x7ff7b03b), X(0x7ff7e5d7), X(0x7ff81a6f), X(0x7ff84e06), X(0x7ff880a1), X(0x7ff8b241), X(0x7ff8e2ea), X(0x7ff912a0), X(0x7ff94165), X(0x7ff96f3d), X(0x7ff99c2b), X(0x7ff9c831), X(0x7ff9f354), X(0x7ffa1d95), X(0x7ffa46f9), X(0x7ffa6f81), X(0x7ffa9731), X(0x7ffabe0d), X(0x7ffae416), X(0x7ffb0951), X(0x7ffb2dbf), X(0x7ffb5164), X(0x7ffb7442), X(0x7ffb965d), X(0x7ffbb7b8), X(0x7ffbd854), X(0x7ffbf836), X(0x7ffc175f), X(0x7ffc35d3), X(0x7ffc5394), X(0x7ffc70a5), X(0x7ffc8d09), X(0x7ffca8c2), X(0x7ffcc3d4), X(0x7ffcde3f), X(0x7ffcf809), X(0x7ffd1132), X(0x7ffd29be), X(0x7ffd41ae), X(0x7ffd5907), X(0x7ffd6fc9), X(0x7ffd85f9), X(0x7ffd9b97), X(0x7ffdb0a7), X(0x7ffdc52b), X(0x7ffdd926), X(0x7ffdec99), X(0x7ffdff88), X(0x7ffe11f4), X(0x7ffe23e0), X(0x7ffe354f), X(0x7ffe4642), X(0x7ffe56bc), X(0x7ffe66bf), X(0x7ffe764e), X(0x7ffe856a), X(0x7ffe9416), X(0x7ffea254), X(0x7ffeb026), X(0x7ffebd8e), X(0x7ffeca8f), X(0x7ffed72a), X(0x7ffee362), X(0x7ffeef38), X(0x7ffefaaf), X(0x7fff05c9), X(0x7fff1087), X(0x7fff1aec), X(0x7fff24f9), X(0x7fff2eb1), X(0x7fff3816), X(0x7fff4128), X(0x7fff49eb), X(0x7fff5260), X(0x7fff5a88), X(0x7fff6266), X(0x7fff69fc), X(0x7fff714b), X(0x7fff7854), X(0x7fff7f1a), X(0x7fff859f), X(0x7fff8be3), X(0x7fff91ea), X(0x7fff97b3), X(0x7fff9d41), X(0x7fffa296), X(0x7fffa7b3), X(0x7fffac99), X(0x7fffb14b), X(0x7fffb5c9), X(0x7fffba15), X(0x7fffbe31), X(0x7fffc21d), X(0x7fffc5dc), X(0x7fffc96f), X(0x7fffccd8), X(0x7fffd016), X(0x7fffd32d), X(0x7fffd61c), X(0x7fffd8e7), X(0x7fffdb8d), X(0x7fffde0f), X(0x7fffe071), X(0x7fffe2b1), X(0x7fffe4d2), X(0x7fffe6d5), X(0x7fffe8bb), X(0x7fffea85), X(0x7fffec34), X(0x7fffedc9), X(0x7fffef45), X(0x7ffff0aa), X(0x7ffff1f7), X(0x7ffff330), X(0x7ffff453), X(0x7ffff562), X(0x7ffff65f), X(0x7ffff749), X(0x7ffff823), X(0x7ffff8ec), X(0x7ffff9a6), X(0x7ffffa51), X(0x7ffffaee), X(0x7ffffb7e), X(0x7ffffc02), X(0x7ffffc7a), X(0x7ffffce7), X(0x7ffffd4a), X(0x7ffffda3), X(0x7ffffdf4), X(0x7ffffe3c), X(0x7ffffe7c), X(0x7ffffeb6), X(0x7ffffee8), X(0x7fffff15), X(0x7fffff3c), X(0x7fffff5e), X(0x7fffff7b), X(0x7fffff95), X(0x7fffffaa), X(0x7fffffbc), X(0x7fffffcb), X(0x7fffffd7), X(0x7fffffe2), X(0x7fffffea), X(0x7ffffff0), X(0x7ffffff5), X(0x7ffffff9), X(0x7ffffffb), X(0x7ffffffd), X(0x7ffffffe), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), }; static const LOOKUP_T vwin8192[4096] = { X(0x0000007c), X(0x0000045c), X(0x00000c1d), X(0x000017bd), X(0x0000273e), X(0x00003a9f), X(0x000051e0), X(0x00006d02), X(0x00008c03), X(0x0000aee5), X(0x0000d5a7), X(0x00010049), X(0x00012ecb), X(0x0001612d), X(0x00019770), X(0x0001d193), X(0x00020f96), X(0x00025178), X(0x0002973c), X(0x0002e0df), X(0x00032e62), X(0x00037fc5), X(0x0003d509), X(0x00042e2c), X(0x00048b30), X(0x0004ec13), X(0x000550d7), X(0x0005b97a), X(0x000625fe), X(0x00069661), X(0x00070aa4), X(0x000782c8), X(0x0007fecb), X(0x00087eae), X(0x00090271), X(0x00098a14), X(0x000a1597), X(0x000aa4f9), X(0x000b383b), X(0x000bcf5d), X(0x000c6a5f), X(0x000d0941), X(0x000dac02), X(0x000e52a3), X(0x000efd23), X(0x000fab84), X(0x00105dc3), X(0x001113e3), X(0x0011cde2), X(0x00128bc0), X(0x00134d7e), X(0x0014131b), X(0x0014dc98), X(0x0015a9f4), X(0x00167b30), X(0x0017504a), X(0x00182945), X(0x0019061e), X(0x0019e6d7), X(0x001acb6f), X(0x001bb3e6), X(0x001ca03c), X(0x001d9071), X(0x001e8485), X(0x001f7c79), X(0x0020784b), X(0x002177fc), X(0x00227b8c), X(0x002382fb), X(0x00248e49), X(0x00259d76), X(0x0026b081), X(0x0027c76b), X(0x0028e234), X(0x002a00dc), X(0x002b2361), X(0x002c49c6), X(0x002d7409), X(0x002ea22a), X(0x002fd42a), X(0x00310a08), X(0x003243c5), X(0x00338160), X(0x0034c2d9), X(0x00360830), X(0x00375165), X(0x00389e78), X(0x0039ef6a), X(0x003b4439), X(0x003c9ce6), X(0x003df971), X(0x003f59da), X(0x0040be20), X(0x00422645), X(0x00439247), X(0x00450226), X(0x004675e3), X(0x0047ed7e), X(0x004968f5), X(0x004ae84b), X(0x004c6b7d), X(0x004df28d), X(0x004f7d7a), X(0x00510c44), X(0x00529eeb), X(0x00543570), X(0x0055cfd1), X(0x00576e0f), X(0x00591029), X(0x005ab621), X(0x005c5ff5), X(0x005e0da6), X(0x005fbf33), X(0x0061749d), X(0x00632de4), X(0x0064eb06), X(0x0066ac05), X(0x006870e0), X(0x006a3998), X(0x006c062b), X(0x006dd69b), X(0x006faae6), X(0x0071830d), X(0x00735f10), X(0x00753eef), X(0x007722a9), X(0x00790a3f), X(0x007af5b1), X(0x007ce4fe), X(0x007ed826), X(0x0080cf29), X(0x0082ca08), X(0x0084c8c2), X(0x0086cb57), X(0x0088d1c7), X(0x008adc11), X(0x008cea37), X(0x008efc37), X(0x00911212), X(0x00932bc7), X(0x00954957), X(0x00976ac2), X(0x00999006), X(0x009bb925), X(0x009de61e), X(0x00a016f1), X(0x00a24b9e), X(0x00a48425), X(0x00a6c086), X(0x00a900c0), X(0x00ab44d4), X(0x00ad8cc2), X(0x00afd889), X(0x00b22829), X(0x00b47ba2), X(0x00b6d2f5), X(0x00b92e21), X(0x00bb8d26), X(0x00bdf004), X(0x00c056ba), X(0x00c2c149), X(0x00c52fb1), X(0x00c7a1f1), X(0x00ca180a), X(0x00cc91fb), X(0x00cf0fc5), X(0x00d19166), X(0x00d416df), X(0x00d6a031), X(0x00d92d5a), X(0x00dbbe5b), X(0x00de5333), X(0x00e0ebe3), X(0x00e3886b), X(0x00e628c9), X(0x00e8ccff), X(0x00eb750c), X(0x00ee20f0), X(0x00f0d0ab), X(0x00f3843d), X(0x00f63ba5), X(0x00f8f6e4), X(0x00fbb5fa), X(0x00fe78e5), X(0x01013fa7), X(0x01040a3f), X(0x0106d8ae), X(0x0109aaf2), X(0x010c810c), X(0x010f5afb), X(0x011238c0), X(0x01151a5b), X(0x0117ffcb), X(0x011ae910), X(0x011dd62a), X(0x0120c719), X(0x0123bbdd), X(0x0126b476), X(0x0129b0e4), X(0x012cb126), X(0x012fb53c), X(0x0132bd27), X(0x0135c8e6), X(0x0138d879), X(0x013bebdf), X(0x013f031a), X(0x01421e28), X(0x01453d0a), X(0x01485fbf), X(0x014b8648), X(0x014eb0a4), X(0x0151ded2), X(0x015510d4), X(0x015846a8), X(0x015b8050), X(0x015ebdc9), X(0x0161ff15), X(0x01654434), X(0x01688d24), X(0x016bd9e6), X(0x016f2a7b), X(0x01727ee1), X(0x0175d718), X(0x01793321), X(0x017c92fc), X(0x017ff6a7), X(0x01835e24), X(0x0186c972), X(0x018a3890), X(0x018dab7f), X(0x0191223f), X(0x01949ccf), X(0x01981b2f), X(0x019b9d5f), X(0x019f235f), X(0x01a2ad2f), X(0x01a63acf), X(0x01a9cc3e), X(0x01ad617c), X(0x01b0fa8a), X(0x01b49767), X(0x01b83813), X(0x01bbdc8d), X(0x01bf84d6), X(0x01c330ee), X(0x01c6e0d4), X(0x01ca9488), X(0x01ce4c0b), X(0x01d2075b), X(0x01d5c679), X(0x01d98964), X(0x01dd501d), X(0x01e11aa3), X(0x01e4e8f6), X(0x01e8bb17), X(0x01ec9104), X(0x01f06abd), X(0x01f44844), X(0x01f82996), X(0x01fc0eb5), X(0x01fff7a0), X(0x0203e456), X(0x0207d4d9), X(0x020bc926), X(0x020fc140), X(0x0213bd24), X(0x0217bcd4), X(0x021bc04e), X(0x021fc793), X(0x0223d2a3), X(0x0227e17d), X(0x022bf421), X(0x02300a90), X(0x023424c8), X(0x023842ca), X(0x023c6495), X(0x02408a2a), X(0x0244b389), X(0x0248e0b0), X(0x024d11a0), X(0x02514659), X(0x02557eda), X(0x0259bb24), X(0x025dfb35), X(0x02623f0f), X(0x026686b1), X(0x026ad21a), X(0x026f214b), X(0x02737443), X(0x0277cb02), X(0x027c2588), X(0x028083d5), X(0x0284e5e9), X(0x02894bc2), X(0x028db562), X(0x029222c8), X(0x029693f4), X(0x029b08e6), X(0x029f819d), X(0x02a3fe19), X(0x02a87e5b), X(0x02ad0261), X(0x02b18a2c), X(0x02b615bb), X(0x02baa50f), X(0x02bf3827), X(0x02c3cf03), X(0x02c869a3), X(0x02cd0807), X(0x02d1aa2d), X(0x02d65017), X(0x02daf9c4), X(0x02dfa734), X(0x02e45866), X(0x02e90d5b), X(0x02edc612), X(0x02f2828b), X(0x02f742c6), X(0x02fc06c3), X(0x0300ce80), X(0x030599ff), X(0x030a6940), X(0x030f3c40), X(0x03141302), X(0x0318ed84), X(0x031dcbc6), X(0x0322adc8), X(0x0327938a), X(0x032c7d0c), X(0x03316a4c), X(0x03365b4d), X(0x033b500c), X(0x03404889), X(0x034544c6), X(0x034a44c0), X(0x034f4879), X(0x03544ff0), X(0x03595b24), X(0x035e6a16), X(0x03637cc5), X(0x03689331), X(0x036dad5a), X(0x0372cb40), X(0x0377ece2), X(0x037d1240), X(0x03823b5a), X(0x03876830), X(0x038c98c1), X(0x0391cd0e), X(0x03970516), X(0x039c40d8), X(0x03a18055), X(0x03a6c38d), X(0x03ac0a7f), X(0x03b1552b), X(0x03b6a390), X(0x03bbf5af), X(0x03c14b88), X(0x03c6a519), X(0x03cc0263), X(0x03d16366), X(0x03d6c821), X(0x03dc3094), X(0x03e19cc0), X(0x03e70ca2), X(0x03ec803d), X(0x03f1f78e), X(0x03f77296), X(0x03fcf155), X(0x040273cb), X(0x0407f9f7), X(0x040d83d9), X(0x04131170), X(0x0418a2bd), X(0x041e37c0), X(0x0423d077), X(0x04296ce4), X(0x042f0d04), X(0x0434b0da), X(0x043a5863), X(0x044003a0), X(0x0445b290), X(0x044b6534), X(0x04511b8b), X(0x0456d595), X(0x045c9352), X(0x046254c1), X(0x046819e1), X(0x046de2b4), X(0x0473af39), X(0x04797f6e), X(0x047f5355), X(0x04852aec), X(0x048b0635), X(0x0490e52d), X(0x0496c7d6), X(0x049cae2e), X(0x04a29836), X(0x04a885ed), X(0x04ae7753), X(0x04b46c68), X(0x04ba652b), X(0x04c0619d), X(0x04c661bc), X(0x04cc658a), X(0x04d26d04), X(0x04d8782c), X(0x04de8701), X(0x04e49983), X(0x04eaafb0), X(0x04f0c98a), X(0x04f6e710), X(0x04fd0842), X(0x05032d1e), X(0x050955a6), X(0x050f81d8), X(0x0515b1b5), X(0x051be53d), X(0x05221c6e), X(0x05285748), X(0x052e95cd), X(0x0534d7fa), X(0x053b1dd0), X(0x0541674e), X(0x0547b475), X(0x054e0544), X(0x055459bb), X(0x055ab1d9), X(0x05610d9e), X(0x05676d0a), X(0x056dd01c), X(0x057436d5), X(0x057aa134), X(0x05810f38), X(0x058780e2), X(0x058df631), X(0x05946f25), X(0x059aebbe), X(0x05a16bfa), X(0x05a7efdb), X(0x05ae775f), X(0x05b50287), X(0x05bb9152), X(0x05c223c0), X(0x05c8b9d0), X(0x05cf5382), X(0x05d5f0d6), X(0x05dc91cc), X(0x05e33663), X(0x05e9de9c), X(0x05f08a75), X(0x05f739ee), X(0x05fded07), X(0x0604a3c0), X(0x060b5e19), X(0x06121c11), X(0x0618dda8), X(0x061fa2dd), X(0x06266bb1), X(0x062d3822), X(0x06340831), X(0x063adbde), X(0x0641b328), X(0x06488e0e), X(0x064f6c91), X(0x06564eaf), X(0x065d346a), X(0x06641dc0), X(0x066b0ab1), X(0x0671fb3d), X(0x0678ef64), X(0x067fe724), X(0x0686e27f), X(0x068de173), X(0x0694e400), X(0x069bea27), X(0x06a2f3e6), X(0x06aa013d), X(0x06b1122c), X(0x06b826b3), X(0x06bf3ed1), X(0x06c65a86), X(0x06cd79d1), X(0x06d49cb3), X(0x06dbc32b), X(0x06e2ed38), X(0x06ea1adb), X(0x06f14c13), X(0x06f880df), X(0x06ffb940), X(0x0706f535), X(0x070e34bd), X(0x071577d9), X(0x071cbe88), X(0x072408c9), X(0x072b569d), X(0x0732a802), X(0x0739fcf9), X(0x07415582), X(0x0748b19b), X(0x07501145), X(0x0757747f), X(0x075edb49), X(0x076645a3), X(0x076db38c), X(0x07752503), X(0x077c9a09), X(0x0784129e), X(0x078b8ec0), X(0x07930e70), X(0x079a91ac), X(0x07a21876), X(0x07a9a2cc), X(0x07b130ad), X(0x07b8c21b), X(0x07c05714), X(0x07c7ef98), X(0x07cf8ba6), X(0x07d72b3f), X(0x07dece62), X(0x07e6750e), X(0x07ee1f43), X(0x07f5cd01), X(0x07fd7e48), X(0x08053316), X(0x080ceb6d), X(0x0814a74a), X(0x081c66af), X(0x0824299a), X(0x082bf00c), X(0x0833ba03), X(0x083b8780), X(0x08435882), X(0x084b2d09), X(0x08530514), X(0x085ae0a3), X(0x0862bfb6), X(0x086aa24c), X(0x08728865), X(0x087a7201), X(0x08825f1e), X(0x088a4fbe), X(0x089243de), X(0x089a3b80), X(0x08a236a2), X(0x08aa3545), X(0x08b23767), X(0x08ba3d09), X(0x08c2462a), X(0x08ca52c9), X(0x08d262e7), X(0x08da7682), X(0x08e28d9c), X(0x08eaa832), X(0x08f2c645), X(0x08fae7d4), X(0x09030cdf), X(0x090b3566), X(0x09136168), X(0x091b90e5), X(0x0923c3dc), X(0x092bfa4d), X(0x09343437), X(0x093c719b), X(0x0944b277), X(0x094cf6cc), X(0x09553e99), X(0x095d89dd), X(0x0965d899), X(0x096e2acb), X(0x09768073), X(0x097ed991), X(0x09873625), X(0x098f962e), X(0x0997f9ac), X(0x09a0609e), X(0x09a8cb04), X(0x09b138dd), X(0x09b9aa29), X(0x09c21ee8), X(0x09ca9719), X(0x09d312bc), X(0x09db91d0), X(0x09e41456), X(0x09ec9a4b), X(0x09f523b1), X(0x09fdb087), X(0x0a0640cc), X(0x0a0ed47f), X(0x0a176ba2), X(0x0a200632), X(0x0a28a42f), X(0x0a31459a), X(0x0a39ea72), X(0x0a4292b5), X(0x0a4b3e65), X(0x0a53ed80), X(0x0a5ca006), X(0x0a6555f7), X(0x0a6e0f51), X(0x0a76cc16), X(0x0a7f8c44), X(0x0a884fda), X(0x0a9116d9), X(0x0a99e140), X(0x0aa2af0e), X(0x0aab8043), X(0x0ab454df), X(0x0abd2ce1), X(0x0ac60849), X(0x0acee716), X(0x0ad7c948), X(0x0ae0aedf), X(0x0ae997d9), X(0x0af28437), X(0x0afb73f7), X(0x0b04671b), X(0x0b0d5da0), X(0x0b165788), X(0x0b1f54d0), X(0x0b285579), X(0x0b315983), X(0x0b3a60ec), X(0x0b436bb5), X(0x0b4c79dd), X(0x0b558b63), X(0x0b5ea048), X(0x0b67b88a), X(0x0b70d429), X(0x0b79f324), X(0x0b83157c), X(0x0b8c3b30), X(0x0b95643f), X(0x0b9e90a8), X(0x0ba7c06c), X(0x0bb0f38a), X(0x0bba2a01), X(0x0bc363d1), X(0x0bcca0f9), X(0x0bd5e17a), X(0x0bdf2552), X(0x0be86c81), X(0x0bf1b706), X(0x0bfb04e2), X(0x0c045613), X(0x0c0daa99), X(0x0c170274), X(0x0c205da3), X(0x0c29bc25), X(0x0c331dfb), X(0x0c3c8323), X(0x0c45eb9e), X(0x0c4f576a), X(0x0c58c688), X(0x0c6238f6), X(0x0c6baeb5), X(0x0c7527c3), X(0x0c7ea421), X(0x0c8823cd), X(0x0c91a6c8), X(0x0c9b2d10), X(0x0ca4b6a6), X(0x0cae4389), X(0x0cb7d3b8), X(0x0cc16732), X(0x0ccafdf8), X(0x0cd49809), X(0x0cde3564), X(0x0ce7d609), X(0x0cf179f7), X(0x0cfb212e), X(0x0d04cbad), X(0x0d0e7974), X(0x0d182a83), X(0x0d21ded8), X(0x0d2b9673), X(0x0d355154), X(0x0d3f0f7b), X(0x0d48d0e6), X(0x0d529595), X(0x0d5c5d88), X(0x0d6628be), X(0x0d6ff737), X(0x0d79c8f2), X(0x0d839dee), X(0x0d8d762c), X(0x0d9751aa), X(0x0da13068), X(0x0dab1266), X(0x0db4f7a3), X(0x0dbee01e), X(0x0dc8cbd8), X(0x0dd2bace), X(0x0ddcad02), X(0x0de6a272), X(0x0df09b1e), X(0x0dfa9705), X(0x0e049627), X(0x0e0e9883), X(0x0e189e19), X(0x0e22a6e8), X(0x0e2cb2f0), X(0x0e36c230), X(0x0e40d4a8), X(0x0e4aea56), X(0x0e55033b), X(0x0e5f1f56), X(0x0e693ea7), X(0x0e73612c), X(0x0e7d86e5), X(0x0e87afd3), X(0x0e91dbf3), X(0x0e9c0b47), X(0x0ea63dcc), X(0x0eb07383), X(0x0ebaac6b), X(0x0ec4e883), X(0x0ecf27cc), X(0x0ed96a44), X(0x0ee3afea), X(0x0eedf8bf), X(0x0ef844c2), X(0x0f0293f2), X(0x0f0ce64e), X(0x0f173bd6), X(0x0f21948a), X(0x0f2bf069), X(0x0f364f72), X(0x0f40b1a5), X(0x0f4b1701), X(0x0f557f86), X(0x0f5feb32), X(0x0f6a5a07), X(0x0f74cc02), X(0x0f7f4124), X(0x0f89b96b), X(0x0f9434d8), X(0x0f9eb369), X(0x0fa9351e), X(0x0fb3b9f7), X(0x0fbe41f3), X(0x0fc8cd11), X(0x0fd35b51), X(0x0fddecb2), X(0x0fe88134), X(0x0ff318d6), X(0x0ffdb397), X(0x10085177), X(0x1012f275), X(0x101d9691), X(0x10283dca), X(0x1032e81f), X(0x103d9591), X(0x1048461e), X(0x1052f9c5), X(0x105db087), X(0x10686a62), X(0x10732756), X(0x107de763), X(0x1088aa87), X(0x109370c2), X(0x109e3a14), X(0x10a9067c), X(0x10b3d5f9), X(0x10bea88b), X(0x10c97e31), X(0x10d456eb), X(0x10df32b8), X(0x10ea1197), X(0x10f4f387), X(0x10ffd889), X(0x110ac09b), X(0x1115abbe), X(0x112099ef), X(0x112b8b2f), X(0x11367f7d), X(0x114176d9), X(0x114c7141), X(0x11576eb6), X(0x11626f36), X(0x116d72c1), X(0x11787957), X(0x118382f6), X(0x118e8f9e), X(0x11999f4f), X(0x11a4b208), X(0x11afc7c7), X(0x11bae08e), X(0x11c5fc5a), X(0x11d11b2c), X(0x11dc3d02), X(0x11e761dd), X(0x11f289ba), X(0x11fdb49b), X(0x1208e27e), X(0x12141362), X(0x121f4748), X(0x122a7e2d), X(0x1235b812), X(0x1240f4f6), X(0x124c34d9), X(0x125777b9), X(0x1262bd96), X(0x126e0670), X(0x12795245), X(0x1284a115), X(0x128ff2e0), X(0x129b47a5), X(0x12a69f63), X(0x12b1fa19), X(0x12bd57c7), X(0x12c8b86c), X(0x12d41c08), X(0x12df829a), X(0x12eaec21), X(0x12f6589d), X(0x1301c80c), X(0x130d3a6f), X(0x1318afc4), X(0x1324280b), X(0x132fa344), X(0x133b216d), X(0x1346a286), X(0x1352268e), X(0x135dad85), X(0x1369376a), X(0x1374c43c), X(0x138053fb), X(0x138be6a5), X(0x13977c3b), X(0x13a314bc), X(0x13aeb026), X(0x13ba4e79), X(0x13c5efb5), X(0x13d193d9), X(0x13dd3ae4), X(0x13e8e4d6), X(0x13f491ad), X(0x1400416a), X(0x140bf40b), X(0x1417a98f), X(0x142361f7), X(0x142f1d41), X(0x143adb6d), X(0x14469c7a), X(0x14526067), X(0x145e2734), X(0x1469f0df), X(0x1475bd69), X(0x14818cd0), X(0x148d5f15), X(0x14993435), X(0x14a50c31), X(0x14b0e708), X(0x14bcc4b8), X(0x14c8a542), X(0x14d488a5), X(0x14e06edf), X(0x14ec57f1), X(0x14f843d9), X(0x15043297), X(0x1510242b), X(0x151c1892), X(0x15280fcd), X(0x153409dc), X(0x154006bc), X(0x154c066e), X(0x155808f1), X(0x15640e44), X(0x15701666), X(0x157c2157), X(0x15882f16), X(0x15943fa2), X(0x15a052fb), X(0x15ac691f), X(0x15b8820f), X(0x15c49dc8), X(0x15d0bc4c), X(0x15dcdd98), X(0x15e901ad), X(0x15f52888), X(0x1601522b), X(0x160d7e93), X(0x1619adc1), X(0x1625dfb3), X(0x16321469), X(0x163e4be2), X(0x164a861d), X(0x1656c31a), X(0x166302d8), X(0x166f4555), X(0x167b8a92), X(0x1687d28e), X(0x16941d47), X(0x16a06abe), X(0x16acbaf0), X(0x16b90ddf), X(0x16c56388), X(0x16d1bbeb), X(0x16de1708), X(0x16ea74dd), X(0x16f6d56a), X(0x170338ae), X(0x170f9ea8), X(0x171c0758), X(0x172872bd), X(0x1734e0d6), X(0x174151a2), X(0x174dc520), X(0x175a3b51), X(0x1766b432), X(0x17732fc4), X(0x177fae05), X(0x178c2ef4), X(0x1798b292), X(0x17a538dd), X(0x17b1c1d4), X(0x17be4d77), X(0x17cadbc5), X(0x17d76cbc), X(0x17e4005e), X(0x17f096a7), X(0x17fd2f98), X(0x1809cb31), X(0x1816696f), X(0x18230a53), X(0x182faddc), X(0x183c5408), X(0x1848fcd8), X(0x1855a849), X(0x1862565d), X(0x186f0711), X(0x187bba64), X(0x18887057), X(0x189528e9), X(0x18a1e418), X(0x18aea1e3), X(0x18bb624b), X(0x18c8254e), X(0x18d4eaeb), X(0x18e1b321), X(0x18ee7df1), X(0x18fb4b58), X(0x19081b57), X(0x1914edec), X(0x1921c317), X(0x192e9ad6), X(0x193b7529), X(0x19485210), X(0x19553189), X(0x19621393), X(0x196ef82e), X(0x197bdf59), X(0x1988c913), X(0x1995b55c), X(0x19a2a432), X(0x19af9595), X(0x19bc8983), X(0x19c97ffd), X(0x19d67900), X(0x19e3748e), X(0x19f072a3), X(0x19fd7341), X(0x1a0a7665), X(0x1a177c10), X(0x1a248440), X(0x1a318ef4), X(0x1a3e9c2c), X(0x1a4babe7), X(0x1a58be24), X(0x1a65d2e2), X(0x1a72ea20), X(0x1a8003de), X(0x1a8d201a), X(0x1a9a3ed5), X(0x1aa7600c), X(0x1ab483bf), X(0x1ac1a9ee), X(0x1aced297), X(0x1adbfdba), X(0x1ae92b56), X(0x1af65b69), X(0x1b038df4), X(0x1b10c2f5), X(0x1b1dfa6b), X(0x1b2b3456), X(0x1b3870b5), X(0x1b45af87), X(0x1b52f0ca), X(0x1b60347f), X(0x1b6d7aa4), X(0x1b7ac339), X(0x1b880e3c), X(0x1b955bad), X(0x1ba2ab8b), X(0x1baffdd5), X(0x1bbd528a), X(0x1bcaa9a9), X(0x1bd80332), X(0x1be55f24), X(0x1bf2bd7d), X(0x1c001e3d), X(0x1c0d8164), X(0x1c1ae6ef), X(0x1c284edf), X(0x1c35b932), X(0x1c4325e7), X(0x1c5094fe), X(0x1c5e0677), X(0x1c6b7a4f), X(0x1c78f086), X(0x1c86691b), X(0x1c93e40d), X(0x1ca1615c), X(0x1caee107), X(0x1cbc630c), X(0x1cc9e76b), X(0x1cd76e23), X(0x1ce4f733), X(0x1cf2829a), X(0x1d001057), X(0x1d0da06a), X(0x1d1b32d1), X(0x1d28c78c), X(0x1d365e9a), X(0x1d43f7f9), X(0x1d5193a9), X(0x1d5f31aa), X(0x1d6cd1f9), X(0x1d7a7497), X(0x1d881982), X(0x1d95c0ba), X(0x1da36a3d), X(0x1db1160a), X(0x1dbec422), X(0x1dcc7482), X(0x1dda272b), X(0x1de7dc1a), X(0x1df59350), X(0x1e034ccb), X(0x1e11088a), X(0x1e1ec68c), X(0x1e2c86d1), X(0x1e3a4958), X(0x1e480e20), X(0x1e55d527), X(0x1e639e6d), X(0x1e7169f1), X(0x1e7f37b2), X(0x1e8d07b0), X(0x1e9ad9e8), X(0x1ea8ae5b), X(0x1eb68507), X(0x1ec45dec), X(0x1ed23908), X(0x1ee0165b), X(0x1eedf5e4), X(0x1efbd7a1), X(0x1f09bb92), X(0x1f17a1b6), X(0x1f258a0d), X(0x1f337494), X(0x1f41614b), X(0x1f4f5032), X(0x1f5d4147), X(0x1f6b3489), X(0x1f7929f7), X(0x1f872192), X(0x1f951b56), X(0x1fa31744), X(0x1fb1155b), X(0x1fbf159a), X(0x1fcd17ff), X(0x1fdb1c8b), X(0x1fe9233b), X(0x1ff72c0f), X(0x20053706), X(0x20134420), X(0x2021535a), X(0x202f64b4), X(0x203d782e), X(0x204b8dc6), X(0x2059a57c), X(0x2067bf4e), X(0x2075db3b), X(0x2083f943), X(0x20921964), X(0x20a03b9e), X(0x20ae5fef), X(0x20bc8657), X(0x20caaed5), X(0x20d8d967), X(0x20e7060e), X(0x20f534c7), X(0x21036592), X(0x2111986e), X(0x211fcd59), X(0x212e0454), X(0x213c3d5d), X(0x214a7873), X(0x2158b594), X(0x2166f4c1), X(0x217535f8), X(0x21837938), X(0x2191be81), X(0x21a005d0), X(0x21ae4f26), X(0x21bc9a81), X(0x21cae7e0), X(0x21d93743), X(0x21e788a8), X(0x21f5dc0e), X(0x22043174), X(0x221288da), X(0x2220e23e), X(0x222f3da0), X(0x223d9afe), X(0x224bfa58), X(0x225a5bac), X(0x2268bef9), X(0x2277243f), X(0x22858b7d), X(0x2293f4b0), X(0x22a25fda), X(0x22b0ccf8), X(0x22bf3c09), X(0x22cdad0d), X(0x22dc2002), X(0x22ea94e8), X(0x22f90bbe), X(0x23078482), X(0x2315ff33), X(0x23247bd1), X(0x2332fa5b), X(0x23417acf), X(0x234ffd2c), X(0x235e8173), X(0x236d07a0), X(0x237b8fb4), X(0x238a19ae), X(0x2398a58c), X(0x23a7334d), X(0x23b5c2f1), X(0x23c45477), X(0x23d2e7dd), X(0x23e17d22), X(0x23f01446), X(0x23fead47), X(0x240d4825), X(0x241be4dd), X(0x242a8371), X(0x243923dd), X(0x2447c622), X(0x24566a3e), X(0x24651031), X(0x2473b7f8), X(0x24826194), X(0x24910d03), X(0x249fba44), X(0x24ae6957), X(0x24bd1a39), X(0x24cbccea), X(0x24da816a), X(0x24e937b7), X(0x24f7efcf), X(0x2506a9b3), X(0x25156560), X(0x252422d6), X(0x2532e215), X(0x2541a31a), X(0x255065e4), X(0x255f2a74), X(0x256df0c7), X(0x257cb8dd), X(0x258b82b4), X(0x259a4e4c), X(0x25a91ba4), X(0x25b7eaba), X(0x25c6bb8e), X(0x25d58e1e), X(0x25e46269), X(0x25f3386e), X(0x2602102d), X(0x2610e9a4), X(0x261fc4d3), X(0x262ea1b7), X(0x263d8050), X(0x264c609e), X(0x265b429e), X(0x266a2650), X(0x26790bb3), X(0x2687f2c6), X(0x2696db88), X(0x26a5c5f7), X(0x26b4b213), X(0x26c39fda), X(0x26d28f4c), X(0x26e18067), X(0x26f0732b), X(0x26ff6796), X(0x270e5da7), X(0x271d555d), X(0x272c4eb7), X(0x273b49b5), X(0x274a4654), X(0x27594495), X(0x27684475), X(0x277745f4), X(0x27864910), X(0x27954dc9), X(0x27a4541e), X(0x27b35c0d), X(0x27c26596), X(0x27d170b7), X(0x27e07d6f), X(0x27ef8bbd), X(0x27fe9ba0), X(0x280dad18), X(0x281cc022), X(0x282bd4be), X(0x283aeaeb), X(0x284a02a7), X(0x28591bf2), X(0x286836cb), X(0x28775330), X(0x28867120), X(0x2895909b), X(0x28a4b19e), X(0x28b3d42a), X(0x28c2f83d), X(0x28d21dd5), X(0x28e144f3), X(0x28f06d94), X(0x28ff97b8), X(0x290ec35d), X(0x291df082), X(0x292d1f27), X(0x293c4f4a), X(0x294b80eb), X(0x295ab407), X(0x2969e89e), X(0x29791eaf), X(0x29885639), X(0x29978f3b), X(0x29a6c9b3), X(0x29b605a0), X(0x29c54302), X(0x29d481d7), X(0x29e3c21e), X(0x29f303d6), X(0x2a0246fd), X(0x2a118b94), X(0x2a20d198), X(0x2a301909), X(0x2a3f61e6), X(0x2a4eac2c), X(0x2a5df7dc), X(0x2a6d44f4), X(0x2a7c9374), X(0x2a8be359), X(0x2a9b34a2), X(0x2aaa8750), X(0x2ab9db60), X(0x2ac930d1), X(0x2ad887a3), X(0x2ae7dfd3), X(0x2af73962), X(0x2b06944e), X(0x2b15f096), X(0x2b254e38), X(0x2b34ad34), X(0x2b440d89), X(0x2b536f34), X(0x2b62d236), X(0x2b72368d), X(0x2b819c38), X(0x2b910336), X(0x2ba06b86), X(0x2bafd526), X(0x2bbf4015), X(0x2bceac53), X(0x2bde19de), X(0x2bed88b5), X(0x2bfcf8d7), X(0x2c0c6a43), X(0x2c1bdcf7), X(0x2c2b50f3), X(0x2c3ac635), X(0x2c4a3cbd), X(0x2c59b488), X(0x2c692d97), X(0x2c78a7e7), X(0x2c882378), X(0x2c97a049), X(0x2ca71e58), X(0x2cb69da4), X(0x2cc61e2c), X(0x2cd59ff0), X(0x2ce522ed), X(0x2cf4a723), X(0x2d042c90), X(0x2d13b334), X(0x2d233b0d), X(0x2d32c41a), X(0x2d424e5a), X(0x2d51d9cc), X(0x2d61666e), X(0x2d70f440), X(0x2d808340), X(0x2d90136e), X(0x2d9fa4c7), X(0x2daf374c), X(0x2dbecafa), X(0x2dce5fd1), X(0x2dddf5cf), X(0x2ded8cf4), X(0x2dfd253d), X(0x2e0cbeab), X(0x2e1c593b), X(0x2e2bf4ed), X(0x2e3b91c0), X(0x2e4b2fb1), X(0x2e5acec1), X(0x2e6a6eee), X(0x2e7a1037), X(0x2e89b29b), X(0x2e995618), X(0x2ea8faad), X(0x2eb8a05a), X(0x2ec8471c), X(0x2ed7eef4), X(0x2ee797df), X(0x2ef741dc), X(0x2f06eceb), X(0x2f16990a), X(0x2f264639), X(0x2f35f475), X(0x2f45a3bd), X(0x2f555412), X(0x2f650570), X(0x2f74b7d8), X(0x2f846b48), X(0x2f941fbe), X(0x2fa3d53a), X(0x2fb38bbb), X(0x2fc3433f), X(0x2fd2fbc5), X(0x2fe2b54c), X(0x2ff26fd3), X(0x30022b58), X(0x3011e7db), X(0x3021a55a), X(0x303163d4), X(0x30412348), X(0x3050e3b5), X(0x3060a519), X(0x30706773), X(0x30802ac3), X(0x308fef06), X(0x309fb43d), X(0x30af7a65), X(0x30bf417d), X(0x30cf0985), X(0x30ded27a), X(0x30ee9c5d), X(0x30fe672b), X(0x310e32e3), X(0x311dff85), X(0x312dcd0f), X(0x313d9b80), X(0x314d6ad7), X(0x315d3b12), X(0x316d0c30), X(0x317cde31), X(0x318cb113), X(0x319c84d4), X(0x31ac5974), X(0x31bc2ef1), X(0x31cc054b), X(0x31dbdc7f), X(0x31ebb48e), X(0x31fb8d74), X(0x320b6733), X(0x321b41c7), X(0x322b1d31), X(0x323af96e), X(0x324ad67e), X(0x325ab45f), X(0x326a9311), X(0x327a7291), X(0x328a52e0), X(0x329a33fb), X(0x32aa15e1), X(0x32b9f892), X(0x32c9dc0c), X(0x32d9c04d), X(0x32e9a555), X(0x32f98b22), X(0x330971b4), X(0x33195909), X(0x3329411f), X(0x333929f6), X(0x3349138c), X(0x3358fde1), X(0x3368e8f2), X(0x3378d4c0), X(0x3388c147), X(0x3398ae89), X(0x33a89c82), X(0x33b88b32), X(0x33c87a98), X(0x33d86ab2), X(0x33e85b80), X(0x33f84d00), X(0x34083f30), X(0x34183210), X(0x3428259f), X(0x343819db), X(0x34480ec3), X(0x34580455), X(0x3467fa92), X(0x3477f176), X(0x3487e902), X(0x3497e134), X(0x34a7da0a), X(0x34b7d384), X(0x34c7cda0), X(0x34d7c85e), X(0x34e7c3bb), X(0x34f7bfb7), X(0x3507bc50), X(0x3517b985), X(0x3527b756), X(0x3537b5c0), X(0x3547b4c3), X(0x3557b45d), X(0x3567b48d), X(0x3577b552), X(0x3587b6aa), X(0x3597b895), X(0x35a7bb12), X(0x35b7be1e), X(0x35c7c1b9), X(0x35d7c5e1), X(0x35e7ca96), X(0x35f7cfd6), X(0x3607d5a0), X(0x3617dbf3), X(0x3627e2cd), X(0x3637ea2d), X(0x3647f212), X(0x3657fa7b), X(0x36680366), X(0x36780cd2), X(0x368816bf), X(0x3698212b), X(0x36a82c14), X(0x36b83779), X(0x36c8435a), X(0x36d84fb4), X(0x36e85c88), X(0x36f869d2), X(0x37087793), X(0x371885c9), X(0x37289473), X(0x3738a38f), X(0x3748b31d), X(0x3758c31a), X(0x3768d387), X(0x3778e461), X(0x3788f5a7), X(0x37990759), X(0x37a91975), X(0x37b92bf9), X(0x37c93ee4), X(0x37d95236), X(0x37e965ed), X(0x37f97a08), X(0x38098e85), X(0x3819a363), X(0x3829b8a2), X(0x3839ce3f), X(0x3849e43a), X(0x3859fa91), X(0x386a1143), X(0x387a284f), X(0x388a3fb4), X(0x389a5770), X(0x38aa6f83), X(0x38ba87ea), X(0x38caa0a5), X(0x38dab9b2), X(0x38ead311), X(0x38faecbf), X(0x390b06bc), X(0x391b2107), X(0x392b3b9e), X(0x393b5680), X(0x394b71ac), X(0x395b8d20), X(0x396ba8dc), X(0x397bc4dd), X(0x398be124), X(0x399bfdae), X(0x39ac1a7a), X(0x39bc3788), X(0x39cc54d5), X(0x39dc7261), X(0x39ec902a), X(0x39fcae2f), X(0x3a0ccc70), X(0x3a1ceaea), X(0x3a2d099c), X(0x3a3d2885), X(0x3a4d47a5), X(0x3a5d66f9), X(0x3a6d8680), X(0x3a7da63a), X(0x3a8dc625), X(0x3a9de63f), X(0x3aae0688), X(0x3abe26fe), X(0x3ace47a0), X(0x3ade686d), X(0x3aee8963), X(0x3afeaa82), X(0x3b0ecbc7), X(0x3b1eed32), X(0x3b2f0ec2), X(0x3b3f3075), X(0x3b4f524a), X(0x3b5f7440), X(0x3b6f9656), X(0x3b7fb889), X(0x3b8fdada), X(0x3b9ffd46), X(0x3bb01fce), X(0x3bc0426e), X(0x3bd06526), X(0x3be087f6), X(0x3bf0aada), X(0x3c00cdd4), X(0x3c10f0e0), X(0x3c2113fe), X(0x3c31372d), X(0x3c415a6b), X(0x3c517db7), X(0x3c61a110), X(0x3c71c475), X(0x3c81e7e4), X(0x3c920b5c), X(0x3ca22edc), X(0x3cb25262), X(0x3cc275ee), X(0x3cd2997e), X(0x3ce2bd11), X(0x3cf2e0a6), X(0x3d03043b), X(0x3d1327cf), X(0x3d234b61), X(0x3d336ef0), X(0x3d43927a), X(0x3d53b5ff), X(0x3d63d97c), X(0x3d73fcf1), X(0x3d84205c), X(0x3d9443bd), X(0x3da46711), X(0x3db48a58), X(0x3dc4ad91), X(0x3dd4d0ba), X(0x3de4f3d1), X(0x3df516d7), X(0x3e0539c9), X(0x3e155ca6), X(0x3e257f6d), X(0x3e35a21d), X(0x3e45c4b4), X(0x3e55e731), X(0x3e660994), X(0x3e762bda), X(0x3e864e03), X(0x3e96700d), X(0x3ea691f7), X(0x3eb6b3bf), X(0x3ec6d565), X(0x3ed6f6e8), X(0x3ee71845), X(0x3ef7397c), X(0x3f075a8c), X(0x3f177b73), X(0x3f279c30), X(0x3f37bcc2), X(0x3f47dd27), X(0x3f57fd5f), X(0x3f681d68), X(0x3f783d40), X(0x3f885ce7), X(0x3f987c5c), X(0x3fa89b9c), X(0x3fb8baa7), X(0x3fc8d97c), X(0x3fd8f819), X(0x3fe9167e), X(0x3ff934a8), X(0x40095296), X(0x40197049), X(0x40298dbd), X(0x4039aaf2), X(0x4049c7e7), X(0x4059e49a), X(0x406a010a), X(0x407a1d36), X(0x408a391d), X(0x409a54bd), X(0x40aa7015), X(0x40ba8b25), X(0x40caa5ea), X(0x40dac063), X(0x40eada90), X(0x40faf46e), X(0x410b0dfe), X(0x411b273d), X(0x412b402a), X(0x413b58c4), X(0x414b710a), X(0x415b88fa), X(0x416ba093), X(0x417bb7d5), X(0x418bcebe), X(0x419be54c), X(0x41abfb7e), X(0x41bc1153), X(0x41cc26ca), X(0x41dc3be2), X(0x41ec5099), X(0x41fc64ef), X(0x420c78e1), X(0x421c8c6f), X(0x422c9f97), X(0x423cb258), X(0x424cc4b2), X(0x425cd6a2), X(0x426ce827), X(0x427cf941), X(0x428d09ee), X(0x429d1a2c), X(0x42ad29fb), X(0x42bd3959), X(0x42cd4846), X(0x42dd56bf), X(0x42ed64c3), X(0x42fd7252), X(0x430d7f6a), X(0x431d8c0a), X(0x432d9831), X(0x433da3dd), X(0x434daf0d), X(0x435db9c0), X(0x436dc3f5), X(0x437dcdab), X(0x438dd6df), X(0x439ddf92), X(0x43ade7c1), X(0x43bdef6c), X(0x43cdf691), X(0x43ddfd2f), X(0x43ee0345), X(0x43fe08d2), X(0x440e0dd4), X(0x441e124b), X(0x442e1634), X(0x443e198f), X(0x444e1c5a), X(0x445e1e95), X(0x446e203e), X(0x447e2153), X(0x448e21d5), X(0x449e21c0), X(0x44ae2115), X(0x44be1fd1), X(0x44ce1df4), X(0x44de1b7d), X(0x44ee186a), X(0x44fe14ba), X(0x450e106b), X(0x451e0b7e), X(0x452e05ef), X(0x453dffbf), X(0x454df8eb), X(0x455df173), X(0x456de956), X(0x457de092), X(0x458dd726), X(0x459dcd10), X(0x45adc251), X(0x45bdb6e5), X(0x45cdaacd), X(0x45dd9e06), X(0x45ed9091), X(0x45fd826a), X(0x460d7392), X(0x461d6407), X(0x462d53c8), X(0x463d42d4), X(0x464d3129), X(0x465d1ec6), X(0x466d0baa), X(0x467cf7d3), X(0x468ce342), X(0x469ccdf3), X(0x46acb7e7), X(0x46bca11c), X(0x46cc8990), X(0x46dc7143), X(0x46ec5833), X(0x46fc3e5f), X(0x470c23c6), X(0x471c0867), X(0x472bec40), X(0x473bcf50), X(0x474bb196), X(0x475b9311), X(0x476b73c0), X(0x477b53a1), X(0x478b32b4), X(0x479b10f6), X(0x47aaee67), X(0x47bacb06), X(0x47caa6d1), X(0x47da81c7), X(0x47ea5be7), X(0x47fa3530), X(0x480a0da1), X(0x4819e537), X(0x4829bbf3), X(0x483991d3), X(0x484966d6), X(0x48593afb), X(0x48690e3f), X(0x4878e0a3), X(0x4888b225), X(0x489882c4), X(0x48a8527e), X(0x48b82153), X(0x48c7ef41), X(0x48d7bc47), X(0x48e78863), X(0x48f75396), X(0x49071ddc), X(0x4916e736), X(0x4926afa2), X(0x4936771f), X(0x49463dac), X(0x49560347), X(0x4965c7ef), X(0x49758ba4), X(0x49854e63), X(0x4995102c), X(0x49a4d0fe), X(0x49b490d7), X(0x49c44fb6), X(0x49d40d9a), X(0x49e3ca82), X(0x49f3866c), X(0x4a034159), X(0x4a12fb45), X(0x4a22b430), X(0x4a326c19), X(0x4a4222ff), X(0x4a51d8e1), X(0x4a618dbd), X(0x4a714192), X(0x4a80f45f), X(0x4a90a623), X(0x4aa056dd), X(0x4ab0068b), X(0x4abfb52c), X(0x4acf62c0), X(0x4adf0f44), X(0x4aeebab9), X(0x4afe651c), X(0x4b0e0e6c), X(0x4b1db6a9), X(0x4b2d5dd1), X(0x4b3d03e2), X(0x4b4ca8dd), X(0x4b5c4cbf), X(0x4b6bef88), X(0x4b7b9136), X(0x4b8b31c8), X(0x4b9ad13d), X(0x4baa6f93), X(0x4bba0ccb), X(0x4bc9a8e2), X(0x4bd943d7), X(0x4be8dda9), X(0x4bf87658), X(0x4c080de1), X(0x4c17a444), X(0x4c27397f), X(0x4c36cd92), X(0x4c46607b), X(0x4c55f239), X(0x4c6582cb), X(0x4c75122f), X(0x4c84a065), X(0x4c942d6c), X(0x4ca3b942), X(0x4cb343e6), X(0x4cc2cd57), X(0x4cd25594), X(0x4ce1dc9c), X(0x4cf1626d), X(0x4d00e707), X(0x4d106a68), X(0x4d1fec8f), X(0x4d2f6d7a), X(0x4d3eed2a), X(0x4d4e6b9d), X(0x4d5de8d1), X(0x4d6d64c5), X(0x4d7cdf79), X(0x4d8c58eb), X(0x4d9bd11a), X(0x4dab4804), X(0x4dbabdaa), X(0x4dca3209), X(0x4dd9a520), X(0x4de916ef), X(0x4df88774), X(0x4e07f6ae), X(0x4e17649c), X(0x4e26d13c), X(0x4e363c8f), X(0x4e45a692), X(0x4e550f44), X(0x4e6476a4), X(0x4e73dcb2), X(0x4e83416c), X(0x4e92a4d1), X(0x4ea206df), X(0x4eb16796), X(0x4ec0c6f5), X(0x4ed024fa), X(0x4edf81a5), X(0x4eeedcf3), X(0x4efe36e5), X(0x4f0d8f79), X(0x4f1ce6ad), X(0x4f2c3c82), X(0x4f3b90f4), X(0x4f4ae405), X(0x4f5a35b1), X(0x4f6985fa), X(0x4f78d4dc), X(0x4f882257), X(0x4f976e6a), X(0x4fa6b914), X(0x4fb60254), X(0x4fc54a28), X(0x4fd49090), X(0x4fe3d58b), X(0x4ff31917), X(0x50025b33), X(0x50119bde), X(0x5020db17), X(0x503018dd), X(0x503f552f), X(0x504e900b), X(0x505dc971), X(0x506d0160), X(0x507c37d7), X(0x508b6cd3), X(0x509aa055), X(0x50a9d25b), X(0x50b902e4), X(0x50c831ef), X(0x50d75f7b), X(0x50e68b87), X(0x50f5b612), X(0x5104df1a), X(0x5114069f), X(0x51232ca0), X(0x5132511a), X(0x5141740f), X(0x5150957b), X(0x515fb55f), X(0x516ed3b8), X(0x517df087), X(0x518d0bca), X(0x519c257f), X(0x51ab3da7), X(0x51ba543f), X(0x51c96947), X(0x51d87cbd), X(0x51e78ea1), X(0x51f69ef1), X(0x5205adad), X(0x5214bad3), X(0x5223c662), X(0x5232d05a), X(0x5241d8b9), X(0x5250df7d), X(0x525fe4a7), X(0x526ee835), X(0x527dea26), X(0x528cea78), X(0x529be92c), X(0x52aae63f), X(0x52b9e1b0), X(0x52c8db80), X(0x52d7d3ac), X(0x52e6ca33), X(0x52f5bf15), X(0x5304b251), X(0x5313a3e5), X(0x532293d0), X(0x53318212), X(0x53406ea8), X(0x534f5993), X(0x535e42d2), X(0x536d2a62), X(0x537c1043), X(0x538af475), X(0x5399d6f6), X(0x53a8b7c4), X(0x53b796e0), X(0x53c67447), X(0x53d54ffa), X(0x53e429f6), X(0x53f3023b), X(0x5401d8c8), X(0x5410ad9c), X(0x541f80b5), X(0x542e5213), X(0x543d21b5), X(0x544bef9a), X(0x545abbc0), X(0x54698627), X(0x54784ece), X(0x548715b3), X(0x5495dad6), X(0x54a49e35), X(0x54b35fd0), X(0x54c21fa6), X(0x54d0ddb5), X(0x54df99fd), X(0x54ee547c), X(0x54fd0d32), X(0x550bc41d), X(0x551a793d), X(0x55292c91), X(0x5537de16), X(0x55468dce), X(0x55553bb6), X(0x5563e7cd), X(0x55729213), X(0x55813a87), X(0x558fe127), X(0x559e85f2), X(0x55ad28e9), X(0x55bbca08), X(0x55ca6950), X(0x55d906c0), X(0x55e7a257), X(0x55f63c13), X(0x5604d3f4), X(0x561369f8), X(0x5621fe1f), X(0x56309067), X(0x563f20d1), X(0x564daf5a), X(0x565c3c02), X(0x566ac6c7), X(0x56794faa), X(0x5687d6a8), X(0x56965bc1), X(0x56a4def4), X(0x56b36040), X(0x56c1dfa4), X(0x56d05d1f), X(0x56ded8af), X(0x56ed5255), X(0x56fbca0f), X(0x570a3fdc), X(0x5718b3bc), X(0x572725ac), X(0x573595ad), X(0x574403bd), X(0x57526fdb), X(0x5760da07), X(0x576f423f), X(0x577da883), X(0x578c0cd1), X(0x579a6f29), X(0x57a8cf8a), X(0x57b72df2), X(0x57c58a61), X(0x57d3e4d6), X(0x57e23d50), X(0x57f093cd), X(0x57fee84e), X(0x580d3ad1), X(0x581b8b54), X(0x5829d9d8), X(0x5838265c), X(0x584670dd), X(0x5854b95c), X(0x5862ffd8), X(0x5871444f), X(0x587f86c1), X(0x588dc72c), X(0x589c0591), X(0x58aa41ed), X(0x58b87c40), X(0x58c6b489), X(0x58d4eac7), X(0x58e31ef9), X(0x58f1511f), X(0x58ff8137), X(0x590daf40), X(0x591bdb3a), X(0x592a0524), X(0x59382cfc), X(0x594652c2), X(0x59547675), X(0x59629815), X(0x5970b79f), X(0x597ed513), X(0x598cf071), X(0x599b09b7), X(0x59a920e5), X(0x59b735f9), X(0x59c548f4), X(0x59d359d2), X(0x59e16895), X(0x59ef753b), X(0x59fd7fc4), X(0x5a0b882d), X(0x5a198e77), X(0x5a2792a0), X(0x5a3594a9), X(0x5a43948e), X(0x5a519251), X(0x5a5f8df0), X(0x5a6d876a), X(0x5a7b7ebe), X(0x5a8973ec), X(0x5a9766f2), X(0x5aa557d0), X(0x5ab34685), X(0x5ac1330f), X(0x5acf1d6f), X(0x5add05a3), X(0x5aeaebaa), X(0x5af8cf84), X(0x5b06b12f), X(0x5b1490ab), X(0x5b226df7), X(0x5b304912), X(0x5b3e21fc), X(0x5b4bf8b2), X(0x5b59cd35), X(0x5b679f84), X(0x5b756f9e), X(0x5b833d82), X(0x5b91092e), X(0x5b9ed2a3), X(0x5bac99e0), X(0x5bba5ee3), X(0x5bc821ac), X(0x5bd5e23a), X(0x5be3a08c), X(0x5bf15ca1), X(0x5bff1679), X(0x5c0cce12), X(0x5c1a836c), X(0x5c283686), X(0x5c35e760), X(0x5c4395f7), X(0x5c51424c), X(0x5c5eec5e), X(0x5c6c942b), X(0x5c7a39b4), X(0x5c87dcf7), X(0x5c957df3), X(0x5ca31ca8), X(0x5cb0b915), X(0x5cbe5338), X(0x5ccbeb12), X(0x5cd980a1), X(0x5ce713e5), X(0x5cf4a4dd), X(0x5d023387), X(0x5d0fbfe4), X(0x5d1d49f2), X(0x5d2ad1b1), X(0x5d38571f), X(0x5d45da3c), X(0x5d535b08), X(0x5d60d981), X(0x5d6e55a7), X(0x5d7bcf78), X(0x5d8946f5), X(0x5d96bc1c), X(0x5da42eec), X(0x5db19f65), X(0x5dbf0d86), X(0x5dcc794e), X(0x5dd9e2bd), X(0x5de749d1), X(0x5df4ae8a), X(0x5e0210e7), X(0x5e0f70e7), X(0x5e1cce8a), X(0x5e2a29ce), X(0x5e3782b4), X(0x5e44d93a), X(0x5e522d5f), X(0x5e5f7f23), X(0x5e6cce85), X(0x5e7a1b85), X(0x5e876620), X(0x5e94ae58), X(0x5ea1f42a), X(0x5eaf3797), X(0x5ebc789d), X(0x5ec9b73c), X(0x5ed6f372), X(0x5ee42d41), X(0x5ef164a5), X(0x5efe999f), X(0x5f0bcc2f), X(0x5f18fc52), X(0x5f262a09), X(0x5f335553), X(0x5f407e2f), X(0x5f4da49d), X(0x5f5ac89b), X(0x5f67ea29), X(0x5f750946), X(0x5f8225f2), X(0x5f8f402b), X(0x5f9c57f2), X(0x5fa96d44), X(0x5fb68023), X(0x5fc3908c), X(0x5fd09e7f), X(0x5fdda9fc), X(0x5feab302), X(0x5ff7b990), X(0x6004bda5), X(0x6011bf40), X(0x601ebe62), X(0x602bbb09), X(0x6038b534), X(0x6045ace4), X(0x6052a216), X(0x605f94cb), X(0x606c8502), X(0x607972b9), X(0x60865df2), X(0x609346aa), X(0x60a02ce1), X(0x60ad1096), X(0x60b9f1c9), X(0x60c6d079), X(0x60d3aca5), X(0x60e0864d), X(0x60ed5d70), X(0x60fa320d), X(0x61070424), X(0x6113d3b4), X(0x6120a0bc), X(0x612d6b3c), X(0x613a3332), X(0x6146f89f), X(0x6153bb82), X(0x61607bd9), X(0x616d39a5), X(0x6179f4e5), X(0x6186ad98), X(0x619363bd), X(0x61a01753), X(0x61acc85b), X(0x61b976d3), X(0x61c622bc), X(0x61d2cc13), X(0x61df72d8), X(0x61ec170c), X(0x61f8b8ad), X(0x620557ba), X(0x6211f434), X(0x621e8e18), X(0x622b2568), X(0x6237ba21), X(0x62444c44), X(0x6250dbd0), X(0x625d68c4), X(0x6269f320), X(0x62767ae2), X(0x6283000b), X(0x628f829a), X(0x629c028e), X(0x62a87fe6), X(0x62b4faa2), X(0x62c172c2), X(0x62cde844), X(0x62da5b29), X(0x62e6cb6e), X(0x62f33915), X(0x62ffa41c), X(0x630c0c83), X(0x63187248), X(0x6324d56d), X(0x633135ef), X(0x633d93ce), X(0x6349ef0b), X(0x635647a3), X(0x63629d97), X(0x636ef0e6), X(0x637b418f), X(0x63878f92), X(0x6393daef), X(0x63a023a4), X(0x63ac69b1), X(0x63b8ad15), X(0x63c4edd1), X(0x63d12be3), X(0x63dd674b), X(0x63e9a008), X(0x63f5d61a), X(0x64020980), X(0x640e3a39), X(0x641a6846), X(0x642693a5), X(0x6432bc56), X(0x643ee258), X(0x644b05ab), X(0x6457264e), X(0x64634441), X(0x646f5f83), X(0x647b7814), X(0x64878df3), X(0x6493a120), X(0x649fb199), X(0x64abbf5f), X(0x64b7ca71), X(0x64c3d2ce), X(0x64cfd877), X(0x64dbdb69), X(0x64e7dba6), X(0x64f3d92b), X(0x64ffd3fa), X(0x650bcc11), X(0x6517c16f), X(0x6523b415), X(0x652fa402), X(0x653b9134), X(0x65477bad), X(0x6553636a), X(0x655f486d), X(0x656b2ab3), X(0x65770a3d), X(0x6582e70a), X(0x658ec11a), X(0x659a986d), X(0x65a66d00), X(0x65b23ed5), X(0x65be0deb), X(0x65c9da41), X(0x65d5a3d7), X(0x65e16aac), X(0x65ed2ebf), X(0x65f8f011), X(0x6604aea1), X(0x66106a6e), X(0x661c2377), X(0x6627d9be), X(0x66338d40), X(0x663f3dfd), X(0x664aebf5), X(0x66569728), X(0x66623f95), X(0x666de53b), X(0x6679881b), X(0x66852833), X(0x6690c583), X(0x669c600b), X(0x66a7f7ca), X(0x66b38cc0), X(0x66bf1eec), X(0x66caae4f), X(0x66d63ae6), X(0x66e1c4b3), X(0x66ed4bb4), X(0x66f8cfea), X(0x67045153), X(0x670fcfef), X(0x671b4bbe), X(0x6726c4bf), X(0x67323af3), X(0x673dae58), X(0x67491eee), X(0x67548cb5), X(0x675ff7ab), X(0x676b5fd2), X(0x6776c528), X(0x678227ad), X(0x678d8761), X(0x6798e443), X(0x67a43e52), X(0x67af958f), X(0x67bae9f9), X(0x67c63b8f), X(0x67d18a52), X(0x67dcd640), X(0x67e81f59), X(0x67f3659d), X(0x67fea90c), X(0x6809e9a5), X(0x68152768), X(0x68206254), X(0x682b9a68), X(0x6836cfa6), X(0x6842020b), X(0x684d3199), X(0x68585e4d), X(0x68638829), X(0x686eaf2b), X(0x6879d354), X(0x6884f4a2), X(0x68901316), X(0x689b2eb0), X(0x68a6476d), X(0x68b15d50), X(0x68bc7056), X(0x68c78080), X(0x68d28dcd), X(0x68dd983e), X(0x68e89fd0), X(0x68f3a486), X(0x68fea65d), X(0x6909a555), X(0x6914a16f), X(0x691f9aa9), X(0x692a9104), X(0x69358480), X(0x6940751b), X(0x694b62d5), X(0x69564daf), X(0x696135a7), X(0x696c1abe), X(0x6976fcf3), X(0x6981dc46), X(0x698cb8b6), X(0x69979243), X(0x69a268ed), X(0x69ad3cb4), X(0x69b80d97), X(0x69c2db96), X(0x69cda6b0), X(0x69d86ee5), X(0x69e33436), X(0x69edf6a1), X(0x69f8b626), X(0x6a0372c5), X(0x6a0e2c7e), X(0x6a18e350), X(0x6a23973c), X(0x6a2e4840), X(0x6a38f65d), X(0x6a43a191), X(0x6a4e49de), X(0x6a58ef42), X(0x6a6391be), X(0x6a6e3151), X(0x6a78cdfa), X(0x6a8367ba), X(0x6a8dfe90), X(0x6a98927c), X(0x6aa3237d), X(0x6aadb194), X(0x6ab83cc0), X(0x6ac2c500), X(0x6acd4a55), X(0x6ad7ccbf), X(0x6ae24c3c), X(0x6aecc8cd), X(0x6af74271), X(0x6b01b929), X(0x6b0c2cf4), X(0x6b169dd1), X(0x6b210bc1), X(0x6b2b76c2), X(0x6b35ded6), X(0x6b4043fc), X(0x6b4aa632), X(0x6b55057a), X(0x6b5f61d3), X(0x6b69bb3d), X(0x6b7411b7), X(0x6b7e6541), X(0x6b88b5db), X(0x6b930385), X(0x6b9d4e3f), X(0x6ba79607), X(0x6bb1dadf), X(0x6bbc1cc6), X(0x6bc65bbb), X(0x6bd097bf), X(0x6bdad0d0), X(0x6be506f0), X(0x6bef3a1d), X(0x6bf96a58), X(0x6c0397a0), X(0x6c0dc1f5), X(0x6c17e957), X(0x6c220dc6), X(0x6c2c2f41), X(0x6c364dc9), X(0x6c40695c), X(0x6c4a81fc), X(0x6c5497a7), X(0x6c5eaa5d), X(0x6c68ba1f), X(0x6c72c6eb), X(0x6c7cd0c3), X(0x6c86d7a6), X(0x6c90db92), X(0x6c9adc8a), X(0x6ca4da8b), X(0x6caed596), X(0x6cb8cdab), X(0x6cc2c2ca), X(0x6cccb4f2), X(0x6cd6a424), X(0x6ce0905e), X(0x6cea79a1), X(0x6cf45fee), X(0x6cfe4342), X(0x6d0823a0), X(0x6d120105), X(0x6d1bdb73), X(0x6d25b2e8), X(0x6d2f8765), X(0x6d3958ea), X(0x6d432777), X(0x6d4cf30a), X(0x6d56bba5), X(0x6d608147), X(0x6d6a43f0), X(0x6d7403a0), X(0x6d7dc056), X(0x6d877a13), X(0x6d9130d6), X(0x6d9ae4a0), X(0x6da4956f), X(0x6dae4345), X(0x6db7ee20), X(0x6dc19601), X(0x6dcb3ae7), X(0x6dd4dcd3), X(0x6dde7bc4), X(0x6de817bb), X(0x6df1b0b6), X(0x6dfb46b7), X(0x6e04d9bc), X(0x6e0e69c7), X(0x6e17f6d5), X(0x6e2180e9), X(0x6e2b0801), X(0x6e348c1d), X(0x6e3e0d3d), X(0x6e478b62), X(0x6e51068a), X(0x6e5a7eb7), X(0x6e63f3e7), X(0x6e6d661b), X(0x6e76d552), X(0x6e80418e), X(0x6e89aacc), X(0x6e93110f), X(0x6e9c7454), X(0x6ea5d49d), X(0x6eaf31e9), X(0x6eb88c37), X(0x6ec1e389), X(0x6ecb37de), X(0x6ed48936), X(0x6eddd790), X(0x6ee722ee), X(0x6ef06b4d), X(0x6ef9b0b0), X(0x6f02f315), X(0x6f0c327c), X(0x6f156ee6), X(0x6f1ea852), X(0x6f27dec1), X(0x6f311232), X(0x6f3a42a5), X(0x6f43701a), X(0x6f4c9a91), X(0x6f55c20a), X(0x6f5ee686), X(0x6f680803), X(0x6f712682), X(0x6f7a4203), X(0x6f835a86), X(0x6f8c700b), X(0x6f958291), X(0x6f9e921a), X(0x6fa79ea4), X(0x6fb0a830), X(0x6fb9aebd), X(0x6fc2b24c), X(0x6fcbb2dd), X(0x6fd4b06f), X(0x6fddab03), X(0x6fe6a299), X(0x6fef9730), X(0x6ff888c9), X(0x70017763), X(0x700a62ff), X(0x70134b9c), X(0x701c313b), X(0x702513dc), X(0x702df37e), X(0x7036d021), X(0x703fa9c6), X(0x7048806d), X(0x70515415), X(0x705a24bf), X(0x7062f26b), X(0x706bbd17), X(0x707484c6), X(0x707d4976), X(0x70860b28), X(0x708ec9dc), X(0x70978591), X(0x70a03e48), X(0x70a8f400), X(0x70b1a6bb), X(0x70ba5677), X(0x70c30335), X(0x70cbacf5), X(0x70d453b6), X(0x70dcf77a), X(0x70e59840), X(0x70ee3607), X(0x70f6d0d1), X(0x70ff689d), X(0x7107fd6b), X(0x71108f3b), X(0x71191e0d), X(0x7121a9e2), X(0x712a32b9), X(0x7132b892), X(0x713b3b6e), X(0x7143bb4c), X(0x714c382d), X(0x7154b211), X(0x715d28f7), X(0x71659ce0), X(0x716e0dcc), X(0x71767bbb), X(0x717ee6ac), X(0x71874ea1), X(0x718fb399), X(0x71981594), X(0x71a07493), X(0x71a8d094), X(0x71b1299a), X(0x71b97fa2), X(0x71c1d2af), X(0x71ca22bf), X(0x71d26fd2), X(0x71dab9ea), X(0x71e30106), X(0x71eb4526), X(0x71f3864a), X(0x71fbc472), X(0x7203ff9e), X(0x720c37cf), X(0x72146d05), X(0x721c9f3f), X(0x7224ce7e), X(0x722cfac2), X(0x7235240b), X(0x723d4a59), X(0x72456dad), X(0x724d8e05), X(0x7255ab63), X(0x725dc5c7), X(0x7265dd31), X(0x726df1a0), X(0x72760315), X(0x727e1191), X(0x72861d12), X(0x728e259a), X(0x72962b28), X(0x729e2dbd), X(0x72a62d59), X(0x72ae29fc), X(0x72b623a5), X(0x72be1a56), X(0x72c60e0e), X(0x72cdfece), X(0x72d5ec95), X(0x72ddd764), X(0x72e5bf3b), X(0x72eda41a), X(0x72f58601), X(0x72fd64f1), X(0x730540e9), X(0x730d19e9), X(0x7314eff3), X(0x731cc305), X(0x73249321), X(0x732c6046), X(0x73342a75), X(0x733bf1ad), X(0x7343b5ef), X(0x734b773b), X(0x73533591), X(0x735af0f2), X(0x7362a95d), X(0x736a5ed3), X(0x73721153), X(0x7379c0df), X(0x73816d76), X(0x73891719), X(0x7390bdc7), X(0x73986181), X(0x73a00247), X(0x73a7a01a), X(0x73af3af8), X(0x73b6d2e4), X(0x73be67dc), X(0x73c5f9e1), X(0x73cd88f3), X(0x73d51513), X(0x73dc9e40), X(0x73e4247c), X(0x73eba7c5), X(0x73f3281c), X(0x73faa582), X(0x74021ff7), X(0x7409977b), X(0x74110c0d), X(0x74187daf), X(0x741fec61), X(0x74275822), X(0x742ec0f3), X(0x743626d5), X(0x743d89c7), X(0x7444e9c9), X(0x744c46dd), X(0x7453a101), X(0x745af837), X(0x74624c7f), X(0x74699dd8), X(0x7470ec44), X(0x747837c2), X(0x747f8052), X(0x7486c5f5), X(0x748e08ac), X(0x74954875), X(0x749c8552), X(0x74a3bf43), X(0x74aaf648), X(0x74b22a62), X(0x74b95b90), X(0x74c089d2), X(0x74c7b52a), X(0x74cedd97), X(0x74d6031a), X(0x74dd25b2), X(0x74e44561), X(0x74eb6226), X(0x74f27c02), X(0x74f992f5), X(0x7500a6ff), X(0x7507b820), X(0x750ec659), X(0x7515d1aa), X(0x751cda14), X(0x7523df96), X(0x752ae231), X(0x7531e1e5), X(0x7538deb2), X(0x753fd89a), X(0x7546cf9b), X(0x754dc3b7), X(0x7554b4ed), X(0x755ba33e), X(0x75628eaa), X(0x75697732), X(0x75705cd5), X(0x75773f95), X(0x757e1f71), X(0x7584fc6a), X(0x758bd67f), X(0x7592adb2), X(0x75998203), X(0x75a05371), X(0x75a721fe), X(0x75adeda9), X(0x75b4b673), X(0x75bb7c5c), X(0x75c23f65), X(0x75c8ff8d), X(0x75cfbcd6), X(0x75d6773f), X(0x75dd2ec8), X(0x75e3e373), X(0x75ea953f), X(0x75f1442d), X(0x75f7f03d), X(0x75fe996f), X(0x76053fc5), X(0x760be33d), X(0x761283d8), X(0x76192197), X(0x761fbc7b), X(0x76265482), X(0x762ce9af), X(0x76337c01), X(0x763a0b78), X(0x76409814), X(0x764721d7), X(0x764da8c1), X(0x76542cd1), X(0x765aae08), X(0x76612c67), X(0x7667a7ee), X(0x766e209d), X(0x76749675), X(0x767b0975), X(0x7681799f), X(0x7687e6f3), X(0x768e5170), X(0x7694b918), X(0x769b1deb), X(0x76a17fe9), X(0x76a7df13), X(0x76ae3b68), X(0x76b494ea), X(0x76baeb98), X(0x76c13f74), X(0x76c7907c), X(0x76cddeb3), X(0x76d42a18), X(0x76da72ab), X(0x76e0b86d), X(0x76e6fb5e), X(0x76ed3b7f), X(0x76f378d0), X(0x76f9b352), X(0x76ffeb05), X(0x77061fe8), X(0x770c51fe), X(0x77128145), X(0x7718adbf), X(0x771ed76c), X(0x7724fe4c), X(0x772b225f), X(0x773143a7), X(0x77376223), X(0x773d7dd3), X(0x774396ba), X(0x7749acd5), X(0x774fc027), X(0x7755d0af), X(0x775bde6f), X(0x7761e965), X(0x7767f193), X(0x776df6fa), X(0x7773f998), X(0x7779f970), X(0x777ff681), X(0x7785f0cd), X(0x778be852), X(0x7791dd12), X(0x7797cf0d), X(0x779dbe43), X(0x77a3aab6), X(0x77a99465), X(0x77af7b50), X(0x77b55f79), X(0x77bb40e0), X(0x77c11f85), X(0x77c6fb68), X(0x77ccd48a), X(0x77d2aaec), X(0x77d87e8d), X(0x77de4f6f), X(0x77e41d92), X(0x77e9e8f5), X(0x77efb19b), X(0x77f57782), X(0x77fb3aad), X(0x7800fb1a), X(0x7806b8ca), X(0x780c73bf), X(0x78122bf7), X(0x7817e175), X(0x781d9438), X(0x78234440), X(0x7828f18f), X(0x782e9c25), X(0x78344401), X(0x7839e925), X(0x783f8b92), X(0x78452b46), X(0x784ac844), X(0x7850628b), X(0x7855fa1c), X(0x785b8ef8), X(0x7861211e), X(0x7866b090), X(0x786c3d4d), X(0x7871c757), X(0x78774ead), X(0x787cd351), X(0x78825543), X(0x7887d483), X(0x788d5111), X(0x7892caef), X(0x7898421c), X(0x789db69a), X(0x78a32868), X(0x78a89787), X(0x78ae03f8), X(0x78b36dbb), X(0x78b8d4d1), X(0x78be393a), X(0x78c39af6), X(0x78c8fa06), X(0x78ce566c), X(0x78d3b026), X(0x78d90736), X(0x78de5b9c), X(0x78e3ad58), X(0x78e8fc6c), X(0x78ee48d7), X(0x78f3929b), X(0x78f8d9b7), X(0x78fe1e2c), X(0x79035ffb), X(0x79089f24), X(0x790ddba8), X(0x79131587), X(0x79184cc2), X(0x791d8159), X(0x7922b34d), X(0x7927e29e), X(0x792d0f4d), X(0x7932395a), X(0x793760c6), X(0x793c8591), X(0x7941a7bd), X(0x7946c749), X(0x794be435), X(0x7950fe84), X(0x79561634), X(0x795b2b47), X(0x79603dbc), X(0x79654d96), X(0x796a5ad4), X(0x796f6576), X(0x79746d7e), X(0x797972eb), X(0x797e75bf), X(0x798375f9), X(0x7988739b), X(0x798d6ea5), X(0x79926717), X(0x79975cf2), X(0x799c5037), X(0x79a140e6), X(0x79a62f00), X(0x79ab1a85), X(0x79b00376), X(0x79b4e9d3), X(0x79b9cd9d), X(0x79beaed4), X(0x79c38d79), X(0x79c8698d), X(0x79cd4310), X(0x79d21a03), X(0x79d6ee66), X(0x79dbc03a), X(0x79e08f7f), X(0x79e55c36), X(0x79ea265f), X(0x79eeedfc), X(0x79f3b30c), X(0x79f87590), X(0x79fd3589), X(0x7a01f2f7), X(0x7a06addc), X(0x7a0b6636), X(0x7a101c08), X(0x7a14cf52), X(0x7a198013), X(0x7a1e2e4d), X(0x7a22da01), X(0x7a27832f), X(0x7a2c29d7), X(0x7a30cdfa), X(0x7a356f99), X(0x7a3a0eb4), X(0x7a3eab4c), X(0x7a434561), X(0x7a47dcf5), X(0x7a4c7207), X(0x7a510498), X(0x7a5594a9), X(0x7a5a223a), X(0x7a5ead4d), X(0x7a6335e0), X(0x7a67bbf6), X(0x7a6c3f8f), X(0x7a70c0ab), X(0x7a753f4b), X(0x7a79bb6f), X(0x7a7e3519), X(0x7a82ac48), X(0x7a8720fe), X(0x7a8b933b), X(0x7a9002ff), X(0x7a94704b), X(0x7a98db20), X(0x7a9d437e), X(0x7aa1a967), X(0x7aa60cd9), X(0x7aaa6dd7), X(0x7aaecc61), X(0x7ab32877), X(0x7ab7821b), X(0x7abbd94b), X(0x7ac02e0a), X(0x7ac48058), X(0x7ac8d035), X(0x7acd1da3), X(0x7ad168a1), X(0x7ad5b130), X(0x7ad9f751), X(0x7ade3b05), X(0x7ae27c4c), X(0x7ae6bb27), X(0x7aeaf796), X(0x7aef319a), X(0x7af36934), X(0x7af79e64), X(0x7afbd12c), X(0x7b00018a), X(0x7b042f81), X(0x7b085b10), X(0x7b0c8439), X(0x7b10aafc), X(0x7b14cf5a), X(0x7b18f153), X(0x7b1d10e8), X(0x7b212e1a), X(0x7b2548e9), X(0x7b296155), X(0x7b2d7761), X(0x7b318b0b), X(0x7b359c55), X(0x7b39ab3f), X(0x7b3db7cb), X(0x7b41c1f8), X(0x7b45c9c8), X(0x7b49cf3b), X(0x7b4dd251), X(0x7b51d30b), X(0x7b55d16b), X(0x7b59cd70), X(0x7b5dc71b), X(0x7b61be6d), X(0x7b65b366), X(0x7b69a608), X(0x7b6d9653), X(0x7b718447), X(0x7b756fe5), X(0x7b79592e), X(0x7b7d4022), X(0x7b8124c3), X(0x7b850710), X(0x7b88e70a), X(0x7b8cc4b3), X(0x7b90a00a), X(0x7b947911), X(0x7b984fc8), X(0x7b9c242f), X(0x7b9ff648), X(0x7ba3c612), X(0x7ba79390), X(0x7bab5ec1), X(0x7baf27a5), X(0x7bb2ee3f), X(0x7bb6b28e), X(0x7bba7493), X(0x7bbe344e), X(0x7bc1f1c1), X(0x7bc5acec), X(0x7bc965cf), X(0x7bcd1c6c), X(0x7bd0d0c3), X(0x7bd482d4), X(0x7bd832a1), X(0x7bdbe02a), X(0x7bdf8b70), X(0x7be33473), X(0x7be6db34), X(0x7bea7fb4), X(0x7bee21f4), X(0x7bf1c1f3), X(0x7bf55fb3), X(0x7bf8fb35), X(0x7bfc9479), X(0x7c002b7f), X(0x7c03c04a), X(0x7c0752d8), X(0x7c0ae32b), X(0x7c0e7144), X(0x7c11fd23), X(0x7c1586c9), X(0x7c190e36), X(0x7c1c936c), X(0x7c20166b), X(0x7c239733), X(0x7c2715c6), X(0x7c2a9224), X(0x7c2e0c4e), X(0x7c318444), X(0x7c34fa07), X(0x7c386d98), X(0x7c3bdef8), X(0x7c3f4e26), X(0x7c42bb25), X(0x7c4625f4), X(0x7c498e95), X(0x7c4cf507), X(0x7c50594c), X(0x7c53bb65), X(0x7c571b51), X(0x7c5a7913), X(0x7c5dd4aa), X(0x7c612e17), X(0x7c64855b), X(0x7c67da76), X(0x7c6b2d6a), X(0x7c6e7e37), X(0x7c71ccdd), X(0x7c75195e), X(0x7c7863ba), X(0x7c7babf1), X(0x7c7ef206), X(0x7c8235f7), X(0x7c8577c6), X(0x7c88b774), X(0x7c8bf502), X(0x7c8f306f), X(0x7c9269bd), X(0x7c95a0ec), X(0x7c98d5fe), X(0x7c9c08f2), X(0x7c9f39cb), X(0x7ca26887), X(0x7ca59528), X(0x7ca8bfb0), X(0x7cabe81d), X(0x7caf0e72), X(0x7cb232af), X(0x7cb554d4), X(0x7cb874e2), X(0x7cbb92db), X(0x7cbeaebe), X(0x7cc1c88d), X(0x7cc4e047), X(0x7cc7f5ef), X(0x7ccb0984), X(0x7cce1b08), X(0x7cd12a7b), X(0x7cd437dd), X(0x7cd74330), X(0x7cda4c74), X(0x7cdd53aa), X(0x7ce058d3), X(0x7ce35bef), X(0x7ce65cff), X(0x7ce95c04), X(0x7cec58ff), X(0x7cef53f0), X(0x7cf24cd7), X(0x7cf543b7), X(0x7cf8388f), X(0x7cfb2b60), X(0x7cfe1c2b), X(0x7d010af1), X(0x7d03f7b2), X(0x7d06e26f), X(0x7d09cb29), X(0x7d0cb1e0), X(0x7d0f9696), X(0x7d12794b), X(0x7d1559ff), X(0x7d1838b4), X(0x7d1b156a), X(0x7d1df022), X(0x7d20c8dd), X(0x7d239f9b), X(0x7d26745e), X(0x7d294725), X(0x7d2c17f1), X(0x7d2ee6c4), X(0x7d31b39f), X(0x7d347e81), X(0x7d37476b), X(0x7d3a0e5f), X(0x7d3cd35d), X(0x7d3f9665), X(0x7d425779), X(0x7d451699), X(0x7d47d3c6), X(0x7d4a8f01), X(0x7d4d484b), X(0x7d4fffa3), X(0x7d52b50c), X(0x7d556885), X(0x7d581a0f), X(0x7d5ac9ac), X(0x7d5d775c), X(0x7d60231f), X(0x7d62ccf6), X(0x7d6574e3), X(0x7d681ae6), X(0x7d6abeff), X(0x7d6d612f), X(0x7d700178), X(0x7d729fd9), X(0x7d753c54), X(0x7d77d6e9), X(0x7d7a6f9a), X(0x7d7d0666), X(0x7d7f9b4f), X(0x7d822e55), X(0x7d84bf79), X(0x7d874ebc), X(0x7d89dc1e), X(0x7d8c67a1), X(0x7d8ef144), X(0x7d91790a), X(0x7d93fef2), X(0x7d9682fd), X(0x7d99052d), X(0x7d9b8581), X(0x7d9e03fb), X(0x7da0809b), X(0x7da2fb62), X(0x7da57451), X(0x7da7eb68), X(0x7daa60a8), X(0x7dacd413), X(0x7daf45a9), X(0x7db1b56a), X(0x7db42357), X(0x7db68f71), X(0x7db8f9b9), X(0x7dbb6230), X(0x7dbdc8d6), X(0x7dc02dac), X(0x7dc290b3), X(0x7dc4f1eb), X(0x7dc75156), X(0x7dc9aef4), X(0x7dcc0ac5), X(0x7dce64cc), X(0x7dd0bd07), X(0x7dd31379), X(0x7dd56821), X(0x7dd7bb01), X(0x7dda0c1a), X(0x7ddc5b6b), X(0x7ddea8f7), X(0x7de0f4bd), X(0x7de33ebe), X(0x7de586fc), X(0x7de7cd76), X(0x7dea122e), X(0x7dec5525), X(0x7dee965a), X(0x7df0d5d0), X(0x7df31386), X(0x7df54f7e), X(0x7df789b8), X(0x7df9c235), X(0x7dfbf8f5), X(0x7dfe2dfa), X(0x7e006145), X(0x7e0292d5), X(0x7e04c2ac), X(0x7e06f0cb), X(0x7e091d32), X(0x7e0b47e1), X(0x7e0d70db), X(0x7e0f981f), X(0x7e11bdaf), X(0x7e13e18a), X(0x7e1603b3), X(0x7e182429), X(0x7e1a42ed), X(0x7e1c6001), X(0x7e1e7b64), X(0x7e209518), X(0x7e22ad1d), X(0x7e24c375), X(0x7e26d81f), X(0x7e28eb1d), X(0x7e2afc70), X(0x7e2d0c17), X(0x7e2f1a15), X(0x7e31266a), X(0x7e333115), X(0x7e353a1a), X(0x7e374177), X(0x7e39472e), X(0x7e3b4b3f), X(0x7e3d4dac), X(0x7e3f4e75), X(0x7e414d9a), X(0x7e434b1e), X(0x7e4546ff), X(0x7e474140), X(0x7e4939e0), X(0x7e4b30e2), X(0x7e4d2644), X(0x7e4f1a09), X(0x7e510c30), X(0x7e52fcbc), X(0x7e54ebab), X(0x7e56d900), X(0x7e58c4bb), X(0x7e5aaedd), X(0x7e5c9766), X(0x7e5e7e57), X(0x7e6063b2), X(0x7e624776), X(0x7e6429a5), X(0x7e660a3f), X(0x7e67e945), X(0x7e69c6b8), X(0x7e6ba299), X(0x7e6d7ce7), X(0x7e6f55a5), X(0x7e712cd3), X(0x7e730272), X(0x7e74d682), X(0x7e76a904), X(0x7e7879f9), X(0x7e7a4962), X(0x7e7c173f), X(0x7e7de392), X(0x7e7fae5a), X(0x7e817799), X(0x7e833f50), X(0x7e85057f), X(0x7e86ca27), X(0x7e888d49), X(0x7e8a4ee5), X(0x7e8c0efd), X(0x7e8dcd91), X(0x7e8f8aa1), X(0x7e914630), X(0x7e93003c), X(0x7e94b8c8), X(0x7e966fd4), X(0x7e982560), X(0x7e99d96e), X(0x7e9b8bfe), X(0x7e9d3d10), X(0x7e9eeca7), X(0x7ea09ac2), X(0x7ea24762), X(0x7ea3f288), X(0x7ea59c35), X(0x7ea7446a), X(0x7ea8eb27), X(0x7eaa906c), X(0x7eac343c), X(0x7eadd696), X(0x7eaf777b), X(0x7eb116ed), X(0x7eb2b4eb), X(0x7eb45177), X(0x7eb5ec91), X(0x7eb7863b), X(0x7eb91e74), X(0x7ebab53e), X(0x7ebc4a99), X(0x7ebdde87), X(0x7ebf7107), X(0x7ec1021b), X(0x7ec291c3), X(0x7ec42001), X(0x7ec5acd5), X(0x7ec7383f), X(0x7ec8c241), X(0x7eca4adb), X(0x7ecbd20d), X(0x7ecd57da), X(0x7ecedc41), X(0x7ed05f44), X(0x7ed1e0e2), X(0x7ed3611d), X(0x7ed4dff6), X(0x7ed65d6d), X(0x7ed7d983), X(0x7ed95438), X(0x7edacd8f), X(0x7edc4586), X(0x7eddbc20), X(0x7edf315c), X(0x7ee0a53c), X(0x7ee217c1), X(0x7ee388ea), X(0x7ee4f8b9), X(0x7ee6672f), X(0x7ee7d44c), X(0x7ee94012), X(0x7eeaaa80), X(0x7eec1397), X(0x7eed7b59), X(0x7eeee1c6), X(0x7ef046df), X(0x7ef1aaa5), X(0x7ef30d18), X(0x7ef46e39), X(0x7ef5ce09), X(0x7ef72c88), X(0x7ef889b8), X(0x7ef9e599), X(0x7efb402c), X(0x7efc9972), X(0x7efdf16b), X(0x7eff4818), X(0x7f009d79), X(0x7f01f191), X(0x7f03445f), X(0x7f0495e4), X(0x7f05e620), X(0x7f073516), X(0x7f0882c5), X(0x7f09cf2d), X(0x7f0b1a51), X(0x7f0c6430), X(0x7f0daccc), X(0x7f0ef425), X(0x7f103a3b), X(0x7f117f11), X(0x7f12c2a5), X(0x7f1404fa), X(0x7f15460f), X(0x7f1685e6), X(0x7f17c47f), X(0x7f1901db), X(0x7f1a3dfb), X(0x7f1b78e0), X(0x7f1cb28a), X(0x7f1deafa), X(0x7f1f2231), X(0x7f20582f), X(0x7f218cf5), X(0x7f22c085), X(0x7f23f2de), X(0x7f252401), X(0x7f2653f0), X(0x7f2782ab), X(0x7f28b032), X(0x7f29dc87), X(0x7f2b07aa), X(0x7f2c319c), X(0x7f2d5a5e), X(0x7f2e81f0), X(0x7f2fa853), X(0x7f30cd88), X(0x7f31f18f), X(0x7f33146a), X(0x7f343619), X(0x7f35569c), X(0x7f3675f6), X(0x7f379425), X(0x7f38b12c), X(0x7f39cd0a), X(0x7f3ae7c0), X(0x7f3c0150), X(0x7f3d19ba), X(0x7f3e30fe), X(0x7f3f471e), X(0x7f405c1a), X(0x7f416ff3), X(0x7f4282a9), X(0x7f43943e), X(0x7f44a4b2), X(0x7f45b405), X(0x7f46c239), X(0x7f47cf4e), X(0x7f48db45), X(0x7f49e61f), X(0x7f4aefdc), X(0x7f4bf87e), X(0x7f4d0004), X(0x7f4e0670), X(0x7f4f0bc2), X(0x7f500ffb), X(0x7f51131c), X(0x7f521525), X(0x7f531618), X(0x7f5415f4), X(0x7f5514bb), X(0x7f56126e), X(0x7f570f0c), X(0x7f580a98), X(0x7f590511), X(0x7f59fe78), X(0x7f5af6ce), X(0x7f5bee14), X(0x7f5ce44a), X(0x7f5dd972), X(0x7f5ecd8b), X(0x7f5fc097), X(0x7f60b296), X(0x7f61a389), X(0x7f629370), X(0x7f63824e), X(0x7f647021), X(0x7f655ceb), X(0x7f6648ad), X(0x7f673367), X(0x7f681d19), X(0x7f6905c6), X(0x7f69ed6d), X(0x7f6ad40f), X(0x7f6bb9ad), X(0x7f6c9e48), X(0x7f6d81e0), X(0x7f6e6475), X(0x7f6f460a), X(0x7f70269d), X(0x7f710631), X(0x7f71e4c6), X(0x7f72c25c), X(0x7f739ef4), X(0x7f747a8f), X(0x7f75552e), X(0x7f762ed1), X(0x7f770779), X(0x7f77df27), X(0x7f78b5db), X(0x7f798b97), X(0x7f7a605a), X(0x7f7b3425), X(0x7f7c06fa), X(0x7f7cd8d9), X(0x7f7da9c2), X(0x7f7e79b7), X(0x7f7f48b8), X(0x7f8016c5), X(0x7f80e3e0), X(0x7f81b009), X(0x7f827b40), X(0x7f834588), X(0x7f840edf), X(0x7f84d747), X(0x7f859ec1), X(0x7f86654d), X(0x7f872aec), X(0x7f87ef9e), X(0x7f88b365), X(0x7f897641), X(0x7f8a3832), X(0x7f8af93a), X(0x7f8bb959), X(0x7f8c7890), X(0x7f8d36df), X(0x7f8df448), X(0x7f8eb0ca), X(0x7f8f6c67), X(0x7f90271e), X(0x7f90e0f2), X(0x7f9199e2), X(0x7f9251f0), X(0x7f93091b), X(0x7f93bf65), X(0x7f9474ce), X(0x7f952958), X(0x7f95dd01), X(0x7f968fcd), X(0x7f9741ba), X(0x7f97f2ca), X(0x7f98a2fd), X(0x7f995254), X(0x7f9a00d0), X(0x7f9aae71), X(0x7f9b5b38), X(0x7f9c0726), X(0x7f9cb23b), X(0x7f9d5c78), X(0x7f9e05de), X(0x7f9eae6e), X(0x7f9f5627), X(0x7f9ffd0b), X(0x7fa0a31b), X(0x7fa14856), X(0x7fa1ecbf), X(0x7fa29054), X(0x7fa33318), X(0x7fa3d50b), X(0x7fa4762c), X(0x7fa5167e), X(0x7fa5b601), X(0x7fa654b5), X(0x7fa6f29b), X(0x7fa78fb3), X(0x7fa82bff), X(0x7fa8c77f), X(0x7fa96234), X(0x7fa9fc1e), X(0x7faa953e), X(0x7fab2d94), X(0x7fabc522), X(0x7fac5be8), X(0x7facf1e6), X(0x7fad871d), X(0x7fae1b8f), X(0x7faeaf3b), X(0x7faf4222), X(0x7fafd445), X(0x7fb065a4), X(0x7fb0f641), X(0x7fb1861b), X(0x7fb21534), X(0x7fb2a38c), X(0x7fb33124), X(0x7fb3bdfb), X(0x7fb44a14), X(0x7fb4d56f), X(0x7fb5600c), X(0x7fb5e9ec), X(0x7fb6730f), X(0x7fb6fb76), X(0x7fb78323), X(0x7fb80a15), X(0x7fb8904d), X(0x7fb915cc), X(0x7fb99a92), X(0x7fba1ea0), X(0x7fbaa1f7), X(0x7fbb2497), X(0x7fbba681), X(0x7fbc27b5), X(0x7fbca835), X(0x7fbd2801), X(0x7fbda719), X(0x7fbe257e), X(0x7fbea331), X(0x7fbf2032), X(0x7fbf9c82), X(0x7fc01821), X(0x7fc09311), X(0x7fc10d52), X(0x7fc186e4), X(0x7fc1ffc8), X(0x7fc277ff), X(0x7fc2ef89), X(0x7fc36667), X(0x7fc3dc9a), X(0x7fc45221), X(0x7fc4c6ff), X(0x7fc53b33), X(0x7fc5aebe), X(0x7fc621a0), X(0x7fc693db), X(0x7fc7056f), X(0x7fc7765c), X(0x7fc7e6a3), X(0x7fc85645), X(0x7fc8c542), X(0x7fc9339b), X(0x7fc9a150), X(0x7fca0e63), X(0x7fca7ad3), X(0x7fcae6a2), X(0x7fcb51cf), X(0x7fcbbc5c), X(0x7fcc2649), X(0x7fcc8f97), X(0x7fccf846), X(0x7fcd6058), X(0x7fcdc7cb), X(0x7fce2ea2), X(0x7fce94dd), X(0x7fcefa7b), X(0x7fcf5f7f), X(0x7fcfc3e8), X(0x7fd027b7), X(0x7fd08aed), X(0x7fd0ed8b), X(0x7fd14f90), X(0x7fd1b0fd), X(0x7fd211d4), X(0x7fd27214), X(0x7fd2d1bf), X(0x7fd330d4), X(0x7fd38f55), X(0x7fd3ed41), X(0x7fd44a9a), X(0x7fd4a761), X(0x7fd50395), X(0x7fd55f37), X(0x7fd5ba48), X(0x7fd614c9), X(0x7fd66eba), X(0x7fd6c81b), X(0x7fd720ed), X(0x7fd77932), X(0x7fd7d0e8), X(0x7fd82812), X(0x7fd87eae), X(0x7fd8d4bf), X(0x7fd92a45), X(0x7fd97f40), X(0x7fd9d3b0), X(0x7fda2797), X(0x7fda7af5), X(0x7fdacdca), X(0x7fdb2018), X(0x7fdb71dd), X(0x7fdbc31c), X(0x7fdc13d5), X(0x7fdc6408), X(0x7fdcb3b6), X(0x7fdd02df), X(0x7fdd5184), X(0x7fdd9fa5), X(0x7fdded44), X(0x7fde3a60), X(0x7fde86fb), X(0x7fded314), X(0x7fdf1eac), X(0x7fdf69c4), X(0x7fdfb45d), X(0x7fdffe76), X(0x7fe04811), X(0x7fe0912e), X(0x7fe0d9ce), X(0x7fe121f0), X(0x7fe16996), X(0x7fe1b0c1), X(0x7fe1f770), X(0x7fe23da4), X(0x7fe2835f), X(0x7fe2c89f), X(0x7fe30d67), X(0x7fe351b5), X(0x7fe3958c), X(0x7fe3d8ec), X(0x7fe41bd4), X(0x7fe45e46), X(0x7fe4a042), X(0x7fe4e1c8), X(0x7fe522da), X(0x7fe56378), X(0x7fe5a3a1), X(0x7fe5e358), X(0x7fe6229b), X(0x7fe6616d), X(0x7fe69fcc), X(0x7fe6ddbb), X(0x7fe71b39), X(0x7fe75847), X(0x7fe794e5), X(0x7fe7d114), X(0x7fe80cd5), X(0x7fe84827), X(0x7fe8830c), X(0x7fe8bd84), X(0x7fe8f78f), X(0x7fe9312f), X(0x7fe96a62), X(0x7fe9a32b), X(0x7fe9db8a), X(0x7fea137e), X(0x7fea4b09), X(0x7fea822b), X(0x7feab8e5), X(0x7feaef37), X(0x7feb2521), X(0x7feb5aa4), X(0x7feb8fc1), X(0x7febc478), X(0x7febf8ca), X(0x7fec2cb6), X(0x7fec603e), X(0x7fec9363), X(0x7fecc623), X(0x7fecf881), X(0x7fed2a7c), X(0x7fed5c16), X(0x7fed8d4e), X(0x7fedbe24), X(0x7fedee9b), X(0x7fee1eb1), X(0x7fee4e68), X(0x7fee7dc0), X(0x7feeacb9), X(0x7feedb54), X(0x7fef0991), X(0x7fef3771), X(0x7fef64f5), X(0x7fef921d), X(0x7fefbee8), X(0x7fefeb59), X(0x7ff0176f), X(0x7ff0432a), X(0x7ff06e8c), X(0x7ff09995), X(0x7ff0c444), X(0x7ff0ee9c), X(0x7ff1189b), X(0x7ff14243), X(0x7ff16b94), X(0x7ff1948e), X(0x7ff1bd32), X(0x7ff1e581), X(0x7ff20d7b), X(0x7ff2351f), X(0x7ff25c70), X(0x7ff2836d), X(0x7ff2aa17), X(0x7ff2d06d), X(0x7ff2f672), X(0x7ff31c24), X(0x7ff34185), X(0x7ff36695), X(0x7ff38b55), X(0x7ff3afc4), X(0x7ff3d3e4), X(0x7ff3f7b4), X(0x7ff41b35), X(0x7ff43e69), X(0x7ff4614e), X(0x7ff483e6), X(0x7ff4a631), X(0x7ff4c82f), X(0x7ff4e9e1), X(0x7ff50b47), X(0x7ff52c62), X(0x7ff54d33), X(0x7ff56db9), X(0x7ff58df5), X(0x7ff5ade7), X(0x7ff5cd90), X(0x7ff5ecf1), X(0x7ff60c09), X(0x7ff62ada), X(0x7ff64963), X(0x7ff667a5), X(0x7ff685a1), X(0x7ff6a357), X(0x7ff6c0c7), X(0x7ff6ddf1), X(0x7ff6fad7), X(0x7ff71778), X(0x7ff733d6), X(0x7ff74fef), X(0x7ff76bc6), X(0x7ff78759), X(0x7ff7a2ab), X(0x7ff7bdba), X(0x7ff7d888), X(0x7ff7f315), X(0x7ff80d61), X(0x7ff8276c), X(0x7ff84138), X(0x7ff85ac4), X(0x7ff87412), X(0x7ff88d20), X(0x7ff8a5f0), X(0x7ff8be82), X(0x7ff8d6d7), X(0x7ff8eeef), X(0x7ff906c9), X(0x7ff91e68), X(0x7ff935cb), X(0x7ff94cf2), X(0x7ff963dd), X(0x7ff97a8f), X(0x7ff99105), X(0x7ff9a742), X(0x7ff9bd45), X(0x7ff9d30f), X(0x7ff9e8a0), X(0x7ff9fdf9), X(0x7ffa131a), X(0x7ffa2803), X(0x7ffa3cb4), X(0x7ffa512f), X(0x7ffa6573), X(0x7ffa7981), X(0x7ffa8d59), X(0x7ffaa0fc), X(0x7ffab46a), X(0x7ffac7a3), X(0x7ffadaa8), X(0x7ffaed78), X(0x7ffb0015), X(0x7ffb127f), X(0x7ffb24b6), X(0x7ffb36bb), X(0x7ffb488d), X(0x7ffb5a2e), X(0x7ffb6b9d), X(0x7ffb7cdb), X(0x7ffb8de9), X(0x7ffb9ec6), X(0x7ffbaf73), X(0x7ffbbff1), X(0x7ffbd03f), X(0x7ffbe05e), X(0x7ffbf04f), X(0x7ffc0012), X(0x7ffc0fa6), X(0x7ffc1f0d), X(0x7ffc2e47), X(0x7ffc3d54), X(0x7ffc4c35), X(0x7ffc5ae9), X(0x7ffc6971), X(0x7ffc77ce), X(0x7ffc8600), X(0x7ffc9407), X(0x7ffca1e4), X(0x7ffcaf96), X(0x7ffcbd1f), X(0x7ffcca7e), X(0x7ffcd7b4), X(0x7ffce4c1), X(0x7ffcf1a5), X(0x7ffcfe62), X(0x7ffd0af6), X(0x7ffd1763), X(0x7ffd23a9), X(0x7ffd2fc8), X(0x7ffd3bc1), X(0x7ffd4793), X(0x7ffd533f), X(0x7ffd5ec5), X(0x7ffd6a27), X(0x7ffd7563), X(0x7ffd807a), X(0x7ffd8b6e), X(0x7ffd963d), X(0x7ffda0e8), X(0x7ffdab70), X(0x7ffdb5d5), X(0x7ffdc017), X(0x7ffdca36), X(0x7ffdd434), X(0x7ffdde0f), X(0x7ffde7c9), X(0x7ffdf161), X(0x7ffdfad8), X(0x7ffe042f), X(0x7ffe0d65), X(0x7ffe167b), X(0x7ffe1f71), X(0x7ffe2848), X(0x7ffe30ff), X(0x7ffe3997), X(0x7ffe4211), X(0x7ffe4a6c), X(0x7ffe52a9), X(0x7ffe5ac8), X(0x7ffe62c9), X(0x7ffe6aae), X(0x7ffe7275), X(0x7ffe7a1f), X(0x7ffe81ad), X(0x7ffe891f), X(0x7ffe9075), X(0x7ffe97b0), X(0x7ffe9ece), X(0x7ffea5d2), X(0x7ffeacbb), X(0x7ffeb38a), X(0x7ffeba3e), X(0x7ffec0d8), X(0x7ffec758), X(0x7ffecdbf), X(0x7ffed40d), X(0x7ffeda41), X(0x7ffee05d), X(0x7ffee660), X(0x7ffeec4b), X(0x7ffef21f), X(0x7ffef7da), X(0x7ffefd7e), X(0x7fff030b), X(0x7fff0881), X(0x7fff0de0), X(0x7fff1328), X(0x7fff185b), X(0x7fff1d77), X(0x7fff227e), X(0x7fff276f), X(0x7fff2c4b), X(0x7fff3112), X(0x7fff35c4), X(0x7fff3a62), X(0x7fff3eeb), X(0x7fff4360), X(0x7fff47c2), X(0x7fff4c0f), X(0x7fff504a), X(0x7fff5471), X(0x7fff5885), X(0x7fff5c87), X(0x7fff6076), X(0x7fff6452), X(0x7fff681d), X(0x7fff6bd6), X(0x7fff6f7d), X(0x7fff7313), X(0x7fff7698), X(0x7fff7a0c), X(0x7fff7d6f), X(0x7fff80c2), X(0x7fff8404), X(0x7fff8736), X(0x7fff8a58), X(0x7fff8d6b), X(0x7fff906e), X(0x7fff9362), X(0x7fff9646), X(0x7fff991c), X(0x7fff9be3), X(0x7fff9e9c), X(0x7fffa146), X(0x7fffa3e2), X(0x7fffa671), X(0x7fffa8f1), X(0x7fffab65), X(0x7fffadca), X(0x7fffb023), X(0x7fffb26f), X(0x7fffb4ae), X(0x7fffb6e0), X(0x7fffb906), X(0x7fffbb20), X(0x7fffbd2e), X(0x7fffbf30), X(0x7fffc126), X(0x7fffc311), X(0x7fffc4f1), X(0x7fffc6c5), X(0x7fffc88f), X(0x7fffca4d), X(0x7fffcc01), X(0x7fffcdab), X(0x7fffcf4a), X(0x7fffd0e0), X(0x7fffd26b), X(0x7fffd3ec), X(0x7fffd564), X(0x7fffd6d2), X(0x7fffd838), X(0x7fffd993), X(0x7fffdae6), X(0x7fffdc31), X(0x7fffdd72), X(0x7fffdeab), X(0x7fffdfdb), X(0x7fffe104), X(0x7fffe224), X(0x7fffe33c), X(0x7fffe44d), X(0x7fffe556), X(0x7fffe657), X(0x7fffe751), X(0x7fffe844), X(0x7fffe930), X(0x7fffea15), X(0x7fffeaf3), X(0x7fffebca), X(0x7fffec9b), X(0x7fffed66), X(0x7fffee2a), X(0x7fffeee8), X(0x7fffefa0), X(0x7ffff053), X(0x7ffff0ff), X(0x7ffff1a6), X(0x7ffff247), X(0x7ffff2e4), X(0x7ffff37a), X(0x7ffff40c), X(0x7ffff499), X(0x7ffff520), X(0x7ffff5a3), X(0x7ffff621), X(0x7ffff69b), X(0x7ffff710), X(0x7ffff781), X(0x7ffff7ee), X(0x7ffff857), X(0x7ffff8bb), X(0x7ffff91c), X(0x7ffff979), X(0x7ffff9d2), X(0x7ffffa27), X(0x7ffffa79), X(0x7ffffac8), X(0x7ffffb13), X(0x7ffffb5b), X(0x7ffffba0), X(0x7ffffbe2), X(0x7ffffc21), X(0x7ffffc5d), X(0x7ffffc96), X(0x7ffffccd), X(0x7ffffd01), X(0x7ffffd32), X(0x7ffffd61), X(0x7ffffd8e), X(0x7ffffdb8), X(0x7ffffde0), X(0x7ffffe07), X(0x7ffffe2b), X(0x7ffffe4d), X(0x7ffffe6d), X(0x7ffffe8b), X(0x7ffffea8), X(0x7ffffec3), X(0x7ffffedc), X(0x7ffffef4), X(0x7fffff0a), X(0x7fffff1f), X(0x7fffff33), X(0x7fffff45), X(0x7fffff56), X(0x7fffff66), X(0x7fffff75), X(0x7fffff82), X(0x7fffff8f), X(0x7fffff9a), X(0x7fffffa5), X(0x7fffffaf), X(0x7fffffb8), X(0x7fffffc0), X(0x7fffffc8), X(0x7fffffce), X(0x7fffffd5), X(0x7fffffda), X(0x7fffffdf), X(0x7fffffe4), X(0x7fffffe8), X(0x7fffffeb), X(0x7fffffef), X(0x7ffffff1), X(0x7ffffff4), X(0x7ffffff6), X(0x7ffffff8), X(0x7ffffff9), X(0x7ffffffb), X(0x7ffffffc), X(0x7ffffffd), X(0x7ffffffd), X(0x7ffffffe), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), X(0x7fffffff), }; mednafen/tremor/floor1.c000664 001750 001750 00000034776 12726204343 016361 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: floor backend 1 implementation ********************************************************************/ #include #include #include #include "ogg.h" #include "ivorbiscodec.h" #include "codec_internal.h" #include "registry.h" #include "codebook.h" #include "misc.h" #include "block.h" #define floor1_rangedB 140 /* floor 1 fixed at -140dB to 0dB range */ typedef struct { int forward_index[VIF_POSIT+2]; int hineighbor[VIF_POSIT]; int loneighbor[VIF_POSIT]; int posts; int n; int quant_q; vorbis_info_floor1 *vi; } vorbis_look_floor1; /***********************************************/ static void floor1_free_info(vorbis_info_floor *i){ vorbis_info_floor1 *info=(vorbis_info_floor1 *)i; if(info){ memset(info,0,sizeof(*info)); _ogg_free(info); } } static void floor1_free_look(vorbis_look_floor *i){ vorbis_look_floor1 *look=(vorbis_look_floor1 *)i; if(look){ memset(look,0,sizeof(*look)); _ogg_free(look); } } static int ilog(unsigned int v){ int ret=0; while(v){ ret++; v>>=1; } return(ret); } static int icomp(const void *a,const void *b){ return(**(int **)a-**(int **)b); } static vorbis_info_floor *floor1_unpack (vorbis_info *vi,oggpack_buffer *opb){ codec_setup_info *ci=(codec_setup_info *)vi->codec_setup; int j,k,count=0,maxclass=-1,rangebits; vorbis_info_floor1 *info=(vorbis_info_floor1 *)_ogg_calloc(1,sizeof(*info)); /* read partitions */ info->partitions=oggpack_read(opb,5); /* only 0 to 31 legal */ for(j=0;jpartitions;j++){ info->partitionclass[j]=oggpack_read(opb,4); /* only 0 to 15 legal */ if(info->partitionclass[j]<0)goto err_out; if(maxclasspartitionclass[j])maxclass=info->partitionclass[j]; } /* read partition classes */ for(j=0;jclass_dim[j]=oggpack_read(opb,3)+1; /* 1 to 8 */ info->class_subs[j]=oggpack_read(opb,2); /* 0,1,2,3 bits */ if(info->class_subs[j]<0) goto err_out; if(info->class_subs[j])info->class_book[j]=oggpack_read(opb,8); if(info->class_book[j]<0 || info->class_book[j]>=ci->books) goto err_out; for(k=0;k<(1<class_subs[j]);k++){ info->class_subbook[j][k]=oggpack_read(opb,8)-1; if(info->class_subbook[j][k]<-1 || info->class_subbook[j][k]>=ci->books) goto err_out; } } /* read the post list */ info->mult=oggpack_read(opb,2)+1; /* only 1,2,3,4 legal now */ rangebits=oggpack_read(opb,4); if(rangebits<0)goto err_out; for(j=0,k=0;jpartitions;j++){ count+=info->class_dim[info->partitionclass[j]]; if(count>VIF_POSIT)goto err_out; for(;kpostlist[k+2]=oggpack_read(opb,rangebits); if(t<0 || t>=(1<postlist[0]=0; info->postlist[1]=1<postlist+j; qsort(sortpointer,count+2,sizeof(*sortpointer),icomp); for(j=1;jvi=info; look->n=info->postlist[1]; /* we drop each position value in-between already decoded values, and use linear interpolation to predict each new value past the edges. The positions are read in the order of the position list... we precompute the bounding positions in the lookup. Of course, the neighbors can change (if a position is declined), but this is an initial mapping */ for(i=0;ipartitions;i++)n+=info->class_dim[info->partitionclass[i]]; n+=2; look->posts=n; /* also store a sorted position index */ for(i=0;ipostlist+i; qsort(sortpointer,n,sizeof(*sortpointer),icomp); /* points from sort order back to range number */ for(i=0;iforward_index[i]=sortpointer[i]-info->postlist; /* quantize values to multiplier spec */ switch(info->mult){ case 1: /* 1024 -> 256 */ look->quant_q=256; break; case 2: /* 1024 -> 128 */ look->quant_q=128; break; case 3: /* 1024 -> 86 */ look->quant_q=86; break; case 4: /* 1024 -> 64 */ look->quant_q=64; break; } /* discover our neighbors for decode where we don't use fit flags (that would push the neighbors outward) */ for(i=0;in; int currentx=info->postlist[i+2]; for(j=0;jpostlist[j]; if(x>lx && xcurrentx){ hi=j; hx=x; } } look->loneighbor[i]=lo; look->hineighbor[i]=hi; } return(look); } static int render_point(int x0,int x1,int y0,int y1,int x){ y0&=0x7fff; /* mask off flag */ y1&=0x7fff; { int dy=y1-y0; int adx=x1-x0; int ady=abs(dy); int err=ady*(x-x0); int off=err/adx; if(dy<0)return(y0-off); return(y0+off); } } #ifdef _LOW_ACCURACY_ # define XdB(n) ((((n)>>8)+1)>>1) #else # define XdB(n) (n) #endif static const ogg_int32_t FLOOR_fromdB_LOOKUP[256]={ XdB(0x000000e5), XdB(0x000000f4), XdB(0x00000103), XdB(0x00000114), XdB(0x00000126), XdB(0x00000139), XdB(0x0000014e), XdB(0x00000163), XdB(0x0000017a), XdB(0x00000193), XdB(0x000001ad), XdB(0x000001c9), XdB(0x000001e7), XdB(0x00000206), XdB(0x00000228), XdB(0x0000024c), XdB(0x00000272), XdB(0x0000029b), XdB(0x000002c6), XdB(0x000002f4), XdB(0x00000326), XdB(0x0000035a), XdB(0x00000392), XdB(0x000003cd), XdB(0x0000040c), XdB(0x00000450), XdB(0x00000497), XdB(0x000004e4), XdB(0x00000535), XdB(0x0000058c), XdB(0x000005e8), XdB(0x0000064a), XdB(0x000006b3), XdB(0x00000722), XdB(0x00000799), XdB(0x00000818), XdB(0x0000089e), XdB(0x0000092e), XdB(0x000009c6), XdB(0x00000a69), XdB(0x00000b16), XdB(0x00000bcf), XdB(0x00000c93), XdB(0x00000d64), XdB(0x00000e43), XdB(0x00000f30), XdB(0x0000102d), XdB(0x0000113a), XdB(0x00001258), XdB(0x0000138a), XdB(0x000014cf), XdB(0x00001629), XdB(0x0000179a), XdB(0x00001922), XdB(0x00001ac4), XdB(0x00001c82), XdB(0x00001e5c), XdB(0x00002055), XdB(0x0000226f), XdB(0x000024ac), XdB(0x0000270e), XdB(0x00002997), XdB(0x00002c4b), XdB(0x00002f2c), XdB(0x0000323d), XdB(0x00003581), XdB(0x000038fb), XdB(0x00003caf), XdB(0x000040a0), XdB(0x000044d3), XdB(0x0000494c), XdB(0x00004e10), XdB(0x00005323), XdB(0x0000588a), XdB(0x00005e4b), XdB(0x0000646b), XdB(0x00006af2), XdB(0x000071e5), XdB(0x0000794c), XdB(0x0000812e), XdB(0x00008993), XdB(0x00009283), XdB(0x00009c09), XdB(0x0000a62d), XdB(0x0000b0f9), XdB(0x0000bc79), XdB(0x0000c8b9), XdB(0x0000d5c4), XdB(0x0000e3a9), XdB(0x0000f274), XdB(0x00010235), XdB(0x000112fd), XdB(0x000124dc), XdB(0x000137e4), XdB(0x00014c29), XdB(0x000161bf), XdB(0x000178bc), XdB(0x00019137), XdB(0x0001ab4a), XdB(0x0001c70e), XdB(0x0001e4a1), XdB(0x0002041f), XdB(0x000225aa), XdB(0x00024962), XdB(0x00026f6d), XdB(0x000297f0), XdB(0x0002c316), XdB(0x0002f109), XdB(0x000321f9), XdB(0x00035616), XdB(0x00038d97), XdB(0x0003c8b4), XdB(0x000407a7), XdB(0x00044ab2), XdB(0x00049218), XdB(0x0004de23), XdB(0x00052f1e), XdB(0x0005855c), XdB(0x0005e135), XdB(0x00064306), XdB(0x0006ab33), XdB(0x00071a24), XdB(0x0007904b), XdB(0x00080e20), XdB(0x00089422), XdB(0x000922da), XdB(0x0009bad8), XdB(0x000a5cb6), XdB(0x000b091a), XdB(0x000bc0b1), XdB(0x000c8436), XdB(0x000d5471), XdB(0x000e3233), XdB(0x000f1e5f), XdB(0x001019e4), XdB(0x001125c1), XdB(0x00124306), XdB(0x001372d5), XdB(0x0014b663), XdB(0x00160ef7), XdB(0x00177df0), XdB(0x001904c1), XdB(0x001aa4f9), XdB(0x001c603d), XdB(0x001e384f), XdB(0x00202f0f), XdB(0x0022467a), XdB(0x002480b1), XdB(0x0026dff7), XdB(0x002966b3), XdB(0x002c1776), XdB(0x002ef4fc), XdB(0x0032022d), XdB(0x00354222), XdB(0x0038b828), XdB(0x003c67c2), XdB(0x004054ae), XdB(0x004482e8), XdB(0x0048f6af), XdB(0x004db488), XdB(0x0052c142), XdB(0x005821ff), XdB(0x005ddc33), XdB(0x0063f5b0), XdB(0x006a74a7), XdB(0x00715faf), XdB(0x0078bdce), XdB(0x0080967f), XdB(0x0088f1ba), XdB(0x0091d7f9), XdB(0x009b5247), XdB(0x00a56a41), XdB(0x00b02a27), XdB(0x00bb9ce2), XdB(0x00c7ce12), XdB(0x00d4ca17), XdB(0x00e29e20), XdB(0x00f15835), XdB(0x0101074b), XdB(0x0111bb4e), XdB(0x01238531), XdB(0x01367704), XdB(0x014aa402), XdB(0x016020a7), XdB(0x017702c3), XdB(0x018f6190), XdB(0x01a955cb), XdB(0x01c4f9cf), XdB(0x01e269a8), XdB(0x0201c33b), XdB(0x0223265a), XdB(0x0246b4ea), XdB(0x026c9302), XdB(0x0294e716), XdB(0x02bfda13), XdB(0x02ed9793), XdB(0x031e4e09), XdB(0x03522ee4), XdB(0x03896ed0), XdB(0x03c445e2), XdB(0x0402efd6), XdB(0x0445ac4b), XdB(0x048cbefc), XdB(0x04d87013), XdB(0x05290c67), XdB(0x057ee5ca), XdB(0x05da5364), XdB(0x063bb204), XdB(0x06a36485), XdB(0x0711d42b), XdB(0x0787710e), XdB(0x0804b299), XdB(0x088a17ef), XdB(0x0918287e), XdB(0x09af747c), XdB(0x0a50957e), XdB(0x0afc2f19), XdB(0x0bb2ef7f), XdB(0x0c759034), XdB(0x0d44d6ca), XdB(0x0e2195bc), XdB(0x0f0cad0d), XdB(0x10070b62), XdB(0x1111aeea), XdB(0x122da66c), XdB(0x135c120f), XdB(0x149e24d9), XdB(0x15f525b1), XdB(0x176270e3), XdB(0x18e7794b), XdB(0x1a85c9ae), XdB(0x1c3f06d1), XdB(0x1e14f07d), XdB(0x200963d7), XdB(0x221e5ccd), XdB(0x2455f870), XdB(0x26b2770b), XdB(0x29363e2b), XdB(0x2be3db5c), XdB(0x2ebe06b6), XdB(0x31c7a55b), XdB(0x3503ccd4), XdB(0x3875c5aa), XdB(0x3c210f44), XdB(0x4009632b), XdB(0x4432b8cf), XdB(0x48a149bc), XdB(0x4d59959e), XdB(0x52606733), XdB(0x57bad899), XdB(0x5d6e593a), XdB(0x6380b298), XdB(0x69f80e9a), XdB(0x70dafda8), XdB(0x78307d76), XdB(0x7fffffff), }; static void render_line(int n, int x0,int x1,int y0,int y1,ogg_int32_t *d){ int dy=y1-y0; int adx=x1-x0; int ady=abs(dy); int base=dy/adx; int sy=(dy<0?base-1:base+1); int x=x0; int y=y0; int err=0; if(n>x1)n=x1; ady-=abs(base*adx); if(x=adx){ err-=adx; y+=sy; }else{ y+=base; } d[x]= MULT31_SHIFT15(d[x],FLOOR_fromdB_LOOKUP[y]); } } static void *floor1_inverse1(vorbis_block *vb,vorbis_look_floor *in){ vorbis_look_floor1 *look=(vorbis_look_floor1 *)in; vorbis_info_floor1 *info=look->vi; codec_setup_info *ci=(codec_setup_info *)vb->vd->vi->codec_setup; int i,j,k; codebook *books=ci->fullbooks; /* unpack wrapped/predicted values from stream */ if(oggpack_read(&vb->opb,1)==1){ int *fit_value=(int *)_vorbis_block_alloc(vb,(look->posts)*sizeof(*fit_value)); fit_value[0]=oggpack_read(&vb->opb,ilog(look->quant_q-1)); fit_value[1]=oggpack_read(&vb->opb,ilog(look->quant_q-1)); /* partition by partition */ /* partition by partition */ for(i=0,j=2;ipartitions;i++){ int classv=info->partitionclass[i]; int cdim=info->class_dim[classv]; int csubbits=info->class_subs[classv]; int csub=1<class_book[classv],&vb->opb); if(cval==-1)goto eop; } for(k=0;kclass_subbook[classv][cval&(csub-1)]; cval>>=csubbits; if(book>=0){ if((fit_value[j+k]=vorbis_book_decode(books+book,&vb->opb))==-1) goto eop; }else{ fit_value[j+k]=0; } } j+=cdim; } /* unwrap positive values and reconsitute via linear interpolation */ for(i=2;iposts;i++){ int predicted=render_point(info->postlist[look->loneighbor[i-2]], info->postlist[look->hineighbor[i-2]], fit_value[look->loneighbor[i-2]], fit_value[look->hineighbor[i-2]], info->postlist[i]); int hiroom=look->quant_q-predicted; int loroom=predicted; int room=(hiroom=room){ if(hiroom>loroom){ val = val-loroom; }else{ val = -1-(val-hiroom); } }else{ if(val&1){ val= -((val+1)>>1); }else{ val>>=1; } } fit_value[i]=(val+predicted)&0x7fff;; fit_value[look->loneighbor[i-2]]&=0x7fff; fit_value[look->hineighbor[i-2]]&=0x7fff; }else{ fit_value[i]=predicted|0x8000; } } return(fit_value); } eop: return(NULL); } static int floor1_inverse2(vorbis_block *vb,vorbis_look_floor *in,void *memo, ogg_int32_t *out){ vorbis_look_floor1 *look=(vorbis_look_floor1 *)in; vorbis_info_floor1 *info=look->vi; codec_setup_info *ci=(codec_setup_info *)vb->vd->vi->codec_setup; int n=ci->blocksizes[vb->W]/2; int j; if(memo){ /* render the lines */ int *fit_value=(int *)memo; int hx=0; int lx=0; int ly=fit_value[0]*info->mult; /* guard lookup against out-of-range values */ ly=(ly<0?0:ly>255?255:ly); for(j=1;jposts;j++){ int current=look->forward_index[j]; int hy=fit_value[current]&0x7fff; if(hy==fit_value[current]){ hx=info->postlist[current]; hy*=info->mult; /* guard lookup against out-of-range values */ hy=(hy<0?0:hy>255?255:hy); render_line(n,lx,hx,ly,hy,out); lx=hx; ly=hy; } } for(j=hx;j. Note that if is * to be included it must be included before this header file. */ #ifndef ifa_broadaddr #define ifa_broadaddr ifa_dstaddr /* broadcast address interface */ #endif #include extern int getifaddrs(struct ifaddrs **ifap); extern void freeifaddrs(struct ifaddrs *ifa); #endif mednafen/tremor/sharedbook.c000664 001750 001750 00000031300 12726204343 017254 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: basic shared codebook operations ********************************************************************/ #include #include #include #include "ogg.h" #include "misc.h" #include "ivorbiscodec.h" #include "codebook.h" /**** pack/unpack helpers ******************************************/ int _ilog(unsigned int v){ int ret=0; while(v){ ret++; v>>=1; } return(ret); } /* 32 bit float (not IEEE; nonnormalized mantissa + biased exponent) : neeeeeee eeemmmmm mmmmmmmm mmmmmmmm Why not IEEE? It's just not that important here. */ #define VQ_FEXP 10 #define VQ_FMAN 21 #define VQ_FEXP_BIAS 768 /* bias toward values smaller than 1. */ static ogg_int32_t _float32_unpack(long val,int *point){ long mant=val&0x1fffff; int sign=val&0x80000000; long exp =(val&0x7fe00000L)>>VQ_FMAN; exp-=(VQ_FMAN-1)+VQ_FEXP_BIAS; if(mant){ while(!(mant&0x40000000)){ mant<<=1; exp-=1; } if(sign)mant= -mant; }else{ sign=0; exp=-9999; } *point=exp; return mant; } /* given a list of word lengths, generate a list of codewords. Works for length ordered or unordered, always assigns the lowest valued codewords first. Extended to handle unused entries (length 0) */ ogg_uint32_t *_make_words(long *l,long n,long sparsecount){ long i,j,count=0; ogg_uint32_t marker[33]; ogg_uint32_t *r=(ogg_uint32_t *)_ogg_malloc((sparsecount?sparsecount:n)*sizeof(*r)); memset(marker,0,sizeof(marker)); for(i=0;i0){ ogg_uint32_t entry=marker[length]; /* when we claim a node for an entry, we also claim the nodes below it (pruning off the imagined tree that may have dangled from it) as well as blocking the use of any nodes directly above for leaves */ /* update ourself */ if(length<32 && (entry>>length)){ /* error condition; the lengths must specify an overpopulated tree */ _ogg_free(r); return(NULL); } r[count++]=entry; /* Look to see if the next shorter marker points to the node above. if so, update it and repeat. */ { for(j=length;j>0;j--){ if(marker[j]&1){ /* have to jump branches */ if(j==1) marker[1]++; else marker[j]=marker[j-1]<<1; break; /* invariant says next upper marker would already have been moved if it was on the same path */ } marker[j]++; } } /* prune the tree; the implicit invariant says all the longer markers were dangling from our just-taken node. Dangle them from our *new* node. */ for(j=length+1;j<33;j++) if((marker[j]>>1) == entry){ entry=marker[j]; marker[j]=marker[j-1]<<1; }else break; }else if(sparsecount==0)count++; } /* sanity check the huffman tree; an underpopulated tree must be rejected. The only exception is the one-node pseudo-nil tree, which appears to be underpopulated because the tree doesn't really exist; there's only one possible 'codeword' or zero bits, but the above tree-gen code doesn't mark that. */ if(sparsecount != 1){ for(i=1;i<33;i++) if(marker[i] & (0xffffffffUL>>(32-i))){ _ogg_free(r); return(NULL); } } /* bitreverse the words because our bitwise packer/unpacker is LSb endian */ for(i=0,count=0;i>j)&1; } if(sparsecount){ if(l[i]) r[count++]=temp; }else r[count++]=temp; } return(r); } /* there might be a straightforward one-line way to do the below that's portable and totally safe against roundoff, but I haven't thought of it. Therefore, we opt on the side of caution */ long _book_maptype1_quantvals(const static_codebook *b){ /* get us a starting hint, we'll polish it below */ int bits=_ilog(b->entries); int vals=b->entries>>((bits-1)*(b->dim-1)/b->dim); while(1){ long acc=1; long acc1=1; int i; for(i=0;idim;i++){ acc*=vals; acc1*=vals+1; } if(acc<=b->entries && acc1>b->entries){ return(vals); }else{ if(acc>b->entries){ vals--; }else{ vals++; } } } } /* different than what _book_unquantize does for mainline: we repack the book in a fixed point format that shares the same binary point. Upon first use, we can shift point if needed */ /* we need to deal with two map types: in map type 1, the values are generated algorithmically (each column of the vector counts through the values in the quant vector). in map type 2, all the values came in in an explicit list. Both value lists must be unpacked */ ogg_int32_t *_book_unquantize(const static_codebook *b,int n,int *sparsemap, int *maxpoint){ long j,k,count=0; if(b->maptype==1 || b->maptype==2){ int quantvals; int minpoint,delpoint; ogg_int32_t mindel=_float32_unpack(b->q_min,&minpoint); ogg_int32_t delta=_float32_unpack(b->q_delta,&delpoint); ogg_int32_t *r=(ogg_int32_t *)_ogg_calloc(n*b->dim,sizeof(*r)); int *rp=(int *)_ogg_calloc(n*b->dim,sizeof(*rp)); *maxpoint=minpoint; /* maptype 1 and 2 both use a quantized value vector, but different sizes */ switch(b->maptype){ case 1: /* most of the time, entries%dimensions == 0, but we need to be well defined. We define that the possible vales at each scalar is values == entries/dim. If entries%dim != 0, we'll have 'too few' values (values*dimentries;j++){ if((sparsemap && b->lengthlist[j]) || !sparsemap){ ogg_int32_t last=0; int lastpoint=0; int indexdiv=1; for(k=0;kdim;k++){ int index= (j/indexdiv)%quantvals; int point=0; int val=VFLOAT_MULTI(delta,delpoint, abs(b->quantlist[index]),&point); val=VFLOAT_ADD(mindel,minpoint,val,point,&point); val=VFLOAT_ADD(last,lastpoint,val,point,&point); if(b->q_sequencep){ last=val; lastpoint=point; } if(sparsemap){ r[sparsemap[count]*b->dim+k]=val; rp[sparsemap[count]*b->dim+k]=point; }else{ r[count*b->dim+k]=val; rp[count*b->dim+k]=point; } if(*maxpointentries;j++){ if((sparsemap && b->lengthlist[j]) || !sparsemap){ ogg_int32_t last=0; int lastpoint=0; for(k=0;kdim;k++){ int point=0; int val=VFLOAT_MULTI(delta,delpoint, abs(b->quantlist[j*b->dim+k]),&point); val=VFLOAT_ADD(mindel,minpoint,val,point,&point); val=VFLOAT_ADD(last,lastpoint,val,point,&point); if(b->q_sequencep){ last=val; lastpoint=point; } if(sparsemap){ r[sparsemap[count]*b->dim+k]=val; rp[sparsemap[count]*b->dim+k]=point; }else{ r[count*b->dim+k]=val; rp[count*b->dim+k]=point; } if(*maxpointdim;j++) if(rp[j]<*maxpoint) r[j]>>=*maxpoint-rp[j]; _ogg_free(rp); return(r); } return(NULL); } void vorbis_staticbook_destroy(static_codebook *b){ if(b->quantlist)_ogg_free(b->quantlist); if(b->lengthlist)_ogg_free(b->lengthlist); memset(b,0,sizeof(*b)); _ogg_free(b); } void vorbis_book_clear(codebook *b){ /* static book is not cleared; we're likely called on the lookup and the static codebook belongs to the info struct */ if(b->valuelist)_ogg_free(b->valuelist); if(b->codelist)_ogg_free(b->codelist); if(b->dec_index)_ogg_free(b->dec_index); if(b->dec_codelengths)_ogg_free(b->dec_codelengths); if(b->dec_firsttable)_ogg_free(b->dec_firsttable); memset(b,0,sizeof(*b)); } static ogg_uint32_t bitreverse(ogg_uint32_t x){ x= ((x>>16)&0x0000ffffUL) | ((x<<16)&0xffff0000UL); x= ((x>> 8)&0x00ff00ffUL) | ((x<< 8)&0xff00ff00UL); x= ((x>> 4)&0x0f0f0f0fUL) | ((x<< 4)&0xf0f0f0f0UL); x= ((x>> 2)&0x33333333UL) | ((x<< 2)&0xccccccccUL); return((x>> 1)&0x55555555UL) | ((x<< 1)&0xaaaaaaaaUL); } static int sort32a(const void *a,const void *b){ return (**(ogg_uint32_t **)a>**(ogg_uint32_t **)b)- (**(ogg_uint32_t **)a<**(ogg_uint32_t **)b); } /* decode codebook arrangement is more heavily optimized than encode */ int vorbis_book_init_decode(codebook *c,const static_codebook *s){ int i,j,n=0,tabn; int *sortindex; memset(c,0,sizeof(*c)); /* count actually used entries */ for(i=0;ientries;i++) if(s->lengthlist[i]>0) n++; c->entries=s->entries; c->used_entries=n; c->dim=s->dim; if(n>0){ /* two different remappings go on here. First, we collapse the likely sparse codebook down only to actually represented values/words. This collapsing needs to be indexed as map-valueless books are used to encode original entry positions as integers. Second, we reorder all vectors, including the entry index above, by sorted bitreversed codeword to allow treeless decode. */ /* perform sort */ ogg_uint32_t *codes=_make_words(s->lengthlist,s->entries,c->used_entries); ogg_uint32_t **codep=(ogg_uint32_t **)alloca(sizeof(*codep)*n); if(codes==NULL)goto err_out; for(i=0;icodelist=(ogg_uint32_t *)_ogg_malloc(n*sizeof(*c->codelist)); /* the index is a reverse index */ for(i=0;icodelist[sortindex[i]]=codes[i]; _ogg_free(codes); c->valuelist=_book_unquantize(s,n,sortindex,&c->binarypoint); c->dec_index=(int *)_ogg_malloc(n*sizeof(*c->dec_index)); for(n=0,i=0;ientries;i++) if(s->lengthlist[i]>0) c->dec_index[sortindex[n++]]=i; c->dec_codelengths=(char *)_ogg_malloc(n*sizeof(*c->dec_codelengths)); for(n=0,i=0;ientries;i++) if(s->lengthlist[i]>0) c->dec_codelengths[sortindex[n++]]=s->lengthlist[i]; c->dec_firsttablen=_ilog(c->used_entries)-4; /* this is magic */ if(c->dec_firsttablen<5)c->dec_firsttablen=5; if(c->dec_firsttablen>8)c->dec_firsttablen=8; tabn=1<dec_firsttablen; c->dec_firsttable=(ogg_uint32_t *)_ogg_calloc(tabn,sizeof(*c->dec_firsttable)); c->dec_maxlength=0; for(i=0;idec_maxlengthdec_codelengths[i]) c->dec_maxlength=c->dec_codelengths[i]; if(c->dec_codelengths[i]<=c->dec_firsttablen){ ogg_uint32_t orig=bitreverse(c->codelist[i]); for(j=0;j<(1<<(c->dec_firsttablen-c->dec_codelengths[i]));j++) c->dec_firsttable[orig|(j<dec_codelengths[i])]=i+1; } } /* now fill in 'unused' entries in the firsttable with hi/lo search hints for the non-direct-hits */ { ogg_uint32_t mask=0xfffffffeUL<<(31-c->dec_firsttablen); long lo=0,hi=0; for(i=0;idec_firsttablen); if(c->dec_firsttable[bitreverse(word)]==0){ while((lo+1)codelist[lo+1]<=word)lo++; while( hi=(c->codelist[hi]&mask))hi++; /* we only actually have 15 bits per hint to play with here. In order to overflow gracefully (nothing breaks, efficiency just drops), encode as the difference from the extremes. */ { unsigned long loval=lo; unsigned long hival=n-hi; if(loval>0x7fff)loval=0x7fff; if(hival>0x7fff)hival=0x7fff; c->dec_firsttable[bitreverse(word)]= 0x80000000UL | (loval<<15) | hival; } } } } } return(0); err_out: vorbis_book_clear(c); return(-1); } mednafen/pce_fast/input.cpp000664 001750 001750 00000021141 12726204343 017110 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "pce.h" #include "input.h" #include "huc.h" #include "../mednafen-endian.h" static int InputTypes[5]; static uint8 *data_ptr[5]; static bool AVPad6Which[5]; // Lower(8 buttons) or higher(4 buttons). static bool AVPad6Enabled[5]; uint16 pce_jp_data[5]; static int64 mouse_last_meow[5]; static int32 mouse_x[5], mouse_y[5]; static uint16 mouse_rel[5]; uint8 pce_mouse_button[5]; uint8 mouse_index[5]; static uint8 sel; static uint8 read_index = 0; static void SyncSettings(void); void PCEINPUT_SettingChanged(const char *name) { SyncSettings(); } void PCEINPUT_Init(void) { SyncSettings(); } void PCEINPUT_SetInput(int port, const char *type, void *ptr) { assert(port < 5); if(!strcasecmp(type, "gamepad")) InputTypes[port] = 1; else if(!strcasecmp(type, "mouse")) InputTypes[port] = 2; else InputTypes[port] = 0; data_ptr[port] = (uint8 *)ptr; } void INPUT_Frame(void) { unsigned x; for(x = 0; x < 5; x++) { if(InputTypes[x] == 1) { uint16 new_data = data_ptr[x][0] | (data_ptr[x][1] << 8); if((new_data & 0x1000) && !(pce_jp_data[x] & 0x1000)) { AVPad6Enabled[x] = !AVPad6Enabled[x]; MDFN_DispMessage("%d-button mode selected for pad %d", AVPad6Enabled[x] ? 6 : 2, x + 1); } pce_jp_data[x] = new_data; } else if(InputTypes[x] == 2) { mouse_x[x] += (int32)MDFN_de32lsb(data_ptr[x] + 0); mouse_y[x] += (int32)MDFN_de32lsb(data_ptr[x] + 4); pce_mouse_button[x] = *(uint8 *)(data_ptr[x] + 8); } } } void INPUT_FixTS(void) { unsigned x; for(x = 0; x < 5; x++) { if(InputTypes[x] == 2) mouse_last_meow[x] -= HuCPU.timestamp; } } static INLINE bool CheckLM(int n) { if((int64)HuCPU.timestamp - mouse_last_meow[n] > 10000) { mouse_last_meow[n] = HuCPU.timestamp; int32 rel_x = (int32)((0-mouse_x[n])); int32 rel_y = (int32)((0-mouse_y[n])); if(rel_x < -127) rel_x = -127; if(rel_x > 127) rel_x = 127; if(rel_y < -127) rel_y = -127; if(rel_y > 127) rel_y = 127; mouse_rel[n] = ((rel_x & 0xF0) >> 4) | ((rel_x & 0x0F) << 4); mouse_rel[n] |= (((rel_y & 0xF0) >> 4) | ((rel_y & 0x0F) << 4)) << 8; mouse_x[n] += (int32)(rel_x); mouse_y[n] += (int32)(rel_y); return(1); } return(0); } uint8 INPUT_Read(unsigned int A) { uint8 ret = 0xF; int tmp_ri = read_index; if(tmp_ri > 4) ret ^= 0xF; else { if(!InputTypes[tmp_ri]) ret ^= 0xF; else if(InputTypes[tmp_ri] == 2) // Mouse { if(sel & 1) { CheckLM(tmp_ri); ret ^= 0xF; ret ^= mouse_rel[tmp_ri] & 0xF; mouse_rel[tmp_ri] >>= 4; } else { if(pce_mouse_button[tmp_ri] & 1) ret ^= 0x3; //pce_mouse_button[tmp_ri]; if(pce_mouse_button[tmp_ri] & 0x2) ret ^= 0x8; } } else { if(InputTypes[tmp_ri] == 1) // Gamepad { if(AVPad6Which[tmp_ri] && AVPad6Enabled[tmp_ri]) { if(sel & 1) ret ^= 0x0F; else ret ^= (pce_jp_data[tmp_ri] >> 8) & 0x0F; } else { if(sel & 1) ret ^= (pce_jp_data[tmp_ri] >> 4) & 0x0F; else ret ^= pce_jp_data[tmp_ri] & 0x0F; } if(!(sel & 1)) AVPad6Which[tmp_ri] = !AVPad6Which[tmp_ri]; } } } if(!PCE_IsCD) ret |= 0x80; // Set when CDROM is not attached //ret |= 0x40; // PC Engine if set, TG16 if clear. Let's leave it clear, PC Engine games don't seem to mind if it's clear, but TG16 games barf if it's set. ret |= 0x30; // Always-set? return(ret); } void INPUT_Write(unsigned int A, uint8 V) { if((V & 1) && !(sel & 2) && (V & 2)) read_index = 0; else if((V & 1) && !(sel & 1)) { if(read_index < 255) read_index++; } sel = V & 3; } int INPUT_StateAction(StateMem *sm, int load, int data_only) { SFORMAT StateRegs[] = { // 0.8.A fix: SFARRAYB(AVPad6Enabled, 5), SFARRAYB(AVPad6Which, 5), SFVARN(mouse_last_meow[0], "mlm_0"), SFVARN(mouse_last_meow[1], "mlm_1"), SFVARN(mouse_last_meow[2], "mlm_2"), SFVARN(mouse_last_meow[3], "mlm_3"), SFVARN(mouse_last_meow[4], "mlm_4"), SFARRAY32(mouse_x, 5), SFARRAY32(mouse_y, 5), SFARRAY16(mouse_rel, 5), SFARRAY(pce_mouse_button, 5), SFARRAY(mouse_index, 5), // end 0.8.A fix SFARRAY16(pce_jp_data, 5), SFVAR(sel), SFVAR(read_index), SFEND }; int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, "JOY"); return(ret); } // GamepadIDII and GamepadIDII_DSR must be EXACTLY the same except for the RUN+SELECT exclusion in the latter. static const InputDeviceInputInfoStruct GamepadIDII[] = { { "i", "I", 12, IDIT_BUTTON_CAN_RAPID, NULL }, { "ii", "II", 11, IDIT_BUTTON_CAN_RAPID, NULL }, { "select", "SELECT", 4, IDIT_BUTTON, NULL }, { "run", "RUN", 5, IDIT_BUTTON, NULL }, { "up", "UP ↑", 0, IDIT_BUTTON, "down" }, { "right", "RIGHT →", 3, IDIT_BUTTON, "left" }, { "down", "DOWN ↓", 1, IDIT_BUTTON, "up" }, { "left", "LEFT ←", 2, IDIT_BUTTON, "right" }, { "iii", "III", 10, IDIT_BUTTON, NULL }, { "iv", "IV", 7, IDIT_BUTTON, NULL }, { "v", "V", 8, IDIT_BUTTON, NULL }, { "vi", "VI", 9, IDIT_BUTTON, NULL }, { "mode_select", "2/6 Mode Select", 6, IDIT_BUTTON, NULL }, }; static const InputDeviceInputInfoStruct GamepadIDII_DSR[] = { { "i", "I", 12, IDIT_BUTTON_CAN_RAPID, NULL }, { "ii", "II", 11, IDIT_BUTTON_CAN_RAPID, NULL }, { "select", "SELECT", 4, IDIT_BUTTON, "run" }, { "run", "RUN", 5, IDIT_BUTTON, "select" }, { "up", "UP ↑", 0, IDIT_BUTTON, "down" }, { "right", "RIGHT →", 3, IDIT_BUTTON, "left" }, { "down", "DOWN ↓", 1, IDIT_BUTTON, "up" }, { "left", "LEFT ←", 2, IDIT_BUTTON, "right" }, { "iii", "III", 10, IDIT_BUTTON, NULL }, { "iv", "IV", 7, IDIT_BUTTON, NULL }, { "v", "V", 8, IDIT_BUTTON, NULL }, { "vi", "VI", 9, IDIT_BUTTON, NULL }, { "mode_select", "2/6 Mode Select", 6, IDIT_BUTTON, NULL }, }; static const InputDeviceInputInfoStruct MouseIDII[] = { { "x_axis", "X Axis", -1, IDIT_X_AXIS_REL }, { "y_axis", "Y Axis", -1, IDIT_Y_AXIS_REL }, { "left", "Left Button", 0, IDIT_BUTTON, NULL }, { "right", "Right Button", 1, IDIT_BUTTON, NULL }, }; // If we add more devices to this array, REMEMBER TO UPDATE the hackish array indexing in the SyncSettings() function // below. static InputDeviceInfoStruct InputDeviceInfo[] = { // None { "none", "none", NULL, NULL, 0, NULL }, // Gamepad { "gamepad", "Gamepad", NULL, NULL, sizeof(GamepadIDII) / sizeof(InputDeviceInputInfoStruct), GamepadIDII, }, // Mouse { "mouse", "Mouse", NULL, NULL, sizeof(MouseIDII) / sizeof(InputDeviceInputInfoStruct), MouseIDII, }, }; static const InputPortInfoStruct PortInfo[] = { { "port1", "Port 1", sizeof(InputDeviceInfo) / sizeof(InputDeviceInfoStruct), InputDeviceInfo, "gamepad" }, { "port2", "Port 2", sizeof(InputDeviceInfo) / sizeof(InputDeviceInfoStruct), InputDeviceInfo, "gamepad" }, { "port3", "Port 3", sizeof(InputDeviceInfo) / sizeof(InputDeviceInfoStruct), InputDeviceInfo, "gamepad" }, { "port4", "Port 4", sizeof(InputDeviceInfo) / sizeof(InputDeviceInfoStruct), InputDeviceInfo, "gamepad" }, { "port5", "Port 5", sizeof(InputDeviceInfo) / sizeof(InputDeviceInfoStruct), InputDeviceInfo, "gamepad" }, }; InputInfoStruct PCEInputInfo = { sizeof(PortInfo) / sizeof(InputPortInfoStruct), PortInfo }; static void SyncSettings(void) { MDFNGameInfo->mouse_sensitivity = MDFN_GetSettingF("pce_fast.mouse_sensitivity"); InputDeviceInfo[1].IDII = MDFN_GetSettingB("pce_fast.disable_softreset") ? GamepadIDII_DSR : GamepadIDII; } libretro-common/include/compat/strcasestr.h000664 001750 001750 00000003577 12726204343 022305 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (strcasestr.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_COMPAT_STRCASESTR_H #define __LIBRETRO_SDK_COMPAT_STRCASESTR_H #include #if defined(RARCH_INTERNAL) && defined(HAVE_CONFIG_H) #include "../../../config.h" #endif #ifndef HAVE_STRCASESTR #ifdef __cplusplus extern "C" { #endif /* Avoid possible naming collisions during link * since we prefer to use the actual name. */ #define strcasestr(haystack, needle) strcasestr_retro__(haystack, needle) char *strcasestr(const char *haystack, const char *needle); #ifdef __cplusplus } #endif #endif #endif mednafen/MemoryStream.cpp000664 001750 001750 00000011123 12726204343 016610 0ustar00sergiosergio000000 000000 #include #include "MemoryStream.h" #ifdef _XBOX #ifndef SIZE_MAX #define SIZE_MAX _UI32_MAX #endif #endif /* TODO: Write and Seek expansion that fail should not corrupt the state. Copy and assignment constructor fixes. */ // TODO 128-bit integers for range checking? MemoryStream::MemoryStream() : data_buffer(NULL), data_buffer_size(0), data_buffer_alloced(0), position(0) { data_buffer_size = 0; data_buffer_alloced = 64; if(!(data_buffer = (uint8*)realloc(data_buffer, data_buffer_alloced))) throw MDFN_Error(ErrnoHolder(errno)); } MemoryStream::MemoryStream(uint64 size_hint) : data_buffer(NULL), data_buffer_size(0), data_buffer_alloced(0), position(0) { data_buffer_size = 0; data_buffer_alloced = (size_hint > SIZE_MAX) ? SIZE_MAX : size_hint; if(!(data_buffer = (uint8*)realloc(data_buffer, data_buffer_alloced))) throw MDFN_Error(ErrnoHolder(errno)); } MemoryStream::MemoryStream(Stream *stream) : data_buffer(NULL), data_buffer_size(0), data_buffer_alloced(0), position(0) { if((position = stream->tell()) != 0) stream->seek(0, SEEK_SET); data_buffer_size = stream->size(); data_buffer_alloced = data_buffer_size; if(!(data_buffer = (uint8*)realloc(data_buffer, data_buffer_alloced))) throw MDFN_Error(ErrnoHolder(errno)); stream->read(data_buffer, data_buffer_size); stream->close(); delete stream; } MemoryStream::MemoryStream(const MemoryStream &zs) { data_buffer_size = zs.data_buffer_size; data_buffer_alloced = zs.data_buffer_alloced; if(!(data_buffer = (uint8*)malloc(data_buffer_alloced))) throw MDFN_Error(ErrnoHolder(errno)); memcpy(data_buffer, zs.data_buffer, data_buffer_size); position = zs.position; } MemoryStream::~MemoryStream() { if(data_buffer) { free(data_buffer); data_buffer = NULL; } } uint64 MemoryStream::attributes(void) { return (ATTRIBUTE_READABLE | ATTRIBUTE_WRITEABLE | ATTRIBUTE_SEEKABLE); } uint8 *MemoryStream::map(void) { return data_buffer; } void MemoryStream::unmap(void) { } INLINE void MemoryStream::grow_if_necessary(uint64 new_required_size) { if(new_required_size > data_buffer_size) { if(new_required_size > data_buffer_alloced) { uint64 new_required_alloced = round_up_pow2(new_required_size); uint8 *new_data_buffer; // first condition will happen at new_required_size > (1ULL << 63) due to round_up_pow2() "wrapping". // second condition can occur when running on a 32-bit system. if(new_required_alloced < new_required_size || new_required_alloced > SIZE_MAX) new_required_alloced = SIZE_MAX; // If constrained alloc size isn't enough, throw an out-of-memory/address-space type error. if(new_required_alloced < new_required_size) throw MDFN_Error(ErrnoHolder(ENOMEM)); if(!(new_data_buffer = (uint8*)realloc(data_buffer, new_required_alloced))) throw MDFN_Error(ErrnoHolder(errno)); // // Assign all in one go after the realloc() so we don't leave our object in an inconsistent state if the realloc() fails. // data_buffer = new_data_buffer; data_buffer_size = new_required_size; data_buffer_alloced = new_required_alloced; } else data_buffer_size = new_required_size; } } uint64 MemoryStream::read(void *data, uint64 count, bool error_on_eos) { if(count > data_buffer_size) { count = data_buffer_size; } if((uint64)position > (data_buffer_size - count)) { count = data_buffer_size - position; } memmove(data, &data_buffer[position], count); position += count; return count; } void MemoryStream::write(const void *data, uint64 count) { uint64 nrs = position + count; if(nrs < position) throw MDFN_Error(ErrnoHolder(EFBIG)); grow_if_necessary(nrs); memmove(&data_buffer[position], data, count); position += count; } void MemoryStream::seek(int64 offset, int whence) { int64 new_position; switch(whence) { default: throw MDFN_Error(ErrnoHolder(EINVAL)); break; case SEEK_SET: new_position = offset; break; case SEEK_CUR: new_position = position + offset; break; case SEEK_END: new_position = data_buffer_size + offset; break; } if(new_position < 0) throw MDFN_Error(ErrnoHolder(EINVAL)); else grow_if_necessary(new_position); position = new_position; } int64 MemoryStream::tell(void) { return position; } int64 MemoryStream::size(void) { return data_buffer_size; } void MemoryStream::close(void) { } int MemoryStream::get_line(std::string &str) { str.clear(); // or str.resize(0)?? while(position < data_buffer_size) { uint8 c = data_buffer[position++]; if(c == '\r' || c == '\n' || c == 0) return(c); str.push_back(c); // Should be faster than str.append(1, c) } return(-1); } libretro-common/file/000700 001750 001750 00000000000 12727366154 015732 5ustar00sergiosergio000000 000000 mednafen/settings-driver.h000664 001750 001750 00000000557 12726204343 016773 0ustar00sergiosergio000000 000000 #ifndef _MDFN_SETTINGS_DRIVER_H #define _MDFN_SETTINGS_DRIVER_H #include "settings-common.h" bool MDFNI_SetSetting(const char *name, const char *value, bool NetplayOverride = FALSE); bool MDFNI_SetSettingB(const char *name, bool value); bool MDFNI_SetSettingUI(const char *name, uint64 value); bool MDFNI_DumpSettingsDef(const char *path); #include #endif mednafen/pce_fast/huc6280.h000664 001750 001750 00000006266 12726204343 016530 0ustar00sergiosergio000000 000000 #ifndef _HuC6280H #define HUC6280_CRAZY_VERSION //#define HUC6280_EXTRA_CRAZY #define HUC6280_LAZY_FLAGS typedef struct __HuC6280 { #ifdef HUC6280_CRAZY_VERSION uint8 *PC, *PC_base; #else uint16 PC; #endif uint8 A,X,Y,S,P,mooPI; #ifdef HUC6280_LAZY_FLAGS uint32 ZNFlags; #endif uint8 MPR[9]; // 8, + 1 for PC overflow from $ffff to $10000 uint8 *FastPageR[9]; uint8 *Page1; //uint8 *PAGE1_W; //const uint8 *PAGE1_R; uint32 IRQlow; /* Simulated IRQ pin held low(or is it high?). And other junk hooked on for speed reasons.*/ int32 timestamp; uint8 IRQMask, IRQMaskDelay; uint8 timer_status; int32 timer_value, timer_load; int32 timer_next_timestamp; uint32 in_block_move; uint16 bmt_src, bmt_dest, bmt_length; uint32 bmt_alternate; #define IBM_TIA 1 #define IBM_TAI 2 #define IBM_TDD 3 #define IBM_TII 4 #define IBM_TIN 5 int32 previous_next_user_event; } HuC6280; void HuC6280_Run(int32 cycles); void HuC6280_ResetTS(void); extern HuC6280 HuCPU; extern uint8 *HuCPUFastMap[0x100]; #define N_FLAG 0x80 #define V_FLAG 0x40 #define T_FLAG 0x20 #define B_FLAG 0x10 #define D_FLAG 0x08 #define I_FLAG 0x04 #define Z_FLAG 0x02 #define C_FLAG 0x01 #define NTSC_CPU 1789772.7272727272727272 #define PAL_CPU 1662607.125 #define MDFN_IQIRQ1 0x002 #define MDFN_IQIRQ2 0x001 #define MDFN_IQTIMER 0x004 #define MDFN_IQRESET 0x020 void HuC6280_Init(void) MDFN_COLD; void HuC6280_Reset(void) MDFN_COLD; void HuC6280_Power(void) MDFN_COLD; void HuC6280_IRQBegin(int w); void HuC6280_IRQEnd(int w); int HuC6280_StateAction(StateMem *sm, int load, int data_only); static INLINE void HuC6280_StealCycle(void) { HuCPU.timestamp++; } static INLINE uint8 HuC6280_TimerRead(unsigned int A) { #if 0 return(HuCPU.timer_value | (PCEIODataBuffer & 0x80)); #endif uint8 tvr = HuCPU.timer_value; if(HuCPU.timer_next_timestamp == HuCPU.timestamp) tvr = (tvr - 1) & 0x7F; return(tvr | (PCEIODataBuffer & 0x80)); } static INLINE void HuC6280_TimerWrite(unsigned int A, uint8 V) { switch(A & 1) { case 0: HuCPU.timer_load = (V & 0x7F); break; case 1: if(V & 1) // Enable counter { if(HuCPU.timer_status == 0) { HuCPU.timer_next_timestamp = HuCPU.timestamp + 1024; HuCPU.timer_value = HuCPU.timer_load; } } HuCPU.timer_status = V & 1; break; } } static INLINE uint8 HuC6280_IRQStatusRead(unsigned int A) { if(!(A & 2)) return(PCEIODataBuffer); switch(A & 1) { case 0: HuC6280_IRQEnd(MDFN_IQTIMER); return(HuCPU.IRQMask ^ 0x7); case 1: { int status = 0; if(HuCPU.IRQlow & MDFN_IQIRQ1) status |= 2; if(HuCPU.IRQlow & MDFN_IQIRQ2) status |= 1; if(HuCPU.IRQlow & MDFN_IQTIMER) status |= 4; return(status | (PCEIODataBuffer & ~(1 | 2 | 4))); } } return(PCEIODataBuffer); } static INLINE void HuC6280_IRQStatusWrite(unsigned int A, uint8 V) { if(!(A & 2)) return; switch(A & 1) { case 0: HuCPU.IRQMask = (V & 0x7) ^ 0x7; break; case 1: HuC6280_IRQEnd(MDFN_IQTIMER); break; } } #define _HuC6280H #endif mednafen/error.h000664 001750 001750 00000002032 12726204343 014761 0ustar00sergiosergio000000 000000 #ifndef __MDFN_ERROR_H #define __MDFN_ERROR_H #include #include #include #ifdef __cplusplus class ErrnoHolder; class MDFN_Error : public std::exception { public: MDFN_Error() throw(); MDFN_Error(int errno_code_new, const char *format, ...) throw(); MDFN_Error(const ErrnoHolder &enh); ~MDFN_Error() throw(); MDFN_Error(const MDFN_Error &ze_error) throw(); MDFN_Error & operator=(const MDFN_Error &ze_error) throw(); virtual const char *what(void) const throw(); int GetErrno(void) const throw(); private: int errno_code; char *error_message; }; class ErrnoHolder { public: ErrnoHolder() { local_errno = 0; local_strerror[0] = 0; } ErrnoHolder(int the_errno) { SetErrno(the_errno); } inline int Errno(void) const { return(local_errno); } const char *StrError(void) const { return(local_strerror); } void operator=(int the_errno) { SetErrno(the_errno); } private: void SetErrno(int the_errno); int local_errno; char local_strerror[256]; }; #endif #endif mednafen/pce_fast/pce.h000664 001750 001750 00000001402 12726204343 016163 0ustar00sergiosergio000000 000000 #ifndef _PCE_H #define _PCE_H #include "../mednafen-types.h" #include "../mednafen.h" #include "../state.h" #include "../general.h" #define PCE_MASTER_CLOCK 21477272.727273 #define DECLFR(x) uint8 MDFN_FASTCALL x (uint32 A) #define DECLFW(x) void MDFN_FASTCALL x (uint32 A, uint8 V) extern uint8 ROMSpace[0x88 * 8192 + 8192]; typedef void (MDFN_FASTCALL *writefunc)(uint32 A, uint8 V); typedef uint8 (MDFN_FASTCALL *readfunc)(uint32 A); extern uint8 PCEIODataBuffer; bool PCE_InitCD(void) MDFN_COLD; extern bool PCE_ACEnabled; // Arcade Card emulation enabled? void PCE_Power(void) MDFN_COLD; extern readfunc PCERead[0x100]; extern writefunc PCEWrite[0x100]; extern int pce_overclocked; extern uint8 BaseRAM[32768 + 8192]; #include "huc6280.h" #endif mednafen/cdrom/CDAccess_Image.h000664 001750 001750 00000003607 12726204343 017457 0ustar00sergiosergio000000 000000 #ifndef __MDFN_CDACCESS_IMAGE_H #define __MDFN_CDACCESS_IMAGE_H #include class Stream; class AudioReader; struct CDRFILE_TRACK_INFO { int32 LBA; uint32 DIFormat; uint8 subq_control; int32 pregap; int32 pregap_dv; int32 postgap; int32 index[2]; int32 sectors; // Not including pregap sectors! Stream *fp; bool FirstFileInstance; bool RawAudioMSBFirst; long FileOffset; unsigned int SubchannelMode; uint32 LastSamplePos; AudioReader *AReader; }; #if 0 struct Medium_Chunk { int64 Offset; // Offset in [..TODO..] uint32 DIFormat; FILE *fp; bool FirstFileInstance; bool RawAudioMSBFirst; unsigned int SubchannelMode; uint32 LastSamplePos; AudioReader *AReader; }; struct CD_Chunk { int32 LBA; int32 Track; int32 Index; bool DataType; Medium_Chunk Medium; }; static std::vector Chunks; #endif class CDAccess_Image : public CDAccess { public: CDAccess_Image(const char *path, bool image_memcache); virtual ~CDAccess_Image(); virtual void Read_Raw_Sector(uint8 *buf, int32 lba); virtual void Read_TOC(CDUtility::TOC *toc); virtual bool Is_Physical(void) throw(); virtual void Eject(bool eject_status); private: int32 NumTracks; int32 FirstTrack; int32 LastTrack; int32 total_sectors; uint8 disc_type; CDRFILE_TRACK_INFO Tracks[100]; // Track #0(HMM?) through 99 std::string base_dir; void ImageOpen(const char *path, bool image_memcache); void Cleanup(void); // MakeSubPQ will OR the simulated P and Q subchannel data into SubPWBuf. void MakeSubPQ(int32 lba, uint8 *SubPWBuf); void ParseTOCFileLineInfo(CDRFILE_TRACK_INFO *track, const int tracknum, const std::string &filename, const char *binoffset, const char *msfoffset, const char *length, bool image_memcache, std::map &toc_streamcache); uint32 GetSectorCount(CDRFILE_TRACK_INFO *track); }; #endif libretro-common/include/queues/000700 001750 001750 00000000000 12727366154 017745 5ustar00sergiosergio000000 000000 Makefile000664 001750 001750 00000022432 12726204343 013350 0ustar00sergiosergio000000 000000 DEBUG = 0 FRONTEND_SUPPORTS_RGB565 = 1 CORE_DIR := . ifeq ($(platform),) platform = unix ifeq ($(shell uname -a),) platform = win else ifneq ($(findstring Darwin,$(shell uname -a)),) platform = osx arch = intel ifeq ($(shell uname -p),powerpc) arch = ppc endif else ifneq ($(findstring MINGW,$(shell uname -a)),) platform = win endif endif # If you have a system with 1GB RAM or more - cache the whole # CD for CD-based systems in order to prevent file access delays/hiccups CACHE_CD = 0 ifneq ($(platform), osx) PTHREAD_FLAGS = -pthread endif HAVE_HES = 0 NEED_BPP = 32 NEED_TREMOR = 1 NEED_BLIP = 1 NEED_CD = 1 NEED_THREADING = 1 NEED_CRC32 = 1 WANT_NEW_API = 1 CORE_DEFINE := -DWANT_PCE_FAST_EMU -DWANT_STEREO_SOUND TARGET_NAME := mednafen_pce_fast_libretro arch = intel ifeq ($(shell uname -p),powerpc) arch = ppc endif ifeq ($(platform), unix) TARGET := $(TARGET_NAME).so fpic := -fPIC SHARED := -shared -Wl,--no-undefined -Wl,--version-script=link.T ifneq ($(shell uname -p | grep -E '((i.|x)86|amd64)'),) IS_X86 = 1 endif LDFLAGS += $(PTHREAD_FLAGS) -lrt FLAGS += $(PTHREAD_FLAGS) -DHAVE_MKDIR else ifeq ($(platform), osx) TARGET := $(TARGET_NAME).dylib fpic := -fPIC SHARED := -dynamiclib LDFLAGS += $(PTHREAD_FLAGS) FLAGS += $(PTHREAD_FLAGS) -DHAVE_MKDIR ifeq ($(arch),ppc) ENDIANNESS_DEFINES := -DMSB_FIRST -DBYTE_ORDER=BIG_ENDIAN OLD_GCC := 1 endif OSXVER = `sw_vers -productVersion | cut -d. -f 2` OSX_LT_MAVERICKS = `(( $(OSXVER) <= 9)) && echo "YES"` fpic += -mmacosx-version-min=10.1 # iOS else ifneq (,$(findstring ios,$(platform))) TARGET := $(TARGET_NAME)_ios.dylib fpic := -fPIC SHARED := -dynamiclib LDFLAGS += $(PTHREAD_FLAGS) FLAGS += $(PTHREAD_FLAGS) ifeq ($(IOSSDK),) IOSSDK := $(shell xcodebuild -version -sdk iphoneos Path) endif CC = cc -arch armv7 -isysroot $(IOSSDK) CXX = c++ -arch armv7 -isysroot $(IOSSDK) IPHONEMINVER := ifeq ($(platform),ios9) IPHONEMINVER = -miphoneos-version-min=8.0 else IPHONEMINVER = -miphoneos-version-min=5.0 endif LDFLAGS += $(IPHONEMINVER) FLAGS += $(IPHONEMINVER) CC += $(IPHONEMINVER) CXX += $(IPHONEMINVER) else ifeq ($(platform), qnx) TARGET := $(TARGET_NAME)_qnx.so fpic := -fPIC SHARED := -lcpp -lm -shared -Wl,--no-undefined -Wl,--version-script=link.T #LDFLAGS += $(PTHREAD_FLAGS) #FLAGS += $(PTHREAD_FLAGS) -DHAVE_MKDIR FLAGS += -DHAVE_MKDIR CC = qcc -Vgcc_ntoarmv7le CXX = QCC -Vgcc_ntoarmv7le_cpp AR = QCC -Vgcc_ntoarmv7le FLAGS += -D__BLACKBERRY_QNX__ -marm -mcpu=cortex-a9 -mfpu=neon -mfloat-abi=softfp else ifeq ($(platform), ps3) TARGET := $(TARGET_NAME)_ps3.a CC = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-gcc.exe CXX = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-g++.exe AR = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-ar.exe ENDIANNESS_DEFINES := -DMSB_FIRST -DBYTE_ORDER=BIG_ENDIAN OLD_GCC := 1 FLAGS += -DHAVE_MKDIR -DARCH_POWERPC_ALTIVEC STATIC_LINKING = 1 else ifeq ($(platform), sncps3) TARGET := $(TARGET_NAME)_ps3.a CC = $(CELL_SDK)/host-win32/sn/bin/ps3ppusnc.exe CXX = $(CELL_SDK)/host-win32/sn/bin/ps3ppusnc.exe AR = $(CELL_SDK)/host-win32/sn/bin/ps3snarl.exe ENDIANNESS_DEFINES := -DMSB_FIRST -DBYTE_ORDER=BIG_ENDIAN CXXFLAGS += -Xc+=exceptions OLD_GCC := 1 NO_GCC := 1 FLAGS += -DHAVE_MKDIR -DARCH_POWERPC_ALTIVEC STATIC_LINKING = 1 else ifeq ($(platform), psl1ght) TARGET := $(TARGET_NAME)_psl1ght.a CC = $(PS3DEV)/ppu/bin/ppu-gcc$(EXE_EXT) CXX = $(PS3DEV)/ppu/bin/ppu-g++$(EXE_EXT) AR = $(PS3DEV)/ppu/bin/ppu-ar$(EXE_EXT) ENDIANNESS_DEFINES := -DMSB_FIRST -DBYTE_ORDER=BIG_ENDIAN FLAGS += -DHAVE_MKDIR -DBYTE_ORDER=BIG_ENDIAN STATIC_LINKING = 1 # PSP else ifeq ($(platform), psp1) TARGET := $(TARGET_NAME)_psp1.a CC = psp-gcc$(EXE_EXT) CXX = psp-g++$(EXE_EXT) AR = psp-ar$(EXE_EXT) FLAGS += -DPSP -G0 FLAGS += -DHAVE_MKDIR STATIC_LINKING = 1 EXTRA_INCLUDES := -I$(shell psp-config --pspsdk-path)/include # Vita # else ifeq ($(platform), vita) TARGET := $(TARGET_NAME)_vita.a CC = arm-vita-eabi-gcc$(EXE_EXT) CXX = arm-vita-eabi-g++$(EXE_EXT) AR = arm-vita-eabi-ar$(EXE_EXT) FLAGS += -DVITA -DHAVE_MKDIR STATIC_LINKING = 1 else ifeq ($(platform), xenon) TARGET := $(TARGET_NAME)_xenon360.a CC = xenon-gcc$(EXE_EXT) CXX = xenon-g++$(EXE_EXT) AR = xenon-ar$(EXE_EXT) ENDIANNESS_DEFINES += -D__LIBXENON__ -m32 -D__ppc__ -DMSB_FIRST -DBYTE_ORDER=BIG_ENDIAN LIBS := $(PTHREAD_FLAGS) FLAGS += -DHAVE_MKDIR STATIC_LINKING = 1 else ifeq ($(platform), ngc) TARGET := $(TARGET_NAME)_ngc.a CC = $(DEVKITPPC)/bin/powerpc-eabi-gcc$(EXE_EXT) CXX = $(DEVKITPPC)/bin/powerpc-eabi-g++$(EXE_EXT) AR = $(DEVKITPPC)/bin/powerpc-eabi-ar$(EXE_EXT) ENDIANNESS_DEFINES += -DGEKKO -DHW_DOL -mrvl -mcpu=750 -meabi -mhard-float -DMSB_FIRST -DBYTE_ORDER=BIG_ENDIAN EXTRA_INCLUDES := -I$(DEVKITPRO)/libogc/include FLAGS += -DHAVE_MKDIR STATIC_LINKING = 1 else ifeq ($(platform), wii) TARGET := $(TARGET_NAME)_wii.a CC = $(DEVKITPPC)/bin/powerpc-eabi-gcc$(EXE_EXT) CXX = $(DEVKITPPC)/bin/powerpc-eabi-g++$(EXE_EXT) AR = $(DEVKITPPC)/bin/powerpc-eabi-ar$(EXE_EXT) ENDIANNESS_DEFINES += -DGEKKO -DHW_RVL -mrvl -mcpu=750 -meabi -mhard-float -DMSB_FIRST -DBYTE_ORDER=BIG_ENDIAN EXTRA_INCLUDES := -I$(DEVKITPRO)/libogc/include FLAGS += -DHAVE_MKDIR STATIC_LINKING = 1 else ifeq ($(platform), rpi1) TARGET := $(TARGET_NAME).so fpic := -fPIC SHARED := -shared -Wl,--no-undefined -Wl,--version-script=link.T CC = gcc LDFLAGS += $(PTHREAD_FLAGS) -lrt FLAGS += $(PTHREAD_FLAGS) -DHAVE_MKDIR IS_X86 = 0 FLAGS += -DARM -marm -march=armv6j -mfpu=vfp -mfloat-abi=hard FLAGS += -fomit-frame-pointer -ffast-math else ifeq ($(platform), rpi2) TARGET := $(TARGET_NAME).so fpic := -fPIC SHARED := -shared -Wl,--no-undefined -Wl,--version-script=link.T CC = gcc LDFLAGS += $(PTHREAD_FLAGS) -lrt FLAGS += $(PTHREAD_FLAGS) -DHAVE_MKDIR IS_X86 = 0 FLAGS += -DARM -marm -mcpu=cortex-a7 -mfpu=neon-vfpv4 -mfloat-abi=hard FLAGS += -fomit-frame-pointer -ffast-math HAVE_NEON = 1 else ifeq ($(platform), rpi3) TARGET := $(TARGET_NAME).so fpic := -fPIC SHARED := -shared -Wl,--no-undefined -Wl,--version-script=link.T CC = gcc LDFLAGS += $(PTHREAD_FLAGS) -lrt FLAGS += $(PTHREAD_FLAGS) -DHAVE_MKDIR IS_X86 = 0 FLAGS += -DARM -marm -mcpu=cortex-a53 -mfpu=neon-fp-armv8 -mfloat-abi=hard FLAGS += -fomit-frame-pointer -ffast-math HAVE_NEON = 1 else ifneq (,$(findstring armv,$(platform))) TARGET := $(TARGET_NAME).so fpic := -fPIC SHARED := -shared -Wl,--no-undefined -Wl,--version-script=link.T CC = gcc LDFLAGS += $(PTHREAD_FLAGS) FLAGS += $(PTHREAD_FLAGS) -DHAVE_MKDIR IS_X86 = 0 ifneq (,$(findstring cortexa8,$(platform))) FLAGS += -marm -mcpu=cortex-a8 ASFLAGS += -mcpu=cortex-a8 else ifneq (,$(findstring cortexa9,$(platform))) FLAGS += -marm -mcpu=cortex-a9 ASFLAGS += -mcpu=cortex-a9 endif FLAGS += -marm ifneq (,$(findstring neon,$(platform))) FLAGS += -mfpu=neon ASFLAGS += -mfpu=neon HAVE_NEON = 1 endif ifneq (,$(findstring softfloat,$(platform))) FLAGS += -mfloat-abi=softfp else ifneq (,$(findstring hardfloat,$(platform))) FLAGS += -mfloat-abi=hard endif FLAGS += -DARM else ifeq ($(platform), gcw0) TARGET := $(TARGET_NAME).so CC = /opt/gcw0-toolchain/usr/bin/mipsel-linux-gcc CXX = /opt/gcw0-toolchain/usr/bin/mipsel-linux-g++ AR = /opt/gcw0-toolchain/usr/bin/mipsel-linux-ar fpic := -fPIC SHARED := -shared -Wl,--no-undefined -Wl,--version-script=link.T LDFLAGS += $(PTHREAD_FLAGS) -lrt FLAGS += $(PTHREAD_FLAGS) -DHAVE_MKDIR FLAGS += -ffast-math -march=mips32 -mtune=mips32r2 -mhard-float else TARGET := $(TARGET_NAME).dll CC = gcc CXX = g++ IS_X86 = 1 SHARED := -shared -Wl,--no-undefined -Wl,--version-script=link.T LDFLAGS += -static-libgcc -static-libstdc++ -lwinmm FLAGS += -DHAVE__MKDIR endif include Makefile.common WARNINGS := -Wall \ -Wno-sign-compare \ -Wno-unused-variable \ -Wno-unused-function \ -Wno-uninitialized \ $(NEW_GCC_WARNING_FLAGS) \ -Wno-strict-aliasing EXTRA_GCC_FLAGS := -funroll-loops ifeq ($(NO_GCC),1) EXTRA_GCC_FLAGS := WARNINGS := else EXTRA_GCC_FLAGS := -g endif OBJECTS := $(SOURCES_CXX:.cpp=.o) $(SOURCES_C:.c=.o) all: $(TARGET) ifeq ($(DEBUG),0) FLAGS += -O2 $(EXTRA_GCC_FLAGS) else FLAGS += -O0 endif LDFLAGS += $(fpic) $(SHARED) FLAGS += $(fpic) $(NEW_GCC_FLAGS) FLAGS += $(INCFLAGS) FLAGS += $(ENDIANNESS_DEFINES) -DSIZEOF_DOUBLE=8 $(WARNINGS) -DMEDNAFEN_VERSION=\"0.9.31\" -DPACKAGE=\"mednafen\" -DMEDNAFEN_VERSION_NUMERIC=931 -DPSS_STYLE=1 -DMPC_FIXED_POINT $(CORE_DEFINE) -DSTDC_HEADERS -D__STDC_LIMIT_MACROS -D__LIBRETRO__ -D_LOW_ACCURACY_ $(EXTRA_INCLUDES) $(SOUND_DEFINE) ifeq ($(IS_X86), 1) FLAGS += -DARCH_X86 endif ifeq ($(CACHE_CD), 1) FLAGS += -D__LIBRETRO_CACHE_CD__ endif ifeq ($(NEED_BPP), 16) FLAGS += -DWANT_16BPP endif ifeq ($(FRONTEND_SUPPORTS_RGB565), 1) FLAGS += -DFRONTEND_SUPPORTS_RGB565 endif ifeq ($(WANT_NEW_API), 1) FLAGS += -DWANT_NEW_API endif CXXFLAGS += $(FLAGS) CFLAGS += $(FLAGS) $(TARGET): $(OBJECTS) ifeq ($(STATIC_LINKING), 1) $(AR) rcs $@ $(OBJECTS) else $(CXX) -o $@ $^ $(LDFLAGS) endif %.o: %.cpp $(CXX) -c -o $@ $< $(CXXFLAGS) %.o: %.c $(CC) -c -o $@ $< $(CFLAGS) clean: rm -f $(TARGET) $(OBJECTS) .PHONY: clean mednafen/mednafen.h000664 001750 001750 00000003034 12726204343 015410 0ustar00sergiosergio000000 000000 #ifndef _MEDNAFEN_H #define _MEDNAFEN_H #include "mednafen-types.h" #include #include #include #define _(String) (String) #include "math_ops.h" #include "git.h" #ifdef _WIN32 #define strcasecmp _stricmp #endif #ifdef __LIBRETRO__ #define GET_FDATA(fp) (fp.f_data) #define GET_FSIZE(fp) (fp.f_size) #define GET_FEXTS(fp) (fp.f_ext) #define GET_FDATA_PTR(fp) (fp->f_data) #define GET_FSIZE_PTR(fp) (fp->f_size) #define GET_FEXTS_PTR(fp) (fp->f_ext) #define gzopen(a, b) fopen(a, b) #define gzread(a, b, c) fread(b, c, 1, a) #define gzclose(a) fclose(a) #define gzgetc(a) fgetc(a) #define gzseek(a,b,c) fseek(a,b,c) #else #define GET_FDATA(fp) (fp.Data()) #define GET_FSIZE(fp) (fp.Size()) #define GET_FDATA_PTR(fp) (fp->data) #define GET_FSIZE_PTR(fp) (fp->size) #define GET_FEXTS_PTR(fp) (fp->ext) #define gzread(a, b, c) gzread(a, b, c) #define gzclose(a) gzclose(a) #define gzgetc(a) gzgetc(a) #define gzseek(a,b,c) gzseek(a,b,c) #endif #ifndef gettext_noop #define gettext_noop(a) (a) #endif extern MDFNGI *MDFNGameInfo; #include "settings.h" void MDFN_PrintError(const char *format, ...); void MDFN_printf(const char *format, ...); void MDFN_DispMessage(const char *format, ...); void MDFN_DebugPrintReal(const char *file, const int line, const char *format, ...); void MDFN_LoadGameCheats(void *override); void MDFN_FlushGameCheats(int nosave); void MDFN_MidSync(EmulateSpecStruct *espec); void MDFN_MidLineUpdate(EmulateSpecStruct *espec, int y); #include "mednafen-driver.h" #include "mednafen-endian.h" #endif mednafen/okiadpcm.h000664 001750 001750 00000006546 12726204343 015435 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 */ #ifndef __MDFN_OKIADPCM_H #define __MDFN_OKIADPCM_H // PC-FX ADPCM decoder not finished! typedef enum { OKIADPCM_MSM5205 = 0, OKIADPCM_MSM5218 = 1, OKIADPCM_COUNT } OKIADPCM_Chip; extern const int OKIADPCM_StepSizes[49]; extern const int OKIADPCM_StepIndexDeltas[16]; extern const int32 OKIADPCM_DeltaTable[49][16]; template class OKIADPCM_Decoder { public: OKIADPCM_Decoder() { assert(CHIP_TYPE < OKIADPCM_COUNT); CurSample = 0x0800; StepSizeIndex = 0; } ~OKIADPCM_Decoder() { } INLINE uint16 GetSample(void) { return(CurSample); } INLINE void SetSample(uint16 new_sample) { assert(new_sample <= 0xFFF); CurSample = new_sample; } INLINE uint8 GetSSI(void) { return(StepSizeIndex); } INLINE void SetSSI(uint8 new_ssi) { assert(new_ssi <= 48); StepSizeIndex = new_ssi; } // DecodeDelta returns the coded delta for the given nibble and (previous) predictor. // It will not wrap nor saturate the returned value, and CurSample is not updated. INLINE int32 DecodeDelta(const uint8 nibble) { int32 ret = OKIADPCM_DeltaTable[StepSizeIndex][nibble]; StepSizeIndex += OKIADPCM_StepIndexDeltas[nibble]; if(StepSizeIndex < 0) StepSizeIndex = 0; if(StepSizeIndex > 48) StepSizeIndex = 48; return(ret); } // This function will return the full 12-bits, it's up to the caller to // truncate as necessary(MSM5205 only has a 10-bit D/A, MSM5218 has a 12-bit D/A) INLINE uint16 Decode(const uint8 nibble) { CurSample += DecodeDelta(nibble); if(CHIP_TYPE == OKIADPCM_MSM5205) { CurSample &= 0xFFF; } else if(CHIP_TYPE == OKIADPCM_MSM5218) { if(CurSample > 0xFFF) CurSample = 0xFFF; if(CurSample < 0) CurSample = 0; } return(CurSample); } private: int32 CurSample; int32 StepSizeIndex; }; template class OKIADPCM_Encoder { public: OKIADPCM_Encoder() { Accum = 0x800; StepSizeIndex = 0; } ~OKIADPCM_Encoder() { } uint8 EncodeSample(uint16 in_sample) { uint8 nibble = 0; int32 sample_delta = in_sample - Accum; int piece; piece = (abs(sample_delta) * 4 / OKIADPCM_StepSizes[StepSizeIndex]); if(piece > 0x7) piece = 0x7; nibble = ((uint32)(sample_delta >> 31) & 0x8) | piece; // Update Accum and StepSizeIndex! Accum += OKIADPCM_DeltaTable[StepSizeIndex][nibble]; StepSizeIndex += OKIADPCM_StepIndexDeltas[nibble]; if(Accum > 0xFFF) Accum = 0xFFF; if(Accum < 0) Accum = 0; if(StepSizeIndex < 0) StepSizeIndex = 0; if(StepSizeIndex > 48) StepSizeIndex = 48; return(nibble); } private: int32 Accum; int32 StepSizeIndex; OKIADPCM_Chip ChipType; }; #endif mednafen/state.h000664 001750 001750 00000007302 12726204343 014755 0ustar00sergiosergio000000 000000 #ifndef _STATE_H #define _STATE_H typedef struct { uint8 *data; uint32 loc; uint32 len; uint32 malloced; uint32 initial_malloc; // A setting! } StateMem; // Eh, we abuse the smem_* in-memory stream code // in a few other places. :) int32 smem_read(StateMem *st, void *buffer, uint32 len); int32 smem_write(StateMem *st, void *buffer, uint32 len); int32 smem_putc(StateMem *st, int value); int32 smem_tell(StateMem *st); int32 smem_seek(StateMem *st, uint32 offset, int whence); int smem_write32le(StateMem *st, uint32 b); int smem_read32le(StateMem *st, uint32 *b); int MDFNSS_SaveSM(void *st, int, int, const void*, const void*, const void*); int MDFNSS_LoadSM(void *st, int, int); // Flag for a single, >= 1 byte native-endian variable #define MDFNSTATE_RLSB 0x80000000 // 32-bit native-endian elements #define MDFNSTATE_RLSB32 0x40000000 // 16-bit native-endian elements #define MDFNSTATE_RLSB16 0x20000000 // 64-bit native-endian elements #define MDFNSTATE_RLSB64 0x10000000 #define MDFNSTATE_BOOL 0x08000000 typedef struct { void *v; // Pointer to the variable/array uint32 size; // Length, in bytes, of the data to be saved EXCEPT: // In the case of MDFNSTATE_BOOL, it is the number of bool elements to save(bool is not always 1-byte). // If 0, the subchunk isn't saved. uint32 flags; // Flags const char *name; // Name //uint32 struct_size; // Only used for MDFNSTATE_ARRAYOFS, sizeof(struct) that members of the linked SFORMAT struct are in. } SFORMAT; INLINE bool SF_IS_BOOL(bool *) { return(1); } INLINE bool SF_IS_BOOL(void *) { return(0); } INLINE uint32 SF_FORCE_AB(bool *) { return(0); } INLINE uint32 SF_FORCE_A8(int8 *) { return(0); } INLINE uint32 SF_FORCE_A8(uint8 *) { return(0); } INLINE uint32 SF_FORCE_A16(int16 *) { return(0); } INLINE uint32 SF_FORCE_A16(uint16 *) { return(0); } INLINE uint32 SF_FORCE_A32(int32 *) { return(0); } INLINE uint32 SF_FORCE_A32(uint32 *) { return(0); } INLINE uint32 SF_FORCE_A64(int64 *) { return(0); } INLINE uint32 SF_FORCE_A64(uint64 *) { return(0); } INLINE uint32 SF_FORCE_D(double *) { return(0); } #define SFVARN(x, n) { &(x), SF_IS_BOOL(&(x)) ? 1 : (uint32_t)sizeof(x), MDFNSTATE_RLSB | (SF_IS_BOOL(&(x)) ? MDFNSTATE_BOOL : 0), n } #define SFVAR(x) SFVARN((x), #x) #define SFARRAYN(x, l, n) { (x), (uint32)(l), 0 | SF_FORCE_A8(x), n } #define SFARRAY(x, l) SFARRAYN((x), (l), #x) #define SFARRAYBN(x, l, n) { (x), (uint32)(l), MDFNSTATE_BOOL | SF_FORCE_AB(x), n } #define SFARRAYB(x, l) SFARRAYBN((x), (l), #x) #define SFARRAY16N(x, l, n) { (x), (uint32)((l) * sizeof(uint16)), MDFNSTATE_RLSB16 | SF_FORCE_A16(x), n } #define SFARRAY16(x, l) SFARRAY16N((x), (l), #x) #define SFARRAY32N(x, l, n) { (x), (uint32)((l) * sizeof(uint32)), MDFNSTATE_RLSB32 | SF_FORCE_A32(x), n } #define SFARRAY32(x, l) SFARRAY32N((x), (l), #x) #define SFARRAY64N(x, l, n) { (x), (uint32)((l) * sizeof(uint64)), MDFNSTATE_RLSB64 | SF_FORCE_A64(x), n } #define SFARRAY64(x, l) SFARRAY64N((x), (l), #x) #if SIZEOF_DOUBLE != 8 #error "sizeof(double) != 8" #endif #define SFARRAYDN(x, l, n) { (x), (uint32)((l) * 8), MDFNSTATE_RLSB64 | SF_FORCE_D(x), n } #define SFARRAYD(x, l) SFARRAYDN((x), (l), #x) #define SFEND { 0, 0, 0, 0 } #include // State-Section Descriptor class SSDescriptor { public: SSDescriptor(SFORMAT *n_sf, const char *n_name, bool n_optional = 0) { sf = n_sf; name = n_name; optional = n_optional; } ~SSDescriptor(void) { } SFORMAT *sf; const char *name; bool optional; }; int MDFNSS_StateAction(void *st, int load, int data_only, std::vector §ions); int MDFNSS_StateAction(void *st, int load, int data_only, SFORMAT *sf, const char *name, bool optional = 0); #endif libretro-common/include/string/stdstring.h000664 001750 001750 00000004245 12726204343 022145 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2015 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (stdstring.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_STDSTRING_H #define __LIBRETRO_SDK_STDSTRING_H #include #include #include #include #include RETRO_BEGIN_DECLS bool string_is_empty(const char *data); bool string_is_equal(const char *a, const char *b); bool string_is_equal_noncase(const char *a, const char *b); char *string_to_upper(char *s); char *string_to_lower(char *s); char *string_ucwords(char* s); char *string_replace_substring(const char *in, const char *pattern, const char *by); /* Remove leading whitespaces */ char *string_trim_whitespace_left(char *const s); /* Remove trailing whitespaces */ char *string_trim_whitespace_right(char *const s); /* Remove leading and trailing whitespaces */ char *string_trim_whitespace(char *const s); RETRO_END_DECLS #endif mednafen/tremor/Version_script.in000664 001750 001750 00000002242 12726204343 020333 0ustar00sergiosergio000000 000000 # # Export file for libvorbisidec # # Only the symbols listed in the global section will be callable from # applications linking to libvorbisidec. # @PACKAGE@.so.1 { global: ov_clear; ov_open; ov_open_callbacks; ov_test; ov_test_callbacks; ov_test_open; ov_bitrate; ov_bitrate_instant; ov_streams; ov_seekable; ov_serialnumber; ov_raw_total; ov_pcm_total; ov_time_total; ov_raw_seek; ov_pcm_seek; ov_pcm_seek_page; ov_time_seek; ov_time_seek_page; ov_raw_tell; ov_pcm_tell; ov_time_tell; ov_info; ov_comment; ov_read; vorbis_info_init; vorbis_info_clear; vorbis_info_blocksize; vorbis_comment_init; vorbis_comment_add; vorbis_comment_add_tag; vorbis_comment_query; vorbis_comment_query_count; vorbis_comment_clear; vorbis_block_init; vorbis_block_clear; vorbis_dsp_clear; vorbis_synthesis_idheader; vorbis_synthesis_headerin; vorbis_synthesis_init; vorbis_synthesis_restart; vorbis_synthesis; vorbis_synthesis_trackonly; vorbis_synthesis_blockin; vorbis_synthesis_pcmout; vorbis_synthesis_read; vorbis_packet_blocksize; local: *; }; mednafen/cdrom/cdromif.h000664 001750 001750 00000004430 12726204343 016363 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 */ #ifndef __MDFN_CDROM_CDROMIF_H #define __MDFN_CDROM_CDROMIF_H #include "CDUtility.h" #include "../Stream.h" #include typedef CDUtility::TOC CD_TOC; class CDIF { public: CDIF(); virtual ~CDIF(); inline void ReadTOC(CDUtility::TOC *read_target) { *read_target = disc_toc; } virtual void HintReadSector(uint32 lba) = 0; virtual bool ReadRawSector(uint8 *buf, uint32 lba) = 0; // Call for mode 1 or mode 2 form 1 only. bool ValidateRawSector(uint8 *buf); // Utility/Wrapped functions // Reads mode 1 and mode2 form 1 sectors(2048 bytes per sector returned) // Will return the type(1, 2) of the first sector read to the buffer supplied, 0 on error int ReadSector(uint8* pBuf, uint32 lba, uint32 nSectors); // Return true if operation succeeded or it was a NOP(either due to not being implemented, or the current status matches eject_status). // Returns false on failure(usually drive error of some kind; not completely fatal, can try again). virtual bool Eject(bool eject_status) = 0; inline bool IsPhysical(void) { return(is_phys_cache); } // For Mode 1, or Mode 2 Form 1. // No reference counting or whatever is done, so if you destroy the CDIF object before you destroy the returned Stream, things will go BOOM. Stream *MakeStream(uint32 lba, uint32 sector_count); protected: bool UnrecoverableError; bool is_phys_cache; CDUtility::TOC disc_toc; bool DiscEjected; }; CDIF *CDIF_Open(const char *path, const bool is_device, bool image_memcache); #endif mednafen/cdrom/lec.cpp000664 001750 001750 00000035546 12726204343 016052 0ustar00sergiosergio000000 000000 /* cdrdao - write audio CD-Rs in disc-at-once mode * * Copyright (C) 1998-2002 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifdef HAVE_CONFIG_H #include #endif #include #include #include "lec.h" #define GF8_PRIM_POLY 0x11d /* x^8 + x^4 + x^3 + x^2 + 1 */ #define EDC_POLY 0x8001801b /* (x^16 + x^15 + x^2 + 1) (x^16 + x^2 + x + 1) */ #define LEC_HEADER_OFFSET 12 #define LEC_DATA_OFFSET 16 #define LEC_MODE1_DATA_LEN 2048 #define LEC_MODE1_EDC_OFFSET 2064 #define LEC_MODE1_INTERMEDIATE_OFFSET 2068 #define LEC_MODE1_P_PARITY_OFFSET 2076 #define LEC_MODE1_Q_PARITY_OFFSET 2248 #define LEC_MODE2_FORM1_DATA_LEN (2048+8) #define LEC_MODE2_FORM1_EDC_OFFSET 2072 #define LEC_MODE2_FORM2_DATA_LEN (2324+8) #define LEC_MODE2_FORM2_EDC_OFFSET 2348 typedef u_int8_t gf8_t; static u_int8_t GF8_LOG[256]; static gf8_t GF8_ILOG[256]; static const class Gf8_Q_Coeffs_Results_01 { private: u_int16_t table[43][256]; public: Gf8_Q_Coeffs_Results_01(); ~Gf8_Q_Coeffs_Results_01() {} const u_int16_t *operator[] (int i) const { return &table[i][0]; } operator const u_int16_t *() const { return &table[0][0]; } } CF8_Q_COEFFS_RESULTS_01; static const class CrcTable { private: u_int32_t table[256]; public: CrcTable(); ~CrcTable() {} u_int32_t operator[](int i) const { return table[i]; } operator const u_int32_t *() const { return table; } } CRCTABLE; static const class ScrambleTable { private: u_int8_t table[2340]; public: ScrambleTable(); ~ScrambleTable() {} u_int8_t operator[](int i) const { return table[i]; } operator const u_int8_t *() const { return table; } } SCRAMBLE_TABLE; /* Creates the logarithm and inverse logarithm table that is required * for performing multiplication in the GF(8) domain. */ static void gf8_create_log_tables() { u_int8_t log; u_int16_t b; for (b = 0; b <= 255; b++) { GF8_LOG[b] = 0; GF8_ILOG[b] = 0; } b = 1; for (log = 0; log < 255; log++) { GF8_LOG[(u_int8_t)b] = log; GF8_ILOG[log] = (u_int8_t)b; b <<= 1; if ((b & 0x100) != 0) b ^= GF8_PRIM_POLY; } } /* Addition in the GF(8) domain: just the XOR of the values. */ #define gf8_add(a, b) (a) ^ (b) /* Multiplication in the GF(8) domain: add the logarithms (modulo 255) * and return the inverse logarithm. Not used! */ #if 0 static gf8_t gf8_mult(gf8_t a, gf8_t b) { int16_t sum; if (a == 0 || b == 0) return 0; sum = GF8_LOG[a] + GF8_LOG[b]; if (sum >= 255) sum -= 255; return GF8_ILOG[sum]; } #endif /* Division in the GF(8) domain: Like multiplication but logarithms a * subtracted. */ static gf8_t gf8_div(gf8_t a, gf8_t b) { int16_t sum; assert(b != 0); if (a == 0) return 0; sum = GF8_LOG[a] - GF8_LOG[b]; if (sum < 0) sum += 255; return GF8_ILOG[sum]; } Gf8_Q_Coeffs_Results_01::Gf8_Q_Coeffs_Results_01() { int i, j; u_int16_t c; gf8_t GF8_COEFFS_HELP[2][45]; u_int8_t GF8_Q_COEFFS[2][45]; gf8_create_log_tables(); /* build matrix H: * 1 1 ... 1 1 * a^44 a^43 ... a^1 a^0 * * */ for (j = 0; j < 45; j++) { GF8_COEFFS_HELP[0][j] = 1; /* e0 */ GF8_COEFFS_HELP[1][j] = GF8_ILOG[44-j]; /* e1 */ } /* resolve equation system for parity byte 0 and 1 */ /* e1' = e1 + e0 */ for (j = 0; j < 45; j++) { GF8_Q_COEFFS[1][j] = gf8_add(GF8_COEFFS_HELP[1][j], GF8_COEFFS_HELP[0][j]); } /* e1'' = e1' / (a^1 + 1) */ for (j = 0; j < 45; j++) { GF8_Q_COEFFS[1][j] = gf8_div(GF8_Q_COEFFS[1][j], GF8_Q_COEFFS[1][43]); } /* e0' = e0 + e1 / a^1 */ for (j = 0; j < 45; j++) { GF8_Q_COEFFS[0][j] = gf8_add(GF8_COEFFS_HELP[0][j], gf8_div(GF8_COEFFS_HELP[1][j], GF8_ILOG[1])); } /* e0'' = e0' / (1 + 1 / a^1) */ for (j = 0; j < 45; j++) { GF8_Q_COEFFS[0][j] = gf8_div(GF8_Q_COEFFS[0][j], GF8_Q_COEFFS[0][44]); } /* * Compute the products of 0..255 with all of the Q coefficients in * advance. When building the scalar product between the data vectors * and the P/Q vectors the individual products can be looked up in * this table * * The P parity coefficients are just a subset of the Q coefficients so * that we do not need to create a separate table for them. */ for (j = 0; j < 43; j++) { table[j][0] = 0; for (i = 1; i < 256; i++) { c = GF8_LOG[i] + GF8_LOG[GF8_Q_COEFFS[0][j]]; if (c >= 255) c -= 255; table[j][i] = GF8_ILOG[c]; c = GF8_LOG[i] + GF8_LOG[GF8_Q_COEFFS[1][j]]; if (c >= 255) c -= 255; table[j][i] |= GF8_ILOG[c]<<8; } } } /* Reverses the bits in 'd'. 'bits' defines the bit width of 'd'. */ static u_int32_t mirror_bits(u_int32_t d, int bits) { int i; u_int32_t r = 0; for (i = 0; i < bits; i++) { r <<= 1; if ((d & 0x1) != 0) r |= 0x1; d >>= 1; } return r; } /* Build the CRC lookup table for EDC_POLY poly. The CRC is 32 bit wide * and reversed (i.e. the bit stream is divided by the EDC_POLY with the * LSB first order). */ CrcTable::CrcTable () { u_int32_t i, j; u_int32_t r; for (i = 0; i < 256; i++) { r = mirror_bits(i, 8); r <<= 24; for (j = 0; j < 8; j++) { if ((r & 0x80000000) != 0) { r <<= 1; r ^= EDC_POLY; } else { r <<= 1; } } r = mirror_bits(r, 32); table[i] = r; } } /* Calculates the CRC of given data with given lengths based on the * table lookup algorithm. */ static u_int32_t calc_edc(u_int8_t *data, int len) { u_int32_t crc = 0; while (len--) { crc = CRCTABLE[(int)(crc ^ *data++) & 0xff] ^ (crc >> 8); } return crc; } /* Build the scramble table as defined in the yellow book. The bytes 12 to 2351 of a sector will be XORed with the data of this table. */ ScrambleTable::ScrambleTable() { u_int16_t i, j; u_int16_t reg = 1; u_int8_t d; for (i = 0; i < 2340; i++) { d = 0; for (j = 0; j < 8; j++) { d >>= 1; if ((reg & 0x1) != 0) d |= 0x80; if ((reg & 0x1) != ((reg >> 1) & 0x1)) { reg >>= 1; reg |= 0x4000; /* 15-bit register */ } else { reg >>= 1; } } table[i] = d; } } /* Calc EDC for a MODE 1 sector */ static void calc_mode1_edc(u_int8_t *sector) { u_int32_t crc = calc_edc(sector, LEC_MODE1_DATA_LEN + 16); sector[LEC_MODE1_EDC_OFFSET] = crc & 0xffL; sector[LEC_MODE1_EDC_OFFSET + 1] = (crc >> 8) & 0xffL; sector[LEC_MODE1_EDC_OFFSET + 2] = (crc >> 16) & 0xffL; sector[LEC_MODE1_EDC_OFFSET + 3] = (crc >> 24) & 0xffL; } /* Calc EDC for a XA form 1 sector */ static void calc_mode2_form1_edc(u_int8_t *sector) { u_int32_t crc = calc_edc(sector + LEC_DATA_OFFSET, LEC_MODE2_FORM1_DATA_LEN); sector[LEC_MODE2_FORM1_EDC_OFFSET] = crc & 0xffL; sector[LEC_MODE2_FORM1_EDC_OFFSET + 1] = (crc >> 8) & 0xffL; sector[LEC_MODE2_FORM1_EDC_OFFSET + 2] = (crc >> 16) & 0xffL; sector[LEC_MODE2_FORM1_EDC_OFFSET + 3] = (crc >> 24) & 0xffL; } /* Calc EDC for a XA form 2 sector */ static void calc_mode2_form2_edc(u_int8_t *sector) { u_int32_t crc = calc_edc(sector + LEC_DATA_OFFSET, LEC_MODE2_FORM2_DATA_LEN); sector[LEC_MODE2_FORM2_EDC_OFFSET] = crc & 0xffL; sector[LEC_MODE2_FORM2_EDC_OFFSET + 1] = (crc >> 8) & 0xffL; sector[LEC_MODE2_FORM2_EDC_OFFSET + 2] = (crc >> 16) & 0xffL; sector[LEC_MODE2_FORM2_EDC_OFFSET + 3] = (crc >> 24) & 0xffL; } /* Writes the sync pattern to the given sector. */ static void set_sync_pattern(u_int8_t *sector) { sector[0] = 0; sector[1] = sector[2] = sector[3] = sector[4] = sector[5] = sector[6] = sector[7] = sector[8] = sector[9] = sector[10] = 0xff; sector[11] = 0; } static u_int8_t bin2bcd(u_int8_t b) { return (((b/10) << 4) & 0xf0) | ((b%10) & 0x0f); } /* Builds the sector header. */ static void set_sector_header(u_int8_t mode, u_int32_t adr, u_int8_t *sector) { sector[LEC_HEADER_OFFSET] = bin2bcd(adr / (60*75)); sector[LEC_HEADER_OFFSET + 1] = bin2bcd((adr / 75) % 60); sector[LEC_HEADER_OFFSET + 2] = bin2bcd(adr % 75); sector[LEC_HEADER_OFFSET + 3] = mode; } /* Calculate the P parities for the sector. * The 43 P vectors of length 24 are combined with the GF8_P_COEFFS. */ static void calc_P_parity(u_int8_t *sector) { int i, j; u_int16_t p01_msb, p01_lsb; u_int8_t *p_lsb_start; u_int8_t *p_lsb; u_int8_t *p0, *p1; u_int8_t d0,d1; p_lsb_start = sector + LEC_HEADER_OFFSET; p1 = sector + LEC_MODE1_P_PARITY_OFFSET; p0 = sector + LEC_MODE1_P_PARITY_OFFSET + 2 * 43; for (i = 0; i <= 42; i++) { p_lsb = p_lsb_start; p01_lsb = p01_msb = 0; for (j = 19; j <= 42; j++) { d0 = *p_lsb; d1 = *(p_lsb+1); p01_lsb ^= CF8_Q_COEFFS_RESULTS_01[j][d0]; p01_msb ^= CF8_Q_COEFFS_RESULTS_01[j][d1]; p_lsb += 2 * 43; } *p0 = p01_lsb; *(p0 + 1) = p01_msb; *p1 = p01_lsb>>8; *(p1 + 1) = p01_msb>>8; p0 += 2; p1 += 2; p_lsb_start += 2; } } /* Calculate the Q parities for the sector. * The 26 Q vectors of length 43 are combined with the GF8_Q_COEFFS. */ static void calc_Q_parity(u_int8_t *sector) { int i, j; u_int16_t q01_lsb, q01_msb; u_int8_t *q_lsb_start; u_int8_t *q_lsb; u_int8_t *q0, *q1, *q_start; u_int8_t d0,d1; q_lsb_start = sector + LEC_HEADER_OFFSET; q_start = sector + LEC_MODE1_Q_PARITY_OFFSET; q1 = sector + LEC_MODE1_Q_PARITY_OFFSET; q0 = sector + LEC_MODE1_Q_PARITY_OFFSET + 2 * 26; for (i = 0; i <= 25; i++) { q_lsb = q_lsb_start; q01_lsb = q01_msb = 0; for (j = 0; j <= 42; j++) { d0 = *q_lsb; d1 = *(q_lsb+1); q01_lsb ^= CF8_Q_COEFFS_RESULTS_01[j][d0]; q01_msb ^= CF8_Q_COEFFS_RESULTS_01[j][d1]; q_lsb += 2 * 44; if (q_lsb >= q_start) { q_lsb -= 2 * 1118; } } *q0 = q01_lsb; *(q0 + 1) = q01_msb; *q1 = q01_lsb>>8; *(q1 + 1) = q01_msb>>8; q0 += 2; q1 += 2; q_lsb_start += 2 * 43; } } /* Encodes a MODE 0 sector. * 'adr' is the current physical sector address * 'sector' must be 2352 byte wide */ void lec_encode_mode0_sector(u_int32_t adr, u_int8_t *sector) { u_int16_t i; set_sync_pattern(sector); set_sector_header(0, adr, sector); sector += 16; for (i = 0; i < 2336; i++) *sector++ = 0; } /* Encodes a MODE 1 sector. * 'adr' is the current physical sector address * 'sector' must be 2352 byte wide containing 2048 bytes user data at * offset 16 */ void lec_encode_mode1_sector(u_int32_t adr, u_int8_t *sector) { set_sync_pattern(sector); set_sector_header(1, adr, sector); calc_mode1_edc(sector); /* clear the intermediate field */ sector[LEC_MODE1_INTERMEDIATE_OFFSET] = sector[LEC_MODE1_INTERMEDIATE_OFFSET + 1] = sector[LEC_MODE1_INTERMEDIATE_OFFSET + 2] = sector[LEC_MODE1_INTERMEDIATE_OFFSET + 3] = sector[LEC_MODE1_INTERMEDIATE_OFFSET + 4] = sector[LEC_MODE1_INTERMEDIATE_OFFSET + 5] = sector[LEC_MODE1_INTERMEDIATE_OFFSET + 6] = sector[LEC_MODE1_INTERMEDIATE_OFFSET + 7] = 0; calc_P_parity(sector); calc_Q_parity(sector); } /* Encodes a MODE 2 sector. * 'adr' is the current physical sector address * 'sector' must be 2352 byte wide containing 2336 bytes user data at * offset 16 */ void lec_encode_mode2_sector(u_int32_t adr, u_int8_t *sector) { set_sync_pattern(sector); set_sector_header(2, adr, sector); } /* Encodes a XA form 1 sector. * 'adr' is the current physical sector address * 'sector' must be 2352 byte wide containing 2048+8 bytes user data at * offset 16 */ void lec_encode_mode2_form1_sector(u_int32_t adr, u_int8_t *sector) { set_sync_pattern(sector); calc_mode2_form1_edc(sector); /* P/Q partiy must not contain the sector header so clear it */ sector[LEC_HEADER_OFFSET] = sector[LEC_HEADER_OFFSET + 1] = sector[LEC_HEADER_OFFSET + 2] = sector[LEC_HEADER_OFFSET + 3] = 0; calc_P_parity(sector); calc_Q_parity(sector); /* finally add the sector header */ set_sector_header(2, adr, sector); } /* Encodes a XA form 2 sector. * 'adr' is the current physical sector address * 'sector' must be 2352 byte wide containing 2324+8 bytes user data at * offset 16 */ void lec_encode_mode2_form2_sector(u_int32_t adr, u_int8_t *sector) { set_sync_pattern(sector); calc_mode2_form2_edc(sector); set_sector_header(2, adr, sector); } /* Scrambles and byte swaps an encoded sector. * 'sector' must be 2352 byte wide. */ void lec_scramble(u_int8_t *sector) { u_int16_t i; const u_int8_t *stable = SCRAMBLE_TABLE; u_int8_t *p = sector; u_int8_t tmp; for (i = 0; i < 6; i++) { /* just swap bytes of sector sync */ tmp = *p; *p = *(p + 1); p++; *p++ = tmp; } for (;i < (2352 / 2); i++) { /* scramble and swap bytes */ tmp = *p ^ *stable++; *p = *(p + 1) ^ *stable++; p++; *p++ = tmp; } } #if 0 #include #include #include #include int main(int argc, char **argv) { char *infile; char *outfile; int fd_in, fd_out; u_int8_t buffer1[2352]; u_int8_t buffer2[2352]; u_int32_t lba; int i; #if 0 for (i = 0; i < 2048; i++) buffer1[i + 16] = 234; lba = 150; for (i = 0; i < 100000; i++) { lec_encode_mode1_sector(lba, buffer1); lec_scramble(buffer2); lba++; } #else if (argc != 3) return 1; infile = argv[1]; outfile = argv[2]; if ((fd_in = open(infile, O_RDONLY)) < 0) { perror("Cannot open input file"); return 1; } if ((fd_out = open(outfile, O_WRONLY|O_CREAT|O_TRUNC, 0666)) < 0) { perror("Cannot open output file"); return 1; } lba = 150; do { if (read(fd_in, buffer1, 2352) != 2352) break; switch (*(buffer1 + 12 + 3)) { case 1: memcpy(buffer2 + 16, buffer1 + 16, 2048); lec_encode_mode1_sector(lba, buffer2); break; case 2: if ((*(buffer1 + 12 + 4 + 2) & 0x20) != 0) { /* form 2 sector */ memcpy(buffer2 + 16, buffer1 + 16, 2324 + 8); lec_encode_mode2_form2_sector(lba, buffer2); } else { /* form 1 sector */ memcpy(buffer2 + 16, buffer1 + 16, 2048 + 8); lec_encode_mode2_form1_sector(lba, buffer2); } break; } if (memcmp(buffer1, buffer2, 2352) != 0) { printf("Verify error at lba %ld\n", lba); } lec_scramble(buffer2); write(fd_out, buffer2, 2352); lba++; } while (1); close(fd_in); close(fd_out); #endif return 0; } #endif libretro-common/include/streams/000700 001750 001750 00000000000 12727366154 020114 5ustar00sergiosergio000000 000000 mednafen/hw_misc/000700 001750 001750 00000000000 12727366154 015111 5ustar00sergiosergio000000 000000 msvc/msvc-2003-xbox1/stdint.h000664 001750 001750 00000017100 12726204343 016723 0ustar00sergiosergio000000 000000 // ISO C9x compliant stdint.h for Microsoft Visual Studio // Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 // // Copyright (c) 2006-2008 Alexander Chemeris // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are met: // // 1. Redistributions of source code must retain the above copyright notice, // this list of conditions and the following disclaimer. // // 2. Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // // 3. The name of the author may be used to endorse or promote products // derived from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // /////////////////////////////////////////////////////////////////////////////// #ifndef __RARCH_STDINT_H #define __RARCH_STDINT_H #if _MSC_VER && (_MSC_VER < 1600) //pre-MSVC 2010 needs an implementation of stdint.h #if _MSC_VER > 1000 #pragma once #endif #include // For Visual Studio 6 in C++ mode and for many Visual Studio versions when // compiling for ARM we should wrap include with 'extern "C++" {}' // or compiler give many errors like this: // error C2733: second C linkage of overloaded function 'wmemchr' not allowed #ifdef __cplusplus extern "C" { #endif # include #ifdef __cplusplus } #endif // Define _W64 macros to mark types changing their size, like intptr_t. #ifndef _W64 # if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300 # define _W64 __w64 # else # define _W64 # endif #endif // 7.18.1 Integer types // 7.18.1.1 Exact-width integer types // Visual Studio 6 and Embedded Visual C++ 4 doesn't // realize that, e.g. char has the same size as __int8 // so we give up on __intX for them. #if (_MSC_VER < 1300) typedef signed char int8_t; typedef signed short int16_t; typedef signed int int32_t; typedef unsigned char uint8_t; typedef unsigned short uint16_t; typedef unsigned int uint32_t; #else typedef signed __int8 int8_t; typedef signed __int16 int16_t; typedef signed __int32 int32_t; typedef unsigned __int8 uint8_t; typedef unsigned __int16 uint16_t; typedef unsigned __int32 uint32_t; #endif typedef signed __int64 int64_t; typedef unsigned __int64 uint64_t; // 7.18.1.2 Minimum-width integer types typedef int8_t int_least8_t; typedef int16_t int_least16_t; typedef int32_t int_least32_t; typedef int64_t int_least64_t; typedef uint8_t uint_least8_t; typedef uint16_t uint_least16_t; typedef uint32_t uint_least32_t; typedef uint64_t uint_least64_t; // 7.18.1.3 Fastest minimum-width integer types typedef int8_t int_fast8_t; typedef int16_t int_fast16_t; typedef int32_t int_fast32_t; typedef int64_t int_fast64_t; typedef uint8_t uint_fast8_t; typedef uint16_t uint_fast16_t; typedef uint32_t uint_fast32_t; typedef uint64_t uint_fast64_t; // 7.18.1.4 Integer types capable of holding object pointers #ifdef _WIN64 // [ typedef signed __int64 intptr_t; typedef unsigned __int64 uintptr_t; #else // _WIN64 ][ typedef _W64 signed int intptr_t; typedef _W64 unsigned int uintptr_t; #endif // _WIN64 ] // 7.18.1.5 Greatest-width integer types typedef int64_t intmax_t; typedef uint64_t uintmax_t; // 7.18.2 Limits of specified-width integer types #if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259 // 7.18.2.1 Limits of exact-width integer types #define INT8_MIN ((int8_t)_I8_MIN) #define INT8_MAX _I8_MAX #define INT16_MIN ((int16_t)_I16_MIN) #define INT16_MAX _I16_MAX #define INT32_MIN ((int32_t)_I32_MIN) #define INT32_MAX _I32_MAX #define INT64_MIN ((int64_t)_I64_MIN) #define INT64_MAX _I64_MAX #define UINT8_MAX _UI8_MAX #define UINT16_MAX _UI16_MAX #define UINT32_MAX _UI32_MAX #define UINT64_MAX _UI64_MAX // 7.18.2.2 Limits of minimum-width integer types #define INT_LEAST8_MIN INT8_MIN #define INT_LEAST8_MAX INT8_MAX #define INT_LEAST16_MIN INT16_MIN #define INT_LEAST16_MAX INT16_MAX #define INT_LEAST32_MIN INT32_MIN #define INT_LEAST32_MAX INT32_MAX #define INT_LEAST64_MIN INT64_MIN #define INT_LEAST64_MAX INT64_MAX #define UINT_LEAST8_MAX UINT8_MAX #define UINT_LEAST16_MAX UINT16_MAX #define UINT_LEAST32_MAX UINT32_MAX #define UINT_LEAST64_MAX UINT64_MAX // 7.18.2.3 Limits of fastest minimum-width integer types #define INT_FAST8_MIN INT8_MIN #define INT_FAST8_MAX INT8_MAX #define INT_FAST16_MIN INT16_MIN #define INT_FAST16_MAX INT16_MAX #define INT_FAST32_MIN INT32_MIN #define INT_FAST32_MAX INT32_MAX #define INT_FAST64_MIN INT64_MIN #define INT_FAST64_MAX INT64_MAX #define UINT_FAST8_MAX UINT8_MAX #define UINT_FAST16_MAX UINT16_MAX #define UINT_FAST32_MAX UINT32_MAX #define UINT_FAST64_MAX UINT64_MAX // 7.18.2.4 Limits of integer types capable of holding object pointers #ifdef _WIN64 // [ # define INTPTR_MIN INT64_MIN # define INTPTR_MAX INT64_MAX # define UINTPTR_MAX UINT64_MAX #else // _WIN64 ][ # define INTPTR_MIN INT32_MIN # define INTPTR_MAX INT32_MAX # define UINTPTR_MAX UINT32_MAX #endif // _WIN64 ] // 7.18.2.5 Limits of greatest-width integer types #define INTMAX_MIN INT64_MIN #define INTMAX_MAX INT64_MAX #define UINTMAX_MAX UINT64_MAX // 7.18.3 Limits of other integer types #ifdef _WIN64 // [ # define PTRDIFF_MIN _I64_MIN # define PTRDIFF_MAX _I64_MAX #else // _WIN64 ][ # define PTRDIFF_MIN _I32_MIN # define PTRDIFF_MAX _I32_MAX #endif // _WIN64 ] #define SIG_ATOMIC_MIN INT_MIN #define SIG_ATOMIC_MAX INT_MAX #ifndef SIZE_MAX // [ # ifdef _WIN64 // [ # define SIZE_MAX _UI64_MAX # else // _WIN64 ][ # define SIZE_MAX _UI32_MAX # endif // _WIN64 ] #endif // SIZE_MAX ] // WCHAR_MIN and WCHAR_MAX are also defined in #ifndef WCHAR_MIN // [ # define WCHAR_MIN 0 #endif // WCHAR_MIN ] #ifndef WCHAR_MAX // [ # define WCHAR_MAX _UI16_MAX #endif // WCHAR_MAX ] #define WINT_MIN 0 #define WINT_MAX _UI16_MAX #endif // __STDC_LIMIT_MACROS ] // 7.18.4 Limits of other integer types #if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 // 7.18.4.1 Macros for minimum-width integer constants #define INT8_C(val) val##i8 #define INT16_C(val) val##i16 #define INT32_C(val) val##i32 #define INT64_C(val) val##i64 #define UINT8_C(val) val##ui8 #define UINT16_C(val) val##ui16 #define UINT32_C(val) val##ui32 #define UINT64_C(val) val##ui64 // 7.18.4.2 Macros for greatest-width integer constants #define INTMAX_C INT64_C #define UINTMAX_C UINT64_C #endif // __STDC_CONSTANT_MACROS ] #else //sanity for everything else #include #endif #endif msvc/msvc-2010-360.sln000664 001750 001750 00000003516 12726204343 015236 0ustar00sergiosergio000000 000000  Microsoft Visual Studio Solution File, Format Version 11.00 # Visual Studio 2010 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "msvc-2010-360", "msvc-2010-360\msvc-2010-360.vcxproj", "{38462FE9-E3FC-4336-B241-50F5599C537B}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution CodeAnalysis|Xbox 360 = CodeAnalysis|Xbox 360 Debug|Xbox 360 = Debug|Xbox 360 Profile_FastCap|Xbox 360 = Profile_FastCap|Xbox 360 Profile|Xbox 360 = Profile|Xbox 360 Release_LTCG|Xbox 360 = Release_LTCG|Xbox 360 Release|Xbox 360 = Release|Xbox 360 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {38462FE9-E3FC-4336-B241-50F5599C537B}.CodeAnalysis|Xbox 360.ActiveCfg = CodeAnalysis|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.CodeAnalysis|Xbox 360.Build.0 = CodeAnalysis|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.Debug|Xbox 360.ActiveCfg = Debug|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.Debug|Xbox 360.Build.0 = Debug|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.Profile_FastCap|Xbox 360.ActiveCfg = Profile_FastCap|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.Profile_FastCap|Xbox 360.Build.0 = Profile_FastCap|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.Profile|Xbox 360.ActiveCfg = Profile|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.Profile|Xbox 360.Build.0 = Profile|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.Release_LTCG|Xbox 360.ActiveCfg = Release_LTCG|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.Release_LTCG|Xbox 360.Build.0 = Release_LTCG|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.Release|Xbox 360.ActiveCfg = Release|Xbox 360 {38462FE9-E3FC-4336-B241-50F5599C537B}.Release|Xbox 360.Build.0 = Release|Xbox 360 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection EndGlobal libretro-common/queues/task_queue.c000664 001750 001750 00000026037 12726204343 020646 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (task_queue.c). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include #include #include #include #ifdef HAVE_THREADS #include #endif typedef struct { retro_task_t *front; retro_task_t *back; } task_queue_t; struct retro_task_impl { void (*push_running)(retro_task_t *); void (*reset)(void); void (*wait)(void); void (*gather)(void); bool (*find)(retro_task_finder_t, void*); void (*init)(void); void (*deinit)(void); }; static task_queue_t tasks_running = {NULL, NULL}; static task_queue_t tasks_finished = {NULL, NULL}; #ifndef RARCH_INTERNAL static void task_queue_msg_push(unsigned prio, unsigned duration, bool flush, const char *fmt, ...) { char buf[1024]; va_list ap; va_start(ap, fmt); vsnprintf(buf, sizeof(buf), fmt, ap); va_end(ap); /* print something here */ } void task_queue_push_progress(retro_task_t *task) { if (task->title) { if (task->finished) { if (task->error) task_queue_msg_push(1, 60, true, "%s: %s", "Task failed\n", task->title); else task_queue_msg_push(1, 60, true, "100%%: %s", task->title); } else { if (task->progress >= 0 && task->progress <= 100) task_queue_msg_push(1, 60, true, "%i%%: %s", task->progress, task->title); else task_queue_msg_push(1, 60, true, "%s...", task->title); } } } #endif static void task_queue_put(task_queue_t *queue, retro_task_t *task) { task->next = NULL; if (queue->front) queue->back->next = task; else queue->front = task; queue->back = task; } static retro_task_t *task_queue_get(task_queue_t *queue) { retro_task_t *task = queue->front; if (task) { queue->front = task->next; task->next = NULL; } return task; } static void retro_task_internal_gather(void) { retro_task_t *task = NULL; while ((task = task_queue_get(&tasks_finished)) != NULL) { task_queue_push_progress(task); if (task->callback) task->callback(task->task_data, task->user_data, task->error); if (task->error) free(task->error); if (task->title) free(task->title); free(task); } } static void retro_task_regular_push_running(retro_task_t *task) { task_queue_put(&tasks_running, task); } static void retro_task_regular_gather(void) { retro_task_t *task = NULL; retro_task_t *queue = NULL; retro_task_t *next = NULL; while ((task = task_queue_get(&tasks_running)) != NULL) { task->next = queue; queue = task; } for (task = queue; task; task = next) { next = task->next; task->handler(task); task_queue_push_progress(task); if (task->finished) task_queue_put(&tasks_finished, task); else retro_task_regular_push_running(task); } retro_task_internal_gather(); } static void retro_task_regular_wait(void) { while (tasks_running.front) retro_task_regular_gather(); } static void retro_task_regular_reset(void) { retro_task_t *task = tasks_running.front; for (; task; task = task->next) task->cancelled = true; } static void retro_task_regular_init(void) { } static void retro_task_regular_deinit(void) { } static bool retro_task_regular_find(retro_task_finder_t func, void *user_data) { retro_task_t *task = tasks_running.front; for (; task; task = task->next) { if (func(task, user_data)) return true; } return false; } static struct retro_task_impl impl_regular = { retro_task_regular_push_running, retro_task_regular_reset, retro_task_regular_wait, retro_task_regular_gather, retro_task_regular_find, retro_task_regular_init, retro_task_regular_deinit }; #ifdef HAVE_THREADS static slock_t *running_lock = NULL; static slock_t *finished_lock = NULL; static scond_t *worker_cond = NULL; static sthread_t *worker_thread = NULL; static bool worker_continue = true; /* use running_lock when touching it */ static void retro_task_threaded_push_running(retro_task_t *task) { slock_lock(running_lock); task_queue_put(&tasks_running, task); scond_signal(worker_cond); slock_unlock(running_lock); } static void retro_task_threaded_gather(void) { retro_task_t *task = NULL; slock_lock(running_lock); for (task = tasks_running.front; task; task = task->next) task_queue_push_progress(task); slock_unlock(running_lock); slock_lock(finished_lock); retro_task_internal_gather(); slock_unlock(finished_lock); } static void retro_task_threaded_wait(void) { bool wait = false; do { retro_task_threaded_gather(); slock_lock(running_lock); wait = (tasks_running.front != NULL); slock_unlock(running_lock); } while (wait); } static void retro_task_threaded_reset(void) { retro_task_t *task = NULL; slock_lock(running_lock); for (task = tasks_running.front; task; task = task->next) task->cancelled = true; slock_unlock(running_lock); } static bool retro_task_threaded_find( retro_task_finder_t func, void *user_data) { retro_task_t *task = NULL; slock_lock(running_lock); for (task = tasks_running.front; task; task = task->next) { if (func(task, user_data)) return true; } slock_unlock(running_lock); return false; } static void threaded_worker(void *userdata) { (void)userdata; for (;;) { retro_task_t *queue = NULL; retro_task_t *task = NULL; retro_task_t *next = NULL; /* pop all into a local queue, * tasks are in the reverse order here. */ slock_lock(running_lock); if (!worker_continue) break; /* should we keep running until all tasks finished? */ while ((task = task_queue_get(&tasks_running)) != NULL) { task->next = queue; queue = task; } if (queue == NULL) /* no tasks running, lets wait a bit */ { scond_wait(worker_cond, running_lock); slock_unlock(running_lock); continue; } slock_unlock(running_lock); for (task = queue; task; task = next) { next = task->next; task->handler(task); if (task->finished) { slock_lock(finished_lock); task_queue_put(&tasks_finished, task); slock_unlock(finished_lock); } else retro_task_threaded_push_running(task); } } slock_unlock(running_lock); } static void retro_task_threaded_init(void) { running_lock = slock_new(); finished_lock = slock_new(); worker_cond = scond_new(); slock_lock(running_lock); worker_continue = true; slock_unlock(running_lock); worker_thread = sthread_create(threaded_worker, NULL); } static void retro_task_threaded_deinit(void) { slock_lock(running_lock); worker_continue = false; scond_signal(worker_cond); slock_unlock(running_lock); sthread_join(worker_thread); scond_free(worker_cond); slock_free(running_lock); slock_free(finished_lock); worker_thread = NULL; worker_cond = NULL; running_lock = NULL; finished_lock = NULL; } static struct retro_task_impl impl_threaded = { retro_task_threaded_push_running, retro_task_threaded_reset, retro_task_threaded_wait, retro_task_threaded_gather, retro_task_threaded_find, retro_task_threaded_init, retro_task_threaded_deinit }; #endif bool task_queue_ctl(enum task_queue_ctl_state state, void *data) { static struct retro_task_impl *impl_current = NULL; static bool task_threaded_enable = false; switch (state) { case TASK_QUEUE_CTL_DEINIT: if (impl_current) impl_current->deinit(); impl_current = NULL; break; case TASK_QUEUE_CTL_SET_THREADED: task_threaded_enable = true; break; case TASK_QUEUE_CTL_UNSET_THREADED: task_threaded_enable = false; break; case TASK_QUEUE_CTL_IS_THREADED: return task_threaded_enable; case TASK_QUEUE_CTL_INIT: { #ifdef HAVE_THREADS bool *boolean_val = (bool*)data; #endif impl_current = &impl_regular; #ifdef HAVE_THREADS if (*boolean_val) { task_queue_ctl(TASK_QUEUE_CTL_SET_THREADED, NULL); impl_current = &impl_threaded; } #endif impl_current->init(); } break; case TASK_QUEUE_CTL_FIND: { task_finder_data_t *find_data = (task_finder_data_t*)data; if (!impl_current->find(find_data->func, find_data->userdata)) return false; } break; case TASK_QUEUE_CTL_CHECK: { #ifdef HAVE_THREADS bool current_threaded = (impl_current == &impl_threaded); bool want_threaded = task_queue_ctl(TASK_QUEUE_CTL_IS_THREADED, NULL); if (want_threaded != current_threaded) task_queue_ctl(TASK_QUEUE_CTL_DEINIT, NULL); if (!impl_current) task_queue_ctl(TASK_QUEUE_CTL_INIT, NULL); #endif impl_current->gather(); } break; case TASK_QUEUE_CTL_PUSH: { /* The lack of NULL checks in the following functions * is proposital to ensure correct control flow by the users. */ retro_task_t *task = (retro_task_t*)data; impl_current->push_running(task); break; } case TASK_QUEUE_CTL_RESET: impl_current->reset(); break; case TASK_QUEUE_CTL_WAIT: impl_current->wait(); break; case TASK_QUEUE_CTL_NONE: default: break; } return true; } mednafen/cdrom/SimpleFIFO.h000664 001750 001750 00000003001 12726204343 016626 0ustar00sergiosergio000000 000000 #ifndef __MDFN_SIMPLEFIFO_H #define __MDFN_SIMPLEFIFO_H #include #include #include "../math_ops.h" template class SimpleFIFO { public: // Constructor SimpleFIFO(uint32 the_size) // Size should be a power of 2! { data.resize(round_up_pow2(the_size)); size = the_size; read_pos = 0; write_pos = 0; in_count = 0; } // Destructor INLINE ~SimpleFIFO() { } INLINE uint32 CanRead(void) { return(in_count); } INLINE uint32 CanWrite(void) { return(size - in_count); } INLINE T ReadUnit(bool peek = false) { T ret; assert(in_count > 0); ret = data[read_pos]; if(!peek) { read_pos = (read_pos + 1) & (data.size() - 1); in_count--; } return(ret); } INLINE uint8 ReadByte(bool peek = false) { assert(sizeof(T) == 1); return(ReadUnit(peek)); } INLINE void Write(const T *happy_data, uint32 happy_count) { assert(CanWrite() >= happy_count); while(happy_count) { data[write_pos] = *happy_data; write_pos = (write_pos + 1) & (data.size() - 1); in_count++; happy_data++; happy_count--; } } INLINE void WriteUnit(const T& wr_data) { Write(&wr_data, 1); } INLINE void WriteByte(const T& wr_data) { assert(sizeof(T) == 1); Write(&wr_data, 1); } INLINE void Flush(void) { read_pos = 0; write_pos = 0; in_count = 0; } //private: std::vector data; uint32 size; uint32 read_pos; // Read position uint32 write_pos; // Write position uint32 in_count; // Number of units in the FIFO }; #endif mednafen/mempatcher-driver.h000664 001750 001750 00000002533 12726204343 017254 0ustar00sergiosergio000000 000000 #ifndef __MDFN_MEMPATCHER_DRIVER_H #define __MDFN_MEMPATCHER_DRIVER_H int MDFNI_DecodePAR(const char *code, uint32 *a, uint8 *v, uint8 *c, char *type); int MDFNI_DecodeGG(const char *str, uint32 *a, uint8 *v, uint8 *c, char *type); int MDFNI_AddCheat(const char *name, uint32 addr, uint64 val, uint64 compare, char type, unsigned int length, bool bigendian); int MDFNI_DelCheat(uint32 which); int MDFNI_ToggleCheat(uint32 which); int32 MDFNI_CheatSearchGetCount(void); void MDFNI_CheatSearchGetRange(uint32 first, uint32 last, int (*callb)(uint32 a, uint8 last, uint8 current)); void MDFNI_CheatSearchGet(int (*callb)(uint32 a, uint64 last, uint64 current, void *data), void *data); void MDFNI_CheatSearchBegin(void); void MDFNI_CheatSearchEnd(int type, uint64 v1, uint64 v2, unsigned int bytelen, bool bigendian); void MDFNI_ListCheats(int (*callb)(char *name, uint32 a, uint64 v, uint64 compare, int s, char type, unsigned int length, bool bigendian, void *data), void *data); int MDFNI_GetCheat(uint32 which, char **name, uint32 *a, uint64 *v, uint64 *compare, int *s, char *type, unsigned int *length, bool *bigendian); int MDFNI_SetCheat(uint32 which, const char *name, uint32 a, uint64 v, uint64 compare, int s, char type, unsigned int length, bool bigendian); void MDFNI_CheatSearchShowExcluded(void); void MDFNI_CheatSearchSetCurrentAsOriginal(void); #endif libretro-common/include/compat/apple_compat.h000664 001750 001750 00000003516 12726204343 022545 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (apple_compat.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifdef __APPLE__ #include #endif #ifdef __OBJC__ #if (MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4) typedef int NSInteger; typedef unsigned NSUInteger; typedef float CGFloat; #endif #endif #ifdef IOS #ifndef __IPHONE_5_0 #warning "This project uses features only available in iOS SDK 5.0 and later." #endif #ifdef __OBJC__ #import #import #import #include #endif #endif mednafen/mednafen-types.h000664 001750 001750 00000004423 12726204343 016555 0ustar00sergiosergio000000 000000 #ifndef __MDFN_TYPES #define __MDFN_TYPES #include #include typedef int8_t int8; typedef int16_t int16; typedef int32_t int32; typedef int64_t int64; typedef uint8_t uint8; typedef uint16_t uint16; typedef uint32_t uint32; typedef uint64_t uint64; #ifdef __GNUC__ #define MDFN_UNLIKELY(n) __builtin_expect((n) != 0, 0) #define MDFN_LIKELY(n) __builtin_expect((n) != 0, 1) #define INLINE inline __attribute__((always_inline)) #define NO_INLINE __attribute__((noinline)) #if defined(__386__) || defined(__i386__) || defined(__i386) || defined(_M_IX86) || defined(_M_I386) #define MDFN_FASTCALL __attribute__((fastcall)) #else #define MDFN_FASTCALL #endif #define MDFN_ALIGN(n) __attribute__ ((aligned (n))) #define MDFN_FORMATSTR(a,b,c) __attribute__ ((format (a, b, c))); #define MDFN_WARN_UNUSED_RESULT __attribute__ ((warn_unused_result)) #define MDFN_NOWARN_UNUSED __attribute__((unused)) #elif defined(_MSC_VER) #define roundf(in) (in >= 0.0f ? floorf(in + 0.5f) : ceilf(in - 0.5f)) #define INLINE inline #define NO_INLINE #define MDFN_LIKELY(n) ((n) != 0) #define MDFN_UNLIKELY(n) ((n) != 0) #define MDFN_FASTCALL #define MDFN_ALIGN(n) __declspec(align(n)) #define MDFN_FORMATSTR(a,b,c) #define MDFN_WARN_UNUSED_RESULT #define MDFN_NOWARN_UNUSED #else #error "Not compiling with GCC nor MSVC" #define INLINE inline #define NO_INLINE #define MDFN_FASTCALL #define MDFN_ALIGN(n) // hence the #error. #define MDFN_FORMATSTR(a,b,c) #define MDFN_WARN_UNUSED_RESULT #endif typedef struct { union { struct { #ifdef MSB_FIRST uint8 High; uint8 Low; #else uint8 Low; uint8 High; #endif } Union8; uint16 Val16; }; } Uuint16; typedef struct { union { struct { #ifdef MSB_FIRST Uuint16 High; Uuint16 Low; #else Uuint16 Low; Uuint16 High; #endif } Union16; uint32 Val32; }; } Uuint32; typedef uint32 UTF32; /* at least 32 bits */ typedef uint16 UTF16; /* at least 16 bits */ typedef uint8 UTF8; /* typically 8 bits */ typedef unsigned char Boolean; /* 0 or 1 */ #ifndef FALSE #define FALSE 0 #endif #ifndef TRUE #define TRUE 1 #endif #define MDFN_COLD #undef require #define require( expr ) assert( expr ) #include "error.h" #endif libretro-common/include/retro_inline.h000664 001750 001750 00000003253 12726204343 021305 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2015 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (retro_inline.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_INLINE_H #define __LIBRETRO_SDK_INLINE_H #ifndef INLINE #if !defined(__cplusplus) && defined(_WIN32) #define INLINE _inline #elif defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L #define INLINE inline #elif defined(__GNUC__) #define INLINE __inline__ #else #define INLINE #endif #endif #endif mednafen/tremor/registry.h000664 001750 001750 00000002633 12726204343 017017 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: registry for time, floor, res backends and channel mappings ********************************************************************/ #ifndef _V_REG_H_ #define _V_REG_H_ #define VI_TRANSFORMB 1 #define VI_WINDOWB 1 #define VI_TIMEB 1 #define VI_FLOORB 2 #define VI_RESB 3 #define VI_MAPB 1 #include "backends.h" #if defined(_WIN32) && defined(VORBISDLL_IMPORT) # define EXTERN __declspec(dllimport) extern #else # define EXTERN extern #endif EXTERN vorbis_func_floor *_floor_P[]; EXTERN vorbis_func_residue *_residue_P[]; EXTERN vorbis_func_mapping *_mapping_P[]; #endif libretro-common/include/compat/000700 001750 001750 00000000000 12727366154 017721 5ustar00sergiosergio000000 000000 mednafen/cdrom/audioreader.cpp000664 001750 001750 00000014212 12726204343 017556 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 */ // AR_Open(), and AudioReader, will NOT take "ownership" of the Stream object(IE it won't ever delete it). Though it does assume it has exclusive access // to it for as long as the AudioReader object exists. // Don't allow exceptions to propagate into the vorbis/musepack/etc. libraries, as it could easily leave the state of the library's decoder "object" in an // inconsistent state, which would cause all sorts of unfun when we try to destroy it while handling the exception farther up. #include "../mednafen.h" #include "audioreader.h" #include "../tremor/ivorbisfile.h" #ifdef HAVE_LIBSNDFILE #include #endif #ifdef HAVE_OPUSFILE #include "audioreader_opus.h" #endif #include #include #include #include "../general.h" #include "../mednafen-endian.h" AudioReader::AudioReader() : LastReadPos(0) { } AudioReader::~AudioReader() { } int64 AudioReader::Read_(int16 *buffer, int64 frames) { abort(); return(false); } bool AudioReader::Seek_(int64 frame_offset) { abort(); return(false); } int64 AudioReader::FrameCount(void) { abort(); return(0); } /* ** ** ** ** ** ** ** ** ** */ class OggVorbisReader : public AudioReader { public: OggVorbisReader(Stream *fp); ~OggVorbisReader(); int64 Read_(int16 *buffer, int64 frames); bool Seek_(int64 frame_offset); int64 FrameCount(void); private: OggVorbis_File ovfile; Stream *fw; }; static size_t iov_read_func(void *ptr, size_t size, size_t nmemb, void *user_data) { Stream *fw = (Stream*)user_data; if(!size) return(0); try { return fw->read(ptr, size * nmemb, false) / size; } catch(...) { return(0); } } static int iov_seek_func(void *user_data, ogg_int64_t offset, int whence) { Stream *fw = (Stream*)user_data; try { fw->seek(offset, whence); return(0); } catch(...) { return(-1); } } static int iov_close_func(void *user_data) { Stream *fw = (Stream*)user_data; try { fw->close(); return(0); } catch(...) { return EOF; } } static long iov_tell_func(void *user_data) { Stream *fw = (Stream*)user_data; try { return fw->tell(); } catch(...) { return(-1); } } OggVorbisReader::OggVorbisReader(Stream *fp) : fw(fp) { ov_callbacks cb; memset(&cb, 0, sizeof(cb)); cb.read_func = iov_read_func; cb.seek_func = iov_seek_func; cb.close_func = iov_close_func; cb.tell_func = iov_tell_func; fp->seek(0, SEEK_SET); if(ov_open_callbacks(fp, &ovfile, NULL, 0, cb)) throw(0); } OggVorbisReader::~OggVorbisReader() { ov_clear(&ovfile); } int64 OggVorbisReader::Read_(int16 *buffer, int64 frames) { uint8 *tw_buf = (uint8 *)buffer; int cursection = 0; long toread = frames * sizeof(int16) * 2; while(toread > 0) { long didread = ov_read(&ovfile, (char*)tw_buf, toread, &cursection); if(didread == 0) break; tw_buf = (uint8 *)tw_buf + didread; toread -= didread; } return(frames - toread / sizeof(int16) / 2); } bool OggVorbisReader::Seek_(int64 frame_offset) { ov_pcm_seek(&ovfile, frame_offset); return(true); } int64 OggVorbisReader::FrameCount(void) { return(ov_pcm_total(&ovfile, -1)); } /* ** ** ** ** ** ** ** ** ** */ #ifdef HAVE_LIBSNDFILE class SFReader : public AudioReader { public: SFReader(Stream *fp); ~SFReader(); int64 Read_(int16 *buffer, int64 frames); bool Seek_(int64 frame_offset); int64 FrameCount(void); private: SNDFILE *sf; SF_INFO sfinfo; SF_VIRTUAL_IO sfvf; Stream *fw; }; static sf_count_t isf_get_filelen(void *user_data) { Stream *fw = (Stream*)user_data; try { return fw->size(); } catch(...) { return(-1); } } static sf_count_t isf_seek(sf_count_t offset, int whence, void *user_data) { Stream *fw = (Stream*)user_data; try { //printf("Seek: offset=%lld, whence=%lld\n", (long long)offset, (long long)whence); fw->seek(offset, whence); return fw->tell(); } catch(...) { //printf(" SEEK FAILED\n"); return(-1); } } static sf_count_t isf_read(void *ptr, sf_count_t count, void *user_data) { Stream *fw = (Stream*)user_data; try { sf_count_t ret = fw->read(ptr, count, false); //printf("Read: count=%lld, ret=%lld\n", (long long)count, (long long)ret); return ret; } catch(...) { //printf(" READ FAILED\n"); return(0); } } static sf_count_t isf_write(const void *ptr, sf_count_t count, void *user_data) { return(0); } static sf_count_t isf_tell(void *user_data) { Stream *fw = (Stream*)user_data; try { return fw->tell(); } catch(...) { return(-1); } } SFReader::SFReader(Stream *fp) : fw(fp) { fp->seek(0, SEEK_SET); memset(&sfvf, 0, sizeof(sfvf)); sfvf.get_filelen = isf_get_filelen; sfvf.seek = isf_seek; sfvf.read = isf_read; sfvf.write = isf_write; sfvf.tell = isf_tell; memset(&sfinfo, 0, sizeof(sfinfo)); if(!(sf = sf_open_virtual(&sfvf, SFM_READ, &sfinfo, (void*)fp))) throw(0); } SFReader::~SFReader() { sf_close(sf); } int64 SFReader::Read_(int16 *buffer, int64 frames) { return(sf_read_short(sf, (short*)buffer, frames * 2) / 2); } bool SFReader::Seek_(int64 frame_offset) { // FIXME error condition if(sf_seek(sf, frame_offset, SEEK_SET) != frame_offset) return(false); return(true); } int64 SFReader::FrameCount(void) { return(sfinfo.frames); } #endif AudioReader *AR_Open(Stream *fp) { #ifdef HAVE_OPUSFILE try { return new OpusReader(fp); } catch(int i) { } #endif try { return new OggVorbisReader(fp); } catch(int i) { } #ifdef HAVE_LIBSNDFILE try { return new SFReader(fp); } catch(int i) { } #endif return(NULL); } libretro-common/000700 001750 001750 00000000000 12727366154 015013 5ustar00sergiosergio000000 000000 mednafen/tremor/registry.c000664 001750 001750 00000003351 12726204343 017010 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: registry for floor, res backends and channel mappings ********************************************************************/ #include "ivorbiscodec.h" #include "codec_internal.h" #include "registry.h" #include "misc.h" /* seems like major overkill now; the backend numbers will grow into the infrastructure soon enough */ extern vorbis_func_floor floor0_exportbundle; extern vorbis_func_floor floor1_exportbundle; extern vorbis_func_residue residue0_exportbundle; extern vorbis_func_residue residue1_exportbundle; extern vorbis_func_residue residue2_exportbundle; extern vorbis_func_mapping mapping0_exportbundle; vorbis_func_floor *_floor_P[]={ &floor0_exportbundle, &floor1_exportbundle, }; vorbis_func_residue *_residue_P[]={ &residue0_exportbundle, &residue1_exportbundle, &residue2_exportbundle, }; vorbis_func_mapping *_mapping_P[]={ &mapping0_exportbundle, }; libretro-common/include/compat/msvc/000700 001750 001750 00000000000 12727366154 020671 5ustar00sergiosergio000000 000000 libretro-common/file/retro_stat.c000664 001750 001750 00000012334 12726204343 020271 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2015 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (retro_stat.c). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include #include #include #include #if defined(_WIN32) #ifdef _MSC_VER #define setmode _setmode #endif #ifdef _XBOX #include #define INVALID_FILE_ATTRIBUTES -1 #else #include #include #include #include #endif #elif defined(VITA) #define SCE_ERROR_ERRNO_EEXIST 0x80010011 #include #include #include #else #include #include #include #endif #if defined(PSP) #include #endif #ifdef __HAIKU__ #include #endif #if defined(__CELLOS_LV2__) #include #endif #if defined(VITA) #define FIO_S_ISDIR PSP2_S_ISDIR #endif #if (defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)) || defined(__QNX__) || defined(PSP) #include /* stat() is defined here */ #endif #include #include enum stat_mode { IS_DIRECTORY = 0, IS_CHARACTER_SPECIAL, IS_VALID }; static bool path_stat(const char *path, enum stat_mode mode, int32_t *size) { #if defined(VITA) || defined(PSP) SceIoStat buf; char *tmp = strdup(path); size_t len = strlen(tmp); if (tmp[len-1] == '/') tmp[len-1]='\0'; if (sceIoGetstat(tmp, &buf) < 0) { free(tmp); return false; } free(tmp); #elif defined(__CELLOS_LV2__) CellFsStat buf; if (cellFsStat(path, &buf) < 0) return false; #elif defined(_WIN32) WIN32_FILE_ATTRIBUTE_DATA file_info; GET_FILEEX_INFO_LEVELS fInfoLevelId = GetFileExInfoStandard; DWORD ret = GetFileAttributesEx(path, fInfoLevelId, &file_info); if (ret == 0) return false; #else struct stat buf; if (stat(path, &buf) < 0) return false; #endif #if defined(_WIN32) if (size) *size = file_info.nFileSizeLow; #else if (size) *size = buf.st_size; #endif switch (mode) { case IS_DIRECTORY: #if defined(VITA) || defined(PSP) return FIO_S_ISDIR(buf.st_mode); #elif defined(__CELLOS_LV2__) return ((buf.st_mode & S_IFMT) == S_IFDIR); #elif defined(_WIN32) return (file_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); #else return S_ISDIR(buf.st_mode); #endif case IS_CHARACTER_SPECIAL: #if defined(VITA) || defined(PSP) || defined(__CELLOS_LV2__) || defined(_WIN32) return false; #else return S_ISCHR(buf.st_mode); #endif case IS_VALID: return true; } return false; } /** * path_is_directory: * @path : path * * Checks if path is a directory. * * Returns: true (1) if path is a directory, otherwise false (0). */ bool path_is_directory(const char *path) { return path_stat(path, IS_DIRECTORY, NULL); } bool path_is_character_special(const char *path) { return path_stat(path, IS_CHARACTER_SPECIAL, NULL); } bool path_is_valid(const char *path) { return path_stat(path, IS_VALID, NULL); } int32_t path_get_size(const char *path) { int32_t filesize = 0; if (path_stat(path, IS_VALID, &filesize)) return filesize; return -1; } /** * path_mkdir_norecurse: * @dir : directory * * Create directory on filesystem. * * Returns: true (1) if directory could be created, otherwise false (0). **/ bool mkdir_norecurse(const char *dir) { int ret; #if defined(_WIN32) ret = _mkdir(dir); #elif defined(IOS) ret = mkdir(dir, 0755); #elif defined(VITA) || defined(PSP) ret = sceIoMkdir(dir, 0777); #else ret = mkdir(dir, 0750); #endif /* Don't treat this as an error. */ #if defined(VITA) if ((ret == SCE_ERROR_ERRNO_EEXIST) && path_is_directory(dir)) ret = 0; #elif defined(PSP) if ((ret == -1) && path_is_directory(dir)) ret = 0; #else if (ret < 0 && errno == EEXIST && path_is_directory(dir)) ret = 0; #endif if (ret < 0) printf("mkdir(%s) error: %s.\n", dir, strerror(errno)); return ret == 0; } mednafen/masmem.h000664 001750 001750 00000010303 12726204343 015107 0ustar00sergiosergio000000 000000 #ifndef __MDFN_PSX_MASMEM_H #define __MDFN_PSX_MASMEM_H // TODO, WIP (big-endian stores and loads not fully supported yet) #ifdef LSB_FIRST #define MAS_NATIVE_IS_BIGENDIAN 0 #else #define MAS_NATIVE_IS_BIGENDIAN 1 #endif static INLINE uint16 LoadU16_RBO(const uint16 *a) { #ifdef ARCH_POWERPC uint16 tmp; __asm__ ("lhbrx %0, %y1" : "=r"(tmp) : "Z"(*a)); return(tmp); #else uint16 tmp = *a; return((tmp << 8) | (tmp >> 8)); #endif } static INLINE uint32 LoadU32_RBO(const uint32 *a) { #ifdef ARCH_POWERPC uint32 tmp; __asm__ ("lwbrx %0, %y1" : "=r"(tmp) : "Z"(*a)); return(tmp); #else uint32 tmp = *a; return((tmp << 24) | ((tmp & 0xFF00) << 8) | ((tmp >> 8) & 0xFF00) | (tmp >> 24)); #endif } static INLINE void StoreU16_RBO(uint16 *a, const uint16 v) { #ifdef ARCH_POWERPC __asm__ ("sthbrx %0, %y1" : : "r"(v), "Z"(*a)); #else uint16 tmp = (v << 8) | (v >> 8); *a = tmp; #endif } static INLINE void StoreU32_RBO(uint32 *a, const uint32 v) { #ifdef ARCH_POWERPC __asm__ ("stwbrx %0, %y1" : : "r"(v), "Z"(*a)); #else uint32 tmp = (v << 24) | ((v & 0xFF00) << 8) | ((v >> 8) & 0xFF00) | (v >> 24); *a = tmp; #endif } static INLINE uint16 LoadU16_LE(const uint16 *a) { #ifdef MSB_FIRST return LoadU16_RBO(a); #else return *a; #endif } static INLINE uint32 LoadU32_LE(const uint32 *a) { #ifdef MSB_FIRST return LoadU32_RBO(a); #else return *a; #endif } static INLINE void StoreU16_LE(uint16 *a, const uint16 v) { #ifdef MSB_FIRST StoreU16_RBO(a, v); #else *a = v; #endif } static INLINE void StoreU32_LE(uint32 *a, const uint32 v) { #ifdef MSB_FIRST StoreU32_RBO(a, v); #else *a = v; #endif } // address must not be >= size specified by template parameter, and address must be a multiple of the byte-size of the // unit(1,2,4) being read(except for Read/WriteU24, which only needs to be byte-aligned). // // max_unit_type should be uint16 or uint32 // // pre_padding and post_padding are specified in units of sizeof(max_unit_type). // template //, unsigned pre_padding_count, unsigned post_padding_count> struct MultiAccessSizeMem { //max_unit_type pre_padding[pre_padding_count ? pre_padding_count : 1]; union { uint8 data8[size]; uint16 data16[size / sizeof(uint16)]; uint32 data32[size / sizeof(uint32)]; }; //max_unit_type post_padding[post_padding_count ? post_padding_count : 1]; INLINE uint8 ReadU8(uint32 address) { return data8[address]; } INLINE uint16 ReadU16(uint32 address) { if(MAS_NATIVE_IS_BIGENDIAN == big_endian) return *(uint16*)(((uint8*)data16) + address); else return LoadU16_RBO((uint16*)(((uint8*)data16) + address)); } INLINE uint32 ReadU32(uint32 address) { if(MAS_NATIVE_IS_BIGENDIAN == big_endian) return *(uint32*)(((uint8*)data32) + address); else return LoadU32_RBO((uint32*)(((uint8*)data32) + address)); } INLINE uint32 ReadU24(uint32 address) { uint32 ret; if(!big_endian) { ret = ReadU8(address) | (ReadU8(address + 1) << 8) | (ReadU8(address + 2) << 16); } return(ret); } INLINE void WriteU8(uint32 address, uint8 value) { data8[address] = value; } INLINE void WriteU16(uint32 address, uint16 value) { if(MAS_NATIVE_IS_BIGENDIAN == big_endian) *(uint16*)(((uint8*)data16) + address) = value; else StoreU16_RBO((uint16*)(((uint8*)data16) + address), value); } INLINE void WriteU32(uint32 address, uint32 value) { if(MAS_NATIVE_IS_BIGENDIAN == big_endian) *(uint32*)(((uint8*)data32) + address) = value; else StoreU32_RBO((uint32*)(((uint8*)data32) + address), value); } INLINE void WriteU24(uint32 address, uint32 value) { if(!big_endian) { WriteU8(address + 0, value >> 0); WriteU8(address + 1, value >> 8); WriteU8(address + 2, value >> 16); } } template INLINE T Read(uint32 address) { if(sizeof(T) == 4) return(ReadU32(address)); else if(sizeof(T) == 2) return(ReadU16(address)); else return(ReadU8(address)); } template INLINE void Write(uint32 address, T value) { if(sizeof(T) == 4) WriteU32(address, value); else if(sizeof(T) == 2) WriteU16(address, value); else WriteU8(address, value); } }; #undef MAS_NATIVE_IS_BIGENDIAN #endif msvc/msvc-2010-360/msvc-2010-360.vcxproj.filters000664 001750 001750 00000017671 12726204343 021451 0ustar00sergiosergio000000 000000  {4FC737F1-C7A5-4376-A066-2A32D752A2FF} cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx {93995380-89BD-4b04-88EB-625FBE52EBFB} h;hpp;hxx;hm;inl;inc;xsd {7e2d28e1-7dea-4830-b6d9-eda0e7a17ecd} {1e91b900-1745-439d-9376-bc26074e1010} {82077d1a-8197-4b2f-8098-2818f64b525d} {6ba4afd0-4a16-411a-9fa9-c63e451b35bf} {84c0bb6f-44c5-45dd-8bd0-80caa8076b21} {8daa3df8-836e-4061-b2b1-2dc7da46390f} {691cb3fc-62c8-4ac6-9c02-9f23e66368f7} {6e70f6f2-5174-46d4-9bd6-33725139e84c} Source Files Source Files Source Files Source Files\mednafen Source Files\mednafen Source Files\mednafen Source Files\mednafen Source Files\mednafen Source Files\mednafen Source Files\mednafen Source Files\mednafen Source Files\mednafen Source Files\mednafen Source Files\mednafen Source Files\mednafen Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\cdrom Source Files\mednafen\hw_misc\arcade_card Source Files\mednafen\pce_fast Source Files\mednafen\pce_fast Source Files\mednafen\pce_fast Source Files\mednafen\pce_fast Source Files\mednafen\pce_fast Source Files\mednafen\pce_fast Source Files\mednafen\sound Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor Source Files\mednafen\tremor mednafen/cdrom/l-ec.cpp000664 001750 001750 00000027033 12726204343 016117 0ustar00sergiosergio000000 000000 /* dvdisaster: Additional error correction for optical media. * Copyright (C) 2004-2007 Carsten Gnoerlich. * Project home page: http://www.dvdisaster.com * Email: carsten@dvdisaster.com -or- cgnoerlich@fsfe.org * * The Reed-Solomon error correction draws a lot of inspiration - and even code - * from Phil Karn's excellent Reed-Solomon library: http://www.ka9q.net/code/fec/ * * 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, * or direct your browser at http://www.gnu.org. */ #include "dvdisaster.h" #include "galois-inlines.h" #define MIN(a, b) (((a) < (b)) ? (a) : (b)) /*** *** Mapping between cd frame and parity vectors ***/ /* * Mapping of frame bytes to P/Q Vectors */ int PToByteIndex(int p, int i) { return 12 + p + i*86; } void ByteIndexToP(int b, int *p, int *i) { *p = (b-12)%86; *i = (b-12)/86; } int QToByteIndex(int q, int i) { int offset = 12 + (q & 1); if(i == 43) return 2248+q; if(i == 44) return 2300+q; q&=~1; return offset + (q*43 + i*88) % 2236; } void ByteIndexToQ(int b, int *q, int *i) { int x,y,offset; if(b >= 2300) { *i = 44; *q = (b-2300); return; } if(b >= 2248) { *i = 43; *q = (b-2248); return; } offset = b&1; b = (b-12)/2; x = b/43; y = (b-(x*43))%26; *i = b-(x*43); *q = 2*((x+26-y)%26)+offset; } /* * There are 86 vectors of P-parity, yielding a RS(26,24) code. */ void GetPVector(unsigned char *frame, unsigned char *data, int n) { int i; int w_idx = n+12; for(i=0; i<26; i++, w_idx+=86) data[i] = frame[w_idx]; } void SetPVector(unsigned char *frame, unsigned char *data, int n) { int i; int w_idx = n+12; for(i=0; i<26; i++, w_idx+=86) frame[w_idx] = data[i]; } void FillPVector(unsigned char *frame, unsigned char data, int n) { int i; int w_idx = n+12; for(i=0; i<26; i++, w_idx+=86) frame[w_idx] = data; } void OrPVector(unsigned char *frame, unsigned char value, int n) { int i; int w_idx = n+12; for(i=0; i<26; i++, w_idx+=86) frame[w_idx] |= value; } void AndPVector(unsigned char *frame, unsigned char value, int n) { int i; int w_idx = n+12; for(i=0; i<26; i++, w_idx+=86) frame[w_idx] &= value; } /* * There are 52 vectors of Q-parity, yielding a RS(45,43) code. */ void GetQVector(unsigned char *frame, unsigned char *data, int n) { int offset = 12 + (n & 1); int w_idx = (n&~1) * 43; int i; for(i=0; i<43; i++, w_idx+=88) data[i] = frame[(w_idx % 2236) + offset]; data[43] = frame[2248 + n]; data[44] = frame[2300 + n]; } void SetQVector(unsigned char *frame, unsigned char *data, int n) { int offset = 12 + (n & 1); int w_idx = (n&~1) * 43; int i; for(i=0; i<43; i++, w_idx+=88) frame[(w_idx % 2236) + offset] = data[i]; frame[2248 + n] = data[43]; frame[2300 + n] = data[44]; } void FillQVector(unsigned char *frame, unsigned char data, int n) { int offset = 12 + (n & 1); int w_idx = (n&~1) * 43; int i; for(i=0; i<43; i++, w_idx+=88) frame[(w_idx % 2236) + offset] = data; frame[2248 + n] = data; frame[2300 + n] = data; } void OrQVector(unsigned char *frame, unsigned char data, int n) { int offset = 12 + (n & 1); int w_idx = (n&~1) * 43; int i; for(i=0; i<43; i++, w_idx+=88) frame[(w_idx % 2236) + offset] |= data; frame[2248 + n] |= data; frame[2300 + n] |= data; } void AndQVector(unsigned char *frame, unsigned char data, int n) { int offset = 12 + (n & 1); int w_idx = (n&~1) * 43; int i; for(i=0; i<43; i++, w_idx+=88) frame[(w_idx % 2236) + offset] &= data; frame[2248 + n] &= data; frame[2300 + n] &= data; } /*** *** C2 error counting ***/ int CountC2Errors(unsigned char *frame) { int i,count = 0; frame += 2352; for(i=0; i<294; i++, frame++) { if(*frame & 0x01) count++; if(*frame & 0x02) count++; if(*frame & 0x04) count++; if(*frame & 0x08) count++; if(*frame & 0x10) count++; if(*frame & 0x20) count++; if(*frame & 0x40) count++; if(*frame & 0x80) count++; } return count; } /*** *** L-EC error correction for CD raw data sectors ***/ /* * These could be used from ReedSolomonTables, * but hardcoding them is faster. */ #define NROOTS 2 #define LEC_FIRST_ROOT 0 //GF_ALPHA0 #define LEC_PRIM_ELEM 1 #define LEC_PRIMTH_ROOT 1 /* * Calculate the error syndrome */ int DecodePQ(ReedSolomonTables *rt, unsigned char *data, int padding, int *erasure_list, int erasure_count) { GaloisTables *gt = rt->gfTables; int syndrome[NROOTS]; int lambda[NROOTS+1]; int omega[NROOTS+1]; int b[NROOTS+1]; int reg[NROOTS+1]; int root[NROOTS]; int loc[NROOTS]; int syn_error; int deg_lambda,lambda_roots; int deg_omega; int shortened_size = GF_FIELDMAX - padding; int corrected = 0; int i,j,k; int r,el; /*** Form the syndromes: Evaluate data(x) at roots of g(x) */ for(i=0; ialphaTo[mod_fieldmax(gt->indexOf[syndrome[i]] + (LEC_FIRST_ROOT+i)*LEC_PRIM_ELEM)]; /*** Convert syndrome to index form, check for nonzero condition. */ syn_error = 0; for(i=0; iindexOf[syndrome[i]]; } /*** If the syndrome is zero, everything is fine. */ if(!syn_error) return 0; /*** Initialize lambda to be the erasure locator polynomial */ lambda[0] = 1; lambda[1] = lambda[2] = 0; erasure_list[0] += padding; erasure_list[1] += padding; if(erasure_count > 2) /* sanity check */ erasure_count = 0; if(erasure_count > 0) { lambda[1] = gt->alphaTo[mod_fieldmax(LEC_PRIM_ELEM*(GF_FIELDMAX-1-erasure_list[0]))]; for(i=1; i0; j--) { int tmp = gt->indexOf[lambda[j-1]]; if(tmp != GF_ALPHA0) lambda[j] ^= gt->alphaTo[mod_fieldmax(u + tmp)]; } } } for(i=0; iindexOf[lambda[i]]; /*** Berlekamp-Massey algorithm to determine error+erasure locator polynomial */ r = erasure_count; /* r is the step number */ el = erasure_count; /* Compute discrepancy at the r-th step in poly-form */ while(++r <= NROOTS) { int discr_r = 0; for(i=0; ialphaTo[mod_fieldmax(gt->indexOf[lambda[i]] + syndrome[r-i-1])]; discr_r = gt->indexOf[discr_r]; if(discr_r == GF_ALPHA0) { /* B(x) = x*B(x) */ memmove(b+1, b, NROOTS*sizeof(b[0])); b[0] = GF_ALPHA0; } else { int t[NROOTS+1]; /* T(x) = lambda(x) - discr_r*x*b(x) */ t[0] = lambda[0]; for(i=0; ialphaTo[mod_fieldmax(discr_r + b[i])]; else t[i+1] = lambda[i+1]; } if(2*el <= r+erasure_count-1) { el = r + erasure_count - el; /* B(x) <-- inv(discr_r) * lambda(x) */ for(i=0; i<=NROOTS; i++) b[i] = (lambda[i] == 0) ? GF_ALPHA0 : mod_fieldmax(gt->indexOf[lambda[i]] - discr_r + GF_FIELDMAX); } else { /* 2 lines below: B(x) <-- x*B(x) */ memmove(b+1, b, NROOTS*sizeof(b[0])); b[0] = GF_ALPHA0; } memcpy(lambda, t, (NROOTS+1)*sizeof(t[0])); } } /*** Convert lambda to index form and compute deg(lambda(x)) */ deg_lambda = 0; for(i=0; iindexOf[lambda[i]]; if(lambda[i] != GF_ALPHA0) deg_lambda = i; } /*** Find roots of the error+erasure locator polynomial by Chien search */ memcpy(reg+1, lambda+1, NROOTS*sizeof(reg[0])); lambda_roots = 0; /* Number of roots of lambda(x) */ for(i=1, k=LEC_PRIMTH_ROOT-1; i<=GF_FIELDMAX; i++, k=mod_fieldmax(k+LEC_PRIMTH_ROOT)) { int q=1; /* lambda[0] is always 0 */ for(j=deg_lambda; j>0; j--) { if(reg[j] != GF_ALPHA0) { reg[j] = mod_fieldmax(reg[j] + j); q ^= gt->alphaTo[reg[j]]; } } if(q != 0) continue; /* Not a root */ /* store root in index-form and the error location number */ root[lambda_roots] = i; loc[lambda_roots] = k; /* If we've already found max possible roots, abort the search to save time */ if(++lambda_roots == deg_lambda) break; } /* deg(lambda) unequal to number of roots => uncorrectable error detected This is not reliable for very small numbers of roots, e.g. nroots = 2 */ if(deg_lambda != lambda_roots) { return -1; } /* Compute err+eras evaluator poly omega(x) = syn(x)*lambda(x) (modulo x**nroots). in index form. Also find deg(omega). */ deg_omega = deg_lambda-1; for(i=0; i<=deg_omega; i++) { int tmp = 0; for(j=i; j>=0; j--) { if((syndrome[i - j] != GF_ALPHA0) && (lambda[j] != GF_ALPHA0)) tmp ^= gt->alphaTo[mod_fieldmax(syndrome[i - j] + lambda[j])]; } omega[i] = gt->indexOf[tmp]; } /* Compute error values in poly-form. num1 = omega(inv(X(l))), num2 = inv(X(l))**(FIRST_ROOT-1) and den = lambda_pr(inv(X(l))) all in poly-form. */ for(j=lambda_roots-1; j>=0; j--) { int num1 = 0; int num2; int den; int location = loc[j]; for(i=deg_omega; i>=0; i--) { if(omega[i] != GF_ALPHA0) num1 ^= gt->alphaTo[mod_fieldmax(omega[i] + i * root[j])]; } num2 = gt->alphaTo[mod_fieldmax(root[j] * (LEC_FIRST_ROOT - 1) + GF_FIELDMAX)]; den = 0; /* lambda[i+1] for i even is the formal derivative lambda_pr of lambda[i] */ for(i=MIN(deg_lambda, NROOTS-1) & ~1; i>=0; i-=2) { if(lambda[i+1] != GF_ALPHA0) den ^= gt->alphaTo[mod_fieldmax(lambda[i+1] + i * root[j])]; } /* Apply error to data */ if(num1 != 0 && location >= padding) { corrected++; data[location-padding] ^= gt->alphaTo[mod_fieldmax(gt->indexOf[num1] + gt->indexOf[num2] + GF_FIELDMAX - gt->indexOf[den])]; /* If no erasures were given, at most one error was corrected. Return its position in erasure_list[0]. */ if(!erasure_count) erasure_list[0] = location-padding; } #if 1 else return -3; #endif } /*** Form the syndromes: Evaluate data(x) at roots of g(x) */ for(i=0; ialphaTo[mod_fieldmax(gt->indexOf[syndrome[i]] + (LEC_FIRST_ROOT+i)*LEC_PRIM_ELEM)]; } /*** Convert syndrome to index form, check for nonzero condition. */ #if 1 for(i=0; i> 24) & 0x80) | ((HU_ZNFlags & 0xFF) ? 0 : Z_FLAG); //((((HU_ZNFlags & 0xFF) - 1) >> 8) & Z_FLAG); #define EXPAND_FLAGS() HU_ZNFlags = (HU_P << 24) | ((HU_P & Z_FLAG) ^ Z_FLAG); #else #define COMPRESS_FLAGS() #define EXPAND_FLAGS() #endif #ifdef HUC6280_CRAZY_VERSION #define GetRealPC() ((unsigned int)(HU_PC - HU_PC_base)) #define GetRealPC_EXTERNAL() ((unsigned int)(HuCPU.PC - HuCPU.PC_base)) #else #define GetRealPC() (HU_PC) #define GetRealPC_EXTERNAL() (HuCPU.PC) #endif #ifdef HUC6280_CRAZY_VERSION #define SetPC(value) { unsigned int tempmoo = value; HU_PC = &HuCPU.FastPageR[tempmoo >> 13][tempmoo]; \ HU_PC_base = HU_PC - tempmoo; } #define SetPC_EXTERNAL(value) { unsigned int tempmoo = value; \ HuCPU.PC = &HuCPU.FastPageR[tempmoo >> 13][tempmoo]; HuCPU.PC_base = HuCPU.PC - tempmoo; } #else #define SetPC(value) { HU_PC = (value); } #define SetPC_EXTERNAL(value) { HuCPU.PC = (value); } #endif // Page change PC, GET IT?! #ifdef HUC6280_CRAZY_VERSION #define FixPC_PC() SetPC(GetRealPC()); #else #define FixPC_PC() #endif //#define IncPC() { HU_PC++; if(!(GetRealPC() & 0x1FFF)) printf("Bank crossing: %04x\n", GetRealPC()); } //#define IncPC() HU_PC++; #if 0 #define IncPC() { HU_PC++; if(!(GetRealPC() & 0x1FFF) && \ HuCPU.MPR[(GetRealPC() - 1) >> 13] != (HuCPU.MPR[(GetRealPC()) >> 13] - 1)) \ printf("Bank crossing: %04x, %02x, %02x\n", GetRealPC(), HuCPU.MPR[(GetRealPC() - 1) >> 13], \ HuCPU.MPR[GetRealPC() >> 13]); } #else #define IncPC() HU_PC++; #endif #ifdef HUC6280_CRAZY_VERSION #define RdAtPC() (*HU_PC) //#define RdAtAndIncPC_16() (HU_PC += 2, *(uint16 *)(HU_PC - 2)) #else #define RdAtPC() RdOp(HU_PC) //#define RdAtAndIncPC_16() (RdOp(HU_PC++) | ((RdOp(HU_PC++) << 8))) #endif // If we change this definition, we'll need to also fix HuC6280_StealCycle() in huc6280.h #define ADDCYC(x) { HuCPU.timestamp += x; } static uint8 dummy_bank[8192 + 8192]; // + 8192 for PC-as-ptr safety padding #define SET_MPR(arg_i, arg_v) \ { \ const unsigned int wmpr = arg_i, wbank = arg_v; \ if(wmpr == 1) \ { \ HU_Page1 = HuCPUFastMap[wbank] ? HuCPUFastMap[wbank] + wbank * 8192 : dummy_bank; \ } \ HuCPU.MPR[wmpr] = wbank; \ HuCPU.FastPageR[wmpr] = HuCPUFastMap[wbank] ? (HuCPUFastMap[wbank] + wbank * 8192) - wmpr * 8192 : (dummy_bank - wmpr * 8192); \ } void HuC6280_SetMPR(int i, int v) { uint8 *Page1_local = HuCPU.Page1; SET_MPR(i, v); HuCPU.Page1 = Page1_local; } static void HuC6280_FlushMPRCache(void) { for(int x = 0; x < 9; x++) HuC6280_SetMPR(x, HuCPU.MPR[x & 0x7]); } static INLINE uint8 RdMem(unsigned int A) { uint8 wmpr = HuCPU.MPR[A >> 13]; return(PCERead[wmpr]((wmpr << 13) | (A & 0x1FFF))); } static INLINE uint16 RdMem16(unsigned int A) { return(RdMem(A) | (RdMem(A + 1) << 8)); } static INLINE void WrMem(unsigned int A, uint8 V) { uint8 wmpr = HuCPU.MPR[A >> 13]; PCEWrite[wmpr]((wmpr << 13) | (A & 0x1FFF), V); } static INLINE uint8 RdOp(unsigned int A) { return(HuCPU.FastPageR[A >> 13][A]); } #define PUSH(V) \ { \ HU_Page1[0x100 + HU_S] = V; \ HU_S--; \ } #define PUSH_PC() \ { \ unsigned int real_pc = GetRealPC(); \ PUSH(real_pc >> 8); \ PUSH(real_pc); \ } #define POP() HU_Page1[0x100 + ++HU_S] #define POP_PC() \ { \ unsigned int npc; \ npc = POP(); \ npc |= POP() << 8; \ SetPC(npc); \ } // Hopefully we never RTS to 0x0000. ;) #define POP_PC_AP() \ { \ uint32 npc; \ npc = POP(); \ npc |= POP() << 8; \ npc++; \ SetPC(npc); \ } /* Some of these operations will only make sense if you know what the flag constants are. */ #ifdef HUC6280_LAZY_FLAGS #define X_ZN(zort) { HU_ZNFlags = (int32)(int8)(uint8)(zort); } #define X_ZN_BIT(opres, argie) { HU_ZNFlags = (opres) | ((argie) << 24); } #else static uint8 ZNTable[256]; #define X_ZN(zort) HU_P&=~(Z_FLAG|N_FLAG);HU_P|=ZNTable[zort] #define X_ZN_BIT(opres, argie) { HU_P &= ~(Z_FLAG | N_FLAG); HU_P |= ZNTable[opres] & Z_FLAG; HU_P |= argie & N_FLAG; } #endif #define JR(cond) \ { \ if(cond) \ { \ int32 disp; \ disp = 1 + (int8)RdAtPC(); \ ADDCYC(2); \ HU_PC+=disp; \ } \ else IncPC(); \ } #define BRA \ { \ int32 disp; \ disp = 1 + (int8)RdAtPC(); \ HU_PC+=disp; \ } #define BBRi(bitto) JR(!(x & (1 << bitto))) #define BBSi(bitto) JR(x & (1 << bitto)) #define ST0 VDC_Write_ST(0, x) #define ST1 VDC_Write_ST(2, x) #define ST2 VDC_Write_ST(3, x) #define LDA HU_A=x;X_ZN(HU_A) #define LDX HU_X=x;X_ZN(HU_X) #define LDY HU_Y=x;X_ZN(HU_Y) /* All of the freaky arithmetic operations. */ #define AND HU_A&=x;X_ZN(HU_A); // FIXME: #define BIT HU_P&=~V_FLAG; X_ZN_BIT(x & HU_A, x); HU_P |= x & V_FLAG; #define EOR HU_A^=x;X_ZN(HU_A); #define ORA HU_A|=x;X_ZN(HU_A); #define ADC { \ if(HU_P & D_FLAG) \ { \ uint32 tmp; \ tmp = (HU_A & 0x0F) + (x & 0x0F) + (HU_P & 1); \ if(tmp >= 0x0A) \ tmp += 0x06; \ tmp += (HU_A & 0xF0) + (x & 0xF0); \ if(tmp >= 0xA0) \ tmp += 0x60; \ HU_P &= ~C_FLAG; \ if(tmp & 0xFF00) \ HU_P |= C_FLAG; \ HU_A = tmp; \ X_ZN(HU_A); \ } \ else \ { \ uint32 l=HU_A+x+(HU_P&1); \ HU_P&=~(C_FLAG|V_FLAG); \ HU_P|=((((HU_A^x)&0x80)^0x80) & ((HU_A^l)&0x80))>>1; \ HU_P|=(l>>8)&C_FLAG; \ HU_A=l; \ X_ZN(HU_A); \ } \ } #define SBC if(HU_P & D_FLAG) \ { \ const uint8 m = (HU_A & 0xF) - (x & 0xF) - ((HU_P & 1) ^ 1); \ const uint8 n = (HU_A >> 4) - (x >> 4) - ((m >> 4) & 1); \ uint8 res = (n << 4) | (m & 0xF); \ if(m & 0x10) \ res -= 0x06; \ if(n & 0x10) \ res -= 0x60; \ HU_A = res; \ HU_P &= ~C_FLAG; \ HU_P |= ((n >> 4) & 0x1) ^ 1; \ X_ZN(HU_A); \ } else { \ uint32 l=HU_A-x-((HU_P&1)^1); \ HU_P&=~(C_FLAG|V_FLAG); \ HU_P|=((HU_A^l)&(HU_A^x)&0x80)>>1; \ HU_P|=((l>>8)&C_FLAG)^C_FLAG; \ HU_A=l; \ X_ZN(HU_A); \ } #define CMPL(a1,a2) { \ uint32 t=a1-a2; \ X_ZN(t&0xFF); \ HU_P&=~C_FLAG; \ HU_P|=((t>>8)&C_FLAG)^C_FLAG; \ } #define TAM for(int i = 0; i < 8; i ++) { \ if(x & (1 << i)) \ { \ SET_MPR(i, HU_A); \ } \ } SET_MPR(8, HuCPU.MPR[0]); #define TMA for(int i = 0; i < 8; i ++) { \ if(x & (1 << i)) \ HU_A = HuCPU.MPR[i]; \ } #define CSL #define CSH #define RMB(bitto) x &= ~(1 << (bitto & 7)) #define SMB(bitto) x |= 1 << (bitto & 7) // FIXME #define TSB { HU_P &= ~V_FLAG; X_ZN_BIT(x | HU_A, x); HU_P |= x & V_FLAG; x |= HU_A; } #define TRB { HU_P &= ~V_FLAG; X_ZN_BIT(x & ~HU_A, x); HU_P |= x & V_FLAG; x &= ~HU_A; } #define TST { HU_P &= ~V_FLAG; X_ZN_BIT(x & zoomhack, x); HU_P |= x & V_FLAG; } #define CMP CMPL(HU_A,x) #define CPX CMPL(HU_X,x) #define CPY CMPL(HU_Y,x) /* The following operations modify the byte being worked on. */ #define DEC x--;X_ZN(x) #define INC x++;X_ZN(x) #define ASL HU_P&=~C_FLAG;HU_P|=x>>7;x<<=1;X_ZN(x) #define LSR HU_P&=~C_FLAG;HU_P|=x&1;x>>=1;X_ZN(x) #define ROL { \ uint8 l=x>>7; \ x<<=1; \ x|=HU_P&C_FLAG; \ HU_P&=~C_FLAG; \ HU_P|=l; \ X_ZN(x); \ } #define ROR { \ uint8 l=x&1; \ x>>=1; \ x|=(HU_P&C_FLAG)<<7; \ HU_P&=~C_FLAG; \ HU_P|=l; \ X_ZN(x); \ } /* Absolute */ #define GetAB(target) \ { \ target=RdAtPC(); \ IncPC(); \ target|=RdAtPC()<<8; \ IncPC(); \ } /* Absolute Indexed(for reads) */ #define GetABI(target, i) \ { \ unsigned int tmp; \ GetAB(tmp); \ target=tmp; \ target+=i; \ } /* Zero Page */ #define GetZP(target) \ { \ target=RdAtPC(); \ IncPC(); \ } /* Zero Page Indexed */ #define GetZPI(target,i) \ { \ target=i+RdAtPC(); \ IncPC(); \ } /* Indirect */ #define GetIND(target) \ { \ uint8 tmp; \ tmp=RdAtPC(); \ IncPC(); \ target=HU_Page1[tmp]; \ tmp++; \ target|=HU_Page1[tmp]<<8; \ } /* Indexed Indirect */ #define GetIX(target) \ { \ uint8 tmp; \ tmp=RdAtPC(); \ IncPC(); \ tmp+=HU_X; \ target=HU_Page1[tmp]; \ tmp++; \ target|=HU_Page1[tmp] <<8; \ } /* Indirect Indexed(for reads) */ #define GetIY(target) \ { \ unsigned int rt; \ uint8 tmp; \ tmp=RdAtPC(); \ rt=HU_Page1[tmp]; \ tmp++; \ rt|=HU_Page1[tmp]<<8; \ target = (rt + HU_Y); \ IncPC(); \ } /* Now come the macros to wrap up all of the above stuff addressing mode functions and operation macros. Note that operation macros will always operate(redundant redundant) on the variable "x". */ #define RMW_A(op) {uint8 x=HU_A; op; HU_A=x; break; } /* Meh... */ #define RMW_AB(op) {unsigned int EA; uint8 x; GetAB(EA); x=RdMem(EA); op; WrMem(EA,x); break; } #define RMW_ABI(reg,op) {unsigned int EA; uint8 x; GetABI(EA,reg); x=RdMem(EA); op; WrMem(EA,x); break; } #define RMW_ABX(op) RMW_ABI(HU_X,op) #define RMW_ABY(op) RMW_ABI(HU_Y,op) #define RMW_IND(op) { unsigned int EA; uint8 x; GetIND(EA); x = RdMem(EA); op; WrMem(EA, x); break; } #define RMW_IX(op) { unsigned int EA; uint8 x; GetIX(EA); x=RdMem(EA); op; WrMem(EA,x); break; } #define RMW_IY(op) { unsigned int EA; uint8 x; GetIY(EA); x=RdMem(EA); op; WrMem(EA,x); break; } #define RMW_ZP(op) { uint8 EA; uint8 x; GetZP(EA); x=HU_Page1[EA]; op; HU_Page1[EA] = x; break; } #define RMW_ZPX(op) { uint8 EA; uint8 x; GetZPI(EA,HU_X); x=HU_Page1[EA]; op; HU_Page1[EA] = x; break;} #define LD_IM(op) { uint8 x; x=RdAtPC(); IncPC(); op; break; } #define LD_ZP(op) { uint8 EA; uint8 x; GetZP(EA); x=HU_Page1[EA]; op; break; } #define LD_ZPX(op) { uint8 EA; uint8 x; GetZPI(EA,HU_X); x=HU_Page1[EA]; op; break; } #define LD_ZPY(op) { uint8 EA; uint8 x; GetZPI(EA,HU_Y); x=HU_Page1[EA]; op; break; } #define LD_AB(op) { unsigned int EA; uint8 x; GetAB(EA); x=RdMem(EA); op; break; } #define LD_ABI(reg,op) { unsigned int EA; uint8 x; GetABI(EA,reg); x=RdMem(EA); op; break; } #define LD_ABX(op) LD_ABI(HU_X,op) #define LD_ABY(op) LD_ABI(HU_Y,op) #define LD_IND(op) { unsigned int EA; uint8 x; GetIND(EA); x=RdMem(EA); op; break; } #define LD_IX(op) { unsigned int EA; uint8 x; GetIX(EA); x=RdMem(EA); op; break; } #define LD_IY(op) { unsigned int EA; uint8 x; GetIY(EA); x=RdMem(EA); op; break; } #define BMT_PREHONK(pork) HuCPU.in_block_move = IBM_##pork; #define BMT_HONKHONK(pork) if(HuCPU.timestamp >= next_user_event) goto GetOutBMT; continue_the_##pork: #define BMT_TDD BMT_PREHONK(TDD); do { ADDCYC(6); WrMem(HuCPU.bmt_dest, RdMem(HuCPU.bmt_src)); HuCPU.bmt_src--; HuCPU.bmt_dest--; BMT_HONKHONK(TDD); HuCPU.bmt_length--; } while(HuCPU.bmt_length); #define BMT_TAI BMT_PREHONK(TAI); {HuCPU.bmt_alternate = 0; do { ADDCYC(6); WrMem(HuCPU.bmt_dest, RdMem(HuCPU.bmt_src + HuCPU.bmt_alternate)); HuCPU.bmt_dest++; HuCPU.bmt_alternate ^= 1; BMT_HONKHONK(TAI); HuCPU.bmt_length--; } while(HuCPU.bmt_length); } #define BMT_TIA BMT_PREHONK(TIA); {HuCPU.bmt_alternate = 0; do { ADDCYC(6); WrMem(HuCPU.bmt_dest + HuCPU.bmt_alternate, RdMem(HuCPU.bmt_src)); HuCPU.bmt_src++; HuCPU.bmt_alternate ^= 1; BMT_HONKHONK(TIA); HuCPU.bmt_length--; } while(HuCPU.bmt_length); } #define BMT_TII BMT_PREHONK(TII); do { ADDCYC(6); WrMem(HuCPU.bmt_dest, RdMem(HuCPU.bmt_src)); HuCPU.bmt_src++; HuCPU.bmt_dest++; BMT_HONKHONK(TII); HuCPU.bmt_length--; } while(HuCPU.bmt_length); #define BMT_TIN BMT_PREHONK(TIN); do { ADDCYC(6); WrMem(HuCPU.bmt_dest, RdMem(HuCPU.bmt_src)); HuCPU.bmt_src++; BMT_HONKHONK(TIN); HuCPU.bmt_length--; } while(HuCPU.bmt_length); // Block memory transfer load #define LD_BMT(op) { PUSH(HU_Y); PUSH(HU_A); PUSH(HU_X); GetAB(HuCPU.bmt_src); GetAB(HuCPU.bmt_dest); GetAB(HuCPU.bmt_length); op; HuCPU.in_block_move = 0; HU_X = POP(); HU_A = POP(); HU_Y = POP(); break; } #define ST_ZP(r) {uint8 EA; GetZP(EA); HU_Page1[EA] = r; break;} #define ST_ZPX(r) {uint8 EA; GetZPI(EA,HU_X); HU_Page1[EA] = r; break;} #define ST_ZPY(r) {uint8 EA; GetZPI(EA,HU_Y); HU_Page1[EA] = r; break;} #define ST_AB(r) {unsigned int EA; GetAB(EA); WrMem(EA, r); break;} #define ST_ABI(reg,r) {unsigned int EA; GetABI(EA,reg); WrMem(EA,r); break; } #define ST_ABX(r) ST_ABI(HU_X,r) #define ST_ABY(r) ST_ABI(HU_Y,r) #define ST_IND(r) {unsigned int EA; GetIND(EA); WrMem(EA,r); break; } #define ST_IX(r) {unsigned int EA; GetIX(EA); WrMem(EA,r); break; } #define ST_IY(r) {unsigned int EA; GetIY(EA); WrMem(EA,r); break; } static const uint8 CycTable[256] = { /*0x00*/ 8, 7, 3, 4, 6, 4, 6, 7, 3, 2, 2, 2, 7, 5, 7, 6, /*0x10*/ 2, 7, 7, 4, 6, 4, 6, 7, 2, 5, 2, 2, 7, 5, 7, 6, /*0x20*/ 7, 7, 3, 4, 4, 4, 6, 7, 4, 2, 2, 2, 5, 5, 7, 6, /*0x30*/ 2, 7, 7, 2, 4, 4, 6, 7, 2, 5, 2, 2, 5, 5, 7, 6, /*0x40*/ 7, 7, 3, 4, 8, 4, 6, 7, 3, 2, 2, 2, 4, 5, 7, 6, /*0x50*/ 2, 7, 7, 5, 3, 4, 6, 7, 2, 5, 3, 2, 2, 5, 7, 6, /*0x60*/ 7, 7, 2, 2, 4, 4, 6, 7, 4, 2, 2, 2, 7, 5, 7, 6, /*0x70*/ 2, 7, 7, 17, 4, 4, 6, 7, 2, 5, 4, 2, 7, 5, 7, 6, /*0x80*/ 4, 7, 2, 7, 4, 4, 4, 7, 2, 2, 2, 2, 5, 5, 5, 6, /*0x90*/ 2, 7, 7, 8, 4, 4, 4, 7, 2, 5, 2, 2, 5, 5, 5, 6, /*0xA0*/ 2, 7, 2, 7, 4, 4, 4, 7, 2, 2, 2, 2, 5, 5, 5, 6, /*0xB0*/ 2, 7, 7, 8, 4, 4, 4, 7, 2, 5, 2, 2, 5, 5, 5, 6, /*0xC0*/ 2, 7, 2, 17, 4, 4, 6, 7, 2, 2, 2, 2, 5, 5, 7, 6, /*0xD0*/ 2, 7, 7, 17, 3, 4, 6, 7, 2, 5, 3, 2, 2, 5, 7, 6, /*0xE0*/ 2, 7, 2, 17, 4, 4, 6, 7, 2, 2, 2, 2, 5, 5, 7, 6, /*0xF0*/ 2, 7, 7, 17, 2, 4, 6, 7, 2, 5, 4, 2, 2, 5, 7, 6, }; #if 0 static bool WillIRQOccur(void) NO_INLINE; static bool WillIRQOccur(void) { bool ret = false; if(HU_IRQlow) { if(!(HU_PI&I_FLAG)) { if(HU_IRQlow & MDFN_IQTIMER & HuCPU.IRQMaskDelay) ret = true; else if((HU_IRQlow & MDFN_IQIRQ1 & HuCPU.IRQMaskDelay) || ((HU_IRQlow >> 8) & MDFN_IQIRQ1 & HuCPU.IRQMaskDelay)) ret = true; else if(HU_IRQlow & MDFN_IQIRQ2 & HuCPU.IRQMaskDelay) ret = true; } } return(true); } #endif void HuC6280_IRQBegin(int w) { HU_IRQlow|=w; } void HuC6280_IRQEnd(int w) { HU_IRQlow&=~w; } void HuC6280_Reset(void) { HuCPU.timer_next_timestamp = HuCPU.timestamp + 1024; HuCPU.timer_load = 0; HuCPU.timer_value = 0; HuCPU.timer_status = 0; HuCPU.in_block_move = 0; unsigned int npc; HuCPU.IRQMask = HuCPU.IRQMaskDelay = 7; HuC6280_SetMPR(0, 0xFF); HuC6280_SetMPR(8, 0xFF); HuC6280_SetMPR(1, 0xF8); for(int i = 2; i < 8; i++) HuC6280_SetMPR(i, 0); npc = RdMem16(0xFFFE); #define PC_local HuCPU.PC SetPC(npc); #undef PC_local HuCPU.mooPI = I_FLAG; HuCPU.P = I_FLAG; HU_IRQlow = 0; } void HuC6280_Init(void) { memset((void *)&HuCPU,0,sizeof(HuCPU)); memset(dummy_bank, 0, sizeof(dummy_bank)); #ifdef HUC6280_LAZY_FLAGS #else for(int x=0; x < 256; x++) if(!x) ZNTable[x]=Z_FLAG; else if (x&0x80) ZNTable[x]=N_FLAG; else ZNTable[x]=0; #endif } void HuC6280_Power(void) { HuCPU.IRQlow = 0; HuCPU.A = 0; HuCPU.X = 0; HuCPU.Y = 0; HuCPU.S = 0; HuCPU.P = 0; HuCPU.mooPI = 0; #if 0 HU_PC = HU_PC_base = NULL; #else HuCPU.PC = 0; #endif HuCPU.timestamp = 0; for(int i = 0; i < 9; i++) { HuCPU.MPR[i] = 0; HuCPU.FastPageR[i] = NULL; } HuC6280_Reset(); } void HuC6280_Run(int32 cycles) { const int32 next_user_event = HuCPU.previous_next_user_event + cycles * pce_overclocked; HuCPU.previous_next_user_event = next_user_event; LOAD_LOCALS(); if(HuCPU.timestamp >= next_user_event) return; int32 next_event; if(HuCPU.in_block_move) { next_event = (next_user_event < HuCPU.timer_next_timestamp) ? next_user_event : HuCPU.timer_next_timestamp; switch(HuCPU.in_block_move) { case IBM_TIA: goto continue_the_TIA; case IBM_TAI: goto continue_the_TAI; case IBM_TDD: goto continue_the_TDD; case IBM_TII: goto continue_the_TII; case IBM_TIN: goto continue_the_TIN; } } while(MDFN_LIKELY(HuCPU.timestamp < next_user_event)) { next_event = (next_user_event < HuCPU.timer_next_timestamp) ? next_user_event : HuCPU.timer_next_timestamp; while(MDFN_LIKELY(HuCPU.timestamp < next_event)) { uint8 b1; if(HU_IRQlow) { if(!(HU_PI&I_FLAG)) { uint32 tmpa = 0; if(HU_IRQlow & MDFN_IQTIMER & HuCPU.IRQMaskDelay) tmpa = 0xFFFA; else if((HU_IRQlow & MDFN_IQIRQ1 & HuCPU.IRQMaskDelay) || ((HU_IRQlow >> 8) & MDFN_IQIRQ1 & HuCPU.IRQMaskDelay)) tmpa = 0xFFF8; else if(HU_IRQlow & MDFN_IQIRQ2 & HuCPU.IRQMaskDelay) tmpa = 0xFFF6; if(tmpa) { unsigned int npc; ADDCYC(8); PUSH_PC(); COMPRESS_FLAGS(); PUSH((HU_P&~B_FLAG)); HU_P |= I_FLAG; HU_P &= ~(T_FLAG | D_FLAG); HU_PI = HU_P; npc = RdMem16(tmpa); SetPC(npc); if(tmpa == 0xFFF8) HU_IRQlow &= ~0x200; continue; } } } // end if(HU_IRQlow) //printf("%04x\n", GetRealPC()); HU_PI = HU_P; HuCPU.IRQMaskDelay = HuCPU.IRQMask; b1 = RdAtPC(); ADDCYC(CycTable[b1]); IncPC(); switch(b1) { #include "huc6280_ops.inc" } #ifndef HUC6280_EXTRA_CRAZY FixPC_PC(); #endif } // end while(HuCPU.timestamp < next_event) while(HuCPU.timestamp >= HuCPU.timer_next_timestamp) { HuCPU.timer_next_timestamp += 1024 * pce_overclocked; if(HuCPU.timer_status) { HuCPU.timer_value --; if(HuCPU.timer_value < 0) { HuCPU.timer_value = HuCPU.timer_load; HuC6280_IRQBegin(MDFN_IQTIMER); } } } } // end while(HuCPU.timestamp < next_user_event) GetOutBMT: SAVE_LOCALS(); } void HuC6280_ResetTS(void) { HuCPU.timer_next_timestamp -= HuCPU.timestamp; HuCPU.previous_next_user_event -= HuCPU.timestamp; HuCPU.timestamp = 0; } int HuC6280_StateAction(StateMem *sm, int load, int data_only) { uint16 tmp_PC = GetRealPC_EXTERNAL(); #define P_local HuCPU.P COMPRESS_FLAGS(); SFORMAT SFCPU[]= { SFVARN(tmp_PC, "PC"), SFVARN(HuCPU.A, "A"), SFVARN(HuCPU.P, "P"), SFVARN(HuCPU.X, "X"), SFVARN(HuCPU.Y, "Y"), SFVARN(HuCPU.S, "S"), SFVARN(HuCPU.mooPI, "PI"), SFVARN(HuCPU.IRQMask, "IRQMask"), SFVARN(HuCPU.IRQMaskDelay, "IRQMaskDelay"), SFARRAYN(HuCPU.MPR, 8, "MPR"), SFVARN(HuCPU.timer_status, "timer_status"), SFVARN(HuCPU.timer_value, "timer_value"), SFVARN(HuCPU.timer_load, "timer_load"), SFVARN(HuCPU.IRQlow, "IRQlow"), SFVARN(HuCPU.in_block_move, "IBM"), SFVARN(HuCPU.bmt_src, "IBM_SRC"), SFVARN(HuCPU.bmt_dest, "IBM_DEST"), SFVARN(HuCPU.bmt_length, "IBM_LENGTH"), SFVARN(HuCPU.bmt_alternate, "IBM_ALTERNATE"), SFVARN(HuCPU.timestamp, "timestamp"), SFVARN(HuCPU.timer_next_timestamp, "timer_next_timestamp"), SFVARN(HuCPU.previous_next_user_event, "previous_next_user_event"), SFEND }; int ret = MDFNSS_StateAction(sm, load, data_only, SFCPU, "CPU"); if(load) { // Update MPR cache HuC6280_FlushMPRCache(); // This must be after the MPR cache is updated: SetPC_EXTERNAL(tmp_PC); } EXPAND_FLAGS(); #undef P_local return(ret); } mednafen/tremor/backends.h000664 001750 001750 00000011037 12726204343 016717 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: backend and mapping structures ********************************************************************/ /* this is exposed up here because we need it for static modes. Lookups for each backend aren't exposed because there's no reason to do so */ #ifndef _vorbis_backend_h_ #define _vorbis_backend_h_ #include "codec_internal.h" /* this would all be simpler/shorter with templates, but.... */ /* Transform backend generic *************************************/ /* only mdct right now. Flesh it out more if we ever transcend mdct in the transform domain */ /* Floor backend generic *****************************************/ typedef struct{ vorbis_info_floor *(*unpack)(vorbis_info *,oggpack_buffer *); vorbis_look_floor *(*look) (vorbis_dsp_state *,vorbis_info_mode *, vorbis_info_floor *); void (*free_info) (vorbis_info_floor *); void (*free_look) (vorbis_look_floor *); void *(*inverse1) (struct vorbis_block *,vorbis_look_floor *); int (*inverse2) (struct vorbis_block *,vorbis_look_floor *, void *buffer,ogg_int32_t *); } vorbis_func_floor; typedef struct{ int order; long rate; long barkmap; int ampbits; int ampdB; int numbooks; /* <= 16 */ int books[16]; } vorbis_info_floor0; #define VIF_POSIT 63 #define VIF_CLASS 16 #define VIF_PARTS 31 typedef struct{ int partitions; /* 0 to 31 */ int partitionclass[VIF_PARTS]; /* 0 to 15 */ int class_dim[VIF_CLASS]; /* 1 to 8 */ int class_subs[VIF_CLASS]; /* 0,1,2,3 (bits: 1< #include #ifdef MSB_FIRST #ifndef le32toh #define le32toh(l) ((((l)>>24) & 0xff) | (((l)>>8) & 0xff00) \ | (((l)<<8) & 0xff0000) | (((l)<<24) & 0xff000000)) #endif #ifndef le16toh #define le16toh(l) ((((l)>>8) & 0xff) | (((l)<<8) & 0xff00)) #endif #else #ifndef le32toh #define le32toh(l) (l) #endif #ifndef le16toh #define le16toh(l) (l) #endif #endif #ifndef htole32 #define htole32 le32toh #endif #ifndef htole16 #define htole16 le16toh #endif #ifdef __cplusplus extern "C" { #endif int write16le(uint16_t b, FILE *fp); int write32le(uint32_t b, FILE *fp); int read32le(uint32_t *Bufo, FILE *fp); void Endian_A16_Swap(void *src, uint32_t nelements); void Endian_A32_Swap(void *src, uint32_t nelements); void Endian_A64_Swap(void *src, uint32_t nelements); void Endian_A16_NE_to_LE(void *src, uint32_t nelements); void Endian_A32_NE_to_LE(void *src, uint32_t nelements); void Endian_A64_NE_to_LE(void *src, uint32_t nelements); void Endian_A16_LE_to_NE(void *src, uint32_t nelements); void Endian_A16_BE_to_NE(void *src, uint32_t nelements); void Endian_A32_LE_to_NE(void *src, uint32_t nelements); void Endian_A64_LE_to_NE(void *src, uint32_t nelements); void Endian_V_LE_to_NE(void *src, uint32_t bytesize); void Endian_V_NE_to_LE(void *src, uint32_t bytesize); void FlipByteOrder(uint8_t *src, uint32_t count); // The following functions can encode/decode to unaligned addresses. static inline void MDFN_en16lsb(uint8_t *buf, uint16_t morp) { buf[0]=morp; buf[1]=morp>>8; } static inline void MDFN_en24lsb(uint8_t *buf, uint32_t morp) { buf[0]=morp; buf[1]=morp>>8; buf[2]=morp>>16; } static inline void MDFN_en32lsb(uint8_t *buf, uint32_t morp) { buf[0]=morp; buf[1]=morp>>8; buf[2]=morp>>16; buf[3]=morp>>24; } static inline void MDFN_en64lsb(uint8_t *buf, uint64_t morp) { buf[0]=morp >> 0; buf[1]=morp >> 8; buf[2]=morp >> 16; buf[3]=morp >> 24; buf[4]=morp >> 32; buf[5]=morp >> 40; buf[6]=morp >> 48; buf[7]=morp >> 56; } static inline void MDFN_en16msb(uint8_t *buf, uint16_t morp) { buf[0] = morp >> 8; buf[1] = morp; } static inline void MDFN_en24msb(uint8_t *buf, uint32_t morp) { buf[0] = morp >> 16; buf[1] = morp >> 8; buf[2] = morp; } static inline void MDFN_en32msb(uint8_t *buf, uint32_t morp) { buf[0] = morp >> 24; buf[1] = morp >> 16; buf[2] = morp >> 8; buf[3] = morp; } static inline void MDFN_en64msb(uint8_t *buf, uint64_t morp) { buf[0] = morp >> 56; buf[1] = morp >> 48; buf[2] = morp >> 40; buf[3] = morp >> 32; buf[4] = morp >> 24; buf[5] = morp >> 16; buf[6] = morp >> 8; buf[7] = morp >> 0; } static inline uint16_t MDFN_de16lsb(const uint8_t *morp) { return(morp[0] | (morp[1] << 8)); } static inline uint32_t MDFN_de24lsb(const uint8_t *morp) { return(morp[0]|(morp[1]<<8)|(morp[2]<<16)); } static inline uint32_t MDFN_de32lsb(const uint8_t *morp) { return(morp[0]|(morp[1]<<8)|(morp[2]<<16)|(morp[3]<<24)); } static inline uint64_t MDFN_de64lsb(const uint8_t *morp) { uint64_t ret = 0; ret |= (uint64_t)morp[0]; ret |= (uint64_t)morp[1] << 8; ret |= (uint64_t)morp[2] << 16; ret |= (uint64_t)morp[3] << 24; ret |= (uint64_t)morp[4] << 32; ret |= (uint64_t)morp[5] << 40; ret |= (uint64_t)morp[6] << 48; ret |= (uint64_t)morp[7] << 56; return(ret); } static inline uint16_t MDFN_de16msb(const uint8_t *morp) { return(morp[1] | (morp[0] << 8)); } static inline uint32_t MDFN_de24msb(const uint8_t *morp) { return((morp[2]<<0)|(morp[1]<<8)|(morp[0]<<16)); } static inline uint32_t MDFN_de32msb(const uint8_t *morp) { return(morp[3]|(morp[2]<<8)|(morp[1]<<16)|(morp[0]<<24)); } #ifdef __cplusplus } #endif #endif mednafen/MemoryStream.h000664 001750 001750 00000003524 12726204343 016263 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 */ // TODO/WIP #ifndef _MEMORY_STREAM_H #define _MEMORY_STREAM_H #include "Stream.h" class MemoryStream : public Stream { public: MemoryStream(); MemoryStream(uint64 size_hint); MemoryStream(Stream *stream); // Will create a MemoryStream equivalent of the contents of "stream", and then "delete stream". // Will only work if stream->tell() == 0, or if "stream" is seekable. // stream will be deleted even if this constructor throws. MemoryStream(const MemoryStream &zs); MemoryStream & operator=(const MemoryStream &zs); virtual ~MemoryStream(); virtual uint64 attributes(void); virtual uint8 *map(void); virtual void unmap(void); virtual uint64 read(void *data, uint64 count, bool error_on_eos = true); virtual void write(const void *data, uint64 count); virtual void seek(int64 offset, int whence); virtual int64 tell(void); virtual int64 size(void); virtual void close(void); virtual int get_line(std::string &str); private: uint8 *data_buffer; uint64 data_buffer_size; uint64 data_buffer_alloced; int64 position; void grow_if_necessary(uint64 new_required_size); }; #endif mednafen/tremor/ivorbiscodec.h000664 001750 001750 00000015322 12726204343 017621 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: libvorbis codec headers ********************************************************************/ #ifndef _vorbis_codec_h_ #define _vorbis_codec_h_ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ #include "ogg.h" typedef struct vorbis_info{ int version; int channels; long rate; /* The below bitrate declarations are *hints*. Combinations of the three values carry the following implications: all three set to the same value: implies a fixed rate bitstream only nominal set: implies a VBR stream that averages the nominal bitrate. No hard upper/lower limit upper and or lower set: implies a VBR bitstream that obeys the bitrate limits. nominal may also be set to give a nominal rate. none set: the coder does not care to speculate. */ long bitrate_upper; long bitrate_nominal; long bitrate_lower; long bitrate_window; void *codec_setup; } vorbis_info; /* vorbis_dsp_state buffers the current vorbis audio analysis/synthesis state. The DSP state belongs to a specific logical bitstream ****************************************************/ typedef struct vorbis_dsp_state{ int analysisp; vorbis_info *vi; ogg_int32_t **pcm; ogg_int32_t **pcmret; int pcm_storage; int pcm_current; int pcm_returned; int preextrapolate; int eofflag; long lW; long W; long nW; long centerW; ogg_int64_t granulepos; ogg_int64_t sequence; void *backend_state; } vorbis_dsp_state; typedef struct vorbis_block{ /* necessary stream state for linking to the framing abstraction */ ogg_int32_t **pcm; /* this is a pointer into local storage */ oggpack_buffer opb; long lW; long W; long nW; int pcmend; int mode; int eofflag; ogg_int64_t granulepos; ogg_int64_t sequence; vorbis_dsp_state *vd; /* For read-only access of configuration */ /* local storage to avoid remallocing; it's up to the mapping to structure it */ void *localstore; long localtop; long localalloc; long totaluse; struct alloc_chain *reap; } vorbis_block; /* vorbis_block is a single block of data to be processed as part of the analysis/synthesis stream; it belongs to a specific logical bitstream, but is independant from other vorbis_blocks belonging to that logical bitstream. *************************************************/ struct alloc_chain{ void *ptr; struct alloc_chain *next; }; /* vorbis_info contains all the setup information specific to the specific compression/decompression mode in progress (eg, psychoacoustic settings, channel setup, options, codebook etc). vorbis_info and substructures are in backends.h. *********************************************************************/ /* the comments are not part of vorbis_info so that vorbis_info can be static storage */ typedef struct vorbis_comment{ /* unlimited user comment fields. libvorbis writes 'libvorbis' whatever vendor is set to in encode */ char **user_comments; int *comment_lengths; int comments; char *vendor; } vorbis_comment; /* libvorbis encodes in two abstraction layers; first we perform DSP and produce a packet (see docs/analysis.txt). The packet is then coded into a framed OggSquish bitstream by the second layer (see docs/framing.txt). Decode is the reverse process; we sync/frame the bitstream and extract individual packets, then decode the packet back into PCM audio. The extra framing/packetizing is used in streaming formats, such as files. Over the net (such as with UDP), the framing and packetization aren't necessary as they're provided by the transport and the streaming layer is not used */ /* Vorbis PRIMITIVES: general ***************************************/ extern void vorbis_info_init(vorbis_info *vi); extern void vorbis_info_clear(vorbis_info *vi); extern int vorbis_info_blocksize(vorbis_info *vi,int zo); extern void vorbis_comment_init(vorbis_comment *vc); extern void vorbis_comment_add(vorbis_comment *vc, char *comment); extern void vorbis_comment_add_tag(vorbis_comment *vc, char *tag, char *contents); extern char *vorbis_comment_query(vorbis_comment *vc, char *tag, int count); extern int vorbis_comment_query_count(vorbis_comment *vc, char *tag); extern void vorbis_comment_clear(vorbis_comment *vc); extern int vorbis_block_init(vorbis_dsp_state *v, vorbis_block *vb); extern int vorbis_block_clear(vorbis_block *vb); extern void vorbis_dsp_clear(vorbis_dsp_state *v); /* Vorbis PRIMITIVES: synthesis layer *******************************/ extern int vorbis_synthesis_idheader(ogg_packet *op); extern int vorbis_synthesis_headerin(vorbis_info *vi,vorbis_comment *vc, ogg_packet *op); extern int vorbis_synthesis_init(vorbis_dsp_state *v,vorbis_info *vi); extern int vorbis_synthesis_restart(vorbis_dsp_state *v); extern int vorbis_synthesis(vorbis_block *vb,ogg_packet *op); extern int vorbis_synthesis_trackonly(vorbis_block *vb,ogg_packet *op); extern int vorbis_synthesis_blockin(vorbis_dsp_state *v,vorbis_block *vb); extern int vorbis_synthesis_pcmout(vorbis_dsp_state *v,ogg_int32_t ***pcm); extern int vorbis_synthesis_read(vorbis_dsp_state *v,int samples); extern long vorbis_packet_blocksize(vorbis_info *vi,ogg_packet *op); /* Vorbis ERRORS and return codes ***********************************/ #define OV_FALSE -1 #define OV_EOF -2 #define OV_HOLE -3 #define OV_EREAD -128 #define OV_EFAULT -129 #define OV_EIMPL -130 #define OV_EINVAL -131 #define OV_ENOTVORBIS -132 #define OV_EBADHEADER -133 #define OV_EVERSION -134 #define OV_ENOTAUDIO -135 #define OV_EBADPACKET -136 #define OV_EBADLINK -137 #define OV_ENOSEEK -138 #ifdef __cplusplus } #endif /* __cplusplus */ #endif mednafen/video.h000664 001750 001750 00000002336 12726204343 014745 0ustar00sergiosergio000000 000000 #ifndef __MDFN_VIDEO_H #define __MDFN_VIDEO_H #include #if defined(FRONTEND_SUPPORTS_RGB565) /* 16bit color - RGB565 */ #define RED_MASK 0xf800 #define GREEN_MASK 0x7e0 #define BLUE_MASK 0x1f #define RED_EXPAND 3 #define GREEN_EXPAND 2 #define BLUE_EXPAND 3 #define RED_SHIFT 11 #define GREEN_SHIFT 5 #define BLUE_SHIFT 0 #define MAKECOLOR(r, g, b, a) (((r >> RED_EXPAND) << RED_SHIFT) | ((g >> GREEN_EXPAND) << GREEN_SHIFT) | ((b >> BLUE_EXPAND) << BLUE_SHIFT)) #else /* 16bit color - RGB555 */ #define RED_MASK 0x7c00 #define GREEN_MASK 0x3e0 #define BLUE_MASK 0x1f #define RED_EXPAND 3 #define GREEN_EXPAND 3 #define BLUE_EXPAND 3 #define RED_SHIFT 10 #define GREEN_SHIFT 5 #define BLUE_SHIFT 0 #define MAKECOLOR(r, g, b, a) (((r >> RED_EXPAND) << RED_SHIFT) | ((g >> GREEN_EXPAND) << GREEN_SHIFT) | ((b >> BLUE_EXPAND) << BLUE_SHIFT)) #endif #ifdef __cplusplus extern "C" { #endif typedef struct { int32_t x, y, w, h; } MDFN_Rect; typedef struct { unsigned int colorspace; uint8_t r_shift; uint8_t g_shift; uint8_t b_shift; uint8_t a_shift; } MDFN_PixelFormat; typedef struct { uint16_t *pixels; int32_t width; int32_t height; int32_t pitch; } MDFN_Surface; #ifdef __cplusplus } #endif #endif mednafen/include/blargg_source.h000664 001750 001750 00000004574 12726204343 020106 0ustar00sergiosergio000000 000000 // Included at the beginning of library source files, after all other #include lines #ifndef BLARGG_SOURCE_H #define BLARGG_SOURCE_H // If debugging is enabled, abort program if expr is false. Meant for checking // internal state and consistency. A failed assertion indicates a bug in the module. // void assert( bool expr ); #include // If debugging is enabled and expr is false, abort program. Meant for checking // caller-supplied parameters and operations that are outside the control of the // module. A failed requirement indicates a bug outside the module. // void require( bool expr ); #undef require #define require( expr ) assert( expr ) // Like printf() except output goes to debug log file. Might be defined to do // nothing (not even evaluate its arguments). // void dprintf( const char* format, ... ); inline void blargg_dprintf_( const char*, ... ) { } #undef dprintf #define dprintf (1) ? (void) 0 : blargg_dprintf_ // If enabled, evaluate expr and if false, make debug log entry with source file // and line. Meant for finding situations that should be examined further, but that // don't indicate a problem. In all cases, execution continues normally. #undef check #define check( expr ) ((void) 0) // If expr yields error string, return it from current function, otherwise continue. #undef RETURN_ERR #define RETURN_ERR( expr ) do { \ blargg_err_t blargg_return_err_ = (expr); \ if ( blargg_return_err_ ) return blargg_return_err_; \ } while ( 0 ) // If ptr is 0, return out of memory error string. #undef CHECK_ALLOC #define CHECK_ALLOC( ptr ) do { if ( (ptr) == 0 ) return "Out of memory"; } while ( 0 ) // Avoid any macros which evaluate their arguments multiple times #undef min #undef max // using const references generates crappy code, and I am currenly only using these // for built-in types, so they take arguments by value template inline T min( T x, T y ) { if ( x < y ) return x; return y; } template inline T max( T x, T y ) { if ( x < y ) return y; return x; } // TODO: good idea? bad idea? #undef byte #define byte byte_ typedef unsigned char byte; // deprecated #define BLARGG_CHECK_ALLOC CHECK_ALLOC #define BLARGG_RETURN_ERR RETURN_ERR // BLARGG_SOURCE_BEGIN: If defined, #included, allowing redefition of dprintf and check #ifdef BLARGG_SOURCE_BEGIN #include BLARGG_SOURCE_BEGIN #endif #endif mednafen/mednafen-endian.c000664 001750 001750 00000011221 12726204343 016634 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "mednafen-endian.h" void Endian_A16_Swap(void *src, uint32_t nelements) { uint32_t i; uint8_t *nsrc = (uint8_t *)src; for(i = 0; i < nelements; i++) { uint8_t tmp = nsrc[i * 2]; nsrc[i * 2] = nsrc[i * 2 + 1]; nsrc[i * 2 + 1] = tmp; } } void Endian_A32_Swap(void *src, uint32_t nelements) { uint32_t i; uint8_t *nsrc = (uint8_t *)src; for(i = 0; i < nelements; i++) { uint8_t tmp1 = nsrc[i * 4]; uint8_t tmp2 = nsrc[i * 4 + 1]; nsrc[i * 4] = nsrc[i * 4 + 3]; nsrc[i * 4 + 1] = nsrc[i * 4 + 2]; nsrc[i * 4 + 2] = tmp2; nsrc[i * 4 + 3] = tmp1; } } void Endian_A64_Swap(void *src, uint32_t nelements) { uint32_t i; uint8_t *nsrc = (uint8_t *)src; for(i = 0; i < nelements; i++) { unsigned z; uint8_t *base = &nsrc[i * 8]; for(z = 0; z < 4; z++) { uint8_t tmp = base[z]; base[z] = base[7 - z]; base[7 - z] = tmp; } } } void Endian_A16_NE_to_LE(void *src, uint32_t nelements) { #ifdef MSB_FIRST Endian_A16_Swap(src, nelements); #endif } void Endian_A32_NE_to_LE(void *src, uint32_t nelements) { #ifdef MSB_FIRST Endian_A32_Swap(src, nelements); #endif } void Endian_A64_NE_to_LE(void *src, uint32_t nelements) { #ifdef MSB_FIRST Endian_A64_Swap(src, nelements); #endif } void Endian_A16_LE_to_NE(void *src, uint32_t nelements) { #ifdef MSB_FIRST uint32_t i; uint8_t *nsrc = (uint8_t *)src; for(i = 0; i < nelements; i++) { uint8_t tmp = nsrc[i * 2]; nsrc[i * 2] = nsrc[i * 2 + 1]; nsrc[i * 2 + 1] = tmp; } #endif } void Endian_A16_BE_to_NE(void *src, uint32_t nelements) { #ifndef MSB_FIRST uint32_t i; uint8_t *nsrc = (uint8_t *)src; for(i = 0; i < nelements; i++) { uint8_t tmp = nsrc[i * 2]; nsrc[i * 2] = nsrc[i * 2 + 1]; nsrc[i * 2 + 1] = tmp; } #endif } void Endian_A32_LE_to_NE(void *src, uint32_t nelements) { #ifdef MSB_FIRST uint32_t i; uint8_t *nsrc = (uint8_t *)src; for(i = 0; i < nelements; i++) { uint8_t tmp1 = nsrc[i * 4]; uint8_t tmp2 = nsrc[i * 4 + 1]; nsrc[i * 4] = nsrc[i * 4 + 3]; nsrc[i * 4 + 1] = nsrc[i * 4 + 2]; nsrc[i * 4 + 2] = tmp2; nsrc[i * 4 + 3] = tmp1; } #endif } void Endian_A64_LE_to_NE(void *src, uint32_t nelements) { #ifdef MSB_FIRST uint32_t i; uint8_t *nsrc = (uint8_t *)src; for(i = 0; i < nelements; i++) { unsigned z; uint8_t *base = &nsrc[i * 8]; for(z = 0; z < 4; z++) { uint8_t tmp = base[z]; base[z] = base[7 - z]; base[7 - z] = tmp; } } #endif } void FlipByteOrder(uint8_t *src, uint32_t count) { uint8_t *start=src; uint8_t *end=src+count-1; if((count&1) || !count) return; /* This shouldn't happen. */ count >>= 1; while(count--) { uint8_t tmp; tmp=*end; *end=*start; *start=tmp; end--; start++; } } void Endian_V_LE_to_NE(void *src, uint32_t bytesize) { #ifdef MSB_FIRST FlipByteOrder((uint8_t *)src, bytesize); #endif } void Endian_V_NE_to_LE(void *src, uint32_t bytesize) { #ifdef MSB_FIRST FlipByteOrder((uint8_t *)src, bytesize); #endif } int write16le(uint16_t b, FILE *fp) { uint8_t s[2]; s[0]=b; s[1]=b>>8; return((fwrite(s,1,2,fp)<2)?0:2); } int write32le(uint32_t b, FILE *fp) { uint8_t s[4]; s[0]=b; s[1]=b>>8; s[2]=b>>16; s[3]=b>>24; return((fwrite(s,1,4,fp)<4)?0:4); } int read32le(uint32_t *Bufo, FILE *fp) { uint32_t buf; if(fread(&buf,1,4,fp)<4) return 0; #ifdef MSB_FIRST *(uint32_t*)Bufo=((buf&0xFF)<<24)|((buf&0xFF00)<<8)|((buf&0xFF0000)>>8)|((buf&0xFF000000)>>24); #else *(uint32_t*)Bufo=buf; #endif return 1; } int read16le(char *d, FILE *fp) { #ifdef MSB_FIRST int ret; ret=fread(d+1,1,1,fp); ret+=fread(d,1,1,fp); return ret<2?0:2; #else return((fread(d,1,2,fp)<2)?0:2); #endif } mednafen/cdrom/lec.h000664 001750 001750 00000004402 12726204343 015502 0ustar00sergiosergio000000 000000 /* cdrdao - write audio CD-Rs in disc-at-once mode * * Copyright (C) 1998-2002 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef __LEC_H__ #define __LEC_H__ #ifdef HAVE_CONFIG_H #include #endif #include typedef uint32_t u_int32_t; typedef uint16_t u_int16_t; typedef uint8_t u_int8_t; #ifndef TRUE #define TRUE 1 #endif /* Encodes a MODE 0 sector. * 'adr' is the current physical sector address * 'sector' must be 2352 byte wide */ void lec_encode_mode0_sector(u_int32_t adr, u_int8_t *sector); /* Encodes a MODE 1 sector. * 'adr' is the current physical sector address * 'sector' must be 2352 byte wide containing 2048 bytes user data at * offset 16 */ void lec_encode_mode1_sector(u_int32_t adr, u_int8_t *sector); /* Encodes a MODE 2 sector. * 'adr' is the current physical sector address * 'sector' must be 2352 byte wide containing 2336 bytes user data at * offset 16 */ void lec_encode_mode2_sector(u_int32_t adr, u_int8_t *sector); /* Encodes a XA form 1 sector. * 'adr' is the current physical sector address * 'sector' must be 2352 byte wide containing 2048+8 bytes user data at * offset 16 */ void lec_encode_mode2_form1_sector(u_int32_t adr, u_int8_t *sector); /* Encodes a XA form 2 sector. * 'adr' is the current physical sector address * 'sector' must be 2352 byte wide containing 2324+8 bytes user data at * offset 16 */ void lec_encode_mode2_form2_sector(u_int32_t adr, u_int8_t *sector); /* Scrambles and byte swaps an encoded sector. * 'sector' must be 2352 byte wide. */ void lec_scramble(u_int8_t *sector); #endif mednafen/okiadpcm.cpp000664 001750 001750 00000002715 12726204343 015762 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "mednafen.h" #include "okiadpcm.h" #include const int OKIADPCM_StepSizes[49] = { // These can also be generated like: // double start = 16; // for(int x = 0; x < 49; x++) // { // printf("%d, ", (int)start); // start *= 1.1; // } 16, 17, 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282, 1411, 1552, }; const int OKIADPCM_StepIndexDeltas[16] = { -1, -1, -1, -1, 2, 4, 6, 8, -1, -1, -1, -1, 2, 4, 6, 8 }; const int32 OKIADPCM_DeltaTable[49][16] = { #ifndef OKIADPCM_GENERATE_DELTATABLE #include "okiadpcm-deltatable.h" #endif }; msvc/msvc-2003-xbox1.sln000664 001750 001750 00000002716 12726204343 015772 0ustar00sergiosergio000000 000000 Microsoft Visual Studio Solution File, Format Version 8.00 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "msvc-2003-xbox1", "msvc-2003-xbox1/msvc-2003-xbox1.vcproj", "{8FD514E6-2E2A-4599-99B1-9A413535492F}" ProjectSection(ProjectDependencies) = postProject EndProjectSection EndProject Global GlobalSection(SolutionConfiguration) = preSolution Debug = Debug Profile = Profile Profile_FastCap = Profile_FastCap Release = Release Release_LTCG = Release_LTCG EndGlobalSection GlobalSection(ProjectConfiguration) = postSolution {8FD514E6-2E2A-4599-99B1-9A413535492F}.Debug.ActiveCfg = Debug|Xbox {8FD514E6-2E2A-4599-99B1-9A413535492F}.Debug.Build.0 = Debug|Xbox {8FD514E6-2E2A-4599-99B1-9A413535492F}.Profile.ActiveCfg = Profile|Xbox {8FD514E6-2E2A-4599-99B1-9A413535492F}.Profile.Build.0 = Profile|Xbox {8FD514E6-2E2A-4599-99B1-9A413535492F}.Profile_FastCap.ActiveCfg = Profile_FastCap|Xbox {8FD514E6-2E2A-4599-99B1-9A413535492F}.Profile_FastCap.Build.0 = Profile_FastCap|Xbox {8FD514E6-2E2A-4599-99B1-9A413535492F}.Release.ActiveCfg = Release|Xbox {8FD514E6-2E2A-4599-99B1-9A413535492F}.Release.Build.0 = Release|Xbox {8FD514E6-2E2A-4599-99B1-9A413535492F}.Release_LTCG.ActiveCfg = Release_LTCG|Xbox {8FD514E6-2E2A-4599-99B1-9A413535492F}.Release_LTCG.Build.0 = Release_LTCG|Xbox EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution EndGlobalSection GlobalSection(ExtensibilityAddIns) = postSolution EndGlobalSection EndGlobal mednafen/tremor/ivorbisfile_example.c000664 001750 001750 00000005770 12726204343 021177 0ustar00sergiosergio000000 000000 /******************************************************************** * * * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. * * * * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS * * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE * * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. * * * * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 * * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ * * * ******************************************************************** function: simple example decoder using vorbisidec ********************************************************************/ /* Takes a vorbis bitstream from stdin and writes raw stereo PCM to stdout using vorbisfile. Using vorbisfile is much simpler than dealing with libvorbis. */ #include #include #include "ivorbiscodec.h" #include "ivorbisfile.h" #ifdef _WIN32 /* We need the following two to set stdin/stdout to binary */ #include #include #endif char pcmout[4096]; /* take 4k out of the data segment, not the stack */ int main(){ OggVorbis_File vf; int eof=0; int current_section; #ifdef _WIN32 /* We need to set stdin/stdout to binary mode. Damn windows. */ /* Beware the evil ifdef. We avoid these where we can, but this one we cannot. Don't add any more, you'll probably go to hell if you do. */ _setmode( _fileno( stdin ), _O_BINARY ); _setmode( _fileno( stdout ), _O_BINARY ); #endif if(ov_open(stdin, &vf, NULL, 0) < 0) { fprintf(stderr,"Input does not appear to be an Ogg bitstream.\n"); exit(1); } /* Throw the comments plus a few lines about the bitstream we're decoding */ { char **ptr=ov_comment(&vf,-1)->user_comments; vorbis_info *vi=ov_info(&vf,-1); while(*ptr){ fprintf(stderr,"%s\n",*ptr); ++ptr; } fprintf(stderr,"\nBitstream is %d channel, %ldHz\n",vi->channels,vi->rate); fprintf(stderr,"\nDecoded length: %ld samples\n", (long)ov_pcm_total(&vf,-1)); fprintf(stderr,"Encoded by: %s\n\n",ov_comment(&vf,-1)->vendor); } while(!eof){ long ret=ov_read(&vf,pcmout,sizeof(pcmout),¤t_section); if (ret == 0) { /* EOF */ eof=1; } else if (ret < 0) { if(ret==OV_EBADLINK){ fprintf(stderr,"Corrupt bitstream section! Exiting.\n"); exit(1); } /* some other error in the stream. Not a problem, just reporting it in case we (the app) cares. In this case, we don't. */ } else { /* we don't bother dealing with sample rate changes, etc, but you'll have to*/ fwrite(pcmout,1,ret,stdout); } } /* cleanup */ ov_clear(&vf); fprintf(stderr,"Done.\n"); return(0); } mednafen/msvc_compat.h000664 001750 001750 00000003465 12726204343 016156 0ustar00sergiosergio000000 000000 /* RetroArch - A frontend for libretro. * Copyright (C) 2010-2012 - Hans-Kristian Arntzen * * RetroArch 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 Found- * ation, either version 3 of the License, or (at your option) any later version. * * RetroArch 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 RetroArch. * If not, see . */ #ifndef __RARCH_MSVC_COMPAT_H #define __RARCH_MSVC_COMPAT_H #ifdef _MSC_VER #undef UNICODE // Do not bother with UNICODE at this time. #include #include #include // Python headers defines ssize_t and sets HAVE_SSIZE_T. Cannot duplicate these efforts. #ifndef HAVE_SSIZE_T #if defined(_WIN64) typedef __int64 ssize_t; #elif defined(_WIN32) typedef int ssize_t; #endif #endif #define snprintf _snprintf #define strtoll _strtoi64 #define strtoull _strtoui64 #define strcasecmp _stricmp #define strncasecmp _strnicmp #define strdup _strdup #define lseek _lseek #include #define strlen _tcslen # define S_IRUSR S_IREAD /* read, user */ # define S_IWUSR S_IWRITE /* write, user */ // Disable some of the annoying warnings. #pragma warning(disable : 4800) #pragma warning(disable : 4244) #pragma warning(disable : 4305) #pragma warning(disable : 4146) #pragma warning(disable : 4267) #define roundf(in) (in >= 0.0f ? floorf(in + 0.5f) : ceilf(in - 0.5f)) #ifndef PATH_MAX #define PATH_MAX MAX_PATH #endif #endif #endif libretro-common/include/queues/task_queue.h000664 001750 001750 00000010536 12726204343 022273 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (task_queue.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __LIBRETRO_SDK_TASK_QUEUE_H__ #define __LIBRETRO_SDK_TASK_QUEUE_H__ #include #include #ifdef __cplusplus extern "C" { #endif enum task_queue_ctl_state { TASK_QUEUE_CTL_NONE = 0, /* Deinitializes the task system. * This deinitializes the task system. * The tasks that are running at * the moment will stay on hold * until TASK_QUEUE_CTL_INIT is called again. */ TASK_QUEUE_CTL_DEINIT, /* Initializes the task system. * This initializes the task system * and chooses an appropriate * implementation according to the settings. * * This must only be called from the main thread. */ TASK_QUEUE_CTL_INIT, /** * Calls func for every running task * until it returns true. * Returns a task or NULL if not found. */ TASK_QUEUE_CTL_FIND, /* Blocks until all tasks have finished. * This must only be called from the main thread. */ TASK_QUEUE_CTL_WAIT, /* Checks for finished tasks * Takes the finished tasks, if any, * and runs their callbacks. * This must only be called from the main thread. */ TASK_QUEUE_CTL_CHECK, /* Pushes a task * The task will start as soon as possible. */ TASK_QUEUE_CTL_PUSH, /* Sends a signal to terminate all the tasks. * * This won't terminate the tasks immediately. * They will finish as soon as possible. * * This must only be called from the main thread. */ TASK_QUEUE_CTL_RESET, TASK_QUEUE_CTL_SET_THREADED, TASK_QUEUE_CTL_UNSET_THREADED, TASK_QUEUE_CTL_IS_THREADED }; typedef struct retro_task retro_task_t; typedef void (*retro_task_callback_t)(void *task_data, void *user_data, const char *error); typedef void (*retro_task_handler_t)(retro_task_t *task); typedef bool (*retro_task_finder_t)(retro_task_t *task, void *userdata); typedef struct { char *source_file; } decompress_task_data_t; struct retro_task { retro_task_handler_t handler; /* always called from the main loop */ retro_task_callback_t callback; /* set to true by the handler to signal * the task has finished executing. */ bool finished; /* set to true by the task system * to signal the task *must* end. */ bool cancelled; /* created by the handler, destroyed by the user */ void *task_data; /* owned by the user */ void *user_data; /* created and destroyed by the code related to the handler */ void *state; /* created by task handler; destroyed by main loop * (after calling the callback) */ char *error; /* -1 = unmettered, 0-100 progress value */ int8_t progress; /* handler can modify but will be * free()d automatically if non-NULL. */ char *title; /* don't touch this. */ retro_task_t *next; }; typedef struct task_finder_data { retro_task_finder_t func; void *userdata; } task_finder_data_t; void task_queue_push_progress(retro_task_t *task); bool task_queue_ctl(enum task_queue_ctl_state state, void *data); #ifdef __cplusplus } #endif #endif mednafen/cdrom/audioreader_opus.cpp000664 001750 001750 00000011221 12726204343 020621 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "../mednafen.h" #include "audioreader.h" #include "audioreader_opus.h" // OPUS SUPPORT NOT DONE YET!!! /* (int64)op_pcm_total() * 44100 / 48000 resampling vs seek, filter delay, etc. to consider */ static size_t iop_read_func(void *ptr, size_t size, size_t nmemb, void *user_data) { Stream *fw = (Stream*)user_data; if(!size) return(0); try { return fw->read(ptr, size * nmemb, false) / size; } catch(...) { return(0); } } static int iop_seek_func(void *user_data, opus_int64 offset, int whence) { Stream *fw = (Stream*)user_data; try { fw->seek(offset, whence); return(0); } catch(...) { return(-1); } } static int iop_close_func(void *user_data) { Stream *fw = (Stream*)user_data; try { fw->close(); return(0); } catch(...) { return EOF; } } static opus_int64 iop_tell_func(void *user_data) { Stream *fw = (Stream*)user_data; try { return fw->tell(); } catch(...) { return(-1); } } /* Error strings copied from libopusfile header file comments. */ static const char *op_errstring(int error) { static const struct { int code; const char *str; } error_table[] = { { OP_EREAD, gettext_noop("OP_EREAD: An underlying read, seek, or tell operation failed when it should have succeeded.") }, { OP_EFAULT, gettext_noop("OP_EFAULT: A NULL pointer was passed where one was unexpected, or an internal memory allocation failed, or an internal library error was encountered.") }, { OP_EIMPL, gettext_noop("OP_EIMPL: The stream used a feature that is not implemented, such as an unsupported channel family.") }, { OP_EINVAL, gettext_noop("OP_EINVAL: One or more parameters to a function were invalid.") }, { OP_ENOTFORMAT, gettext_noop("OP_ENOTFORMAT: A purported Ogg Opus stream did not begin with an Ogg page, or a purported header packet did not start with one of the required strings, \"OpusHead\" or \"OpusTags\".") }, { OP_EBADHEADER, gettext_noop("OP_EBADHEADER: A required header packet was not properly formatted, contained illegal values, or was missing altogether.") }, { OP_EVERSION, gettext_noop("OP_EVERSION: The ID header contained an unrecognized version number.") }, { OP_EBADPACKET, gettext_noop("OP_EBADPACKET: An audio packet failed to decode properly.") }, { OP_EBADLINK, gettext_noop("OP_EBADLINK: We failed to find data we had seen before, or the bitstream structure was sufficiently malformed that seeking to the target destination was impossible.") }, { OP_ENOSEEK, gettext_noop("OP_ENOSEEK: An operation that requires seeking was requested on an unseekable stream.") }, { OP_EBADTIMESTAMP, gettext_noop("OP_EBADTIMESTAMP: The first or last granule position of a link failed basic validity checks.") }, }; for(unsigned i = 0; i < sizeof(error_table) / sizeof(error_table[0]); i++) { if(error_table[i].code == error) { return _(error_table[i].str); } } return _("Unknown"); } OggOpusReader::OggOpusReader(Stream *fp) : fw(fp) { OpusFileCallbacks cb; int error = 0; memset(&cb, 0, sizeof(cb)); cb.read_func = iop_read_func; cb.seek_func = iop_seek_func; cb.close_func = iop_close_func; cb.tell_func = iop_tell_func; fp->seek(0, SEEK_SET); if(!(opfile = op_open_callbacks((void*)fp, &cb, NULL, 0, &error))) { switch(error) { default: throw MDFN_Error(0, _("opusfile: error code: %d(%s)", error, op_errstring(error))); break; case OP_ENOTFORMAT: throw(0); break; } } } OggOpusReader::~OggOpusReader() { op_free(opfile); } int64 OggOpusReader::Read_(int16 *buffer, int64 frames) { int16 *tr_buffer = buffer; int64 tr_count = frames * 2; while(tr_count > 0) { int64 didread = op_read(opfile, tr_buffer, tr_count, NULL); if(didread == 0) break; tr_buffer += didread * 2; tr_count -= didread * 2; } return(frames - (tr_count / 2)); } bool OggOpusReader::Seek_(int64 frame_offset) { op_pcm_seek(opfile, frame_offset); return(true); } int64 OggOpusReader::FrameCount(void) { return(op_pcm_total(pvfile, -1)); } mednafen/mempatcher.h000664 001750 001750 00000001077 12726204343 015765 0ustar00sergiosergio000000 000000 #ifndef __MDFN_MEMPATCHER_H #define __MDFN_MEMPATCHER_H #include "mempatcher-driver.h" #include typedef struct __SUBCHEAT { uint32 addr; uint8 value; int compare; // < 0 on no compare } SUBCHEAT; extern std::vector SubCheats[8]; extern bool SubCheatsOn; bool MDFNMP_Init(uint32 ps, uint32 numpages); void MDFNMP_AddRAM(uint32 size, uint32 address, uint8 *RAM); void MDFNMP_Kill(void); void MDFNMP_InstallReadPatches(void); void MDFNMP_RemoveReadPatches(void); void MDFNMP_ApplyPeriodicCheats(void); extern MDFNSetting MDFNMP_Settings[]; #endif mednafen/hw_misc/arcade_card/arcade_card.h000664 001750 001750 00000002131 12726204343 021701 0ustar00sergiosergio000000 000000 #ifndef __MDFN_PCE_ARCADE_CARD_H #define __MDFN_PCE_ARCADE_CARD_H typedef struct { uint32 base; // 24 bits uint16 offset; // 16 bits uint16 increment; // 16 bits uint8 control; // 7 bits } ACPort_t; typedef struct { ACPort_t ports[4]; uint32 shift_latch; // 32 bits uint8 shift_bits; // signed 4-bit value uint8 rotate_bits; // same } ArcadeCard_t; class ArcadeCard { public: ArcadeCard(void); ~ArcadeCard(); void Power(void); int StateAction(StateMem *sm, int load, int data_only); uint8 Read(uint32 A, bool peek = false); // Pass peek as true if you don't want side-effects from this read(IE in a debugger). void Write(uint32 A, uint8 V); INLINE void PhysWrite(uint32 A, uint8 V) { Write(0x1a00 | ((A >> 9) & 0x30), V); } INLINE uint8 PhysRead(uint32 A, bool peek = false) { return(Read(0x1a00 | ((A >> 9) & 0x30), peek)); } void PeekRAM(uint32 Address, uint32 Length, uint8 *Buffer); void PokeRAM(uint32 Address, uint32 Length, const uint8 *Buffer); private: ArcadeCard_t AC; bool ACRAMUsed; uint8 ACRAM[0x200000]; }; #endif mednafen/file.cpp000664 001750 001750 00000007160 12726204343 015111 0ustar00sergiosergio000000 000000 /* Mednafen - Multi-system Emulator * * 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 "mednafen.h" #include #include #include #include "file.h" #include "general.h" bool MDFNFILE::ApplyIPS(void *unused) { (void)unused; return 1; } // This function should ALWAYS close the system file "descriptor"(gzip library, zip library, or FILE *) it's given, // even if it errors out. bool MDFNFILE::MakeMemWrapAndClose(void *fp) { bool ret = FALSE; location = 0; ::fseek((FILE *)fp, 0, SEEK_END); f_size = ::ftell((FILE *)fp); ::fseek((FILE *)fp, 0, SEEK_SET); if (!(f_data = (uint8*)malloc(f_size))) goto fail; ::fread(f_data, 1, f_size, (FILE *)fp); ret = TRUE; fail: fclose((FILE*)fp); return ret; } MDFNFILE::MDFNFILE() { f_data = NULL; f_size = 0; f_ext = NULL; location = 0; } MDFNFILE::MDFNFILE(const char *path, const void *known_ext, const char *purpose) { (void)known_ext; if (!Open(path, known_ext, purpose, false)) throw(MDFN_Error(0, "TODO ERROR")); } MDFNFILE::~MDFNFILE() { Close(); } bool MDFNFILE::Open(const char *path, const void *known_ext, const char *purpose, const bool suppress_notfound_pe) { FILE *fp; (void)known_ext; if (!(fp = fopen(path, "rb"))) return FALSE; ::fseek(fp, 0, SEEK_SET); if (!MakeMemWrapAndClose(fp)) return FALSE; const char *ld = (const char*)strrchr(path, '.'); f_ext = strdup(ld ? ld + 1 : ""); return(TRUE); } bool MDFNFILE::Close(void) { if (f_ext) free(f_ext); f_ext = 0; if (f_data) free(f_data); f_data = 0; return(1); } uint64 MDFNFILE::fread(void *ptr, size_t element_size, size_t nmemb) { int64 avail = f_size - location; if (nmemb > avail) nmemb = avail; memcpy((uint8*)ptr, f_data + location, nmemb); location += nmemb; return nmemb; } int MDFNFILE::fseek(int64 offset, int whence) { size_t ptr; switch(whence) { case SEEK_SET: ptr = offset; break; case SEEK_CUR: ptr = location + offset; break; case SEEK_END: ptr = f_size + offset; break; } if (ptr <= f_size) { location = ptr; return 0; } return -1; } int MDFNFILE::read16le(uint16 *val) { if ((location + 2) > f_size) return 0; *val = MDFN_de16lsb(f_data + location); location += 2; return 1; } int MDFNFILE::read32le(uint32 *val) { if ((location + 4) > f_size) return 0; *val = MDFN_de32lsb(f_data + location); location += 4; return 1; } char *MDFNFILE::fgets(char *s, int buffer_size) { int pos = 0; if (!buffer_size) return(NULL); if (location >= buffer_size) return(NULL); while(pos < (buffer_size - 1) && location < buffer_size) { int v = f_data[location]; s[pos] = v; location++; pos++; if (v == '\n') break; } if (buffer_size) s[pos] = 0; return s; } mednafen/file.h000664 001750 001750 00000002320 12726204343 014547 0ustar00sergiosergio000000 000000 #ifndef MDFN_FILE_H #define MDFN_FILE_H #include #define MDFNFILE_EC_NOTFOUND 1 #define MDFNFILE_EC_OTHER 2 class MDFNFILE { public: MDFNFILE(); // WIP constructors: MDFNFILE(const char *path, const void *known_ext, const char *purpose = NULL); ~MDFNFILE(); bool Open(const char *path, const void *known_ext, const char *purpose = NULL, const bool suppress_notfound_pe = FALSE); INLINE bool Open(const std::string &path, const void *known_ext, const char *purpose = NULL, const bool suppress_notfound_pe = FALSE) { return(Open(path.c_str(), known_ext, purpose, suppress_notfound_pe)); } bool ApplyIPS(void*); bool Close(void); uint64 fread(void *ptr, size_t size, size_t nmemb); int fseek(int64 offset, int whence); inline uint64 ftell(void) { return(location); } inline void rewind(void) { location = 0; } int read32le(uint32 *Bufo); int read16le(uint16 *Bufo); inline int _fgetc(void) { if(location < f_size) return f_data[location++]; return EOF; } inline int fisarchive(void) { return(0); } char *fgets(char *s, int size); uint8 *f_data; int64 f_size; char *f_ext; private: int64 location; bool MakeMemWrapAndClose(void *tz); }; #endif msvc/msvc-2003-xbox1/msvc-2003-xbox1.vcproj000664 001750 001750 00000033653 12726204343 021076 0ustar00sergiosergio000000 000000 libretro-common/include/retro_miscellaneous.h000664 001750 001750 00000012605 12726204343 022673 0ustar00sergiosergio000000 000000 /* Copyright (C) 2010-2016 The RetroArch team * * --------------------------------------------------------------------------------------- * The following license statement only applies to this file (retro_miscellaneous.h). * --------------------------------------------------------------------------------------- * * Permission is hereby granted, free of charge, * to any person obtaining a copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation the rights to * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ #ifndef __RARCH_MISCELLANEOUS_H #define __RARCH_MISCELLANEOUS_H #include #include #if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__) #include #elif defined(XENON) #include