Skip to content

Instantly share code, notes, and snippets.

@bakueikozo

bakueikozo/Makefile

Last active June 16, 2024 11:28
Show Gist options
  • Save bakueikozo/04089543983ffc9b9d99c04067e73647 to your computer and use it in GitHub Desktop.
Save bakueikozo/04089543983ffc9b9d99c04067e73647 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
dam util functions
#define _GNU_SOURCE
#include <dlfcn.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
typedef struct _RECORD_NUMBER {
char *name;
int value;
} REC_INDEX;
const REC_INDEX recindex[] = {
{"HardwareVersion",1},
{"SoftwareVersion",2},
{"HDD1Name",3},
{"HDD2Name",4},
{"HDD3Name",5},
{"HDD4Name",6},
{"HDD1Free",7},
{"HDD2Free",8},
{"HDD3Free",9},
{"HDD4Free",10},
{"HDDTotalFree",11},
{"SystemID",12},
{"SerialNumber",13},
{"ShopType",17},
{"CommLineKind",19},
{"RegionCode",21},
{"BackGroundColor",23},
{"DemoBGMMode",25},
{"DemoBGMType",27},
{"TerminalNumber",48},
{"SystemSubID",55},
{"RequestView",62},
{"RequestListView",64},
{"CostKaraoke",80},
{"CostScore",83},
{"CalorieKaraoke",154},
{"SpeakerVolume",411},
{"TrainingMinute",429},
{"BGMVolume",434},
{"StopType",460},
{"VolumeControl",461},
{"JacketView",464},
{"SubOutput",465},
{"BGVSelectInCM",467},
{"BGVSelectInOff",468},
{"BGVSelectInBGV",469},
{"SongNameMask",471},
{"CMAdultType",473},
{"SystemSAS",476},
{"BGVSelectInPlay",479},
{"FLmsgInCM",480},
{"FLmsgInKaraoke",481},
{"SEsound",484},
{"OriginalKeyDisplay",487},
{"MessageFrom",489},
{"SoftAdultType",496},
{"EndingGame",497},
{"AutoPowerOn",498},
{"KashoKentelRecordCount",513},
{"KashoKentelPlayCount",514},
{"AuditionRecordCount",515},
{"AuditionPlayCount",516},
{"RecoKaraRecordCount",517},
{"RecoKaraPlayCount",518},
{"BurningRecordCount",519},
{"BurningPlayCount",520},
{"PayMode",609},
{"PromoVolume",615},
{"EnvmVolume",616},
{"IrregulerFlag",618},
{"AutoSetBGMTime",700},
{"AuditionMode",701},
{"ScoreGameTimeout",718},
{"ShopRanking",800},
{"FLmsgSetup",801},
{"AutoBackupWeek",802},
{"AutoBackupTime",803},
{"EnvSetMode",804},
{"StartTimeOfUpdate",805},
{"EndTimeOfUpdate",806},
{"ActiveTimeLock",807},
{"DetailScore",808},
{"Bingo",809},
{"Slot",810},
{"EgyptHoroscope",811},
{"bKawiBawiBo",812},
{"LocalIdStart",900},
{"LocalIdEnd",999},
{"SPhoneNumber",1000},
{"CallBackTimeOver",1002},
{"LineClass",1005},
{"SIDNumber",1006},
{"SendOutLevel",1007},
{"OutLineCallSetting",1009},
{"OutLineCallNumber",1010},
{"DialSpeed",1011},
{"LineAutoDetect",1012},
{"MultiDial",1015},
{"CommStartTime",1016},
{"CommEndTime",1017},
{"WantSongRequest",1018},
{"WantSongStartTime",1019},
{"WantSongEndTime",1020},
{"WantSongPhoneNumber",1021},
{"RequestIdentityNumber",1022},
{"WantSongIDNumber",1022},
{"IPAddress",1030},
{"BBServiceIndex",1033},
{"BBIdNumber",1034},
{"ScoreFlagStart",1100},
{"ScoreFlagEnd",1299},
{"QuichMenuStart",1400},
{"QuichMenuEnd",1499},
{"NTSC",1502},
{"ScoreBn",1503},
{"ScoreAudition",1504},
{"DportOutput",1506},
{"AutoSetBoth",1507},
{"AutoSetBGV",1508},
{"AutoSetBGMFlow",1509},
{"HDDConnectInfo",2133},
{"DAM_COMM_VERSION",3001},
{"FrontOn",3900},
{"END",-1 }
};
char recindextmp[24];
char *GetRecIndex(int n){
REC_INDEX *p=recindex;
while(p->value!=-1){
if( p->value == n ) return p->name;
p++;
}
sprintf(recindextmp,"%d(undefined)",n);
return recindextmp;
}
// �\���̒�`
struct GMInstrument {
int number; // ���F�ԍ�
char name[32]; // ���S�ȉ��F��
char short_name[9]; // �Z�k���ꂽ���F��
};
void psqDisplayChannelVolume(int param_1);
// GM�W���̉��F�z��
struct GMInstrument gm_instruments[] = {
{0, "Acoustic Grand Piano", "Ac.G.Pia"},
{1, "Bright Acoustic Piano", "Br.A.Pia"},
{2, "Electric Grand Piano", "El.G.Pia"},
{3, "Honky-tonk Piano", "Ho.Piano"},
{4, "Electric Piano 1", "El.Pia1"},
{5, "Electric Piano 2", "El.Pia2"},
{6, "Harpsichord", "Harpsi"},
{7, "Clavinet", "Clavine"},
{8, "Celesta", "Celesta"},
{9, "Glockenspiel", "Glocken"},
{10, "Music Box", "Mus.Box"},
{11, "Vibraphone", "Vibraph"},
{12, "Marimba", "Marimba"},
{13, "Xylophone", "Xylopho"},
{14, "Tubular Bells", "Tub.Bel"},
{15, "Dulcimer", "Dulcime"},
{16, "Drawbar Organ", "Dr.Orga"},
{17, "Percussive Organ", "Pe.Orga"},
{18, "Rock Organ", "Roc.Org"},
{19, "Church Organ", "Chu.Org"},
{20, "Reed Organ", "Ree.Org"},
{21, "Accordion", "Accordn"},
{22, "Harmonica", "Harmoni"},
{23, "Tango Accordion", "T.Accor"},
{24, "Acoustic Guitar (nylon)", "A.G.Nyl"},
{25, "Acoustic Guitar (steel)", "A.G.Ste"},
{26, "Electric Guitar (jazz)", "E.G.Jaz"},
{27, "Electric Guitar (clean)", "E.G.Cle"},
{28, "Electric Guitar (muted)", "E.G.Mut"},
{29, "Overdriven Guitar", "Ov.Guit"},
{30, "Distortion Guitar", "Dist.Gu"},
{31, "Guitar harmonics", "G.Harmo"},
{32, "Acoustic Bass", "A.Bass"},
{33, "Electric Bass (finger)", "E.B.Fin"},
{34, "Electric Bass (pick)", "E.B.Pic"},
{35, "Fretless Bass", "Fret.Bas"},
{36, "Slap Bass 1", "SlapB1"},
{37, "Slap Bass 2", "SlapB2"},
{38, "Synth Bass 1", "SynBass1"},
{39, "Synth Bass 2", "SynBass2"},
{40, "Violin", "Violin"},
{41, "Viola", "Viola"},
{42, "Cello", "Cello"},
{43, "Contrabass", "Contrab"},
{44, "Tremolo Strings", "Trem.St"},
{45, "Pizzicato Strings", "Piz.Str"},
{46, "Orchestral Harp", "Or.Harp"},
{47, "Timpani", "Timpani"},
{48, "String Ensemble 1", "StrEns1"},
{49, "String Ensemble 2", "StrEns2"},
{50, "SynthStrings 1", "SynStr1"},
{51, "SynthStrings 2", "SynStr2"},
{52, "Choir Aahs", "ChoirAhs"},
{53, "Voice Oohs", "VoiceOh"},
{54, "Synth Voice", "SynthVo"},
{55, "Orchestra Hit", "Or.HIt"},
{56, "Trumpet", "Trumpet"},
{57, "Trombone", "Trombon"},
{58, "Tuba", "Tuba"},
{59, "Muted Trumpet", "M.Trump"},
{60, "French Horn", "Fr.Horn"},
{61, "Brass Section", "BrasSec"},
{62, "SynthBrass 1", "Sy.Br1"},
{63, "SynthBrass 2", "Sy.Br2"},
{64, "Soprano Sax", "SoprSax"},
{65, "Alto Sax", "AltoSax"},
{66, "Tenor Sax", "TenorSx"},
{67, "Baritone Sax", "BaritSx"},
{68, "Oboe", "Oboe"},
{69, "English Horn", "Eng.Hrn"},
{70, "Bassoon", "Bassoon"},
{71, "Clarinet", "Clarinet"},
{72, "Piccolo", "Piccolo"},
{73, "Flute", "Flute"},
{74, "Recorder", "Recorder"},
{75, "Pan Flute", "PanFlut"},
{76, "Blown Bottle", "BlowBot"},
{77, "Shakuhachi", "Shakuha"},
{78, "Whistle", "Whistle"},
{79, "Ocarina", "Ocarina"},
{80, "Lead 1 (square)", "Lead1Sq"},
{81, "Lead 2 (sawtooth)", "Lead2St"},
{82, "Lead 3 (calliope)", "Lead3Ca"},
{83, "Lead 4 (chiff)", "Lead4Ch"},
{84, "Lead 5 (charang)", "Lead5Ch"},
{85, "Lead 6 (voice)", "Lead6Vo"},
{86, "Lead 7 (fifths)", "Lead7Fi"},
{87, "Lead 8 (bass + lead)", "Lead8BL"},
{88, "Pad 1 (new age)", "Pad1NwA"},
{89, "Pad 2 (warm)", "Pad2Warm"},
{90, "Pad 3 (polysynth)", "Pad3Poly"},
{91, "Pad 4 (choir)", "Pad4Choi"},
{92, "Pad 5 (bowed)", "Pad5Bow"},
{93, "Pad 6 (metallic)", "Pad6Met"},
{94, "Pad 7 (halo)", "Pad7Halo"},
{95, "Pad 8 (sweep)", "Pad8Swp"},
{96, "FX 1 (rain)", "FX1Rain"},
{97, "FX 2 (soundtrack)", "FX2Sndt"},
{98, "FX 3 (crystal)", "FX3Cryt"},
{99, "FX 4 (atmosphere)", "FX4Atmo"},
{100, "FX 5 (brightness)", "FX5Brig"},
{101, "FX 6 (goblins)", "FX6Gbln"},
{102, "FX 7 (echoes)", "FX7Echos"},
{103, "FX 8 (sci-fi)", "FX8SciFi"},
{104, "Sitar", "Sitar"},
{105, "Banjo", "Banjo"},
{106, "Shamisen", "Shamise"},
{107, "Koto", "Koto"},
{108, "Kalimba", "Kalimba"},
{109, "Bag pipe", "Bagpipe"},
{110, "Fiddle", "Fiddle"},
{111, "Shanai", "Shanai"},
{112, "Tinkle Bell", "Tnk.Bel"},
{113, "Agogo", "Agogo"},
{114, "Steel Drums", "Stl.Drm"},
{115, "Woodblock", "WoodBlk"},
{116, "Taiko Drum", "TaikoDr"},
{117, "Melodic Tom", "Mel.Tom"},
{118, "Synth Drum", "Syn.Drm"},
{119, "Reverse Cymbal", "Rev.Cym"},
{120, "Guitar Fret Noise", "Gt.Fret"},
{121, "Breath Noise", "BreathN"},
{122, "Seashore", "Seashre"},
{123, "Bird Tweet", "BirdTw"},
{124, "Telephone Ring", "Tel.Rng"},
{125, "Helicopter", "Heli"},
{126, "Applause", "Applause"},
{127, "Gunshot", "Gunshot"}
};
#define MAX_NOTES 11 // �a���Ɋ܂܂��ő剹����
// �a���̃R�[�h���A�\�����̐��A����э������O�Ƃ������ΓI�ȉ����̔z������\����
struct Chord {
char chord_name[6]; // �a���̃R�[�h���i������A5�����܂Łj
int num_notes; // �\�����̐�
char intervals[MAX_NOTES]; // �������O�Ƃ������ΓI�ȉ������i�[����z��
};
// �a���̃R�[�h���ƁA���ΓI�ȉ��������ꂼ��̍\���̂Ɋi�[����
struct Chord chords[] = {
{"Major", 3, {0, 4, 7}}, // ���W���[�R�[�h
{"Minor", 3, {0, 3, 7}}, // �}�C�i�[�R�[�h
{"Aug", 3, {0, 4, 8}}, // �I�[�M�������g�R�[�h
{"Dim", 3, {0, 3, 6}}, // �f�B�~�j�b�V���R�[�h
{"Maj7", 4, {0, 4, 7, 11}}, // ���W���[�Z�u���X�R�[�h
{"Min7", 4, {0, 3, 7, 10}}, // �}�C�i�[�Z�u���X�R�[�h
{"Dom7", 4, {0, 4, 7, 10}}, // �h�~�i���g�Z�u���X�R�[�h
{"Sus4", 3, {0, 5, 7}}, // �T�X�t�H�[���R�[�h
{"Add9", 4, {0, 4, 7, 14}}, // �A�h�i�C���X�R�[�h
{"Maj6", 4, {0, 4, 7, 9}}, // ���W���[�V�b�N�X�X�R�[�h
{"Min6", 4, {0, 3, 7, 9}}, // �}�C�i�[�V�b�N�X�X�R�[�h
{"Sus2", 3, {0, 2, 7}}, // �T�X�c�[�R�[�h
{"Minmaj7", 4, {0, 3, 7, 11}}, // �}�C�i�[���W���[�Z�u���X�R�[�h
{"6", 4, {0, 4, 7, 9}}, // �V�b�N�X�R�[�h
{"7sus4", 4, {0, 5, 7, 10}}, // �Z�u���T�X�t�H�[���R�[�h
{"7b5", 4, {0, 4, 6, 10}}, // �Z�u���t���b�g�t�@�C�u�X�R�[�h
{"7#5", 4, {0, 4, 8, 10}}, // �Z�u���V���[�v�t�@�C�u�X�R�[�h
{"6/9", 5, {0, 4, 7, 9, 14}}, // �V�b�N�X�I�[�i�C���X�R�[�h
{"m/Maj7", 4, {0, 3, 7, 11}}, // �}�C�i�[���W���[�Z�u���X�R�[�h
{"m6", 4, {0, 3, 7, 9}}, // �}�C�i�[�V�b�N�X�R�[�h
{"m7", 4, {0, 3, 7, 10}}, // �}�C�i�[�Z�u���X�R�[�h
{"m7b5", 4, {0, 3, 6, 10}}, // �}�C�i�[�Z�u���t���b�g�t�@�C�u�X�R�[�h
{"mMaj7", 4, {0, 3, 7, 11}}, // �}�C�i�[���W���[�Z�u���X�R�[�h
{"maj7#5", 4, {0, 4, 8, 11}}, // ���W���[�Z�u���V���[�v�t�@�C�u�X�R�[�h
{"maj7b5", 4, {0, 4, 6, 11}}, // ���W���[�Z�u���t���b�g�t�@�C�u�X�R�[�h
{"maj7sus2", 5, {0, 2, 4, 7, 11}}, // ���W���[�Z�u���T�X�c�[�R�[�h
{"maj7sus4", 4, {0, 5, 7, 11}}, // ���W���[�Z�u���T�X�t�H�[���R�[�h
{"aug7", 4, {0, 4, 8, 10}}, // �I�[�M�������g�Z�u���X�R�[�h
{"dim7", 4, {0, 3, 6, 9}}, // �f�B�~�j�b�V���Z�u���X�R�[�h
{"",0,{}}
};
int remap(int p){
int targetch = 0;
if( p >= 80 ){
// Synth
targetch=8;
}else if( p >= 55 ){
// brass
targetch=7;
}else if( p >= 52 ){
// cho
targetch=6;
}else if(p >= 40 ){
// strings
targetch=5;
}else if( p>= 32){
// base
targetch=4;
}else if( p >= 24 ){
// gt,org
targetch=3;
}else if( p >= 6 ){
// bell
targetch= 2;
}else {
// piano
targetch= 1;
}
return targetch;
}
#define max(a,b) ((a)>(b)?(a):(b))
typedef unsigned char undefined;
typedef unsigned char bool;
typedef unsigned char byte;
typedef unsigned int dword;
typedef long long longlong;
typedef unsigned long long qword;
typedef int sdword;
typedef long long sqword;
typedef unsigned char uchar;
typedef unsigned int uint;
typedef unsigned long ulong;
typedef unsigned long long ulonglong;
typedef unsigned char undefined1;
typedef unsigned short undefined2;
typedef unsigned int undefined3;
typedef unsigned int undefined4;
typedef unsigned long long undefined6;
typedef unsigned long long undefined7;
typedef unsigned long long undefined8;
typedef unsigned short ushort;
typedef unsigned short word;
typedef uchar BYTE;
typedef uint DWORD;
typedef short SWORD;
typedef ushort WORD;
typedef struct tagCharData tagCharData, *PtagCharData;
typedef struct tagCharData * LPCHAR_DATA;
typedef struct tagScrollInfo tagScrollInfo, *PtagScrollInfo;
typedef struct tagScrollInfo * LPSCROLL_INFO;
struct tagLINE_TABLE {
BYTE bLineNumber;
BYTE bLyricChorusNumber;
BYTE bLineType;
BYTE bDisplayType;
BYTE bClearType;
DWORD dwInTime;
DWORD dwInDurationTime;
DWORD dwOutTime;
DWORD dwOutDurationTime;
SWORD wY;
WORD wHeight;
BYTE bNumberOfCharData;
BYTE reserved2;
SWORD wX;
WORD wWidth;
BYTE bBitmapType;
DWORD dwSizeOfBMP;
WORD wBitmapStartX;
WORD wBitmapStartY;
WORD wBitmapEndX;
WORD wBitmapEndY;
bool bBitMapData;
LPCHAR_DATA lpData;
LPSCROLL_INFO lpScrollInfo;
};
typedef struct tagLINE_TABLE tagLINE_TABLE, *PtagLINE_TABLE;
typedef struct tagLINE_TABLE LINE_TABLE;
struct tagScrollInfo {
DWORD dwNumberOfScorllLine;
DWORD dwPreScrollTime;
DWORD dwScrollTime;
DWORD dwPostScrollTime;
DWORD dwTotalPixelOfScroll;
};
struct tagCharData {
WORD wEUC;
BYTE bType;
BYTE bSizeCode;
BYTE bAttribute;
BYTE bRubiBlockNumber;
WORD wX;
WORD wY;
DWORD dwWipeStartTime;
BYTE WipeDeltaArray[24];
DWORD dwWipeEndTime;
};
typedef struct _toneinfo {
int tick;
int ch;
int pitch;
int length;
} toneinfo;
typedef unsigned short uint16_t;
typedef unsigned char uint8_t;
typedef struct _noteOnOffData {
unsigned int tickOn;
unsigned int tickOff;
char pitch;
char velocity;
} noteOnOff;
typedef struct _list {
noteOnOff *chList[16];
int counts[16];
} noteList;
typedef struct _chcounter{
int priority;
int ch;
int count;
int program;
int partmode;
} chcounter;
typedef struct _playingStatus {
int lastShowNum;
int lastHideNum;
int updatecount;
int keyMap[96*128];
int keyMap_Stop[96*128];
int lastTime;
noteList nl;
toneinfo *pTones;
int numoftones;
int tracknum;
chcounter ncount_ch[64];
int pitch_min;
int pitch_max;
} playingStatus;
playingStatus play_status;
typedef struct _noteevent {
int tick;
char channel;
char pitch;
char onoff;
} noteevent;
noteevent noteevents[1024];
int noteevent_read;
int noteevent_write;
int httpmain(int argc,char **argp);
pthread_t thread;
void *thread_func(void *param){
httpmain(0,NULL);
}
void (*pRMTermInit)(char param_1);
void RMTermInit(char param_1){
if(pRMTermInit==NULL){
pRMTermInit=dlsym(RTLD_NEXT, "RMTermInit");
}
printf("-------RMTermInit!!!!!!\n---------");
pRMTermInit(param_1);
pthread_create(&thread, NULL, thread_func, NULL);
return;
}
int _ZN7CScreen6PutBoxEiittm(int this, int x, int y, WORD width, WORD height, DWORD color);
int *pFirstFont;
const char *fontsize[] = { "FONT_SIZE_20","FONT_SIZE_24","FONT_SIZE_32","FONT_SIZE_40","FONT_SIZE_48","FONT_SIZE_60","FONT_SIZE_72",
"FONT_SIZE_30P","FONT_SIZE_36P","FONT_SIZE_44P","FONT_SIZE_58P","FONT_SIZE_73P","FONT_SIZE_88P",
"FONT_SIZE_16","FONT_SIZE_24_24_M","FONT_SIZE_18_24_M","FONT_SIZE_18_24_G","FONT_SIZE_18_20_G","FONT_SIZE_NONE","FONT_SIZE_MAX"};
const char *codetype[] = {"CODE_KS5601","CODE_SJIS","CODE_GB","CODE_BIG5","CODE_ASCII","CODE_TAILAND","CODE_VIETNAM","CODE_EUC_JAPAN","CODE_EUC_KOREA","CODE_UTF8","CODE_IMAGE_FONT","CODE_MAX"};
int fonts[128];
int n_font;
/*
int (*pymhCFile_OpenByNumber)(int **param_1,uint param_2,undefined4 param_3,undefined4 param_4);
int ymhCFile_OpenByNumber(int **param_1,uint param_2,undefined4 param_3,undefined4 param_4){
if(pymhCFile_OpenByNumber==NULL){
pymhCFile_OpenByNumber=dlsym(RTLD_NEXT, "ymhCFile_OpenByNumber");
}
printf("ymhCFile_OpenByNumber(%p,%d,%d,%d)\n",param_1,param_2,param_3,param_4);
return pymhCFile_OpenByNumber(param_1,param_2,param_3,param_4);
}*/
int ppPsqHandle;
undefined4 (*ppsqStart)(int *param_1);
undefined4 psqStart(int *param_1){
if(ppsqStart==NULL){
ppsqStart=dlsym(RTLD_NEXT, "psqStart");
}
printf("psqStart(ppHandle=%p,handle=%p)\n",param_1,*param_1);
ppPsqHandle=param_1;
return ppsqStart(param_1);
}
int * (*ppsqOpen)(int param_1,int param_2,undefined4 *param_3);
int * psqOpen(int param_1,int param_2,undefined4 *param_3){
if(ppsqOpen==NULL){
ppsqOpen=dlsym(RTLD_NEXT, "psqOpen");
}
printf("psqOpen\n");
return ppsqOpen(param_1,param_2,param_3);
}
#if 0
undefined4 (*ppsqMidiSendDelayedData)(undefined4 *param_1,uint param_2,undefined param_3,undefined *param_4,uint param_5,int param_6);
undefined4 psqMidiSendDelayedData(undefined4 *param_1,uint param_2,undefined param_3,int param_4,uint param_5,int param_6){
if(ppsqMidiSendDelayedData==NULL){
ppsqMidiSendDelayedData=dlsym(RTLD_NEXT, "psqMidiSendDelayedData");
}
// if( /*param_2== 0x04*/ ){
const char* pn[12] = {"C","C#","D","D#","E","F","F#","G","G#","A","A#","B" };
int t;
for(t=0;t<param_2;t++){
printf("\t");
}
int n;
// printf("@%d DL(param2=%02x,param3=%02x):",param_6,param_2,param_3);
for(n=0;n<param_5;n++){
// printf("%02x ",(*(char*)(param_4+n))&0xff);
}
noteevent *pw=noteevents+noteevent_write;
pw->channel=((*(char*)(param_4))&0xf) + param_2*16;
if( ((*(char*)(param_4))&0xf0) == 0x90 ){
int pitch = (*(char*)(param_4+1))&0xff;
// printf("ON Pitch=%d [%s] ch=%d",pitch,pn[pitch%12],pw->channel);
pw->onoff=1;
pw->pitch=pitch;
}else{
int pitch = (*(char*)(param_4+1))&0xff;
// printf("OFF Pitch=%d [%s] ",pitch,pn[pitch%12]);
pw->onoff=0;
pw->pitch=pitch;
}
pw->tick=param_6;
// int targetSolo = ( pw->tick / 1000 ) % 32;
noteevent_write=(noteevent_write+1)%1024;
// if( pw->channel==0 || pw->channel==10 || pw->channel== 5 + 16){ *(char*)(param_4+2) = 1 ;}
// printf("\n");
// }
ppsqMidiSendDelayedData(param_1,param_2,param_3,param_4,param_5,param_6);
}
void (*ppsqMidiSendImmediateData)(uint param_1,undefined *param_2,size_t param_3,undefined4 param_4);
void psqMidiSendImmediateData(uint param_1,undefined *param_2,size_t param_3,undefined4 param_4){
if(ppsqMidiSendImmediateData==NULL){
ppsqMidiSendImmediateData=dlsym(RTLD_NEXT, "psqMidiSendImmediateData");
}
int n;
printf("IM(%02x):",param_1);
for(n=0;n<param_3;n++){
printf("%02x ",(*(char*)(param_2+n))&0xff);
}
char *p = (char*)(param_2);
printf("\n");
if( (p[0]&0xff) == 0xf0 && ( ((p[1]&0xff) == 0x11) || ((p[1]&0xff) == 0x11))){
int addr = ( (p[2] << 16) & 0xff0000 ) + ((p[3] << 8) & 0xff00 ) + (p[4] & 0xff );
for( n = 5; n < param_3 -1;n++ ){
printf("%06x : %02x" , addr + n - 5 , p[n] & 0xff );
printf("\n");
}
}
ppsqMidiSendImmediateData(param_1,param_2,param_3,param_4);
}
#endif
#if 0
/*
*/
//char dest[128];
/*
int (*pymhTgScrambleEncode)(int param_1,int param_2,uint param_3);
int ymhTgScrambleEncode(int param_1,int param_2,uint param_3){
int n;
if(pymhTgScrambleEncode==NULL){
pymhTgScrambleEncode=dlsym(RTLD_NEXT, "ymhTgScrambleEncode");
printf("get pymhTgScrambleEncode = %p\n",pymhTgScrambleEncode);
}
// printf("scramble encode param1=%d,0x%p,%d : \n",param_1,param_2,param_3);
for(n=0;n<param_3;n++){
printf("%02x ",(*(char*)(param_2+n))&0xff);
}
printf("\n");
int ret = pymhTgScrambleEncode(param_1,param_2,param_3);
memcpy(dest,param_2,param_3);
return ret;
return ret;
}
*/
void (*ppsqEnterDuration)(int *param_1,undefined channel,undefined pitch,undefined velo,uint dur,undefined param_6);
void psqEnterDuration(int *param_1,undefined channel,undefined pitch,undefined velo,uint dur,undefined param_6){
if(ppsqEnterDuration==NULL){
ppsqEnterDuration=dlsym(RTLD_NEXT, "psqEnterDuration");
}
printf("psqEnterDuration(ch=%d,pitch=%d,velo=%d,dur=%d)\n",channel,pitch,velo,dur);
return ppsqEnterDuration(param_1, channel, pitch, velo, dur, param_6);
}
undefined4 (*ppsqPutChannelMessage)(int **param_1,byte *param_2,uint param_3,int param_4);
undefined4 psqPutChannelMessage(int **param_1,byte *param_2,uint param_3,int param_4){
int *piVar7=*param_1;
undefined4 uVar3 = piVar7[9];
if(ppsqPutChannelMessage==NULL){
ppsqPutChannelMessage=dlsym(RTLD_NEXT, "psqPutChannelMessage");
}
// if( param_4 > 15000 && param_4 < 30000 ){
printf("CHMSG@%d to %d:,param3=%d ",param_4,uVar3,param_3);
int n;
for(n=0;n<param_3;n++){
printf("%02X(%d) ",param_2[n],param_2[n]);
}
printf("\n");
// }
return ppsqPutChannelMessage(param_1,param_2,param_3,param_4);
}
undefined4 (*ppsqPutNoteOnVel)(int param_1,byte *param_2,undefined4 param_3);
undefined4 psqPutNoteOnVel(int param_1,byte *param_2,undefined4 param_3){
if(ppsqPutNoteOnVel==NULL){
ppsqPutNoteOnVel=dlsym(RTLD_NEXT, "psqPutNoteOnVel");
}
// if( (param_2[0]&0xf0) == 4 ){
int tick = *(int*)(param_1+0x44);
printf("psqPutNoteOnVel @%d (%02x-%02x)-%02x\n",tick,param_2[0],param_2[1],param_3);
// }
return ppsqPutNoteOnVel(param_1,param_2,param_3);
}
undefined4 (*ppsqPutNoteOn)(int param_1,byte *param_2,undefined4 param_3);
undefined4 psqPutNoteOn(int param_1,byte *param_2,undefined4 param_3){
if(ppsqPutNoteOn==NULL){
ppsqPutNoteOn=dlsym(RTLD_NEXT, "psqPutNoteOn");
}
// if( (param_2[0]&0xf0) == 4 ){
int tick = *(int*)(param_1+0x44);
printf("psqPutNoteOn@%d (%02x-%02x)\n",tick,param_2[0],param_2[1]);
// }
return ppsqPutNoteOn(param_1,param_2,param_3);
}
#endif
int comp(const void *a, const void *b){
toneinfo *p1=(toneinfo*)a;
toneinfo *p2=(toneinfo*)b;
return p1->tick - p2->tick;
}
int comp_chcount(const void *a, const void *b){
chcounter *p1=(chcounter*)a;
chcounter *p2=(chcounter*)b;
if( p1->priority == p2->priority ){
return p2->count - p1->count;
}else{
return p2->priority - p1->priority;
}
}
int (*pFontCreate)(int this,WORD wFolderNumber,DWORD dwFileNumber,bool bMemoryFont,
int size,int type,int DKFont);
int _ZN9CFontData6CreateEtmb9FONT_SIZE9CODE_TYPEb(int this,WORD wFolderNumber,DWORD dwFileNumber,bool bMemoryFont,
int size,int type,int DKFont){
if(pFontCreate==NULL){
pFontCreate=dlsym(RTLD_NEXT, "_ZN9CFontData6CreateEtmb9FONT_SIZE9CODE_TYPEb");
}
printf("FontDataCreate(CFont=%p,folder=%d,file=%d,bMemory=%d,size=%d(%s),type=%d(%s),dkfont=%d\n",this,wFolderNumber,dwFileNumber,bMemoryFont,size,
fontsize[size],type,codetype[type],DKFont);
if( pFirstFont == NULL ){
pFirstFont=this;
printf("save first font : %p\n",pFirstFont);
}
int ret=pFontCreate(this,wFolderNumber,dwFileNumber,bMemoryFont,size,type,DKFont);
fonts[n_font]=this;
printf("fonts[%d]=%p\n",n_font,fonts[n_font]);
n_font++;
return ret;
}
int (*pSelectFont)(int this,int lpFont,int codeType,WORD CharGap,DWORD FrontColor,DWORD EdgeColor);
int _ZN7CScreen10SelectFontEP9CFontData9CODE_TYPEtmm
(int this,int lpFont,int codeType,WORD CharGap,DWORD FrontColor,DWORD EdgeColor){
//printf("SelectFont(Screen=%p,CFont=%p,CODE_TYPE=%d,chargap=%d,frontColor=%p,edgeColor=%p)\n",
//this,lpFont,codeType,CharGap,FrontColor, EdgeColor);
if(pSelectFont==NULL){
pSelectFont=dlsym(RTLD_NEXT, "_ZN7CScreen10SelectFontEP9CFontData9CODE_TYPEtmm");
}
return pSelectFont(this,lpFont,codeType,CharGap,FrontColor, EdgeColor);
}
char *pBmp=NULL;
int (*pymhCSei2_DrawOpenPScrn)(int context);
int gosenscreen;
int ymhCSei2_DrawOpenPScrn(int context){
if(pymhCSei2_DrawOpenPScrn==NULL){
pymhCSei2_DrawOpenPScrn=dlsym(RTLD_NEXT, "ymhCSei2_DrawOpenPScrn");
}
if( pBmp!= NULL ){
free(pBmp);
pBmp=NULL;
}
int ret = pymhCSei2_DrawOpenPScrn(context);
//printf("ymhCSei2_DrawOpenPScrn::context=%p,screenPtr=%p,value=%p\n",context,context+0x10,*(int*)(context+0x10));
gosenscreen = *(int*)(context+0x10);
return ret;
}
int callTime=0;
int (*pymhCSei2_DrawGosen)(int param1,int param2);
int ymhCSei2_DrawGosen(int param1,int param2){
if(pymhCSei2_DrawGosen==NULL){
pymhCSei2_DrawGosen=dlsym(RTLD_NEXT, "ymhCSei2_DrawGosen");
}
//int ret = pymhCSei2_DrawGosen(param1,param2);
/*
int *ptr=(int*)*(int*)(param1+0x38);
int x=0,y;
for(y=0;y<240;y++){
for(x=0;x<704;x++){
ptr[x+704*y] = 0xff000000 + (y << 8) + x / 3;
}
}
*/
//return ret;
return 1;
}
void _Z21UPGRADE_SetSystemMode13SYSTEM_STATUS(int ss){
int lpHeadScreen = (int)dlsym(RTLD_NEXT, "lpHeadScreen");
int lpMainScreen = (int)dlsym(RTLD_NEXT, "lpMainScreen");
int lpTitleScreen = (int)dlsym(RTLD_NEXT, "lpTitleScreen");;
int lpBackScreen = (int)dlsym(RTLD_NEXT, "lpBackScreen");
int lpGuideScreen = (int)dlsym(RTLD_NEXT, "lpGuideScreen");;
}
int ymhCSei2_DrawNewPageOffset(int param_1,int param_2,int param_3,int param_4){
//printf("ymhCSei2_DrawNewPageOffset(%d,%d,%d,%d)\n",param_1,param_2,param_3,param_4);
return 0;
}
void ymhCSei2_DrawNewPage(int param_1,int param_2,undefined4 *param_3,int param_4){
//printf("ymhCSei2_DrawNewPage(%d,%d,%d,%d)\n",param_1,param_2,param_3,param_4);
}
int ymhCSei2_DrawMixingVScrn(int param_1){
//printf("ymhCSei2_DrawMixingVScrn(%d)\n",param_1);
return 0;
}
int ymhCSei2_DrawEvalTech(int param_1,undefined4 *param_2,int param_3,int param_4,int param_5,int param_6){
return 0;
}
int ymhCSei2_DrawEvalPitch(int param_1,undefined4 *param_2,int param_3,int *param_4,int param_5,int param_6){
return 0;
}
int ymhCSei2_DrawChangeScrollPage(int *param_1,uint param_2){
//printf("ymhCSei2_DrawChangeScrollPage\n");
return 0;
}
int ymhCSei2_DrawStudyRealPitch(int param_1,int param_2,int param_3,int param_4,int param_5){
//printf("ymhCSei2_DrawStudyRealPitch\n");
return 0;
}
int (*pymhCSei2_DrawDispCursor)(int *param_1,int param_2,undefined4 param_3,int param_4);
int ymhCSei2_DrawDispCursor(int *param_1,int param_2,undefined4 param_3,int param_4){
// pymhCSei2_DrawRestoreCsr = dlsym(RTLD_NEXT, "ymhCSei2_DrawRestoreCsr");
// int ret= pymhCSei2_DrawRestoreCsr(param);
// printf("ymhCSei2_DrawRestoreCsr(param=%p,*param=%d)\n",param,*((int*)param));
return 1;
}
int (*pymhCSei2_DrawRestoreCsr)(int param);
int ymhCSei2_DrawRestoreCsr(int param){
// pymhCSei2_DrawRestoreCsr = dlsym(RTLD_NEXT, "ymhCSei2_DrawRestoreCsr");
// int ret= pymhCSei2_DrawRestoreCsr(param);
// printf("ymhCSei2_DrawRestoreCsr(param=%p,*param=%d)\n",param,*((int*)param));
// return ret;
return 1;
}
void _ZN7CScreenC1Ev(int this);
void _ZN7CScreenC2Ev(int this);
int drawx=0;
int (*pymhCSei2_DrawUpdatePScrn)(int param);
char *pCBmp;
char *pCFile;
char pKeyScreen[0x1000];
char pKeyScreen2[0x1000];
int bmpsize;
int n_showTargetPage = 0;
typedef struct _guidePage {
unsigned int start;
unsigned int stop;
} guidePage;
guidePage page[200];
int n_guidePage=-1;
unsigned int musicOffset;
#if 0
int ymhCSei2_DrawUpdatePScrn(int param){
pymhCSei2_DrawUpdatePScrn = dlsym(RTLD_NEXT, "ymhCSei2_DrawUpdatePScrn");
int ret= pymhCSei2_DrawUpdatePScrn(param);
//sprintf("ymhCSei2_DrawUpdatePScrn(param=%p,*param=%d)\n",param,*((int*)param));
// _ZN7CScreen5ClearEm(gosenscreen,rand()&0xffffffff);
// _ZN7CScreen6PutBoxEiittm(gosenscreen, drawx, 0 , 100 , 100 , 0x00ffffff );
drawx++;
// _ZN7CScreen6PutBoxEiittm(gosenscreen, drawx, 0 , 100 , 100 , 0xff00ff00 );
if(drawx > 720 ) drawx = 0;
if( pCBmp == NULL ){
pCFile = calloc(1,0x20);
_ZN5CFileC1Ev(pCFile);
_ZN5CFile4OpenEPc12tagFILE_MODE(pCFile,"/XG/B/scoretest.bmp",0);
pCBmp = calloc(1,0x430);
_ZN7CBitmapC1Ev(pCBmp);
_ZN7CBitmap7LoadBMPER5CFile(pCBmp,pCFile);
_ZN7CScreenC1Ev(pKeyScreen);
_ZN7CScreen6CreateE8LAYER_IDiimm(pKeyScreen,2,0,10,700,500);
_ZN7CScreen6CreateE8LAYER_IDiimm(pKeyScreen2,2,0,10,700,500);
_ZN7CScreen6PutBoxEiittm((int)pKeyScreen, 0 , 0 , 800 , 600 , 0xff010101 );
}
//_ZN7CScreen6PutBoxEiittm(pKeyScreen2, drawx, 0 ,200,200, 0xff00ff00 );
//_ZN7CScreen9PutBitmapER7CBitmapii(gosenscreen,pCBmp,0,0);
//_ZN7CScreen10SelectFontEP9CFontData9CODE_TYPEtmm(gosenscreen,pFirstFont,1,4,0xff000000,0xff00ff00);
//_ZN7CScreen7PutTextEiiPc(gosenscreen,300,300,"HOGEHOGEHOGEHOGE");
return ret;
}
int (*pymhCSei2_DrawAttachPScrn)(int param);
int ymhCSei2_DrawAttachPScrn(int param){
pymhCSei2_DrawAttachPScrn = dlsym(RTLD_NEXT, "ymhCSei2_DrawAttachPScrn");
int ret= pymhCSei2_DrawAttachPScrn(param);
printf("ymhCSei2_DrawAttachPScrn(param=%p,*param=%d)\n",param,*((int*)param));
int x,y;
for(y=0;y<10*24;y+=24){
for(x=0;x<8*7*10;x+=8){
if( x > 12 *8 ){
_ZN7CScreen6PutBoxEiittm(pKeyScreen, 150 + x+1, y+1 , 7 , 23 , 0xffffffff );
}
}
int step = 0;
for(x=0;x<8*7*10;x+=8){
if( x > 12 *8 ){
if( step != 2 && step != 6){
_ZN7CScreen6PutBoxEiittm(pKeyScreen, 150 + x+1 + 4 , y+1 , 6 , 12 , 0xff010101 );
}
}
step++;
if( step == 7 ) step = 0;
}
}
if( pKeyScreen ){
int ci;
for( ci = 0 ;ci < 10 ;ci ++ ){
/*
if( ci == 0 ){
_ZN7CScreen7PutTextEiiPc(pKeyScreen,20,(ci* 24)-8,"Melody");
}else{
_ZN7CScreen7PutTextEiiPc(pKeyScreen,20,(ci* 24)-8,gm_instruments[play_status.ncount_ch[ci].program].short_name);
}*/
const char *names[] ={"Melody","Piano","Bell","Gt/Org","Bass","Strings","Cho","Brass","Synth","other"};
_ZN7CScreen7PutTextEiiPc(pKeyScreen,20,(ci* 24)-8,names[ci]);
}
}
return ret;
}
int (*pGetBuffer)(int screen);
int _ZN7CScreen9GetBufferEv(int screen){
pGetBuffer = dlsym(RTLD_NEXT, "_ZN7CScreen9GetBufferEv");
int ret= pGetBuffer(screen);
printf("GetBuffer(screen=%p) return ptr=%p\n",screen,ret);
return ret;
}
int (*pC01)(int dc);
int printlayersize(int p){
int *layerid=(int *)(p+0xc8);
int *pWidth=(int *)(p+0x18);
int *pHeight=(int *)(p+0x1c);
printf("layerid=%d width=%d height=%d\n",*layerid,*pWidth,*pHeight);
}
#endif
int _ZN7CScreen9GetBufferEv(int p);
#define LAYER_OSD 0
#define LAYER_LYRIC 1
#define LAYER_SCORE 2
#define LAYER_VIDEO 3
#define LAYER_TFT_LYRIC 4
#define LAYER_TFT_BACK 5
#define LAYER_SUB_VIDEO 6
#define LAYER_MEMORY 7
int _not_Z9C01_BeginP18tagDISPLAY_CONTEXT(int dc){
/*
if(pC01==NULL){
pC01=dlsym(RTLD_NEXT, "_Z9C01_BeginP18tagDISPLAY_CONTEXT");
}
int r = pC01(dc);
return r;
*/
printf("_Z9C01_BeginP18tagDISPLAY_CONTEXT");
// char pScreen0[0x900];
// _ZN7CScreenC1Ev(pScreen0);
char pScore[0x900];
_ZN7CScreenC1Ev((int)pScore);
char pLyricTFT[0x900];
_ZN7CScreenC1Ev((int)pLyricTFT);
char pBackTFT[0x900];
_ZN7CScreenC1Ev((int)pBackTFT);
// _ZN7CScreen6CreateE8LAYER_IDiimm(pScreen0,0,0,0,1280,800);
_ZN7CScreen6CreateE8LAYER_IDiimm(pScore,LAYER_SCORE,0,0,800,600);
_ZN7CScreen6CreateE8LAYER_IDiimm(pLyricTFT,LAYER_TFT_LYRIC,320,400,60,60);
_ZN7CScreen6CreateE8LAYER_IDiimm(pBackTFT,LAYER_TFT_BACK,320,600,160,160);
int lpFont=dlsym(RTLD_NEXT, "_ZN10COwnerMode4OpenEP10tagREQUEST");
//int *p=_ZN7CScreen9GetBufferEv(pScreen);
// int *p2=_ZN7CScreen9GetBufferEv(pScreen2);
// _ZN7CScreen5ClearEm(pScreen0,0x3f00ff00);
_ZN7CScreen5ClearEm(pScore,0xffff0000);
_ZN7CScreen5ClearEm(pLyricTFT,0x03f0);
_ZN7CScreen5ClearEm(pBackTFT,0xff00);
// printlayersize(pScreen0);
// printlayersize(pScreen);
// printlayersize(pScreen2);
// printlayersize(pScreen3);
// printlayersize(pScreen4);
// printlayersize(pScreen5);
// printlayersize(pScreen6);
int x,y;
int fontindex=0;
while(1){
char buf[128];
sprintf(buf,"font(%d) A�����P1$",fontindex);
_ZN7CScreen10SelectFontEP9CFontData9CODE_TYPEtmm(pScore,fonts[fontindex],1,2,0xffffffff,0xff0000ff);
_ZN7CScreen5ClearEm(pScore,0xff3f3f3f);
sprintf(buf,"%d %s",fontindex,fontsize[ *(int*)(fonts[fontindex]+0x6c) ]+10);
_ZN7CScreen7PutTextEiiPc(pScore,50,50,buf);
sprintf(buf,"A�����P1$",fontindex);
_ZN7CScreen7PutTextEiiPc(pScore,50,300,buf);
sleep(5);
fontindex=(fontindex+1)%n_font;
}
}
int (*pOwnerOpen)(int this,int req);
int _ZN10COwnerMode4OpenEP10tagREQUEST(int this,int req){
if(pOwnerOpen==NULL){
pOwnerOpen=dlsym(RTLD_NEXT, "_ZN10COwnerMode4OpenEP10tagREQUEST");
}
printf("pOwnerOpen");
int r = pOwnerOpen(this,req);
int pScreen=this + 0x0c;
while(1){
_ZN7CScreen5ClearEm(pScreen,rand()&0xffffffff);
sleep(1);
}
return r;
}
void (*OnLCDTimer)(int pView);
void _ZN5CView10OnLCDTimerEv(int pCView){
if(OnLCDTimer==NULL){
OnLCDTimer=dlsym(RTLD_NEXT, "_ZN5CView10OnLCDTimerEv");
}
printf("OnLCDTimer");
return OnLCDTimer(pCView);
}
int (*pPutText)(int pThis,int x,int y,int str);
int _ZN7CScreen7PutTextEiiPc(int pThis,int x,int y,int str){
if(pPutText==NULL){
pPutText=dlsym(RTLD_NEXT, "_ZN7CScreen7PutTextEiiPc");
}
// printf("PutText(%p,%d,%d,\"%s\")\n",pThis,x,y,str);
return pPutText(pThis,x,y,str);
}
int (*pCopy)(int this, int lpScreen, int x, int y, WORD DispHeight);
int _ZN7CScreen4CopyEPS_iit(int this, int lpScreen, int x, int y, WORD DispHeight){
if(pCopy==NULL){
pCopy=dlsym(RTLD_NEXT, "_ZN7CScreen4CopyEPS_iit");
}
// printf("CScreen::Copy(%p -> %p,x=%d,y=%d,DispHeight=%d)\n",this,lpScreen,x,y,DispHeight);
return pCopy(this,lpScreen,x,y,DispHeight);
}
void (*pScreenConst)(int this);
void (*pScreenConst2)(int this);
void _ZN7CScreenC1Ev(int this){
if(pScreenConst==NULL){
pScreenConst=dlsym(RTLD_NEXT, "_ZN7CScreenC1Ev");
}
// printf("CScreen Constructor(%p)\n",this);
return pScreenConst(this);
}
void _ZN7CScreenC2Ev(int this){
if(pScreenConst2==NULL){
pScreenConst2=dlsym(RTLD_NEXT, "_ZN7CScreenC2Evs");
}
// printf("CScreen Constructor2(%p)\n",this);
return pScreenConst2(this);
}
void (*pScreenFade)(int pScreen,BYTE alpha);
void _ZN7CScreen4FadeEh(int pScreen,BYTE alpha){
if(pScreenFade==NULL){
pScreenFade=dlsym(RTLD_NEXT, "_ZN7CScreen4FadeEh");
}
// printf("CScreen::Fade::(%p,%d)\n",pScreen,alpha);
return pScreenFade(pScreen,alpha);
}
int (*pPutBox)(int this, int x, int y, WORD width, WORD height, DWORD color);
int _ZN7CScreen6PutBoxEiittm(int this, int x, int y, WORD width, WORD height, DWORD color){
if(pPutBox==NULL){
pPutBox=dlsym(RTLD_NEXT, "_ZN7CScreen6PutBoxEiittm");
}
// printf("CScreen::PutBox(%p,x=%d,y=%d,width=%d,height=%d,color=0x%08x)\n",this,x,y,width,height,color);
return pPutBox(this,x,y,width,height,color);
}
void (*pScreenDestory)(int pScreen);
void _ZN7CScreen7DestoryEv(int pScreen){
if(pScreenDestory==NULL){
pScreenDestory=dlsym(RTLD_NEXT, "_ZN7CScreen7DestoryEv");
}
// printf("CScreen::Destory::(%p)\n",pScreen);
return pScreenDestory(pScreen);
}
int (*pScreenCreateFromScreen)(int pScreen,int pScr,int x,int y,DWORD width,DWORD height);
int _ZN7CScreen6CreateERS_iimm(int pScreen,int pScr,int x,int y,DWORD width,DWORD height){
if(pScreenCreateFromScreen==NULL){
pScreenCreateFromScreen=dlsym(RTLD_NEXT, "_ZN7CScreen6CreateERS_iimm");
}
// printf("CScreen::CreateFromSrc::(%p)\n",pScr);
return pScreenCreateFromScreen(pScreen,pScr,x,y,width,height);
}
int (*pScreenCreate)(int pScreen,int id,int x,int y,DWORD width,DWORD height);
int _ZN7CScreen6CreateE8LAYER_IDiimm(int pScreen,int id,int x,int y,DWORD width,DWORD height){
if(pScreenCreate==NULL){
pScreenCreate=dlsym(RTLD_NEXT, "_ZN7CScreen6CreateE8LAYER_IDiimm");
}
const char *layerName[]= {"LAYER_OSD","LAYER_LYRIC","LAYER_SCORE","LAYER_VIDEO","LAYER_TFT_LYRIC","LAYER_TFT_BACK","LAYER_SUB_VIDEO","LAYER_MEMORY","LAYER_MAX"};
// printf("CScreen::Create::(this=%p,layer id=%d(%s),x=%d,y=%d,width=%d,height=%d)\n",pScreen,id,layerName[id],x,y,width,height);
return pScreenCreate(pScreen,id,x,y,width,height);
}
int (*pSinglePlay)(int pVideo,int streamType,WORD folderNumber,DWORD fileNumber,char repeat);
//bool SinglePlay(CVideoPlayer * this, VSTREAM_TYPE StreamType, WORD wFolderNumber, DWORD dwFileNumber, char repeat)
int _ZN12CVideoPlayer10SinglePlayE15tagVSTREAM_TYPEtmb(int pVideo,int streamType,WORD folderNumber,DWORD fileNumber,char repeat){
if(pSinglePlay==NULL){
pSinglePlay=dlsym(RTLD_NEXT, "_ZN12CVideoPlayer10SinglePlayE15tagVSTREAM_TYPEtmb");
}
printf("CVideo::SinglePlay(%p,%d,%d.%d,repeat=%d)\n",pVideo,streamType,folderNumber,fileNumber,repeat);
int ret = pSinglePlay(pVideo,streamType,folderNumber,fileNumber,repeat);
return ret;
}
int (*AddPlayList)(int pVideo,int streamType,
WORD folderNumber,DWORD dwFileNumber,DWORD startFrame,DWORD endFrame,char repeat,DWORD dispStartFrame,DWORD dispEndFrame);
int _ZN12CVideoPlayer11AddPlayListE15tagVSTREAM_TYPEtmmmbmm(int pVideo,int streamType,
WORD folderNumber,DWORD dwFileNumber,DWORD startFrame,DWORD endFrame,char repeat,DWORD dispStartFrame,DWORD dispEndFrame){
if(AddPlayList==NULL){
AddPlayList=dlsym(RTLD_NEXT, "_ZN12CVideoPlayer11AddPlayListE15tagVSTREAM_TYPEtmmmbmm");
}
printf("CVideo::AddPlayList(%p,%d,%d.%d start,end = %d,%d repeat=%d dispStart,end = %d,%d)\n"
,(void*)pVideo,streamType,folderNumber,dwFileNumber,startFrame,endFrame,repeat,dispStartFrame,dispEndFrame);
int ret = AddPlayList(pVideo,streamType,folderNumber,dwFileNumber,startFrame,endFrame,repeat,dispStartFrame,dispEndFrame);
return ret;
}
//bool __thiscall CVideoPlayer::AddPlayList(CVideoPlayer *this,VSTREAM_TYPE StreamType,WORD wFolderNumber,DWORD dwFileNumber,
// DWORD dwStartFrame,DWORD dwEndFrame,bool bRepeat,DWORD dwDispStartFrame,
// DWORD dwDispEndFrame)
int (*pCheckPresent)(int pIndex,WORD *folder,DWORD file,int *type);
/*
VSTREAM_MPEG2 3
VSTREAM_WMBGV 26
VSTREAM_WMV 27
VSTREAM_GRAPHICS 28
VSTREAM_H264 33
VSTREAM_EXTERNAL1 65521
VSTREAM_EXTERNAL2 65522
VSTREAM_EXTERNAL3 65523 */
int songNumTray;
int songNumChapter;
int movieFirst=1;
int ret;
int (*pokdFileReadOpen)(unsigned short *param_1,int param_2,unsigned int param_3,int *param_4sss);
int okdFileReadOpen(unsigned short *param_1,int param_2,unsigned int param_3,int *param_4){
puts("okdFileReadOpen");
pokdFileReadOpen=dlsym(RTLD_NEXT, "okdFileReadOpen");
printf("%x,%x,%x,%x\n",param_1,param_2,param_3,param_4);
printf("number assumed = %d.%d\n",*param_1,*(int *)(param_1+2));
movieFirst=1;
return pokdFileReadOpen(param_1,param_2,param_3,param_4);
}
/*bool __thiscall
COkdPlayer::Open(COkdPlayer *this,YMH_SONGNUM songnum,YMH_OKDP_SONGDATA *data,
YMH_OKDP_OPENMODE eMode,LPVOID lpInfo)*/
char decidedFilename[1024];
int check_file(char *name){
int ret;
printf("check exist %s ",name);
FILE *fp=fopen(name,"rb");
if(fp!=NULL){
printf("exist.\n");
fclose(fp);
return 1;
}
printf("not exist.\n");
return 0;
}
bool _ZN9CMDVIndex15CheckPresentBGVEPtmP15tagVSTREAM_TYPE(int pIndex,WORD *folder,DWORD file,int *type){
if(pCheckPresent==NULL){
pCheckPresent=dlsym(RTLD_NEXT, "_ZN9CMDVIndex15CheckPresentBGVEPtmP15tagVSTREAM_TYPE");
}
printf("before CheckPresent(%p,%d-%d,%d)\n",pIndex,*folder,file,*type);
int maxnum=-1;
if( strlen(decidedFilename) == 0 ){
char buf[255];
// check custom pv
int x;
for(x=0;x<10;x++){
sprintf(buf,"/XG/B/movie/%d/%d",songNumTray,songNumChapter);
if( x > 0 ){
sprintf(buf,"%s.%d",buf,x);
}
if( check_file(buf) ){
maxnum=x;
}
}
if( maxnum != -1 ){
printf("maxnum=%d \n",maxnum);
int decide=0;
decide= rand()%(maxnum+1);
sprintf(buf,"/XG/B/movie/%d/%d",songNumTray,songNumChapter);
if(decide > 0 ){
sprintf(buf,"%s.%d",buf,decide);
}
strcpy(decidedFilename,buf);
printf("decide filename=%s\n",decidedFilename);
}
}
if( strlen(decidedFilename) == 0 ){
return pCheckPresent(pIndex,folder,file,type);
}else{
*folder = 666;
*type = 27;
char target[255];
sprintf(target,"/XG/B/Data/666/666.%d",file);
printf("make symlink source=%s target %s\n",decidedFilename,target);
unlink(target);
symlink(decidedFilename,target);
return pCheckPresent(pIndex,folder,file,type);
}
}
int (*pFunc)(void *p);
int (*pkaraoke_update)(int this);
unsigned int (*pGetCurrentTime)(void *okd); // _ZN14CKaraokePlayer14GetCurrentTimeEv
char pLyricScreen[0x900]={0};
void InitPlayStatus(){
printf("Initialize Playing Status\n\n\n");
play_status.lastTime=0;
memset(play_status.keyMap,96*128*sizeof(int),0);
memset(play_status.keyMap_Stop,96*128*sizeof(int),0);
play_status.lastShowNum = 0;
if( play_status.pTones != NULL ){
free(play_status.pTones );
play_status.pTones=NULL;
}
if( play_status.pTones == NULL ){
play_status.pTones=calloc(sizeof(toneinfo),10240*16);
play_status.lastShowNum = 0;
play_status.tracknum = 0;
play_status.numoftones=0;
int i;
for(i=0;i<64;i++){
play_status.ncount_ch[i].ch=i;
play_status.ncount_ch[i].priority=0;
play_status.ncount_ch[i].count=0;
play_status.ncount_ch[i].partmode=0;
}
}
noteevent_read=noteevent_write=0;
n_guidePage=-1;
n_showTargetPage=-1;
}
int (*okdplayeropen)(void *okdPlayer,int sn,void *songdata,int mode,void *lpInfo);
int _ZN10COkdPlayer4OpenEmP17YMH_OKDP_SONGDATA17YMH_OKDP_OPENMODEPv(
void *okdPlayer,int sn,void *songdata,int mode,void *lpInfo
){
puts("_ZN10COkdPlayer4OpenEmP17YMH_OKDP_SONGDATA17YMH_OKDP_OPENMODEPv");
InitPlayStatus();
okdplayeropen=dlsym(RTLD_NEXT, "_ZN10COkdPlayer4OpenEmP17YMH_OKDP_SONGDATA17YMH_OKDP_OPENMODEPv");
printf("%p,%d-%d,%p,%d,%p\n",okdPlayer,(sn>>8)&0xffff,sn&0xff,songdata,mode,lpInfo);
songNumTray=(sn>>8) &0xffff;
songNumChapter=sn&0xff;
decidedFilename[0]=0;
return okdplayeropen(okdPlayer,sn,songdata,mode,lpInfo);
}
int _ZN14CKaraokePlayer8OkdStartEv(void *p){
FILE *fp=fopen("info.txt","w");
printf("okd_start\n");
int i;
for(i=0;i<play_status.numoftones;i++){
play_status.ncount_ch[play_status.pTones[i].ch].count++;
}
printf("sort ch\n");
for(i=0;i<64;i++){
if(play_status.ncount_ch[i].count>0){
printf("ch [%d] notes =%d program=%d(%s)\n",i,play_status.ncount_ch[i].count,
play_status.ncount_ch[i].program,
gm_instruments[play_status.ncount_ch[i].program].name);
fprintf(fp,"ch [%d] notes =%d program=%d(%s)\n",i,play_status.ncount_ch[i].count,
play_status.ncount_ch[i].program,
gm_instruments[play_status.ncount_ch[i].program].name);
}
}
for(i=63;i>=0;i--){
if( play_status.ncount_ch[i].count > 100 ) {
play_status.ncount_ch[i].priority = 1;
break;
}
}
// printf("---------sorted-----------\n");
qsort(play_status.ncount_ch,64,sizeof(chcounter),comp_chcount);
qsort(play_status.pTones,play_status.numoftones,sizeof(toneinfo),comp);
const char* pn[12] = {"C","C#","D","D#","E","F","F#","G","G#","A","A#","B" };
play_status.pitch_min=255;
play_status.pitch_max=0;
for(i=0;i<64;i++){
if( play_status.ncount_ch[i].count > 0 ){
printf("(%d)ch [%d] notes =%d prio=%d program=%d(%s)->remapto %d ,partmode=%d\n",i,play_status.ncount_ch[i].ch,
play_status.ncount_ch[i].count,
play_status.ncount_ch[i].priority,
play_status.ncount_ch[i].program,
gm_instruments[play_status.ncount_ch[i].program].name,remap(play_status.ncount_ch[i].program),
play_status.ncount_ch[i].partmode
);
fprintf(fp,"(%d)ch [%d] notes =%d prio=%d program=%d(%s)->remapto %d ,partmode=%d\n",i,play_status.ncount_ch[i].ch,
play_status.ncount_ch[i].count,
play_status.ncount_ch[i].priority,
play_status.ncount_ch[i].program,
gm_instruments[play_status.ncount_ch[i].program].name,remap(play_status.ncount_ch[i].program),
play_status.ncount_ch[i].partmode
);
int n=0;
int c=0;
for(n=0;n<play_status.numoftones;n++){
if( play_status.ncount_ch[i].ch == play_status.pTones[n].ch && c < 8){
printf("[%d,%d] @%d pitch=%d(%s%d) length=%d\n",n,c,play_status.pTones[n].tick,
play_status.pTones[n].pitch, pn[ play_status.pTones[n].pitch % 12] , play_status.pTones[n].pitch/12 , play_status.pTones[n].length );
printf("%s ", pn[ play_status.pTones[n].pitch % 12]);
c++;
}
}
}
}
int n;
int c=0;
for(i=0;i<64;i++){
for(n=0;n<play_status.numoftones;n++){
/*
if( play_status.ncount_ch[i].ch == play_status.pTones[n].ch ){
printf("[%d,%d] @%d pitch=%d(%s%d) length=%d\n",n,c,play_status.pTones[n].tick,
play_status.pTones[n].pitch, pn[ play_status.pTones[n].pitch % 12] , play_status.pTones[n].pitch/12 , play_status.pTones[n].length );
c++;
}*/
if( play_status.pitch_min > play_status.pTones[n].pitch ) play_status.pitch_min = play_status.pTones[n].pitch;
if( play_status.pitch_max < play_status.pTones[n].pitch ) play_status.pitch_max = play_status.pTones[n].pitch;
}
}
printf("pitch lowest=%d, highest=%d\n",play_status.pitch_min,play_status.pitch_max);
pFunc=dlsym(RTLD_NEXT, "_ZN14CKaraokePlayer8OkdStartEv");
pGetCurrentTime = dlsym(RTLD_NEXT, "_ZN14CKaraokePlayer14GetCurrentTimeEv");
int ret = pFunc(p);
unsigned int t= pGetCurrentTime( p );
printf("time=%d\n",t);
fclose(fp);
return ret;
}
int lastO = 5;
int pRequestScreen;
static int c;
void (*pMIDI_SetMuteMIDIChannel)(int stream_ID,char Channel,int Mute);
void MIDI_SetMuteMIDIChannel(int stream_ID,char Channel,int Mute){
if( pMIDI_SetMuteMIDIChannel == NULL){
pMIDI_SetMuteMIDIChannel=dlsym(RTLD_NEXT, "MIDI_SetMuteMIDIChannel");
}
printf("MIDI_SetMuteMIDIChannel(%d,%d,%d)\n",stream_ID,Channel,Mute);
pMIDI_SetMuteMIDIChannel(stream_ID,Channel,Mute);
}
int *rotate(int *p,int size){
int n;
int p1=*p;
/*
printf("before rotate ");
for(n=0;n<size;n++){
printf("%d-",p[n]);
}
printf("\n");*/
for(n=0;n<size-1;n++){
p[n]=p[n+1];
}
p[size-1] = (p1+12);
/*
printf("after rotate ");
for(n=0;n<size;n++){
printf("%d-",p[n]);
}
printf("\n");*/
return p;
}
int muteLevel;
int UpdatePlayingInfo(){
FILE *fp=fopen("setoption.html","w");
fprintf(fp,"<html><body>");
const char *ml[] = { "NONE" , "CHORDS" , "CHORDS + BASS" };
fprintf(fp,"Currrent Mute Level = %d (%s)<br><br>",muteLevel,ml[muteLevel]);
fprintf(fp,"<a href=\"mute0\">--- set NONE --- </a><br>");
fprintf(fp,"<a href=\"mute1\">--- set CHORDS --- </a><br>");
fprintf(fp,"<a href=\"mute2\">--- set CHORDS + BASS --- </a><br>");
fprintf(fp,"</body></html>");
fclose(fp);
return 0;
}
int GetMuteLevel(){
return muteLevel;
}
int SetMuteLevel(int n){
muteLevel=n;
UpdatePlayingInfo();
return 0;
}
unsigned long MIDI_GetTimer(int n);
#if 0
int _ZN14CKaraokePlayer6UpdateEv(int this){
const char* pns[12] = {"C","C#","D","D#","E","F","F#","G","G#","A","A#","B" };
if( pkaraoke_update == NULL){
pkaraoke_update=dlsym(RTLD_NEXT, "_ZN14CKaraokePlayer6UpdateEv");
printf("\t_ZN14CKaraokePlayer6UpdateEv(CKaraokePlayer (%p))\n",this);
}
int ret = pkaraoke_update(this);
unsigned int t= /*pGetCurrentTime( this );*/ MIDI_GetTimer(0);
if( t - play_status.lastTime > 1000 ){
noteevent *pw=noteevents+((noteevent_write+1024-1)%1024);
noteevent *pr=noteevents+(noteevent_read);
printf("MIDI Time =%d,writing midi buffer head=%d last=%d\n",MIDI_GetTimer(0),pr->tick,pw->tick);
int sec = ( t / 1000);
play_status.lastTime = t;
if( *pLyricScreen == 0 ){
_ZN7CScreenC1Ev(pLyricScreen);
_ZN7CScreen6CreateE8LAYER_IDiimm(pLyricScreen,LAYER_LYRIC,0,0,1000,100);
}
//_ZN7CScreen5ClearEm(pLyricScreen,0xff000000 + rand()%0xffffff);
for(int t=play_status.lastShowNum;t<play_status.numoftones;t++){
if( play_status.pTones[t].tick < t && play_status.pTones[t].ch == 46){
printf("@%d O%d %s length=%d\n",play_status.pTones[t].tick
,play_status.pTones[t].pitch/12,pns[play_status.pTones[t].pitch%12],
play_status.pTones[t].length);
play_status.lastShowNum = t+1;
}
}
printf("lastShowNum=%d,nuoftones=%d\n",play_status.lastShowNum,play_status.numoftones);
char s[24];
sprintf(s,"play %d sec.",sec);
UpdatePlayingInfo();
/*
if( sec == 10 || sec == 11 ){
int s,ch,i;
//const int addrtoch[16] = { 9,0,1,2,3,4,5,6,7,8,10,11,12,13,14,15 };
for(i=0;i<64;i++){
ch = play_status.ncount_ch[i].ch % 16;
s = play_status.ncount_ch[i].ch /16;
printf("muteLevel=%d\n",muteLevel);
if( muteLevel == 1 ){
if( play_status.ncount_ch[i].partmode == 0 && play_status.ncount_ch[i].ch < 32 ){
if( remap(play_status.ncount_ch[i].program) != 4 ){
}
}
}else if( muteLevel == 2 ){
if( play_status.ncount_ch[i].partmode == 0 && play_status.ncount_ch[i].ch < 32 ){
psqMidiSendImmediateData(s,msg,3,0);
}
}
}
}*/
// int global_lpSystemFont = dlsym(RTLD_NEXT, "global_lpSystemFont");
// printf("global_lpSystemFont=%p\n",global_lpSystemFont);
// int systemfont=_ZN12CSystemFonts7GetFontE9FONT_SIZE9CODE_TYPE(global_lpSystemFont,4,7); // euc-jp
// printf("systemfont=%p\n",systemfont);
// _ZN7CScreen10SelectFontEP9CFontData9CODE_TYPEtmm(pLyricScreen,systemfont,0,0,0xffffffff,0xff000000);
// _ZN7CScreen10SelectFontEP9CFontData9CODE_TYPEtmm(pLyricScreen);
// _ZN7CScreen7PutTextEiiPc(pLyricScreen,0,0,s);
// _ZN7CScreen7PutTextEiiPc(pLyricScreen,0,400,s);
// callTime++;
/*
if( sec > 60 ){
MIDI_SetMuteMIDIChannel(2,sec-60,0);
MIDI_SetMuteMIDIChannel(3,sec-60,0);
}else
if( sec >20 ){
MIDI_SetMuteMIDIChannel(2,sec-20,1);
MIDI_SetMuteMIDIChannel(3,sec-20,1);
}*/
}
#if 1
int pn;
int n;
for(pn=n_showTargetPage;pn<n_guidePage;pn++){
if( page[pn].start < t ){
unsigned int length = page[pn].stop +1 - page[pn].start ;
unsigned int halfBeat = length / 8;
printf("page[%d] start=%d,stop=%d \n",pn,page[pn].start,page[pn].stop);
char linebuf[128]={0};
/*
for(n=0;n<16;n++){
int t;
//const char* pitchname[12] = {"\xa5\xc9","\xa5\xc9\xa1\xf4","\xa5\xec","\xa5\xec\xa1\xf4","\xa5\xdf","\xa5\xd5\xa5\xa1","\xa5\xd5\xa5\xa1\xa1\xf4",
//"\xa5\xbd","\xa5\xbd\xa1\xf4","\xa5\xe9","\xa5\xe9\xa1\xf4","\xa5\xb7" };
const char* pitchname[12] = {"\x83\x68�","\x83\x68\x81\x94","\x83\x8c","\x83\x8c\x81\x94","\x83\x7e","\x83\x74\x83\x40","\x83\x74\x83\x40#","\x83\x5c","\x83\x5c#","\x83\x89","\x83\x89#","\x83\x56" };
for(t=0;t<play_status.nl.counts[n];t++){
if( (play_status.nl.chList[n][t].tickOn >= page[pn].start ) && (play_status.nl.chList[n][t].tickOn <= page[pn].stop ) ){
printf("@%d O%d %s length=%d\n",play_status.nl.chList[n][t].tickOn
,play_status.nl.chList[n][t].pitch/12,pitchname[play_status.nl.chList[n][t].pitch%12],
play_status.nl.chList[n][t].tickOff-play_status.nl.chList[n][t].tickOn);
printf("%s ",pitchname[play_status.nl.chList[n][t].pitch%12]);
strcat(linebuf,pitchname[play_status.nl.chList[n][t].pitch%12]);
strcat(linebuf," ");
if(lastO < play_status.nl.chList[n][t].pitch/12 ){
printf("%c%c",0xa2,0xac);
}else if (lastO > play_status.nl.chList[n][t].pitch/12 ){
printf("%c%c",0xa2,0xad);
}
lastO=play_status.nl.chList[n][t].pitch/12;
}
}
}*/
// printf("\n");
// if(pRequestScreen) _ZN7CScreen5ClearEm(pRequestScreen,0xff00ffff);
// _ZN7CScreen5ClearEm(gosenscreen,0xff000000);
_ZN7CScreen6PutBoxEiittm(gosenscreen, 0 , 0 , 800 , 800 , 0xff00ff0 );
n_showTargetPage = pn+1;
break;
}
}
#endif
#if 0
_ZN7CScreen10SelectFontEP9CFontData9CODE_TYPEtmm(pKeyScreen,fonts[4],1,2,0xffffffff,0xff000001);
int offsety=0;
char timecount[128];
// sprintf(timecount,"%d,%d,%d",lastShowTick,lastShowNum);
//_ZN7CScreen6PutBoxEiittm(gosenscreen, 0 , 0 , 800 , 200 , 0xff000000 );
//_ZN7CScreen7PutTextEiiPc(gosenscreen,50,50,timecount);
// int now=play_status.lastShowTick;
int c=play_status.lastShowNum;
int e;
while(1){
noteevent *pr=noteevents+noteevent_read;
if( pr->tick < t+500 ){
int targetch=remap(play_status.ncount_ch[ pr->channel ].program);
/*
if( pr->channel == 16 ){
targetch=0;
}*/
if( pr->pitch != 0 ){
if( pr->onoff ){
play_status.keyMap[pr->pitch + targetch * 128 ] = 1;
}else{
play_status.keyMap_Stop[pr->pitch + targetch * 128 ] = 1;
}
}
noteevent_read=(noteevent_read+1)%1024;
}else{
break;
}
if( noteevent_read == noteevent_write) break;
}
#endif
if( pKeyScreen ){
int ci;
for( ci = 0 ;ci < 10 ;ci ++ ){
//int c = play_status.ncount_ch[ci].ch;
int p=0;
int notearray[12]={0};
int rootTone=-1;
for( p = 0 ; p<128;p++ ){
// normal octave
if( play_status.keyMap[ p + ci * 128 ] > 0 ) {
notearray[p%12]=1;
if( rootTone == -1 ){
rootTone= p;
}
}
}
int nc=0;
int chordarray[12];
int cc=0;
for(nc=0;nc<12;nc++){
if( notearray[nc]!= 0 ){
chordarray[cc]=nc;
cc++;
}
}
if(cc >= 3){
// printf("p%d chords:",ci);
int c2;
//if( cc == 3 ){
for (int i = 0; i < sizeof(chords) / sizeof(chords[0]); ++i) {
char cn[24]={0};
cc=0;
for(nc=0;nc<12;nc++){
if( notearray[nc]!= 0 ){
chordarray[cc]=nc;
cc++;
}
}
int r;
for(r=0;r<cc;r++){
char arrayOffset[12];
for(c2=0;c2<cc;c2++){
// printf("%s-",pns[ chordarray[c2]%12 ]);
arrayOffset[c2]=chordarray[c2]-chordarray[0];
}
// printf(" : ");
/*
printf(" offseted=");
for(c2=0;c2<cc;c2++){
printf("%d-",arrayOffset[c2]);
}
*/
if (chords[i].num_notes <= 5) {
if( memcmp(arrayOffset,chords[i].intervals,/*chords[i].num_notes*/cc)== 0 ){
// printf("%s",chords[i].chord_name);
sprintf(cn,"%s%s",pns[chordarray[0]%12],chords[i].chord_name);
break;
}
}
rotate(chordarray,cc);
}
if( cn[0]!=0 ){
// printf("\n");
// printf("---part%d:%s---\n",ci,cn);
_ZN7CScreen6PutBoxEiittm(pKeyScreen,150 , (ci* 24) , 100 , 24 , 0xff101010 );
_ZN7CScreen7PutTextEiiPc(pKeyScreen,150,(ci* 24)-8,cn);
break;
}
}
//}
}
if( ci == 4 && rootTone != -1 ){
_ZN7CScreen6PutBoxEiittm(pKeyScreen,150 , (ci* 24) , 100 , 24 , 0xff101010 );
_ZN7CScreen7PutTextEiiPc(pKeyScreen,150,(ci* 24)-8,pns[rootTone%12]);
}
for( p = 0 ; p<128;p++ ){
int xoct = p /12;
int xmod = p %12;
int xpos;
int xblack;
switch(xmod){
//
case 0:
xpos = 0;
xblack = 0;
break;
case 1:
xpos = 1;
xblack = 1;
break;
case 2:
xpos = 2;
xblack = 0;
break;
case 3:
xpos = 3;
xblack = 1;
break;
case 4:
xpos = 4;
xblack = 0;
break;
case 5:
xpos = 6;
xblack = 0;
break;
case 6:
xpos = 7;
xblack = 1;
break;
case 7:
xpos = 8;
xblack = 0;
break;
case 8:
xpos = 9;
xblack = 1;
break;
case 9:
xpos = 10;
xblack = 0;
break;
case 10:
xpos = 11;
xblack = 1;
break;
case 11:
xpos = 12;
xblack = 0;
break;
break;
}
if( play_status.keyMap[ p + ci * 128 ] ) {
_ZN7CScreen6PutBoxEiittm(pKeyScreen, 150+(7 * 8 ) * xoct + xpos * 4 +1 , (ci* 24) + 16 + ( - xblack * 10 ), 6 , 8 , 0xffff0000) ;
play_status.keyMap[ p + ci * 128 ] = 0;
}
if ( play_status.keyMap_Stop[ p + ci * 128 ] ) {
play_status.keyMap_Stop[ p + ci * 128 ] = 0;
_ZN7CScreen6PutBoxEiittm(pKeyScreen, 150+(7 * 8 ) * xoct + xpos * 4 + 1 , (ci* 24) + 16 + ( - xblack * 10 ), 6 , 8 , xblack ? 0xff010101 :0xffffffff ) ;
}
}
}
}
// updatecount++;
return ret;
}
#endif
int (*pClear)(int this,DWORD color);
int _ZN7CScreen5ClearEm(int this,DWORD color){
int type = *(int*)(this+0x10);
printf("CScreen::Clear(%p,%d),type=%d\n",this,color,type);
if(pClear==NULL){
pClear=dlsym(RTLD_NEXT, "_ZN7CScreen5ClearEm");
}
/*
int x;
for(x=0;x<0xcc;x++){
if( x > 0 && ( x % 16 == 0 )) printf("\n");
if( ( x % 16 == 0 ) ) printf("%04x ",x);
printf("%02X ", (*(char*)(this +x )) & 0xff );
}
printf("\n");*/
return pClear(this,color);
}
int (*pMusicUpdateEv)(int pMusic);
int _ZN6CMusic11MusicUpdateEv(int pMusic){
// printf("_ZN6CMusic11MusicUpdateEv(CMusic (%p))\n",pMusic);
if(pMusicUpdateEv==NULL){
pMusicUpdateEv=dlsym(RTLD_NEXT, "_ZN6CMusic11MusicUpdateEv");
printf("m_Active=%d\n",*(int *)(pMusic+(0x0c)));
printf("m_lpKaraokePlayer=%p\n",*(int *)(pMusic+(0x10)));
printf("m_lpRequest=%p\n",*(int *)(pMusic+(0x18)));
}
int pScreen = *(int *)(pMusic+(0x1c));
int pUIView = *(int *)(pMusic+(0x14));
pRequestScreen = pUIView + 0x2400;
int pBlackScreen = pUIView + 0x58c8;
int pBlackScreen2 = pUIView + 0x6194;
int OSDScreen = pUIView + 0x1b34;
int TFTLyric = pUIView + 0x2ccc;
int PlayScreen = pUIView + 0x3598;
int PlayScreen2 = pUIView + 0x4730;
/*
_ZN7CScreen5ClearEm(pBlackScreen,rand());
_ZN7CScreen5ClearEm(pBlackScreen2,0x00ff0000);
_ZN7CScreen5ClearEm(OSDScreen,rand());
_ZN7CScreen5ClearEm(TFTLyric,0x00ff0000);
_ZN7CScreen5ClearEm(PlayScreen,0x00ff0000);
_ZN7CScreen5ClearEm(PlayScreen2,rand());
*/
int pKaraoke = *(int *)(pMusic+(0x10));
int pLyricPlayer = *(int*)(pKaraoke + 0x74);
int ret=pMusicUpdateEv(pMusic);
return ret;
}
int midiHandle=0;
int (*pMidiOpenDevice)();
int MIDI_OpenDevice(void){
printf("------- midi_device_open ----------\n");
pMidiOpenDevice=dlsym(RTLD_NEXT, "MIDI_OpenDevice");
int ret=pMidiOpenDevice();
int m_iMidiHandle= dlsym(RTLD_NEXT, "m_iMidiHandle");
printf("midihandle=%x\n",m_iMidiHandle);
}
int (*pfMIDI_OpenStream)(int StreamType,int TimerID,unsigned short SizeOfStreamBuffer,
unsigned short NumberOfQueue);
int MIDI_OpenStream(int StreamType,int TimerID,unsigned short SizeOfStreamBuffer,
unsigned short NumberOfQueue){
printf("------- MIDI_OpenStream ----------\n");
pfMIDI_OpenStream=dlsym(RTLD_NEXT, "MIDI_OpenStream");
int ret=pfMIDI_OpenStream(StreamType,TimerID,SizeOfStreamBuffer,NumberOfQueue);
printf("ret=%p \n",ret);
return ret;
}
typedef BYTE BOOL;
struct tagWIPE {
BOOL Active;
WORD BaseY;
WORD Height;
WORD CurrntX;
WORD StartX;
WORD EndX;
BYTE Attribute[1280];
DWORD StartTime;
DWORD EndTime;
DWORD time[1280];
};
typedef struct tagWIPE tagWIPE, *PtagWIPE;
typedef struct tagWIPE WIPE;
void dumpWiper(WIPE *pWipe){
printf("Active=%d,BaseY=%d,Height=%d\n",pWipe->Active,pWipe->BaseY,pWipe->Height);
printf("StartTime=%dtick(%d),EndTime=%dtick(%d)\n",pWipe->StartTime,pWipe->StartTime*30,pWipe->EndTime,pWipe->EndTime*30);
DWORD s;
int n=0;
// for(s=pWipe->StartTime;s<pWipe->EndTime;s++){
for(n=0;n<128;n++){
// printf("\t[%d] time=%d attr=0x%x",n,pWipe->time[n],pWipe->Attribute[n]);
}
// if( n >
// }
}
//CLyricPlayer::DrawLine(CLyricPlayer *this,LPLINE_TABLE lpLine,LPWIPE lpWiper,DWORD minusY)
unsigned short (*pDrawLine)(int pLyric,void *pLine,int wiper,unsigned int my);
int linecount=0;
#if 0
unsigned short _ZN12CLyricPlayer8DrawLineEP13tagLINE_TABLEP7tagWIPEm(int pLyric,int pLine,int wiper,unsigned int my){
printf("_ZN12CLyricPlayer8DrawLineEP13tagLINE_TABLEP7tagWIPEm\n");
if(pDrawLine==NULL){
pDrawLine=dlsym(RTLD_NEXT, "_ZN12CLyricPlayer8DrawLineEP13tagLINE_TABLEP7tagWIPEm");
}
/*
int ptr = pLyric;
int off=0;
for(off=0;off<0x2f0;off++){
printf("%p %02x \n",off,(*((char*)(ptr+off)))&0xff);
}*/
LINE_TABLE *pLineTable=(LINE_TABLE *)pLine;
WIPE *pWipe=(WIPE *)wiper;
printf("lpLine->bLineNumber=%d\n",pLineTable->bLineNumber);
// DWORD dwInTime;
// DWORD dwInDurationTime;
// DWORD dwOutTime;
// DWORD dwOutDurationTime;
printf("dwInTime=%d dwInDurationTime=%d dwOutTime=%d dwOutDurationTime=%d\n",pLineTable->dwInTime,pLineTable->dwInDurationTime
,pLineTable->dwOutTime,pLineTable->dwOutDurationTime);
//dumpWiper(pWipe);
// printf("\n");
int n;
printf("lpLine->bNumberOfCharData=%d\n",*((char*)pLine+0x1c));
printf("lpLine->lpData=%p\n",*((int*)((char*)pLine+0x34)));
for(n=0;n<*((char*)pLine+0x1c);n++){
char *p= (int *)(*((int*)((char*)pLine+0x34)));
p=p+0x2c*n;
printf("lpLine->lpData[%d] =%p , %02x %02x %c%c\n",n,p,p[1]&0xff,p[0]&0xff,p[1]&0xff,p[0]&0xff);
}
/*
int pScreen = _ZN12CLyricPlayer9GetScreenEv(pLyric);
_ZN7CScreen5ClearEm(pScreen,0xffff00ff);
*/
/*
char buf[24];
sprintf(buf,"%d",linecount);
*/
int ret= pDrawLine(pLyric,pLine,wiper,my);
//_ZN7CScreen7PutTextEiiPc(pScreen,0,0,buf);
//printf("linecount=%d\n");
return ret;
}
#endif
#if 0
bool __thiscall CMDVIndex::GetSelfBGV(CMDVIndex *this,SONG_NUMBER sn,DWORD dwIndexFileNumber)
_ZN9CMDVIndex10GetSelfBGVE14tagSONG_NUMBERm
bool __thiscall CVideoPlayer::SeekPlayList(CVideoPlayer *this,DWORD timeMs)
int _ZN12CVideoPlayer12SeekPlayListEm(int pVideo,DWORD timeMS){
}
//bool __thiscall CVideoPlayer::AddOffsetPlayList(CVideoPlayer *this)
ZN12CVideoPlayer17AddOffsetPlayListE15tagVSTREAM_TYPEtmmmbmmmmPv
bool AddOffsetPlayList(CVideoPlayer * this, VSTREAM_TYPE StreamType,
WORD wFolderNumber, DWORD dwFileNumber, DWORD dwStartOffset, DWORD dwEndOffset, bool bRepeat,
DWORD dwDispStartFrame, DWORD dwDispEndFrame, DWORD dwBaseFrameInFile, DWORD
dwAdjustDispStartFrame, LPVOID lpWmvInfo
#endif
#if 0
unsigned short (*pLyricPutChar)(int this,int lpTest,DWORD minusY,int fontHeader);
unsigned short _ZN12CLyricPlayer7PutCharEP11tagCharDatamP14tagFONT_HEADER(int this,int lpText,DWORD minusY,int lpFontHeader){
if(pLyricPutChar==NULL){
pLyricPutChar=dlsym(RTLD_NEXT, "_ZN12CLyricPlayer7PutCharEP11tagCharDatamP14tagFONT_HEADER");
}
char *p=(char *)lpText;
printf("LyricPutChar\n");
printf("%c%c %04x - ",p[1],p[0],*(short*)p);
p[0]++;
printf("%c%c %04x \n",p[1],p[0],*(short*)p);
return pLyricPutChar(this,lpText,minusY,lpFontHeader);
}
unsigned short (*pPutChar)(void *pScreen,int x,int y,unsigned short code,void *header);
unsigned short _ZN7CScreen7PutCharEiitP14tagFONT_HEADER(void *pScreen,int x,int y,unsigned short code,void *header){
// printf("_ZN7CScreen7PutCharEiitP14tagFONT_HEADER\n");
if(pPutChar==NULL){
pPutChar=dlsym(RTLD_NEXT, "_ZN7CScreen7PutCharEiitP14tagFONT_HEADER");
}
printf("%c%c %04x - ",((code>>8)&0xff),code&0xff,code);
unsigned short code2=code+1;
printf("%c%c %04x ",((code2>>8)&0xff),code2&0xff,code2);
return pPutChar(pScreen,x,y,code2,header);
}
#endif
#if 0
//bool __thiscall CScreen::Clear(CScreen *this,DWORD color)
/*
int _ZN12CLyricPlayer9GetScreenEv(int this);
*/
int (*plyric_update)(int this);
int _ZN12CLyricPlayer6UpdateEv(int this){
if(plyric_update==NULL){
plyric_update=dlsym(RTLD_NEXT, "_ZN12CLyricPlayer6UpdateEv");
}
int ret = plyric_update(this);
return ret;
}
int (*pokdstop)(void *p);
int _ZN14CKaraokePlayer7OkdStopEv(void *p){
printf("okd stop\n");
pokdstop=dlsym(RTLD_NEXT, "_ZN14CKaraokePlayer7OkdStopEv");
// pthread_kill(thread, 0);
return pokdstop(p);
}
void *(*pymhCSei2_DrawEvalPitch)
(int param_1,undefined4 *param_2,int param_3,int *param_4,int param_5,int param_6);
void *ymhCSei2_DrawEvalPitch(int param_1,undefined4 *param_2,int param_3,int *param_4,int param_5,int param_6){
if(pymhCSei2_DrawEvalPitch==NULL){
pymhCSei2_DrawEvalPitch=dlsym(RTLD_NEXT, "ymhCSei2_DrawEvalPitch");
}
printf("ymhCSei2_DrawEvalPitch,%d,%d,%d,%d,%,%d\n",param_1,param_2,param_3,param_4,param_5,param_6);
return pymhCSei2_DrawEvalPitch(param_1,param_2,param_3,param_4,param_5,param_6);
}
void (*pymhCSei2_DrawNewPage)(int param_1,int param_2,undefined4 *param_3,int param_4);
void ymhCSei2_DrawNewPage(int param_1,int param_2,undefined4 *param_3,int param_4){
if(pymhCSei2_DrawNewPage==NULL){
pymhCSei2_DrawNewPage=dlsym(RTLD_NEXT, "ymhCSei2_DrawNewPage");
}
printf("pymhCSei2_DrawNewPage,%d,%d,%d,%d\n",param_1,param_2,param_3,param_4);
return pymhCSei2_DrawNewPage(param_1,param_2,param_3,param_4);
}
/*
void *(*pCScreen9GetBufferEv)(void* pThis);
void *_ZN7CScreen9GetBufferEv(void* pThis){
if(pCScreen9GetBufferEv==NULL){
pCScreen9GetBufferEv=dlsym(RTLD_NEXT, "pCScreen9GetBufferEv");
}
void *p=pCScreen9GetBufferEv(pThis);
printf("pCScreen9GetBufferEv(%p) ret = %p\n",pThis,p);
return p;
}*/
int (*pMIDI_GetReceivedData)(char Port, uchar * lpBuffer);
int MIDI_GetReceivedData(char Port, uchar * lpBuffer){
if(pMIDI_GetReceivedData==NULL){
pMIDI_GetReceivedData=dlsym(RTLD_NEXT, "MIDI_GetReceivedData");
}
int ret=pMIDI_GetReceivedData(Port,lpBuffer);
/*
if(Port == 1 || Port == 3 ){
if(ret!=0){
printf("recv port[%d] ",Port);
int n;
for(n=0;n<ret;n++){
printf("%02X ",lpBuffer[n]);
}
printf("\n");
}
}*/
return ret;
}
int logging=0;
int cnt2;
FILE *flog;
int (*pMIDI_SendStream)(int stream_ID,ulong Time,uchar Port,uchar channel,uchar *lpBuffer,ushort Length);
int MIDI_SendStream(int stream_ID,ulong Time,uchar Port,uchar channel,uchar *lpBuffer,ushort Length)
{
int y;
if(pMIDI_SendStream==NULL){
pMIDI_SendStream=dlsym(RTLD_NEXT, "MIDI_SendStream");
}
int ret=pMIDI_SendStream(stream_ID,Time,Port,channel,lpBuffer,Length);
//printf("------- MIDI_SendStream ----------\n");
if(logging){
flog=fopen("/XG/B/log0.dat","a+");
/*
printf("stream id=%d time=%d port=%d channel=%d",stream_ID,Time,Port,channel);
for(y=0;y<Length;y++){
printf("%02x ",lpBuffer[y]);
}*/
struct timeval myTime;
struct tm *time_st;
gettimeofday(&myTime, NULL);
time_st = localtime(&myTime.tv_sec);
fprintf(flog,"%d/%02d/%02d %02d:%02d:%02d.%06d\t", // ���ݎ���
time_st->tm_year+1900, // �N
time_st->tm_mon+1, // ��
time_st->tm_mday, // ��
time_st->tm_hour, // ��
time_st->tm_min, // ��
time_st->tm_sec, // �b
myTime.tv_usec // �}�C�N���b
);
fprintf(flog,"%ld\t%d\t%d\t%d\t%d\t",Time,stream_ID,Port,channel,Length);
int n;
for(n=0;n<Length;n++){
fprintf(flog,"%02X ",lpBuffer[n]);
}
fprintf(flog,"\n");
fclose(flog);
}
return ret;
}
unsigned int (*pokdLoadMemory) (int param_1, unsigned int param_2, unsigned int * param_3, unsigned int * param_4, unsigned int * param_5);
unsigned int okdLoadMemory (int param_1, unsigned int param_2, unsigned int * param_3, unsigned int * param_4, unsigned int * param_5){
puts("okdLoadMemory");
pokdLoadMemory=dlsym(RTLD_NEXT, "okdLoadMemory");
printf("%x,%x,%x,%x,%x\n",param_1,param_2,param_3,param_4,param_5);
return pokdLoadMemory(param_1,param_2,param_3,param_4,param_5);
}
int (*pokdFileReadOpen)(unsigned short *param_1,int param_2,unsigned int param_3,int *param_4sss);
int okdFileReadOpen(unsigned short *param_1,int param_2,unsigned int param_3,int *param_4){
if( pTones != NULL ) {
free(pTones);
pTones = NULL;
lastShowNum = 0;
}
puts("okdFileReadOpen");
pokdFileReadOpen=dlsym(RTLD_NEXT, "okdFileReadOpen");
printf("%x,%x,%x,%x\n",param_1,param_2,param_3,param_4);
printf("number assumed = %d.%d\n",param_1[0],param_1[1]);
return pokdFileReadOpen(param_1,param_2,param_3,param_4);
}
unsigned int (*pokdLoad)(int param_1,int param_2,int param_3,int param_4,int param_5);
unsigned int okdLoad(int param_1,int param_2,int param_3,int param_4,int param_5){
puts("okdLoad");
pokdLoad=dlsym(RTLD_NEXT, "okdLoad");
printf("%x,%x,%x,%x,%x\n",param_1,param_2,param_3,param_4,param_5);
return pokdLoad(param_1,param_2,param_3,param_4,param_5);
}
//bool __thiscall CLyricPlayer::Play(CLyricPlayer *this)
int (*pCLyricPlayer4PlayEv)(void *pThis);
int _ZN12CLyricPlayer4PlayEv(void *pThis){
int n;
puts("_ZN12CLyricPlayer4PlayEv");
pCLyricPlayer4PlayEv=dlsym(RTLD_NEXT, "_ZN12CLyricPlayer4PlayEv");
printf("CLyricPlayer this=%p\n",pThis);
void *pGKLHeader = pThis + 0x2c;
struct tagLINE_TABLE *pLineTable = (struct tagLINE_TABLE *)(pThis + 0x14d4);
printf("filesize=%d\n",*((int*)pGKLHeader));
fflush(stdout);
int songsize = *(short*)((char*)pGKLHeader+0x38);
for(n=0;n<songsize;n++){
printf("%02x ",((char*)pGKLHeader+0x3a)[n]&0xff);
}
fflush(stdout);
int ret= pCLyricPlayer4PlayEv(pThis);
return ret;
}
#endif
int to32bit(int d){
char *p=(char *)&d;
int ret= p[0] & 0xff ;
ret =( ret << 8 ) + ( p[1] & 0xff );
ret =( ret << 8 ) + ( p[2] & 0xff );
ret =( ret << 8 ) + ( p[3] & 0xff );
return ret;
}
int readTrack(char *p,int size);
struct PTrackInfo {
// YPTI
uint16_t track_count;
struct _trackmetadata {
uint8_t track_number;
uint8_t flags;
uint16_t use_channel_grouping_flags;
uint16_t default_channel_groups[16];
uint16_t channel_groups[16];
struct _channel_metadata {
uint8_t attributes;
uint8_t ports;
uint8_t control_change_ax;
uint8_t control_change_cx;
} channel_metadata[16];
uint16_t sys_ex_ports;
} track_metadata[4]; // temporary alloc
// struct _trackmetadata track_metadata[] ;
};
int parseTrack(char *p){
//
p=p+4; /// header
p=p+4; /// size
struct PTrackInfo info;
info.track_count= (p[0] << 8) | p[1];
p+=2;
int copySize = sizeof(uint16_t) + sizeof(struct _trackmetadata) * info.track_count;
printf("track metadata copying size = %d(0x%x)\n",copySize,copySize);
memcpy(&info.track_metadata,p,copySize);
int t;
for(t=0;t<info.track_count;t++){
printf("track %d/%d\n",t,info.track_count);
printf("track number=%d\n",info.track_metadata[t].track_number);
printf("other flags : %02x\n",info.track_metadata[t].flags);
printf("ch grouping frag = 0x%02x\n",info.track_metadata[t].use_channel_grouping_flags);
int ch;
printf("default_channel_groups ");
for(ch=0;ch<16;ch++){
printf("%02X ",info.track_metadata[t].default_channel_groups[ch]);
}
printf("\n");
printf("channel_groups ");
for(ch=0;ch<16;ch++){
printf("%2X ",info.track_metadata[t].channel_groups[ch]);
}
printf("\n");
}
return 0;
}
char *MTrackDelta(unsigned char *p,unsigned int *pDur){
unsigned int *pDur_local;
unsigned char *pData_local;
if( (unsigned int)*p < (unsigned int)0x40 ){
pData_local = p + 1;
*pDur = (unsigned int)*p;
}else if( (unsigned int)p[1] < (unsigned int)0x40 ){
*pDur = (unsigned int)*p;
pData_local = p + 2;
*pDur = (unsigned int)p[1] * 0x40 + *pDur;
}else if( (unsigned int)p[2] < (unsigned int)0x40 ){
*pDur = (unsigned int)*p;
*pDur = (unsigned int)p[1] * 0x40 + *pDur;
pData_local = p + 3;
*pDur = (unsigned int)p[2] * 0x1000 + *pDur;
}else {
printf("delta parse error(0x%x)",*p);
pData_local = p + 1;
*pDur = 0;
}
char *pp;
//printf("vtime ");
for(pp=p;pp<pData_local;pp++){
// printf("[%02x]-",*pp);
}
//printf(" calced dalta=%d\n",*pDur);
return pData_local;
}
int MTrack(char *p){
char *pStart=p;
int n;
for(n=0;n<16;n++){
printf("%02x ",p[n]);
}
printf("\n");
p=p+4; // header
int size = ((p[0] << 24) & 0xff000000) + ((p[1] << 16) & 0x00ff0000) + ((p[2] << 8) & 0x0000ff00) + (p[3] & 0xff);
unsigned int tick = 0;
p=p+4; // size
printf("MTrack(%p) size=%d(%x)\n",p,size,size);
char message;
unsigned int length=0;
while( p-pStart <= size || (memcmp(p,"\x00\x00\x00\x00",4) != 0)/*(p[0] + p[1] + p[2] + p[3]) != 0*/ ) {
char param;
if( (*p & 0xf0 )== 0xf0 ){
// printf("status=0x%x ", (*p)&0xff );
message = *p;
p++;
// printf("tick=%d ",length);
// message is last messaege
switch(message&0xff){
case 0xF1:
case 0xF2:
case 0xF4:
case 0xF5:
// 1byte message:
// printf("Beat@%d %02x\n",length, message&0xff);
if( ( message & 0xff )== 0xf4 ){
n_guidePage++;
page[n_guidePage].start=length;
if( n_guidePage > 0 ){
page[n_guidePage-1].stop=length-1;
}
}
break;
case 0xFF:
printf("sysex: ");
do{
printf("%02x ", (*p)&0xff );
p++;
}while( ((*p)&0xff) != 0xfe );
p++;
printf(" \n");
break;
case 0xF3:
case 0xF6:
case 0xF8:
param = *p;
p++;
// printf(" %02x - %02x\n", message,param );
if( (message & 0xff )==0xf6 && ( param & 0xff )== 0){
musicOffset=length;
printf("music offset = %d\n",musicOffset);
}
break;
default:
printf("unknown message 0x%x@%p\n",message,(p-pStart));
}
}else{
p=MTrackDelta(p,&tick);
length=length+tick;
}
}
page[n_guidePage].stop=length;
int pp;
for(pp=0;pp<n_guidePage;pp++){
printf("page[%d] start=%d,stop=%d \n",pp,page[pp].start,page[pp].stop);
}
return 0;
}
unsigned char * CommonCalcContDuration(unsigned char *pData,u_int32_t *pDur)
{
u_int32_t *pDur_local;
unsigned char *pData_local;
u_int32_t uwTmpDur;
*pDur = 0;
pData_local = pData;
while ( !(*pData_local & 0x80) && (*pData_local != '\0')) {
// printf("pData_local=%x\n",*pData_local);
pData_local = MTrackDelta(pData_local,&uwTmpDur);
// printf("mtrdelta %d\n",uwTmpDur);
*pDur = *pDur + uwTmpDur;
}
return pData_local;
}
char* PTrackDelta(char *p,unsigned int *pDur){
}
void noteMake(int ch,unsigned int tick,unsigned int tickOff,char pitch,char vel){
play_status.nl.chList[ch][play_status.nl.counts[ch]].tickOn=tick;
play_status.nl.chList[ch][play_status.nl.counts[ch]].tickOff=tickOff;
play_status.nl.chList[ch][play_status.nl.counts[ch]].pitch=pitch;
play_status.nl.chList[ch][play_status.nl.counts[ch]].velocity=vel;
play_status.nl.counts[ch]++;
}
int PTrack(char *p){
int count[16] = {0 };
int n;
for(n=0;n<32;n++){
printf("%02x ",p[n]&0xff);
}
printf("\n");
p=p+4; // header
unsigned int size = ((p[0] << 24) & 0xff000000) + ((p[1] << 16) & 0x00ff0000) + ((p[2] << 8) & 0x0000ff00) + (p[3] & 0xff);
unsigned int tick = 0;
p=p+4; // size
printf("size=%d(%x)\n",size,size);
unsigned int dur=0,length=0;
int pitch,vel,ch,offvel;
char sysexbuf[128];
int sysexcount=0;
const char* pitchname[12] = {"C","C#","D","D#","E","F","F#","G","G#","A","A#","B" };
while( memcmp(p,"\x00\x00\x00\x00",4)!= 0 ){
// printf("p=%x ",(*p)&0xff);
char status= (*p)&0x80;
if( status ){
switch( (*p) &0xf0){
case 0x90:
count[((*p)>>4)&0x0f]++;
pitch=p[1];
ch=p[0]&0x0f;
//printf("<%02x>@%d noteon ch=%d pitch=%d(%s)\n",p[0]&0xff,length, p[0]&0x0f,p[1],pitchname[p[1]%12]);
vel=64;
p++; // 9n next
p++; // pitch next
p++; // velocity next
// printf("delta[%02x]\n",*p);
p=MTrackDelta(p,&dur);
// noteMake(ch,length,length+dur,pitch,64);
{
toneinfo t;
t.tick=length;
t.pitch=pitch;
t.ch = play_status.tracknum*16+ch;
t.length=dur / 16;
play_status.pTones[play_status.numoftones]=t;
play_status.numoftones++;
}
//printf("delta read dur =%d next byte = [%02x] \n",dur,*p);
//printf(" length=%d\n",dur);
break;
case 0x80:
count[((*p)>>4)&0x0f]++;
pitch=p[1];
ch=p[0]&0x0f;
vel=p[2];
offvel=p[3];
/*
printf("<%02x>@%d noteon(80) ch=%d pitch=%d(%s) vel=%d,%d ",p[0]&0xff,length, p[0]&0x0f,p[1],pitchname[p[1]%12],p[2],p[3]);
{
int d;
for(d=0;d<8;d++){
printf("%02x ",p[d]&0xff);
}
}
printf("\n");
*/
p++; // 8n next
p++; // pitch next
p++; // noteonvel next
p++; // noteoff next
//printf("next delta[%02x]\n",*p);
p=MTrackDelta(p,&dur);
//printf("delta after[%02x] ,dur=%d\n",*p,dur);
//printf("length=%d\n",dur);
{
toneinfo t2;
t2.tick=length;
t2.pitch=pitch;
t2.ch = play_status.tracknum*16+ch;
t2.length=dur / 16;
play_status.pTones[play_status.numoftones]=t2;
play_status.numoftones++;
}
break;
case 0xA0:
count[((*p)>>4)&0x0f]++;
// printf("%02X Alternate ControlChange val=%02x\n",p[0]&0xff,p[1]&0xff);
p++;
p++;
break;
case 0xB0:
count[((*p)>>4)&0x0f]++;
// printf("%02X ControlChange val=%02x-%02x\n",p[0]&0xff,p[1]&0xff,p[2]&0xff);
p++;
p++;
p++;
break;
case 0xC0:
count[((*p)>>4)&0x0f]++;
// printf("%02x Alternate Control Change %02x\n",p[0]&0xff,p[1]&0xff);
p++;
p++;
break;
case 0xD0:
count[((*p)>>4)&0x0f]++;
// printf("ev D\n");
p++;
p++;
break;
case 0xE0:
count[((*p)>>4)&0x0f]++;
// printf("ev E\n");
p++;
p++;
p++;
break;
default:
switch((*p)&0xff){
case 0xF0:
sysexcount=0;
printf("sysex:%02x ",(*p)&0xff);
do{
sysexbuf[sysexcount]=*p;
sysexcount++;
p++;
//printf(" %02x ",(*p)&0xff);
} while( ((*p)&0xff) != 0xf7 );
p++;
int x;
for(x=0;x<sysexcount;x++){
printf("%02x ",sysexbuf[x]&0xff);
}
if( ( sysexbuf[3] & 0xff) == 0x31 ){
int deviceId = sysexbuf[2] - 0x11;
const int addrtopart[16] = { 10,1,2,3,4,5,6,7,8,9,11,12,13,14,15,16 };
printf("\nparam data addr = %02x-%02x-%02x\n", sysexbuf[4],sysexbuf[5],sysexbuf[6] );
int addrBase = ((sysexbuf[4] & 0xff) << 16) | ((sysexbuf[5] & 0xff) << 8) | (sysexbuf[6] & 0xff);
int a=7;
int offset = 0;
for(;a<sysexcount -1 /*&& ((sysexbuf[a]&0xff) != 0xf7 )*/ ;a++){
printf("param data addr = %08x ",addrBase + offset );
int voiceData = ( addrBase + offset ) & 0xff00ff;
switch( voiceData ){
case 0x040000:
printf("VOICE EFFECT NUMBER : 0x%x\n",sysexbuf[a] & 0xff);
break;
case 0x040001:
printf("VOICE MODE : 0x%x\n",sysexbuf[a] & 0xff);
break;
case 0x040002:
printf("VOICE LEVEL : %d\n",sysexbuf[a] & 0xff);
break;
case 0x040003:
case 0x040004:
case 0x040005:
case 0x040006:
case 0x040007:
case 0x040008:
case 0x040009:
case 0x04000a:
printf("VOICE NAME : %c\n",sysexbuf[a] & 0xff);
break;
}
int addrData = (addrBase + offset) & 0xfff0ff;
int chBase = addrtopart[sysexbuf[5] & 0x0f] ;
switch( addrData ){
case 0x000004:
printf("Master Volume : %d\n",sysexbuf[a] & 0xff);
break;
case 0x010003:
printf("Reverce TYPE:%d",sysexbuf[a] & 0xff);
break;
case 0x020000:
printf("Element Reserve:%d",sysexbuf[a] & 0xff);
break;
case 0x020024:
printf("Chorus send:%d",sysexbuf[a] & 0xff);
break;
case 0x020025:
printf("Reverb send:%d",sysexbuf[a] & 0xff);
break;
case 0x020041:
printf("Bend Pitch:%d",sysexbuf[a] & 0xff);
break;
case 0x020001:
printf("part[%d] Bank Select MSB:%d\n",chBase,sysexbuf[a] & 0xff);
break;
case 0x020002:
printf("part[%d] Bank Select LSB:%d\n",chBase,sysexbuf[a] & 0xff);
break;
case 0x020003:
printf("part[%d] Program Number:%d Name=%s\n",chBase,sysexbuf[a] & 0xff,gm_instruments[sysexbuf[a] & 0xff].name);
play_status.ncount_ch[chBase+deviceId*16].program=sysexbuf[a] & 0xff;
break;
case 0x020017:
printf("Part Mode:%d\n",sysexbuf[a] & 0xff);
play_status.ncount_ch[chBase+deviceId*16].partmode=sysexbuf[a] & 0xff;
case 0x02001b:
printf("Volume:%d\n",sysexbuf[a] & 0xff);
break;
}
// printf("\n");
offset++;
}
}
printf("\n");
break;
case 0xF8:
p++;
p++;
p++;
p++;
break;
case 0xF9:
p++;
p++;
break;
case 0xFA:
p++;
p++;
break;
case 0xFD:
p++;
break;
case 0xFE:
{
p++;
char anh=*p;
printf("alter fe[%02x]-%02x-%02x\n",p[0]&0xff,p[1]&0xff,p[2]&0xff);
p++;
p++;
if( (anh & 0xf0) == 0xa0 ) {
p++;
}
printf("\n");
break;
}
}
}
}else{
if( *p == 0 ){
p++;
continue;
}
//printf("delta[%02x]\n",*p);
p=CommonCalcContDuration(p,&dur);
//printf("delta after[%02x] ,dur=%d\n",*p,dur);
length += dur;
//printf("Length=%d\n",length);
}
}
printf("track [%d]\n", play_status.tracknum);
for(n=8;n<=0xe;n++){
printf("0x%x %d\n", n<<4 , count[n]);
}
play_status.tracknum++;
}
int readTrack(char *p,int size){
// vector(toneinfo) vnote=vector_init(toneinfo,1);
int n;
int i;
for(n=0;n<size-4;n++){
if( memcmp(p+n,"\xffMR",3)==0){
printf("MTrack @%p\n",(void*)n);
MTrack(p+n);
}
if( memcmp(p+n,"YP3I",4)==0){
printf("P3Track Infomaiton@%p\n",(void*)n);
}
if( memcmp(p+n,"YPTI",4)==0){
printf("PTrack Infomaiton@%p\n",(void*)n);
parseTrack( p+n );
}
if( memcmp(p+n,"YPXI",4)==0){
printf("PTrack Extended Infomaiton@%p\n",(void*)n);
}
if( memcmp(p+n,"\xffPR",3)==0 && (p[n+3] & 0xff ) < 0x10){
printf("PTrack @%p\n",(void*)n);
PTrack(p+n);
int pn;
for(pn=0;pn<n_guidePage;pn++){
printf("page[%d] start=%d,stop=%d \n",pn,page[pn].start,page[pn].stop);
}
}
}
}
bool (*pf_Z15SETUP_GetRecord13RECORD_NUMBERPvt)(int id,int lpData,WORD length);
bool _Z15SETUP_GetRecord13RECORD_NUMBERPvt(int id,int lpData,WORD length){
if(pf_Z15SETUP_GetRecord13RECORD_NUMBERPvt==NULL){
pf_Z15SETUP_GetRecord13RECORD_NUMBERPvt=dlsym(RTLD_NEXT, "_Z15SETUP_GetRecord13RECORD_NUMBERPvt");
}
bool ret=pf_Z15SETUP_GetRecord13RECORD_NUMBERPvt(id,lpData,length);
printf("GetRecordBytes(%d,%x,%s),length=%d)\n",id,id,GetRecIndex(id),length);
int i;
for(i=0;i<length;i++){
printf("%02x(%c) ",((char *)lpData)[i]&0xff,((char *)lpData)[i]&0xff);
}
printf("\n");
return ret;
}
WORD (*pf_Z13SETUP_GetWord13RECORD_NUMBER)(int n);
WORD _Z13SETUP_GetWord13RECORD_NUMBER(int n){
if(pf_Z13SETUP_GetWord13RECORD_NUMBER==NULL){
pf_Z13SETUP_GetWord13RECORD_NUMBER=dlsym(RTLD_NEXT, "_Z13SETUP_GetWord13RECORD_NUMBER");
}
short ret=pf_Z13SETUP_GetWord13RECORD_NUMBER(n);
printf("GetRecordWord(%d(%x)%s) = %d(%x)\n",n,n,GetRecIndex(n),ret,ret);
return ret;
}
DWORD (*pf_Z9SETUP_Get13RECORD_NUMBER)(int n);
DWORD _Z9SETUP_Get13RECORD_NUMBER(int n){
if(pf_Z9SETUP_Get13RECORD_NUMBER==NULL){
pf_Z9SETUP_Get13RECORD_NUMBER=dlsym(RTLD_NEXT, "_Z9SETUP_Get13RECORD_NUMBER");
}
int ret=pf_Z9SETUP_Get13RECORD_NUMBER(n);
printf("GetRecordDword(%d(%x)%s) = %d(%x)\n",n,n,GetRecIndex(n),ret,ret);
return ret;
}
int _ZN9CBillCoin7IsEmptyEv(int n){
return 0;
}
int (*pf_Z9SETUP_Set13RECORD_NUMBERm)(int n,DWORD data);
int _Z9SETUP_Set13RECORD_NUMBERm(int number,DWORD data){
if(pf_Z9SETUP_Set13RECORD_NUMBERm==NULL){
pf_Z9SETUP_Set13RECORD_NUMBERm=dlsym(RTLD_NEXT, "_Z9SETUP_Set13RECORD_NUMBERm");
}
int ret=pf_Z9SETUP_Set13RECORD_NUMBERm(number,data);
printf("SETUP_Set(%d(%x)%s) = %d(%x)\n",number,number,GetRecIndex(number),data,data);
return ret;
}
int (*pf_Z13SETUP_SetWord13RECORD_NUMBERt)(int n,short data);
int _Z13SETUP_SetWord13RECORD_NUMBERt(int n,short data){
if(pf_Z13SETUP_SetWord13RECORD_NUMBERt==NULL){
pf_Z13SETUP_SetWord13RECORD_NUMBERt=dlsym(RTLD_NEXT, "_Z13SETUP_SetWord13RECORD_NUMBERt");
}
int ret=pf_Z13SETUP_SetWord13RECORD_NUMBERt(n,data);
printf("SETUP_SetWord(%d(%x),%s) = %d(%x)\n",n,n,GetRecIndex(n),data,data);
return ret;
}
int (*pf_Z15SETUP_SetRecord13RECORD_NUMBERPvt)(int id,char *p,short length);
int _Z15SETUP_SetRecord13RECORD_NUMBERPvt(int id,char *lpData,short length){
if(pf_Z15SETUP_SetRecord13RECORD_NUMBERPvt==NULL){
pf_Z15SETUP_SetRecord13RECORD_NUMBERPvt=dlsym(RTLD_NEXT, "_Z15SETUP_SetRecord13RECORD_NUMBERPvt");
}
int ret=pf_Z15SETUP_SetRecord13RECORD_NUMBERPvt(id,lpData,length);
int i;
printf("SETUP_SetRecord(%s) \n",GetRecIndex(id));
for(i=0;i<length;i++){
printf("%02x(%c) ",((char *)lpData)[i]&0xff,((char *)lpData)[i]&0xff);
}
printf("\n");
return ret;
}
char *_ZN11CMusicIndex8GetTitleE14tagSONG_NUMBER(int,int);
char *pMusicIndex;
int GetMusicInfo(int argc,char **argp);
pthread_t threadf;
void *thread_func2(void *param){
GetMusicInfo(0,NULL);
}
typedef struct YMH_OKDP_SONGDATA YMH_OKDP_SONGDATA, *PYMH_OKDP_SONGDATA;
typedef struct YMH_OKDP_FILEPOS YMH_OKDP_FILEPOS, *PYMH_OKDP_FILEPOS;
struct YMH_OKDP_FILEPOS {
ushort folder;
ulong file;
};
struct YMH_OKDP_SONGDATA {
struct YMH_OKDP_FILEPOS mOkdBody;
struct YMH_OKDP_FILEPOS mMmtDiff;
struct YMH_OKDP_FILEPOS mMp3MusDiff;
struct YMH_OKDP_FILEPOS mMp3Voc;
struct YMH_OKDP_FILEPOS mMp3VocDiff;
struct YMH_OKDP_FILEPOS mLyricDiff;
struct YMH_OKDP_FILEPOS mRef;
int refofs;
};
typedef enum YMH_OKDP_OPENMODE {
eYMH_OKDP_OPENMODE_KARAOKE=0,
eYMH_OKDP_OPENMODE_BGM=1,
eYMH_OKDP_OPENMODE_MEDLEY=2
} YMH_OKDP_OPENMODE;
int _ZN10COkdPlayer4OpenEmP17YMH_OKDP_SONGDATA17YMH_OKDP_OPENMODEPv(
void *okdPlayer,int sn,void *songdata,int mode,void *lpInfo);
void _ZN10COkdPlayerC1Ev(int p);
int target;
int GetMusicInfo(int argc,char **argp){
// char buffer[1024*1024];
char *pBuf=NULL;
char pOkd[0x34];
for(int t=2101;t<8000;t++){
for(int c=0;c<100;c++){
int sn = (( t << 8 ) & 0xffffff00) + c;
YMH_OKDP_SONGDATA songdata;
char fname[24];
sprintf(fname,"%04d%02d",t,c);
printf(fname);
target=sn;
for(int d=306;d<=307;d++){
songdata.mOkdBody.folder=d;
songdata.mOkdBody.file=atoi(fname);
char fullpath[1024];
sprintf(fullpath,"/XG/B/Data/%03d/%d/%03d.%s",d,t/1000,d,fname);
if( check_file(fullpath) ){
_ZN10COkdPlayerC1Ev(pOkd);
int ret = _ZN10COkdPlayer4OpenEmP17YMH_OKDP_SONGDATA17YMH_OKDP_OPENMODEPv(pOkd,sn,&songdata,eYMH_OKDP_OPENMODE_KARAOKE,pBuf);
_ZN10COkdPlayer5CloseEv(pOkd);
}else{
printf("%s not found.",fullpath);
}
}
}
}
return 0;
}
int _GetMusicInfo(int argc,char **argp){
printf("-------GetMusicInfo-------\n");
if( pMusicIndex == NULL ){
pMusicIndex=(char *)malloc(0x2c);
memset(pMusicIndex,0,0x2c);
_ZN11CMusicIndexC1Ev(pMusicIndex);
}
for(int t=2351;t<2352;t++){
char fname[255];
sprintf(fname,"/XG/B/Data/song%04d.txt",t);
FILE *fw=fopen(fname,"w");
printf("--------%04d--------\n",t);
for(int c=0;c<100;c++){
// int sn = ((c << 24) & 0xff000000) + t;
int sn = (( t << 8 ) & 0xffffff00) + c;
char *p=_ZN11CMusicIndex8GetTitleE14tagSONG_NUMBER(pMusicIndex,sn);
if( p!=NULL && *p ){
fprintf(fw,"%04d-%02d,%s",t,c,p);
fprintf(fw,"\n");
}
}
fclose(fw);
}
return 0;
}
int noReadTrack=1;
int (*pokdCombine)(int param_1,int param_2,unsigned int *param_3,int param_4);
int okdCombine(int param_1,int param_2,unsigned int *param_3,int param_4){
puts("okdCombine");
char *p=(char *)param_3;
printf("%x,%x,%c%c%c%c,%x\n",param_1,param_2,p[0],p[1],p[2],p[3],param_4);
pokdCombine=dlsym(RTLD_NEXT, "okdCombine");
char name[128];
if( memcmp(p,"YKYI",4) == 0 ){
char *pSize = p+4;
int size = ((pSize[0] << 24) & 0xff000000)
+((pSize[1] << 16) & 0xff0000)
+((pSize[2] << 8) & 0xff00)
+(pSize[3] & 0xff );
sprintf(name,"/XG/B/Data/%04d%02d.%c%c%c%c",target >> 8 , target & 0xff ,p[0],p[1],p[2],p[3]);
FILE *fp=fopen(name,"wb");
if(fp){
fwrite( p + 8 ,1,size,fp);
fclose(fp);
}else{
puts("write out file error.\n");
}
}
int r = pokdCombine(param_1,param_2,param_3,param_4);
return r;
}
int _okdCombine(int param_1,int param_2,unsigned int *param_3,int param_4){
puts("okdCombine");
char *p=(char *)param_3;
printf("%x,%x,%c%c%c%c,%x\n",param_1,param_2,p[0],p[1],p[2],p[3],param_4);
pokdCombine=dlsym(RTLD_NEXT, "okdCombine");
char name[128];
if( noReadTrack == 0 ){
sprintf(name,"/tmp/song-%d-[%c%c%c%c].honeylabin",param_2,p[0],p[1],p[2],p[3]);
FILE *fp=fopen(name,"wb");
if(fp){
fwrite(param_3,4,param_4/4,fp);
fclose(fp);
int n;
for(n=0;n<16;n++){
if(play_status.nl.chList[n]) free(play_status.nl.chList[n]);
play_status.nl.chList[n]=NULL;
play_status.nl.counts[n]=0;
}
for(n=0;n<16;n++){
play_status.nl.chList[n]=calloc(sizeof(noteOnOff),40960);
play_status.nl.counts[n]=0;
}
readTrack(param_3,param_4);
}else{
puts("write out file error.\n");
}
}
int r = pokdCombine(param_1,param_2,param_3,param_4);
return r;
}
Raw
Makefile
CC = mipsel-linux-uclibc-gcc
CFLAGS = -Wall -Wextra -std=c99 -fPIC -Wno-unused
LDFLAGS =
TARGET = /mnt/hgfs/share/mylib.so
SRCS = $(wildcard *.c)
OBJS = $(SRCS:.c=.o)
LIBS = -ldl
.PHONY: all clean
all: $(TARGET)
$(TARGET): $(OBJS)
$(CC) $(CFLAGS) -shared -o $@ $^ $(LIBS)
%.o: %.c
$(CC) $(CFLAGS) -c -o $@ $<
clean:
$(RM) $(TARGET) $(OBJS)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment