iChangzuo/AccompanyCube
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
AccompanyCube/GlobalUnit.cpp
T
alex_q 2191c1aed4 Initial commit
2026-06-13 00:10:11 +08:00

3412 lines
98 KiB
C++
Raw Permalink Blame History

// ---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include <mmsystem.h>
#include "GlobalUnit.h"
#include "CommonUnit.h"
// #include "ComposeStage.h"
// ---------------------------------------------------------------------------
#pragma package(smart_init)
#include <iphlpapi.h>
#pragma comment(lib, "iphlpapi.lib")
#define EX_NULL = NULL
/*************************************************************************************** /
// 全局常量
/************************************************************************************** */
const char *g_strDefaultSoundSet = "Pop default", *g_strSoundSetExt = "SF2",
*g_strMelodyKey[KEY_NUM] = {
"C", "bD", "D", "bE", "E", "F", "#F", "G", "bA", "A", "bB", "B"}, // 调号显示
*g_strTimeSignature[4] = {"4/4", "3/4", "2/4", "6/8"}, // 拍号
*g_strTSName[4] = {"44", "43", "42", "86"}, // 拍号命名
*g_strIntro[MAX_INTRO_NUM] = {"前/间奏-1", "前/间奏-2", "前/间奏-3", "前/间奏-4"
}, // 插入段显示文字
*g_strEnding[MAX_ENDING_NUM] = {"尾奏-1", "尾奏-2", "尾奏-3", "尾奏-4"
}, *g_strFill[COMPOSE_FILL_NUM] = {"加花-1", "加花-2"}, // 加花小节显示文字
*g_strStage = "%c段", // 旋律段显示文字
*g_strStageVar[STAGE_VAR_NUM] = {"(伴奏型1)", "(伴奏型2)", "(伴奏型3)", "(伴奏型4)"
}, // 分段伴奏型文字
*g_strProjError[10] = {
"打开工程失败！\n\n文件不存在",
"打开工程失败！\n\n版本太新，请更新软件到最新版",
"打开工程失败！\n\n专业版工程，请尝试用专业版打开",
"打开工程失败！\n\n无法识别的版本号",
"打开工程失败！\n\n文件已损坏",
"打开工程失败！\n\n音频数据被破环",
"打开工程失败！\n\n使用的风格未下载或已失效",
"指定音色库失效，使用缺省音色库。",
"部分段落风格失效，使用全局风格替换。" };
const COLORREF g_clrBackground = RGB(225, 225, 225), // 背景颜色,
g_clrGrid = RGB(127, 127, 127), // 格子颜色
g_clrText = RGB(0, 0, 0), // 文字颜色
g_clrChordBk = RGB(255, 255, 255), // 和弦背景色
g_clrFocus = RGB(227, 24, 19), // 选中颜色
g_clrPlayLine = RGB(255, 0, 0), // 播放标示线
g_clrStage[STAGE_VAR_NUM] = {
RGB(255, 240, 200), RGB(252, 236, 174), RGB(241, 205, 143),
RGB(242, 185, 121)}, // 分段颜色
g_clrStageDisable[STAGE_VAR_NUM] = {
RGB(206, 194, 162), RGB(204, 191, 141), RGB(195, 166, 116),
RGB(195, 149, 98)}, // 禁用分段颜色
g_clrEnding[MAX_INTRO_NUM] = {
RGB(203, 219, 247), RGB(190, 206, 233), RGB(200, 200, 200),
RGB(192, 192, 192)}, g_clrEndingDisable[MAX_INTRO_NUM] = {
RGB(164, 177, 200), RGB(153, 166, 188), RGB(200, 200, 200),
RGB(192, 192, 192)}, g_clrIntro[MAX_ENDING_NUM] = {
RGB(196, 230, 147), RGB(179, 215, 176), RGB(164, 164, 164),
RGB(156, 156, 156)}, g_clrIntroDisable[MAX_ENDING_NUM] = {
RGB(158, 186, 119), RGB(145, 174, 142), RGB(164, 164, 164),
RGB(156, 156, 156)};
const DWORD g_dwProjectVersion = MAKELONG(8, 2); //ver 2.8
//ver 2.0-2.1禁用，以判断早期版本
//ver 2.4 支持midimelody
//ver 2.5 g_bPredefine读写，支持无Audio
//ver 2.6 风格支付记/录记录工程功能费支付
//ver 2.7 增加工程模式标志 iMode=0,1,2
//ver 2.8 UPLOAD工程不写入声波数据
/*************************************************************************************** /
// 全局变量
/************************************************************************************** */
FONTINFOLIST g_lstFonts; // 音色库列表
MELODYBARLIST g_lstMelodyBars, // 旋律小节信息
g_lstMelodyBars_SVD;
MELODYSTAGELIST g_lstMelodyStages, // 旋律分段
g_lstMelodyStages_SVD;
COMPOSESTAGELIST g_lstComposeStages, // 曲式结构段落表
g_lstComposeStages_SVD;
BARVOLSLIST g_lstCompleteVols, // 全曲音波表
g_lstCompleteVols_SVD;
wstring g_strFontPath, // 音色库路径
g_strFontFile, // 音色库文件名
g_strFontFile_SVD, // 音色库文件名(已保存)
g_strLastSaveFile, // 上次保存音乐文件名
g_strExecutePath, // 执行文件路径
g_strUserPath, // 用户路径
g_strExtFontsPath, //扩展音色库路径
g_strProjectName, // 工程文件名
g_strAutoProjName; // 自动保存文件名
vector<wstring>g_lstRecentProject; // 最近的工程文件
HANDLE g_hProjectEvent; // 工程文件读写互斥变量
string g_strSelectedStyleName; // 选中风格名
vector<int>g_lstStyleSelected; // 选中风格类型集合
DWORD g_iSelectedStyleType = 0; // 选定风格类型
char g_strCurrentVersion[20] = "",
g_strServerURL[256] = "",
g_strPlaybackDevice[256] = "",
g_strRecordDevice[256] = "";
int g_arrIntroBarNum[MAX_INTRO_NUM], // 全局风格前间奏小节数
g_arrEndingBarNum[MAX_ENDING_NUM], // 全局风格尾奏小节数
g_idFont = -1, // 选中音色库序号
g_iSelectedStyleID = -1, // 风格ID
g_iLastStyleID = -1, // 上次使用的风格
g_iMelodyKey = -1, // 主旋律调号
g_iComposeKey = -1, // 伴奏调号，用于录音升降调
g_iMelodyTimeSignature = 0, // 主旋律拍号
g_nMelodyTempo = 75, // 主旋律速度
g_iPlaybackDevice = -1, // 指定播放设备号
g_iPlaybackOutput = -1, // 指定播放输出源
g_iRecordDevice = -1, //指定录音设备号
g_iRecordInput = -1, //录音输入源
g_nRecordChannels = 1, //缺省单通道录音
// g_lSongParam = 0, // 全曲参数
// g_lSongVerifyParam = 0, // 全曲鉴权参数
g_iLastSaveOption = SAVE_COMPOSESONG, // 上次保存选项
g_iLastSaveType = FILETYPE_MP3, // 上次保存文件格式
g_iCurrentPage = -1, // 保存工程时所处的页面
g_iWindowState = wsNormal,
g_iPreStageDefault = 2,
g_iPreStyleSort = STYLESORT_TIME | (STYLESORT_UP<<16),
g_nBuildVersion,
g_iSelectedStyleID_SVD = -1, g_iComposeKey_SVD = -1,
g_iMelodyKey_SVD = -1, // 主旋律调号(已保存)
g_iMelodyTimeSignature_SVD = 0, // 主旋律拍号(已保存)
g_nMelodyTempo_SVD = 75; // 主旋律速度(已保存)
float g_fRecordVolume = -1, // 录音音量
g_fSpeakerVolume = -1, // 喇叭音量
g_fAudioVolume = 1, // 音频音量
g_fMusicVolume = 1, // 伴奏音量
g_fRecordVolume_SVD = -1,
g_fSpeakerVolume_SVD = -1,
g_fAudioVolume_SVD = 1,
g_fMusicVolume_SVD = 1;
double g_dblStep = 0, g_dblTimePerBar = 0;
TUSERINFO g_infoUser;
TSOFTWAREINFO g_infoSoftwareUpdate;
TSONGINFO g_infoSong;
bool g_bRecordAutoAdjust = true, //录音自动音量调节
g_bRecordMoniter = false, //不启用录音监听
g_bShowRecordHint = true, // 噪音侦测
g_bUpdateMandatory = false, // 客户端需要强制更新
g_bMidiMelody = false, //导入MIDI旋律
g_bWeakup = false, // 旋律弱起
g_bShowPlayTick = true, // 显示小节节拍或时间
g_bAutoLogin = true,
g_bLogon = false,
g_bRecProtect = false, // 内录保护
g_bShowProtectMsg = true, //显示内录保护消息
g_bPredefine = false, // 预设工程（不自动编曲/接唱）
g_bAudioLoaded = false, // 音频已加载
g_bBaseComposeLoaded = false, // 基本编曲已加载
g_bComposeLoaded = false, // 编曲已加载
g_bSongLoaded = false, // 全曲已加载
// g_bSongSaved = false, //全曲已保存
g_bAudioChanged = false, // 初始录音修改
g_bSongChanged = false, // 全曲录音修改
g_bSongNeedSave = false, // 全曲录音需保存
g_bAutoSave = false, //是否需要恢复工程 //add by tj 2013/12/30
g_bAutoDownloadStyle = true, //自动下载风格
g_bAutoOpenProject = false, //自动打开上次工程
g_bAutoOpenProjectEnable = false, //自动打开上次工程使能
g_bProjStylePaid = false, //工程风格支付更改
g_iShowType = false, // false,罗马，true，英文
g_bPrebeat = false, //使用预设风格节拍提示
g_bExtFontUsable = false, //扩展音色库可用
g_bExtFont = false, //使用扩展音色库
g_bCanStep = false;
int g_aAudioEffects[MAX_FX_NUM], //启用的音效
g_aAudioEffects_SVD[MAX_FX_NUM];
DWORD g_aAudioEffectTypes[MAX_FX_NUM]; //音效类型
//DWORD g_iMacAddressNum = 0; //mac地址个数
vector<char *> g_lstMacAddress; //mac地址
//vector<char *> g_lstMacAddressNew;
String g_strMP3File; //mp3全曲文件名
UINT g_xDpi=96, g_yDpi=96; //High DPI 自适应
int g_szFont8 = 8,
g_szFont9 = 9,
g_szFont16 = 16;
/*************************************************************************************** /
// 全局函数声明
/************************************************************************************** */
SM_GetVersion f_SM_GetVersion EX_NULL;
SM_Initialize f_SM_Initialize EX_NULL;
SM_Release f_SM_Release EX_NULL;
SM_CheckStyle f_SM_CheckStyle EX_NULL;
SM_GetSegmentBarNum f_SM_GetSegmentBarNum EX_NULL;
SM_GetStyleRecomInfos f_SM_GetStyleRecomInfos EX_NULL;
SM_GetStyleDemo f_SM_GetStyleDemo EX_NULL;
SM_GetStyleInfo f_SM_GetStyleInfo EX_NULL;
SM_GetStyleInfos f_SM_GetStyleInfos EX_NULL;
SM_InputWavNotes f_SM_InputWavNotes EX_NULL;
SM_BaseCompose f_SM_BaseCompose EX_NULL;
SM_Compose f_SM_Compose EX_NULL;
SM_GetPrebeat f_SM_GetPrebeat EX_NULL;
MM_GetVersion f_MM_GetVersion EX_NULL;
MM_InitialObjects f_MM_InitialObjects EX_NULL;
MM_DestroyObjects f_MM_DestroyObjects EX_NULL;
MM_GetFontInfo f_MM_GetFontInfo EX_NULL;
MM_CheckExtFont f_MM_CheckExtFont EX_NULL;
MM_SetFont f_MM_SetFont EX_NULL;
MM_Record f_MM_Record EX_NULL;
MM_LoadMidiMelody f_MM_LoadMidiMelody EX_NULL;
MM_LoadBaseCompose f_MM_LoadBaseCompose EX_NULL;
MM_LoadCompose f_MM_LoadCompose EX_NULL;
MM_LoadPrebeat f_MM_LoadPrebeat EX_NULL;
MM_Play f_MM_Play EX_NULL;
MM_Stop f_MM_Stop EX_NULL;
MM_CheckIODevice f_MM_CheckIODevice EX_NULL;
MM_SetIODevice f_MM_SetIODevice EX_NULL;
MM_GetPlaybackDeviceInfo f_MM_GetPlaybackDeviceInfo EX_NULL;
MM_GetPlaybackOutputInfo f_MM_GetPlaybackOutputInfo EX_NULL;
MM_GetRecordDeviceInfo f_MM_GetRecordDeviceInfo EX_NULL;
MM_GetRecordInputInfo f_MM_GetRecordInputInfo EX_NULL;
MM_RecordTest f_MM_RecordTest EX_NULL;
MM_SetRecordAutoAdjust f_MM_SetRecordAutoAdjust EX_NULL;
MM_SetRecordMoniter f_MM_SetRecordMoniter EX_NULL;
MM_SetRecordProtect f_MM_SetRecordProtect EX_NULL;
MM_ShowAsioPanel f_MM_ShowAsioPanel EX_NULL;
MM_RestartAsioDevice f_MM_RestartAsioDevice EX_NULL;
MM_LoadAudio f_MM_LoadAudio EX_NULL;
MM_ClearAudio f_MM_ClearAudio EX_NULL;
MM_GetMelodyInfo f_MM_GetMelodyInfo EX_NULL;
MM_GetMelody f_MM_GetMelody EX_NULL;
MM_CreateRealTimeMIDIStream f_MM_CreateRealTimeMIDIStream EX_NULL;
MM_FreeRealTimeMIDIStream f_MM_FreeRealTimeMIDIStream EX_NULL;
MM_RealTimeMIDINoteOn f_MM_RealTimeMIDINoteOn EX_NULL;
MM_RealTimeMIDINoteOff f_MM_RealTimeMIDINoteOff EX_NULL;
MM_PlayStyleDemo f_MM_PlayStyleDemo EX_NULL;
MM_SetTempo f_MM_SetTempo EX_NULL;
MM_SetTimeSignature f_MM_SetTimeSignature EX_NULL;
MM_GetAudioVolume f_MM_GetAudioVolume EX_NULL;
MM_GetStreamVolume f_MM_GetStreamVolume EX_NULL;
MM_SetStreamVolume f_MM_SetStreamVolume EX_NULL;
MM_GetLatency f_MM_GetLatency EX_NULL;
MM_GetStreamLength f_MM_GetStreamLength EX_NULL;
MM_SetStreamLength f_MM_SetStreamLength EX_NULL;
MM_CombineSong f_MM_CombineSong EX_NULL;
MM_Save f_MM_Save EX_NULL;
MM_SaveProject f_MM_SaveProject EX_NULL;
MM_LoadProject f_MM_LoadProject EX_NULL;
MM_UserCanceled f_MM_UserCanceled EX_NULL;
MM_LoadAnalysis f_MM_LoadAnalysis EX_NULL;
MM_LoadAudioMP3 f_MM_LoadAudioMP3 EX_NULL;
MM_LoadSongMP3 f_MM_LoadSongMP3 EX_NULL;
MM_ActiveAPR f_MM_ActiveAPR EX_NULL;
MM_SetFxPreset f_MM_SetFxPreset EX_NULL;
CS_GetVersion f_CS_GetVersion EX_NULL;
CS_InitialService f_CS_InitialService EX_NULL;
CS_DestroyService f_CS_DestroyService EX_NULL;
CS_Register f_CS_Register EX_NULL;
CS_Login f_CS_Login EX_NULL;
CS_Logoff f_CS_Logoff EX_NULL;
CS_CancelOperation f_CS_CancelOperation EX_NULL;
CS_DownloadStyle f_CS_DownloadStyle EX_NULL;
CS_GetQnA f_CS_GetQnA EX_NULL;
CS_SubmitQnA f_CS_SubmitQnA EX_NULL;
CS_GetNotice f_CS_GetNotice EX_NULL;
CS_GetNewNoticeNum f_CS_GetNewNoticeNum EX_NULL;
CS_UploadSong f_CS_UploadSong EX_NULL;
CS_GetWebPageURL f_CS_GetWebPageURL EX_NULL;
CS_GetStyleNums f_CS_GetStyleNums EX_NULL;
CS_CheckPayment f_CS_CheckPayment EX_NULL;
CS_ConfirmPayment f_CS_ConfirmPayment EX_NULL;
CS_AutoDownloadStyle f_CS_AutoDownloadStyle EX_NULL;
CS_SaveProject f_CS_SaveProject EX_NULL;
CS_LoadProject f_CS_LoadProject EX_NULL;
CS_ResetProject f_CS_ResetProject EX_NULL;
QR_Encode f_QR_Encode EX_NULL;
/*************************************************************************************** /
// 全局函数实现
/************************************************************************************** */
HRESULT GetMFFunctions(HINSTANCE hDll) {
// VERIFY( hDll );
f_SM_GetVersion = (SM_GetVersion)GetProcAddress(hDll, "SM_GetVersion");
f_SM_Initialize = (SM_Initialize)GetProcAddress(hDll, "SM_Initialize");
f_SM_Release = (SM_Release)GetProcAddress(hDll, "SM_Release");
f_SM_CheckStyle = (SM_CheckStyle)GetProcAddress(hDll, "SM_CheckStyle");
f_SM_GetSegmentBarNum = (SM_GetSegmentBarNum)GetProcAddress(hDll,
"SM_GetSegmentBarNum");
f_SM_GetStyleRecomInfos = (SM_GetStyleRecomInfos)GetProcAddress(hDll,
"SM_GetStyleRecomInfos");
f_SM_GetStyleDemo = (SM_GetStyleDemo)GetProcAddress(hDll,
"SM_GetStyleDemo");
f_SM_GetStyleInfo = (SM_GetStyleInfo)GetProcAddress(hDll,
"SM_GetStyleInfo");
f_SM_GetStyleInfos = (SM_GetStyleInfos)GetProcAddress(hDll,
"SM_GetStyleInfos");
f_SM_InputWavNotes = (SM_InputWavNotes)GetProcAddress(hDll,
"SM_InputWavNotes");
f_SM_BaseCompose = (SM_BaseCompose)GetProcAddress(hDll, "SM_BaseCompose");
f_SM_Compose = (SM_Compose)GetProcAddress(hDll, "SM_Compose");
f_SM_GetPrebeat = (SM_GetPrebeat)GetProcAddress(hDll, "SM_GetPrebeat");
if (!(f_SM_Initialize && f_SM_Release && f_SM_CheckStyle && f_SM_GetVersion &&
f_SM_GetSegmentBarNum && f_SM_GetStyleRecomInfos && f_SM_GetStyleDemo &&
f_SM_InputWavNotes && f_SM_BaseCompose && f_SM_Compose &&
f_SM_GetStyleInfo && f_SM_GetStyleInfos && f_SM_GetPrebeat )){
return S_FALSE;
}
HRESULT hr = f_SM_GetVersion();
if( hr!=SM_VERSION || f_SM_Initialize()!= S_OK ){
return S_FALSE;
}
return S_OK;
}
HRESULT GetMMFunctions(HINSTANCE hDll) {
// VERIFY( hDll );
f_MM_GetVersion = (MM_GetVersion)GetProcAddress(hDll, "MM_GetVersion");
f_MM_InitialObjects = (MM_InitialObjects)GetProcAddress(hDll, "MM_InitialObjects");
f_MM_DestroyObjects = (MM_DestroyObjects)GetProcAddress(hDll, "MM_DestroyObjects");
f_MM_GetFontInfo = (MM_GetFontInfo)GetProcAddress(hDll, "MM_GetFontInfo");
f_MM_CheckExtFont = (MM_CheckExtFont)GetProcAddress(hDll, "MM_CheckExtFont");
f_MM_SetFont = (MM_SetFont)GetProcAddress(hDll, "MM_SetFont");
f_MM_Record = (MM_Record)GetProcAddress(hDll, "MM_Record");
f_MM_LoadMidiMelody = (MM_LoadMidiMelody)GetProcAddress(hDll, "MM_LoadMidiMelody");
f_MM_LoadBaseCompose = (MM_LoadBaseCompose)GetProcAddress(hDll, "MM_LoadBaseCompose");
f_MM_LoadCompose = (MM_LoadCompose)GetProcAddress(hDll, "MM_LoadCompose");
f_MM_LoadPrebeat = (MM_LoadPrebeat)GetProcAddress(hDll, "MM_LoadPrebeat");
f_MM_Play = (MM_Play)GetProcAddress(hDll, "MM_Play");
f_MM_Stop = (MM_Stop)GetProcAddress(hDll, "MM_Stop");
f_MM_CheckIODevice = (MM_CheckIODevice)GetProcAddress(hDll, "MM_CheckIODevice");
f_MM_SetIODevice = (MM_SetIODevice)GetProcAddress(hDll, "MM_SetIODevice");
f_MM_GetPlaybackDeviceInfo = (MM_GetPlaybackDeviceInfo)GetProcAddress(hDll, "MM_GetPlaybackDeviceInfo");
f_MM_GetPlaybackOutputInfo = (MM_GetPlaybackOutputInfo)GetProcAddress(hDll, "MM_GetPlaybackOutputInfo");
f_MM_GetRecordDeviceInfo = (MM_GetRecordDeviceInfo)GetProcAddress(hDll, "MM_GetRecordDeviceInfo");
f_MM_GetRecordInputInfo = (MM_GetRecordInputInfo)GetProcAddress(hDll, "MM_GetRecordInputInfo");
f_MM_RecordTest = (MM_RecordTest)GetProcAddress(hDll, "MM_RecordTest");
f_MM_SetRecordAutoAdjust = (MM_SetRecordAutoAdjust)GetProcAddress(hDll, "MM_SetRecordAutoAdjust");
f_MM_SetRecordMoniter = (MM_SetRecordMoniter)GetProcAddress(hDll, "MM_SetRecordMoniter");
f_MM_SetRecordProtect = (MM_SetRecordProtect)GetProcAddress(hDll, "MM_SetRecordProtect");
f_MM_ShowAsioPanel = (MM_ShowAsioPanel)GetProcAddress(hDll, "MM_ShowAsioPanel");
f_MM_RestartAsioDevice = (MM_RestartAsioDevice)GetProcAddress(hDll, "MM_RestartAsioDevice");
f_MM_LoadAudio = (MM_LoadAudio)GetProcAddress(hDll, "MM_LoadAudio");
f_MM_ClearAudio = (MM_ClearAudio)GetProcAddress(hDll, "MM_ClearAudio");
f_MM_GetMelodyInfo = (MM_GetMelodyInfo)GetProcAddress(hDll, "MM_GetMelodyInfo");
f_MM_GetMelody = (MM_GetMelody)GetProcAddress(hDll, "MM_GetMelody");
f_MM_CreateRealTimeMIDIStream = (MM_CreateRealTimeMIDIStream)GetProcAddress(hDll, "MM_CreateRealTimeMIDIStream");
f_MM_FreeRealTimeMIDIStream = (MM_FreeRealTimeMIDIStream)GetProcAddress(hDll, "MM_FreeRealTimeMIDIStream");
f_MM_RealTimeMIDINoteOn = (MM_RealTimeMIDINoteOn)GetProcAddress(hDll, "MM_RealTimeMIDINoteOn");
f_MM_RealTimeMIDINoteOff = (MM_RealTimeMIDINoteOff)GetProcAddress(hDll, "MM_RealTimeMIDINoteOff");
f_MM_PlayStyleDemo = (MM_PlayStyleDemo)GetProcAddress(hDll, "MM_PlayStyleDemo");
f_MM_SetTempo = (MM_SetTempo)GetProcAddress(hDll, "MM_SetTempo");
f_MM_SetTimeSignature = (MM_SetTimeSignature)GetProcAddress(hDll, "MM_SetTimeSignature");
f_MM_GetAudioVolume = (MM_GetAudioVolume)GetProcAddress(hDll, "MM_GetAudioVolume");
f_MM_GetStreamVolume = (MM_GetStreamVolume)GetProcAddress(hDll, "MM_GetStreamVolume");
f_MM_SetStreamVolume = (MM_SetStreamVolume)GetProcAddress(hDll, "MM_SetStreamVolume");
f_MM_GetLatency = (MM_GetLatency)GetProcAddress(hDll, "MM_GetLatency");
f_MM_GetStreamLength = (MM_GetStreamLength)GetProcAddress(hDll, "MM_GetStreamLength");
f_MM_SetStreamLength = (MM_SetStreamLength)GetProcAddress(hDll, "MM_SetStreamLength");
f_MM_CombineSong = (MM_CombineSong)GetProcAddress(hDll, "MM_CombineSong");
f_MM_Save = (MM_Save)GetProcAddress(hDll, "MM_Save");
f_MM_UserCanceled = (MM_UserCanceled)GetProcAddress(hDll, "MM_UserCanceled");
f_MM_SaveProject = (MM_SaveProject)GetProcAddress(hDll, "MM_SaveProject");
f_MM_LoadProject = (MM_LoadProject)GetProcAddress(hDll, "MM_LoadProject");
f_MM_LoadAnalysis = (MM_LoadAnalysis)GetProcAddress(hDll, "MM_LoadAnalysis");
f_MM_LoadAudioMP3 = (MM_LoadAudioMP3)GetProcAddress(hDll, "MM_LoadAudioMP3");
f_MM_LoadSongMP3 = (MM_LoadSongMP3)GetProcAddress(hDll, "MM_LoadSongMP3");
f_MM_ActiveAPR = (MM_ActiveAPR)GetProcAddress(hDll, "MM_ActiveAPR");
f_MM_SetFxPreset = (MM_SetFxPreset)GetProcAddress(hDll, "MM_SetFxPreset");
if (!(f_MM_InitialObjects && f_MM_DestroyObjects && f_MM_GetFontInfo && f_MM_SetFont &&
f_MM_LoadMidiMelody && f_MM_LoadBaseCompose && f_MM_LoadCompose && f_MM_ClearAudio &&
f_MM_LoadAudio && f_MM_Record && f_MM_Play && f_MM_Stop && f_MM_CombineSong &&
f_MM_Save && f_MM_UserCanceled && f_MM_GetMelodyInfo && f_MM_GetMelody &&
f_MM_CreateRealTimeMIDIStream && f_MM_FreeRealTimeMIDIStream && f_MM_CheckExtFont &&
f_MM_RealTimeMIDINoteOn && f_MM_RealTimeMIDINoteOff && f_MM_SetRecordMoniter &&
f_MM_PlayStyleDemo && f_MM_SetTempo && f_MM_SetTimeSignature && f_MM_LoadPrebeat &&
f_MM_SetFxPreset && f_MM_ActiveAPR && f_MM_GetStreamLength && f_MM_GetAudioVolume &&
f_MM_GetStreamLength && f_MM_GetStreamVolume && f_MM_SetStreamVolume &&
f_MM_SaveProject && f_MM_LoadProject && f_MM_GetLatency && f_MM_RestartAsioDevice &&
f_MM_LoadAnalysis && f_MM_LoadAudioMP3 && f_MM_LoadSongMP3 && f_MM_CheckIODevice &&
f_MM_SetIODevice && f_MM_GetPlaybackDeviceInfo && f_MM_GetPlaybackOutputInfo &&
f_MM_GetRecordDeviceInfo && f_MM_GetRecordInputInfo && f_MM_RecordTest &&
f_MM_SetRecordAutoAdjust && f_MM_SetRecordProtect && f_MM_ShowAsioPanel &&
f_MM_GetVersion ))
{
return S_FALSE;
}
return S_OK;
}
HRESULT GetCSFunctions(HINSTANCE hDll) {
// VERIFY( hDll );
f_CS_GetVersion = (CS_GetVersion)GetProcAddress(hDll, "CS_GetVersion");
f_CS_InitialService = (CS_InitialService)GetProcAddress(hDll,"CS_InitialService");
f_CS_DestroyService = (CS_DestroyService)GetProcAddress(hDll,"CS_DestroyService");
f_CS_Register = (CS_Register)GetProcAddress(hDll, "CS_Register");
f_CS_Login = (CS_Login)GetProcAddress(hDll, "CS_Login");
f_CS_Logoff = (CS_Logoff)GetProcAddress(hDll, "CS_Logoff");
f_CS_CancelOperation = (CS_CancelOperation)GetProcAddress(hDll, "CS_CancelOperation");
f_CS_DownloadStyle = (CS_DownloadStyle)GetProcAddress(hDll, "CS_DownloadStyle");
f_CS_GetQnA = (CS_GetQnA)GetProcAddress(hDll, "CS_GetQnA");
f_CS_SubmitQnA = (CS_SubmitQnA)GetProcAddress(hDll, "CS_SubmitQnA");
f_CS_GetNotice = (CS_GetNotice)GetProcAddress(hDll, "CS_GetNotice");
f_CS_GetNewNoticeNum = (CS_GetNewNoticeNum)GetProcAddress(hDll, "CS_GetNewNoticeNum");
f_CS_UploadSong = (CS_UploadSong)GetProcAddress(hDll, "CS_UploadSong");
f_CS_GetWebPageURL = (CS_GetWebPageURL)GetProcAddress(hDll, "CS_GetWebPageURL");
f_CS_GetStyleNums = (CS_GetStyleNums)GetProcAddress(hDll, "CS_GetStyleNums");
f_CS_CheckPayment = (CS_CheckPayment)GetProcAddress(hDll, "CS_CheckPayment");
f_CS_ConfirmPayment = (CS_ConfirmPayment)GetProcAddress(hDll, "CS_ConfirmPayment");
f_CS_AutoDownloadStyle = (CS_AutoDownloadStyle)GetProcAddress(hDll, "CS_AutoDownloadStyle");
f_CS_SaveProject = (CS_SaveProject)GetProcAddress(hDll, "CS_SaveProject");
f_CS_LoadProject = (CS_LoadProject)GetProcAddress(hDll, "CS_LoadProject");
f_CS_ResetProject = (CS_ResetProject)GetProcAddress(hDll, "CS_ResetProject");
if (!(f_CS_InitialService && f_CS_DestroyService && f_CS_Login && f_CS_Login
&& f_CS_CancelOperation && f_CS_DownloadStyle
&& f_CS_GetQnA && f_CS_SubmitQnA && f_CS_Register && f_CS_UploadSong
&& f_CS_GetWebPageURL && f_CS_GetStyleNums && f_CS_GetNotice
&& f_CS_GetNewNoticeNum && f_CS_CheckPayment && f_CS_ConfirmPayment
&& f_CS_AutoDownloadStyle && f_CS_SaveProject && f_CS_LoadProject
&& f_CS_ResetProject && f_CS_GetVersion )) {
return S_FALSE;
}
return S_OK;
}
HRESULT GetQRFunctions(HINSTANCE hDll) {
f_QR_Encode = (QR_Encode)GetProcAddress(hDll, "QR_Encode");
return S_OK;
}
void SetMelodyTempo(int nTempo, bool bInit) {
if (bInit || g_nMelodyTempo != nTempo) {
int nBeatsPerMeasure;
switch (g_iMelodyTimeSignature) {
case 0:
nBeatsPerMeasure = 4;
break;
case 1:
nBeatsPerMeasure = 3;
break;
case 2:
nBeatsPerMeasure = 2;
break;
case 3:
nBeatsPerMeasure = 3;
break;
}
g_dblStep = TIMER_PLAY_INTERVAL * POINTS_PER_BAR * (double)nTempo /
(double)nBeatsPerMeasure / 60000.0;
g_dblTimePerBar = (double)nBeatsPerMeasure * 60000.0 / nTempo;
f_MM_SetTempo(nTempo);
g_nMelodyTempo = nTempo;
g_bProjStylePaid = false;
}
}
void SetMelodyTS(int iTS, bool bInit) {
if (bInit || g_iMelodyTimeSignature != iTS) {
int nBeatsPerMeasure;
switch (iTS) {
case 0:
nBeatsPerMeasure = 4;
break;
case 1:
nBeatsPerMeasure = 3;
break;
case 2:
nBeatsPerMeasure = 2;
break;
case 3:
nBeatsPerMeasure = 3;
break;
}
g_dblStep = TIMER_PLAY_INTERVAL * POINTS_PER_BAR * (double)
g_nMelodyTempo / (double)nBeatsPerMeasure / 60000.0;
g_dblTimePerBar = (double)nBeatsPerMeasure * 60000.0 / g_nMelodyTempo;
g_iMelodyTimeSignature = iTS;
f_MM_SetTimeSignature( g_iMelodyTimeSignature );
}
}
int ActiveAPR( bool bActive )
{
if( f_MM_ActiveAPR ){
return f_MM_ActiveAPR( bActive );
}
return S_FALSE;
}
void SetWavNotes() {
int nNotesNum = f_MM_GetMelodyInfo(NULL, NULL, NULL);
if (nNotesNum > 0) {
BYTE *keys = new BYTE[nNotesNum];
WORD *delay = new WORD[nNotesNum];
f_MM_GetMelody(keys, delay, g_iMelodyKey);
int nBarNum, nTick = 192;//(g_nMelodyTempo >= 125) ? 24 : (g_nMelodyTempo >= 83) ? 48 : 72;
DebugPrint("MF_InputWaveNote");
f_SM_InputWavNotes(keys, delay, nNotesNum, nTick,
(BYTE)g_iMelodyTimeSignature, g_nMelodyTempo, &nBarNum);
// 计算弱起
int nBeatsPerMeasure;
switch (g_iMelodyTimeSignature) {
case 0:
nBeatsPerMeasure = 4;
break;
case 1:
nBeatsPerMeasure = 3;
break;
case 2:
nBeatsPerMeasure = 2;
break;
case 3:
nBeatsPerMeasure = 3;
break;
}
g_bWeakup = nBarNum>1 && keys[0] == 128 && delay[0] > nTick * nBeatsPerMeasure / 2;
delete[]keys;
delete[]delay;
}
}
void SetPlayTimer(bool bStart, UINT& tTimer, UINT& tAccuracy, void* pUser) {
if (bStart) { // 打开定时器
// 设置定时器
TIMECAPS tc;
MMRESULT mrError;
// 利用函数timeGetDevCaps取出系统分辨率的取值范围，如果有错报错退出
memset(&tc, 0, sizeof(TIMECAPS));
mrError = timeGetDevCaps(&tc, sizeof(TIMECAPS));
if (!mrError == TIMERR_NOERROR) {
DebugPrint("Get system accuracy failed! code = %x", mrError);
}
// 分辨率的值不能超出系统的取值范围
tAccuracy = tc.wPeriodMin > TIMER_ACCURACY ? tc.wPeriodMin :
TIMER_ACCURACY;
tAccuracy = tAccuracy < tc.wPeriodMax ? tAccuracy : tc.wPeriodMax;
// 调用timeBeginPeriod函数设置定时器的分辨率
timeBeginPeriod(tAccuracy);
tTimer = timeSetEvent(TIMER_PLAY_INTERVAL, tAccuracy,
(LPTIMECALLBACK)OnMediaTimer, (DWORD_PTR)pUser, TIME_PERIODIC);
}
else { // 关闭定时器
timeKillEvent(tTimer);
timeEndPeriod(tAccuracy);
}
}
void GetPlayTime(int iStartBar, double dblStartPoint, char* strTime) {
int nBeatsPerMeasure = (g_iMelodyTimeSignature == 0) ? 4 :
(g_iMelodyTimeSignature == 1) ? 3 : (g_iMelodyTimeSignature == 2) ? 2 :
3, nPointPerBeat = POINTS_PER_BAR / nBeatsPerMeasure;
if (g_iMelodyTimeSignature == 3)
nPointPerBeat /= 2;
if (g_bShowPlayTick) {
int iBeat = dblStartPoint / nPointPerBeat, iTick =
120 * (dblStartPoint - iBeat * nPointPerBeat) / nPointPerBeat;
sprintf(strTime, "%03d:%02d:%03d", iStartBar + 1, iBeat + 1, iTick);
}
else {
UINT tStartTime =
(INT)((iStartBar + dblStartPoint / POINTS_PER_BAR) * (double)
nBeatsPerMeasure * 60000.0 / g_nMelodyTempo);
sprintf(strTime, "%03d:%02d:%03d", tStartTime / 60000,
(tStartTime % 60000) / 1000, tStartTime % 1000 );
}
}
void CALLBACK OnMediaTimer(UINT tTimerID, UINT msg, DWORD dwUser, DWORD dwl, DWORD dw2) {
PostMessage((HWND)dwUser, MSG_MEDIATIME, 0, 0);
}
void UpdateGlobalStyle()
{
bool bChangGlobal = !g_lstComposeStages.empty();
for( int i=0; i<g_lstComposeStages.size(); i++ ){
if( g_lstComposeStages[i]->idStyle==g_iSelectedStyleID ){
bChangGlobal = false;
break;
}
}
if( bChangGlobal ){
g_iSelectedStyleID = g_lstComposeStages[0]->idStyle;
g_strSelectedStyleName = g_lstComposeStages[0]->strStyleName;
}
}
void ClearFontList() {
FONTINFOLIST::iterator iFI = g_lstFonts.begin();
while (iFI != g_lstFonts.end()) {
delete(*iFI);
iFI = g_lstFonts.erase(iFI);
}
}
void ClearGlobalVars(int iOperation) {
//g_bSongSaved = false;
g_strMP3File = "";
if (iOperation & LIST_COMPLETEVOLS) {
BARVOLSLIST::iterator iBV = g_lstCompleteVols.begin();
while (iBV != g_lstCompleteVols.end()) {
delete(*iBV);
iBV = g_lstCompleteVols.erase(iBV);
}
g_bSongLoaded = g_bSongNeedSave = false;
}
if (iOperation & LIST_COMPOSESTAGES) {
COMPOSESTAGELIST::iterator iCS = g_lstComposeStages.begin();
while (iCS != g_lstComposeStages.end()) {
delete(*iCS);
iCS = g_lstComposeStages.erase(iCS);
}
g_bComposeLoaded = false;
}
if (iOperation & LIST_MELODYSTAGES) {
MELODYSTAGELIST::iterator iMS = g_lstMelodyStages.begin();
while (iMS != g_lstMelodyStages.end()) {
delete(*iMS);
iMS = g_lstMelodyStages.erase(iMS);
}
g_bBaseComposeLoaded = false;
}
if (iOperation & LIST_MELODYBARS) {
MELODYBARLIST::iterator iMB = g_lstMelodyBars.begin();
while (iMB != g_lstMelodyBars.end()) {
delete(*iMB);
iMB = g_lstMelodyBars.erase(iMB);
}
g_bAudioLoaded = false;
}
else if (iOperation & LIST_MELODYCHORDS) {
MELODYBARLIST::iterator iMB = g_lstMelodyBars.begin();
while (iMB != g_lstMelodyBars.end()) {
(*iMB)->iChords[0] = -1;
(*iMB)->iChords[1] = -1;
(*iMB)->iFill = -1;
iMB++;
}
}
if( (iOperation & LIST_MELODYVOLS) && g_bAudioLoaded ){
MELODYBARLIST::iterator iMB = g_lstMelodyBars.begin();
for( int i=0; i<g_lstMelodyBars.size(); i++ ){
MELODYBAR *pBar = g_lstMelodyBars[i];
memset( &pBar->tBarVol, 0, sizeof(BARVOLS) );
}
g_bAudioLoaded = false;
}
if( iOperation==LIST_ALL ){
f_MM_ClearAudio();
}
}
void ClearSVDVars() {
g_strFontFile_SVD.clear();
g_iSelectedStyleID_SVD = -1;
g_iComposeKey_SVD = -1;
g_iMelodyKey_SVD = -1;
g_iMelodyTimeSignature_SVD = 0;
g_nMelodyTempo_SVD = 75;
g_nMelodyTempo_SVD = g_nMelodyTempo;
g_fRecordVolume_SVD = g_fRecordVolume;
g_fSpeakerVolume_SVD = g_fSpeakerVolume;
g_fAudioVolume_SVD = g_fAudioVolume;
g_fMusicVolume_SVD = g_fMusicVolume;
MELODYBARLIST::iterator iMB = g_lstMelodyBars_SVD.begin();
while (iMB != g_lstMelodyBars_SVD.end()) {
delete(*iMB);
iMB = g_lstMelodyBars_SVD.erase(iMB);
}
MELODYSTAGELIST::iterator iMS = g_lstMelodyStages_SVD.begin();
while (iMS != g_lstMelodyStages_SVD.end()) {
delete(*iMS);
iMS = g_lstMelodyStages_SVD.erase(iMS);
}
COMPOSESTAGELIST::iterator iCS = g_lstComposeStages_SVD.begin();
while (iCS != g_lstComposeStages_SVD.end()) {
delete(*iCS);
iCS = g_lstComposeStages_SVD.erase(iCS);
}
BARVOLSLIST::iterator iBV = g_lstCompleteVols_SVD.begin();
while (iBV != g_lstCompleteVols_SVD.end()) {
delete(*iBV);
iBV = g_lstCompleteVols_SVD.erase(iBV);
}
}
void SaveSVDVars() //add by tj 2013/12/31
{
ClearSVDVars();
// 风格
g_iSelectedStyleID_SVD = g_iSelectedStyleID;
// 旋律主要信息
g_iMelodyKey_SVD = g_iMelodyKey;
g_iMelodyTimeSignature_SVD = g_iMelodyTimeSignature;
g_nMelodyTempo_SVD = g_nMelodyTempo;
// 音色库
g_strFontFile_SVD = g_strFontFile;
// 各项音量设值
g_fRecordVolume_SVD = g_fRecordVolume;
g_fSpeakerVolume_SVD = g_fSpeakerVolume;
g_fAudioVolume_SVD = g_fAudioVolume;
g_fMusicVolume_SVD = g_fMusicVolume;
// 旋律小节表
int nMelodyBarNum = g_lstMelodyBars.size();
for (int i = 0; i < nMelodyBarNum; i++) {
MELODYBAR * pSvdBar = new MELODYBAR;
pSvdBar->iChords[0] = g_lstMelodyBars[i]->iChords[0];
pSvdBar->iChords[1] = g_lstMelodyBars[i]->iChords[1];
pSvdBar->iFill = g_lstMelodyBars[i]->iFill;
pSvdBar->tBarVol.bRecording = g_lstMelodyBars[i]->tBarVol.bRecording;
pSvdBar->tBarVol.bInvalid = g_lstMelodyBars[i]->tBarVol.bInvalid;
for (int j = 0; j < POINTS_PER_BAR; j++) {
pSvdBar->tBarVol.aVols[j] = g_lstMelodyBars[i]->tBarVol.aVols[j];
}
g_lstMelodyBars_SVD.push_back(pSvdBar);
}
// 旋律分段信息
int nMelodyStageNum = g_lstMelodyStages.size();
for (int i = 0; i < nMelodyStageNum; i++) {
MELODYSTAGE* pSvdMStage = new MELODYSTAGE;
pSvdMStage->iFirstBar = g_lstMelodyStages[i]->iFirstBar;
pSvdMStage->iLastBar = g_lstMelodyStages[i]->iLastBar;
pSvdMStage->iVar = g_lstMelodyStages[i]->iVar;
g_lstMelodyStages_SVD.push_back(pSvdMStage);
}
// 曲式分段信息
int nComposeStageNum = g_lstComposeStages.size();
for (int i = 0; i < nComposeStageNum; i++) {
PCOMPOSESTAGE pCStage = g_lstComposeStages[i];
PCOMPOSESTAGE pSvdCStage = new COMPOSESTAGE;
pSvdCStage->iMelodyStage = pCStage->iMelodyStage;
pSvdCStage->nStageBars = pCStage->nStageBars;
pSvdCStage->iVar = pCStage->iVar;
pSvdCStage->idStyle = pCStage->idStyle;
int nFillNum = pCStage->aFills.size();
for (int j = 0; j < nFillNum; j++) {
pSvdCStage->aFills.push_back(pCStage->aFills[j]);
}
g_lstComposeStages_SVD.push_back(pSvdCStage);
}
// iComposeKey
g_iComposeKey_SVD = g_iComposeKey;
// 全曲
// 全曲小节音量
int nCompleteBarNum = g_lstCompleteVols.size();
for (int i = 0; i < nCompleteBarNum; i++) {
BARVOLS* pSvdBV = new BARVOLS;
pSvdBV->bRecording = g_lstCompleteVols[i]->bRecording;
pSvdBV->bInvalid = g_lstCompleteVols[i]->bInvalid;
for (int j = 0; j < POINTS_PER_BAR; j++) {
pSvdBV->aVols[j] = g_lstCompleteVols[i]->aVols[j];
}
g_lstCompleteVols_SVD.push_back(pSvdBV);
}
// 所处页面
// 音效
int nFxNum = MAX_FX_NUM;
memcpy( g_aAudioEffects_SVD, g_aAudioEffects, sizeof(int)*nFxNum );
}
wstring GetElementInfo(int iElem, int iList) {
wstring strInfo;
if (iList == LIST_MELODYSTAGES) {
PMELODYSTAGE pMStage = g_lstMelodyStages[iElem];
strInfo = L"旋律";
strInfo += GetStageName(iElem);
strInfo += L"段 ";
strInfo += str2wstr(g_strStageVar[pMStage->iVar % STAGE_VAR_NUM]);
}
else if (iList == LIST_COMPOSESTAGES) {
PCOMPOSESTAGE pCStage = g_lstComposeStages[iElem];
if (pCStage->iMelodyStage >= COMPOSE_ENDING_1) {
TCHAR buffer[65];
strInfo = L"尾奏 (类型 ";
strInfo += _itow(pCStage->iMelodyStage - COMPOSE_ENDING_1 + 1,
buffer, 10);
}
else if (pCStage->iMelodyStage >= COMPOSE_INTRO_1) {
TCHAR buffer[65];
if (iElem == 0) {
strInfo = L"前奏 (类型 ";
}
else {
strInfo = L"间奏 (类型 ";
}
strInfo += _itow(pCStage->iMelodyStage - COMPOSE_INTRO_1 + 1,
buffer, 10);
strInfo += L")";
}
else {
strInfo = L"旋律";
strInfo += GetStageName(pCStage->iMelodyStage);
strInfo += L"段 ";
strInfo += str2wstr(g_strStageVar[pCStage->iVar % STAGE_VAR_NUM]);
}
if( !strInfo.empty() ){
strInfo += L"\n风格：";
if( pCStage->idStyle==g_iSelectedStyleID ){
strInfo += str2wstr(g_strSelectedStyleName);
}
else{
strInfo += str2wstr(pCStage->strStyleName);
}
}
}
return strInfo;
}
wstring GetStageName(int iStage) {
wstring strName;
strName += TCHAR('A' + (iStage % 26));
int nNum = iStage / 26;
while (nNum > 0) {
wstring strTemp;
strTemp += TCHAR('A' + (nNum % 26));
strTemp += strName;
strName = strTemp;
nNum /= 26;
}
return strName;
}
#include <stdio.h>
#include <stdarg.h>
#include <tchar.h>
#include <time.h>
#define MAX_DEBUG_PRINT 10240
string wstr2str(const wstring& _src) {
int nBufSize = WideCharToMultiByte(GetACP(), 0, _src.c_str(), -1, NULL, 0,
0, FALSE);
char *szBuf = new char[nBufSize];
WideCharToMultiByte(GetACP(), 0, _src.c_str(), -1, szBuf, nBufSize,
0, FALSE);
string strRet(szBuf);
delete[]szBuf;
return strRet;
}
wstring str2wstr(const string& _src) {
int nBufSize = MultiByteToWideChar(GetACP(), 0, _src.c_str(), -1, NULL, 0);
wchar_t *wsBuf = new wchar_t[nBufSize];
MultiByteToWideChar(GetACP(), 0, _src.c_str(), -1, wsBuf, nBufSize);
wstring wstrRet(wsBuf);
delete[]wsBuf;
return wstrRet;
}
string UTF8ToMBCS(const char *pcUtf8) {
// wchar_t pcUnicode[CHAR_BUFSIZE];
int nUnicodeLen = MultiByteToWideChar(CP_UTF8, 0, pcUtf8, -1, NULL, 0);
wchar_t * pcUnicode = new wchar_t[nUnicodeLen + 1];
memset(pcUnicode, 0, nUnicodeLen * 2 + 2);
// utf8 to unicode
MultiByteToWideChar(CP_UTF8, 0, pcUtf8, -1, pcUnicode, nUnicodeLen);
// unicode to gb2312
int nMBCSLen = WideCharToMultiByte(CP_ACP, 0, pcUnicode, -1, NULL, 0,
NULL, NULL);
char *pcMBCS = new char[nMBCSLen + 1];
memset(pcMBCS, 0, nMBCSLen + 1);
WideCharToMultiByte(CP_ACP, 0, pcUnicode, -1, pcMBCS, nMBCSLen, NULL, NULL);
string strMBCS = pcMBCS;
delete[]pcMBCS;
delete[]pcUnicode;
return strMBCS;
}
string GBToUTF8(const char* str)
{
string result;
WCHAR *strSrc;
char *szRes;
//获得临时变量的大小
int i = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
strSrc = new WCHAR[i+1];
MultiByteToWideChar(CP_ACP, 0, str, -1, strSrc, i);
//获得临时变量的大小
i = WideCharToMultiByte(CP_UTF8, 0, strSrc, -1, NULL, 0, NULL, NULL);
szRes = new char[i+1];
int j = WideCharToMultiByte(CP_UTF8, 0, strSrc,-1, szRes, i, NULL, NULL);
result = szRes;
delete []strSrc;
delete []szRes;
return result;
}
void DebugPrint(const char * fmt, ...) {
#ifdef _DEBUG
char sDebug[MAX_DEBUG_PRINT];
sDebug[0] = '\0';
char tbuffer[9];
_strtime(tbuffer);
sprintf(sDebug, "[%s] ", tbuffer);
va_list vaParams;
va_start(vaParams, fmt);
vsprintf(sDebug + strlen(sDebug), fmt, vaParams);
OutputDebugStringA(sDebug);
#endif
}
BOOL SaveProject( LPCSTR strProjectName, int iMode, HWND hNotifyWnd )
{
wstring wstrProj = str2wstr( strProjectName );
DebugPrint("Saving project....");
WaitForSingleObject(g_hProjectEvent, INFINITE);
BOOL bSuccess = FALSE;
FILE *pFile = NULL;
if ((pFile = fopen( strProjectName, "w+b" )) != NULL) {
long lFileSize = 0;
fpos_t posFileSize = 0;
// 保存版本号
fwrite(&g_dwProjectVersion, sizeof(DWORD), 1, pFile);
// 预留文件长度
fgetpos(pFile, &posFileSize);
fwrite(&lFileSize, sizeof(long), 1, pFile);
// 保存模式标志
fwrite(&iMode, sizeof(int), 1, pFile);
// 风格类型 7.23
fwrite(&g_iSelectedStyleType, sizeof(DWORD), 1, pFile);
// 风格
fwrite(&g_iSelectedStyleID, sizeof(int), 1, pFile);
// 旋律主要信息
fwrite(&g_bMidiMelody, sizeof(bool), 1, pFile); //是否为MIDI旋律
fwrite(&g_iMelodyTimeSignature, sizeof(int), 1, pFile); // 拍号
fwrite(&g_nMelodyTempo, sizeof(int), 1, pFile); // 速度
fwrite(&g_iMelodyKey, sizeof(int), 1, pFile); // 调号
// 音色库
string strFont = wstr2str( g_strFontFile );
string strFontUTF8 = GBToUTF8( strFont.c_str() );
int nFontNameLen = strFontUTF8.length() + 1;
fwrite(&nFontNameLen, sizeof(int), 1, pFile);
fwrite( strFontUTF8.c_str(), sizeof(char), nFontNameLen, pFile);
// 各项音量设值
fwrite(&g_fRecordVolume, sizeof(float), 1, pFile);
fwrite(&g_fSpeakerVolume, sizeof(float), 1, pFile);
fwrite(&g_fAudioVolume, sizeof(float), 1, pFile);
fwrite(&g_fMusicVolume, sizeof(float), 1, pFile);
int nMelodyBarNum = g_lstMelodyBars.size();
// 旋律小节表
fwrite(&nMelodyBarNum, sizeof(int), 1, pFile);
// DWORD dwVols[POINTS_PER_BAR];
// memset( dwVols, 0, sizeof(DWORD)*POINTS_PER_BAR );
for (int i = 0; i < nMelodyBarNum; i++) {
fwrite(&g_lstMelodyBars[i]->iChords[0], sizeof(char), 1, pFile);
fwrite(&g_lstMelodyBars[i]->iChords[1], sizeof(char), 1, pFile);
fwrite(&g_lstMelodyBars[i]->iFill, sizeof(char), 1, pFile);
if( iMode!=PROJ_MODE_UPLOAD ){
fwrite(g_lstMelodyBars[i]->tBarVol.aVols, sizeof(DWORD), POINTS_PER_BAR, pFile);
}
}
// 旋律分段信息
int nMelodyStageNum = g_lstMelodyStages.size();
fwrite(&nMelodyStageNum, sizeof(int), 1, pFile);
for (int i = 0; i < nMelodyStageNum; i++) {
fwrite(&g_lstMelodyStages[i]->iFirstBar, sizeof(int), 1, pFile);
fwrite(&g_lstMelodyStages[i]->iLastBar, sizeof(int), 1, pFile);
fwrite(&g_lstMelodyStages[i]->iVar, sizeof(int), 1, pFile);
}
// 曲式分段信息
int nComposeStageNum = g_lstComposeStages.size();
fwrite(&nComposeStageNum, sizeof(int), 1, pFile);
for (int i = 0; i < nComposeStageNum; i++) {
PCOMPOSESTAGE pCStage = g_lstComposeStages[i];
fwrite(&pCStage->iMelodyStage, sizeof(int), 1, pFile);
fwrite(&pCStage->nStageBars, sizeof(int), 1, pFile);
fwrite(&pCStage->iVar, sizeof(int), 1, pFile);
fwrite(&pCStage->idStyle, sizeof(int), 1, pFile);
int nFillNum = pCStage->aFills.size();
fwrite(&nFillNum, sizeof(int), 1, pFile);
for (int j = 0; j < nFillNum; j++) {
fwrite(&pCStage->aFills[j], sizeof(DWORD), 1, pFile);
}
}
// iComposeKey
fwrite(&g_iComposeKey, sizeof(int), 1, pFile);
// 全曲
// 全曲小节音量
int nCompleteBarNum = iMode==PROJ_MODE_UPLOAD ? 0 : g_lstCompleteVols.size();
fwrite(&nCompleteBarNum, sizeof(int), 1, pFile);
for (int i = 0; i < nCompleteBarNum; i++) {
fwrite( g_lstCompleteVols[i]->aVols, sizeof(DWORD), POINTS_PER_BAR, pFile);
}
// 所处页面
fwrite(&g_iCurrentPage, sizeof(int), 1, pFile);
int nFxNum = MAX_FX_NUM;
fwrite( &nFxNum, sizeof(int), 1, pFile );
fwrite( g_aAudioEffects, sizeof(int), nFxNum, pFile );
//预设工程
fwrite( &g_bPredefine, sizeof(bool), 1, pFile );
// 保存文件长度
lFileSize = ftell(pFile);
fclose( pFile );
int lCSSize = f_CS_SaveProject( strProjectName );
if( lCSSize>0 ){
lFileSize += lCSSize;
}
long lMMSize = f_MM_SaveProject( iMode, hNotifyWnd, strProjectName );
if( lMMSize>0 ){
lFileSize += lMMSize;
}
pFile = fopen( strProjectName, "r+b" );
fsetpos(pFile, &posFileSize);
fwrite(&lFileSize, sizeof(long), 1, pFile);
fclose(pFile);
bSuccess = TRUE;
if( iMode==PROJ_MODE_NORMAL ){ //add by tj 2013/12/30
g_bProjStylePaid = false;
ClearAutoProj();
SaveSVDVars();
PostMessage(hNotifyWnd, MSG_OPERATE_COMPLETE, 0, 0);
UpdateRecentProject(wstrProj);
}
else if( iMode==PROJ_MODE_AUTO ){
g_bAutoSave = true;
SetAutoSaveReg();
}
}
if (SetEvent(g_hProjectEvent) == 0) {
DWORD dwError = GetLastError();
DebugPrint("Set Event error! err=%d", dwError);
}
DebugPrint("saving done\n");
if( iMode==PROJ_MODE_NORMAL ){ //add by tj 2013/12/26
if (bSuccess) {
g_strProjectName = wstrProj;
}
else {
PostMessage(hNotifyWnd, MSG_OPERATE_FAILED, E_PROJ_FILENOTEXIST, 0);
}
}
return bSuccess;
}
#include <share.h>
BOOL LoadProject(LPCTSTR strProjectName, HWND hNotifyWnd) {
DebugPrint("Opening project....");
WaitForSingleObject(g_hProjectEvent, INFINITE);
// bool bAutoSave = hNotifyWnd==NULL;
int iMode = hNotifyWnd==NULL ? PROJ_MODE_AUTO : PROJ_MODE_NORMAL;
BOOL bSuccess = FALSE;
int iError = E_PROJ_NOERROR;
g_iCurrentPage = -1;
FILE *pFile = NULL;
if ((pFile = _wfsopen(strProjectName, L"rb", SH_DENYWR)) != NULL) {
DWORD dwProjectVersion;
WORD wMajVersion, wMinVersion;
long lFileSize = 0;
fpos_t posBegin = 0;
// 读取版本号
fread(&dwProjectVersion, sizeof(DWORD), 1, pFile);
if( LOWORD(dwProjectVersion)<2 ){
wMajVersion = LOWORD(dwProjectVersion);
wMinVersion = HIWORD(dwProjectVersion);
dwProjectVersion = MAKELONG( wMinVersion, wMajVersion );
//修改版本号
// fsetpos(pFile, &posBegin);
// fwrite( &dwProjectVersion, sizeof(DWORD), 1, pFile );
}
else{
wMajVersion = HIWORD( dwProjectVersion );
wMinVersion = LOWORD( dwProjectVersion );
}
// 读取文件长度
fread(&lFileSize, sizeof(long), 1, pFile);
// 检测文件长度
fgetpos(pFile, &posBegin);
fseek(pFile, 0, SEEK_END);
if (lFileSize != ftell(pFile)) {
iError = E_PROJ_FILECRUPT;
goto STATEMENT_FALSE;
}
else {
fsetpos(pFile, &posBegin);
}
g_bPredefine = false;
if( wMajVersion<1 || wMajVersion>5 ){
iError = E_PROJ_INVALIDVERSION;
goto STATEMENT_FALSE;
}
else if( wMajVersion>2 ){
iError = E_PROJ_PROVERSION;
goto STATEMENT_FALSE;
}
else if( dwProjectVersion>g_dwProjectVersion ) {
iError = E_PROJ_LATERVERSION;
goto STATEMENT_FALSE;
}
if( wMajVersion==2 && wMinVersion>=7 ){
fread(&iMode, sizeof(int), 1, pFile);
}
if( wMajVersion==1 ){
iError = LoadVersion1(pFile, strProjectName, dwProjectVersion,
hNotifyWnd);
if (iError!=E_PROJ_NOERROR && iError!=E_PROJ_INVALSTAGESTYLE) {
goto STATEMENT_FALSE;
}
if( wMinVersion<1 ){
int nBarNum = g_lstMelodyBars.size(), nBeatsPerMeasure =
g_iMelodyTimeSignature == 0 ? 4 :
g_iMelodyTimeSignature == 1 ? 3 :
g_iMelodyTimeSignature == 2 ? 2 : 3;
DWORD msValid =
nBarNum * nBeatsPerMeasure * 60000 / g_nMelodyTempo;
f_MM_SetStreamLength(2, msValid + 100);
}
}
else if( wMajVersion==2 ){
iError = LoadVersion2( pFile, dwProjectVersion, hNotifyWnd, iMode );
long lPos = ftell( pFile );
fclose( pFile );
if (iError!=E_PROJ_NOERROR && iError!=E_PROJ_INVALSTAGESTYLE) {
goto STATEMENT_FALSE;
}
string strProj = wstr2str( strProjectName );
if( wMinVersion>=6 ){
int nCSSize = f_CS_LoadProject( strProj.c_str(), lPos, dwProjectVersion );
if( nCSSize<0 ){
iError = E_PROJ_FILECRUPT;
goto STATEMENT_FALSE;
}
lPos += nCSSize;
}
if( f_MM_LoadProject( iMode, hNotifyWnd, strProj.c_str(), lPos, dwProjectVersion)!=0 ){
iError = E_PROJ_FILECRUPT;
goto STATEMENT_FALSE;
}
if( f_MM_GetStreamLength(2)>0 ){
SetWavNotes();
g_bAudioLoaded = true;
}
else{
// g_iMelodyKey_SVD = g_iMelodyKey = -1;
ClearGlobalVars( LIST_MELODYVOLS );
g_bPredefine = true;
f_SM_InputWavNotes(NULL, NULL, 0, 192, (BYTE)g_iMelodyTimeSignature,
g_nMelodyTempo, NULL);
}
if( f_MM_GetStreamLength(5)>0 ) {
g_bSongLoaded = true;
}
if( f_MM_GetStreamLength(6)>0 ) {
g_bSongNeedSave = true;
}
else {
ClearGlobalVars(LIST_COMPLETEVOLS);
}
}
g_bkMelody.Clear();
g_bkCompose.Clear();
bSuccess = TRUE;
if( hNotifyWnd ) { //add by tj 2013/12/31
PostMessage(hNotifyWnd, MSG_OPERATE_COMPLETE, iError, 0);
SaveSVDVars();
}
STATEMENT_FALSE:
if( wMajVersion<2 )
fclose(pFile);
}
else {
iError = E_PROJ_FILENOTEXIST;
}
if (SetEvent(g_hProjectEvent) == 0) {
DWORD dwError = GetLastError();
DebugPrint("Set Event error! err=%d", dwError);
}
DebugPrint("opening done\n");
if( hNotifyWnd ) { //add by tj 2013/12/31
if (!bSuccess) {
PostMessage(hNotifyWnd, MSG_OPERATE_FAILED, iError, 0);
}
else {
UpdateRecentProject(strProjectName);
g_strProjectName = strProjectName;
}
}
return bSuccess;
}
int LoadVersion2( FILE *pFile, DWORD dwVersion, HWND hNotifyWnd, int iMode )
{
int nSize, iMelodyKey, iMelodyTimeSignature, nMelodyTempo, nMelodyBarNum,
nMelodyStageNum, nComposeStageNum, nCompleteBarNum;
char strFontFile[MAX_PATH];
string strStyleName;
bool bUseful;
int iError = E_PROJ_NOERROR;
WORD wMinVersion = LOWORD( dwVersion );
// 读取风格
int iStyleID;
fread(&g_iSelectedStyleType, sizeof(DWORD), 1, pFile);
fread(&iStyleID, sizeof(int), 1, pFile);
TSTYLEINFO infoStyle;
HRESULT ret = f_SM_GetStyleInfo(iStyleID, &infoStyle);
if( ret==0 ){
bUseful = f_SM_CheckStyle(iStyleID);
if (!bUseful) {
if( f_CS_DownloadStyle( iStyleID, NULL )!=0 ){
return E_PROJ_INVALIDSTYLE;
}
}
}
else {
DebugPrint("MF_GetStyleInfo error. err=%d", ret);
return E_PROJ_INVALIDSTYLE;
}
// 读取主旋律信息
if( wMinVersion!=3 )
fread(&g_bMidiMelody, sizeof(bool), 1, pFile);
fread(&iMelodyTimeSignature, sizeof(int), 1, pFile);
fread(&nMelodyTempo, sizeof(int), 1, pFile);
fread(&iMelodyKey, sizeof(int), 1, pFile);
SetMelodyTS(iMelodyTimeSignature);
SetMelodyTempo(nMelodyTempo);
g_iMelodyKey = iMelodyKey;
g_iSelectedStyleID = iStyleID;
// 提取风格名称
g_strSelectedStyleName = UTF8ToMBCS( infoStyle.detail.strStyleName ).c_str();
//iStyleID
g_lstStyleSelected.clear();
g_iSelectedStyleType = 0;
for( int i=0; i<sizeof(infoStyle.detail.type); i++ ){
int iType = infoStyle.detail.type[i];
if( iType<0 ) break;
else if( iType>9 ) iType = 9;
g_iSelectedStyleType |= (1 << iType);
}
for( int j=0; j<32; j++ ){
if( g_iSelectedStyleType & (1<<j) ){
g_lstStyleSelected.push_back(j);
}
}
// 读取音色库文件名
fread(&nSize, sizeof(int), 1, pFile);
if (nSize > 0) {
fread(strFontFile, sizeof(char), nSize, pFile);
string strFontGB = UTF8ToMBCS( strFontFile );
wstring wstrFont = str2wstr( strFontGB );
g_strFontFile = wstrFont;
}
// 各项音量设值
fread(&g_fRecordVolume, sizeof(float), 1, pFile);
fread(&g_fSpeakerVolume, sizeof(float), 1, pFile);
fread(&g_fAudioVolume, sizeof(float), 1, pFile);
fread(&g_fMusicVolume, sizeof(float), 1, pFile);
f_MM_SetStreamVolume( 0, g_fSpeakerVolume );
f_MM_SetStreamVolume( 1, g_fRecordVolume );
f_MM_SetStreamVolume( 2, g_fAudioVolume );
f_MM_SetStreamVolume( 3, g_fMusicVolume );
// 全局变量赋值
ClearGlobalVars();
// 旋律小节表
fread(&nMelodyBarNum, sizeof(int), 1, pFile);
for (int i = 0; i < nMelodyBarNum; i++) {
MELODYBAR * pMBar = new MELODYBAR;
fread(&pMBar->iChords[0], sizeof(char), 1, pFile);
fread(&pMBar->iChords[1], sizeof(char), 1, pFile);
fread(&pMBar->iFill, sizeof(char), 1, pFile);
pMBar->tBarVol.bRecording = false;
pMBar->tBarVol.bInvalid = false;
if( iMode==PROJ_MODE_UPLOAD && wMinVersion>=8 )
memset( pMBar->tBarVol.aVols, 0, sizeof(DWORD) * POINTS_PER_BAR );
else
fread(pMBar->tBarVol.aVols, sizeof(DWORD), POINTS_PER_BAR, pFile);
g_lstMelodyBars.push_back(pMBar);
}
// 旋律分段信息
fread(&nMelodyStageNum, sizeof(int), 1, pFile);
for (int i = 0; i < nMelodyStageNum; i++) {
MELODYSTAGE * pMStage = new MELODYSTAGE;
fread(&pMStage->iFirstBar, sizeof(int), 1, pFile);
fread(&pMStage->iLastBar, sizeof(int), 1, pFile);
fread(&pMStage->iVar, sizeof(int), 1, pFile);
g_lstMelodyStages.push_back(pMStage);
}
/*/////////////////////////////
//临时代码
int iDel = -1;
for( int i=0; i<g_lstMelodyStages.size(); i++ ){
MELODYSTAGE * pMStage = g_lstMelodyStages[i];
if( pMStage->iLastBar<0 || pMStage->iLastBar>=nMelodyBarNum ){
pMStage->iLastBar = nMelodyBarNum - 1;
}
if( pMStage->iFirstBar<0 || pMStage->iFirstBar>=nMelodyBarNum ){
iDel = i;
break;
}
}
if( iDel>=0 ){
for( int i=g_lstMelodyStages.size()-1; i>=iDel; i-- ){
delete g_lstMelodyStages[i];
g_lstMelodyStages.erase( g_lstMelodyStages.begin()+i );
}
}
//
*/////////////////////////////
// 曲式分段信息
fread(&nComposeStageNum, sizeof(int), 1, pFile);
for (int i = 0; i < nComposeStageNum; i++) {
COMPOSESTAGE * pCStage = new COMPOSESTAGE;
fread(&pCStage->iMelodyStage, sizeof(int), 1, pFile);
fread(&pCStage->nStageBars, sizeof(int), 1, pFile);
fread(&pCStage->iVar, sizeof(int), 1, pFile);
fread(&pCStage->idStyle, sizeof(int), 1, pFile);
if( pCStage->idStyle!=g_iSelectedStyleID ){
// 提取风格名称
if( f_SM_GetStyleInfo(pCStage->idStyle, &infoStyle)==0
&& ( infoStyle.state==e_Downloaded
|| f_CS_DownloadStyle( pCStage->idStyle, NULL )==0 ) ){
pCStage->strStyleName = UTF8ToMBCS( infoStyle.detail.strStyleName ).c_str();
}
else {
pCStage->idStyle = g_iSelectedStyleID;
if( pCStage->iMelodyStage>=COMPOSE_ENDING_1 ){
int iEnding = pCStage->iMelodyStage - COMPOSE_ENDING_1;
if( infoStyle.detail.aEndingBars[iEnding]>0 ){
pCStage->nStageBars = infoStyle.detail.aEndingBars[iEnding];
}
else{
pCStage->iMelodyStage = COMPOSE_ENDING_1;
pCStage->nStageBars = infoStyle.detail.aEndingBars[0];
}
}
else if( pCStage->iMelodyStage>=COMPOSE_INTRO_1 ){
int iIntro = pCStage->iMelodyStage - COMPOSE_INTRO_1;
if( infoStyle.detail.aIntroBars[iIntro]>0 ){
pCStage->nStageBars = infoStyle.detail.aIntroBars[iIntro];
}
else{
pCStage->iMelodyStage = COMPOSE_INTRO_1;
pCStage->nStageBars = infoStyle.detail.aIntroBars[0];
}
}
iError = E_PROJ_INVALSTAGESTYLE;
}
}
int nFillNum;
fread(&nFillNum, sizeof(int), 1, pFile);
for (int j = 0; j < nFillNum; j++) {
DWORD dwFill;
fread(&dwFill, sizeof(DWORD), 1, pFile);
pCStage->aFills.push_back(dwFill);
}
g_lstComposeStages.push_back(pCStage);
}
// 全曲录音信息
fread(&g_iComposeKey, sizeof(int), 1, pFile);
// 全曲小节音量
fread(&nCompleteBarNum, sizeof(int), 1, pFile);
for (int i = 0; i < nCompleteBarNum; i++) {
BARVOLS * pBVols = new BARVOLS;
pBVols->bRecording = false;
fread(pBVols->aVols, sizeof(DWORD), POINTS_PER_BAR, pFile);
g_lstCompleteVols.push_back(pBVols);
}
// 所处页面
fread(&g_iCurrentPage, sizeof(int), 1, pFile);
//音效
memset( g_aAudioEffects, 0, MAX_FX_NUM*sizeof(int) );
int nFxNum;
fread( &nFxNum, sizeof(int), 1, pFile );
if( nFxNum>0 ){
fread( g_aAudioEffects, sizeof(int), nFxNum, pFile );
for( int i=0; i<nFxNum; i++ ){
f_MM_SetFxPreset( g_aAudioEffectTypes[i], g_aAudioEffects[i] );
}
}
else{
ResetAudioEffects();
}
//预设工程
if( wMinVersion>=5 )
fread( &g_bPredefine, sizeof(bool), 1, pFile );
return iError;
}
int LoadVersion1(FILE *pFile, LPCTSTR strProjectName, DWORD dwVersion, HWND hNotifyWnd)
{
bool bAutoSave = false; //add by tj 2013/12/31
if(hNotifyWnd==NULL)
bAutoSave = true;
int nSize, iMelodyKey, iMelodyTimeSignature, nMelodyTempo, nMelodyBarNum,
nMelodyStageNum, nComposeStageNum, nCompleteBarNum;
long posBegin;
DWORD lAudioSize = 0, lSongSize = 0;
fpos_t posAudioBegin = 0, posSongBegin = 0;
TCHAR strFontFile[MAX_PATH];
string strStyleName;
bool bUseful;
WORD wMinVersion = LOWORD( dwVersion );
int iError = E_PROJ_NOERROR;
// 全局变量赋值
ClearGlobalVars();
fread(&lAudioSize, sizeof(long), 1, pFile);
fread(&lSongSize, sizeof(long), 1, pFile);
int nextRange = 90;
if (lAudioSize > 0) {
nextRange = 90 * lAudioSize / (lAudioSize + lSongSize);
}
posBegin = ftell(pFile);
if (lAudioSize > 0) {
if(!bAutoSave) //add by tj 2013/12/31
PostMessage(hNotifyWnd, MSG_OPERATE_NEXTRANGE, 0, nextRange);
// 旋律音频
posAudioBegin = posBegin;
nSize = f_MM_LoadAudioMP3(hNotifyWnd, strProjectName, posAudioBegin,
dwVersion );
if (nSize > 0) {
// 旋律识别信息
posBegin += nSize +sizeof(DWORD);
nSize = f_MM_LoadAnalysis(hNotifyWnd, strProjectName, posBegin,
dwVersion);
if (nSize > 0) {
posBegin += nSize +sizeof(DWORD);
}
if(!bAutoSave){ //add by tj 2013/12/31
PostMessage(hNotifyWnd, MSG_OPERATE_NEXTRANGE, 0, 0);
PostMessage(hNotifyWnd, MSG_OPERATE_PERCENT, 5 + nextRange, 0);
}
}
else {
return E_PROJ_CANTLOADAUDIO;
}
}
// 读取风格
int iStyleID;
fsetpos(pFile, &posBegin);
if( wMinVersion>1 )
fread(&g_iSelectedStyleType, sizeof(DWORD), 1, pFile);
fread(&iStyleID, sizeof(int), 1, pFile);
TSTYLEINFO infoStyle;
HRESULT ret = f_SM_GetStyleInfo(iStyleID, &infoStyle);
if( ret==0 ){
bUseful = f_SM_CheckStyle(iStyleID);
if (!bUseful) {
if( f_CS_DownloadStyle( iStyleID, NULL )!=0 ){
return E_PROJ_INVALIDSTYLE;
}
}
}
else {
DebugPrint("MF_GetStyleInfo error. err=%d", ret);
return E_PROJ_INVALIDSTYLE;
}
// 读取主旋律信息
if( wMinVersion>=4 ){
fread(&g_bMidiMelody, sizeof(bool), 1, pFile);
}
else{
g_bMidiMelody = false;
}
fread(&iMelodyTimeSignature, sizeof(int), 1, pFile);
fread(&nMelodyTempo, sizeof(int), 1, pFile);
fread(&iMelodyKey, sizeof(int), 1, pFile);
SetMelodyTS(iMelodyTimeSignature);
f_MM_SetTimeSignature(iMelodyTimeSignature);
SetMelodyTempo(nMelodyTempo);
g_iMelodyKey = iMelodyKey;
g_iSelectedStyleID = iStyleID;
// 提取风格名称
g_strSelectedStyleName = UTF8ToMBCS( infoStyle.detail.strStyleName ).c_str();
g_lstStyleSelected.clear();
g_iSelectedStyleType = 0;
for( int i=0; i<sizeof(infoStyle.detail.type); i++ ){
int iType = infoStyle.detail.type[i];
if( iType<0 ) break;
else if( iType>9 ) iType = 9;
g_iSelectedStyleType |= (1 << iType);
}
for( int j=0; j<32; j++ ){
if( g_iSelectedStyleType & (1<<j) ){
g_lstStyleSelected.push_back(j);
}
}
if (lAudioSize > 0) {
SetWavNotes();
}
else{
g_iMelodyKey_SVD = g_iMelodyKey = -1;
}
// 读取音色库文件名
fread(&nSize, sizeof(int), 1, pFile);
if (nSize > 0) {
fread(strFontFile, sizeof(TCHAR), nSize, pFile);
}
g_strFontFile = strFontFile;
// 各项音量设值
fread(&g_fRecordVolume, sizeof(float), 1, pFile);
fread(&g_fSpeakerVolume, sizeof(float), 1, pFile);
fread(&g_fAudioVolume, sizeof(float), 1, pFile);
fread(&g_fMusicVolume, sizeof(float), 1, pFile);
f_MM_SetStreamVolume( 0, g_fSpeakerVolume );
f_MM_SetStreamVolume( 1, g_fRecordVolume );
f_MM_SetStreamVolume( 2, g_fAudioVolume );
f_MM_SetStreamVolume( 3, g_fMusicVolume );
// 旋律小节表
fread(&nMelodyBarNum, sizeof(int), 1, pFile);
for (int i = 0; i < nMelodyBarNum; i++) {
MELODYBAR * pMBar = new MELODYBAR;
fread(&pMBar->iChords[0], sizeof(char), 1, pFile);
fread(&pMBar->iChords[1], sizeof(char), 1, pFile);
fread(&pMBar->iFill, sizeof(char), 1, pFile);
pMBar->tBarVol.bRecording = false;
pMBar->tBarVol.bInvalid = false;
fread(pMBar->tBarVol.aVols, sizeof(DWORD), POINTS_PER_BAR, pFile);
g_lstMelodyBars.push_back(pMBar);
}
if (lAudioSize > 0) {
g_bAudioLoaded = true;
}
// 旋律分段信息
fread(&nMelodyStageNum, sizeof(int), 1, pFile);
for (int i = 0; i < nMelodyStageNum; i++) {
MELODYSTAGE * pMStage = new MELODYSTAGE;
fread(&pMStage->iFirstBar, sizeof(int), 1, pFile);
fread(&pMStage->iLastBar, sizeof(int), 1, pFile);
fread(&pMStage->iVar, sizeof(int), 1, pFile);
g_lstMelodyStages.push_back(pMStage);
}
// 曲式分段信息
fread(&nComposeStageNum, sizeof(int), 1, pFile);
for (int i = 0; i < nComposeStageNum; i++) {
COMPOSESTAGE * pCStage = new COMPOSESTAGE;
fread(&pCStage->iMelodyStage, sizeof(int), 1, pFile);
fread(&pCStage->nStageBars, sizeof(int), 1, pFile);
fread(&pCStage->iVar, sizeof(int), 1, pFile);
fread(&pCStage->idStyle, sizeof(int), 1, pFile);
if( pCStage->idStyle!=g_iSelectedStyleID ){
// 提取风格名称
if( f_SM_GetStyleInfo(pCStage->idStyle, &infoStyle)==0
&& ( infoStyle.state==e_Downloaded
|| f_CS_DownloadStyle( pCStage->idStyle, NULL )==0 ) ){
pCStage->strStyleName = UTF8ToMBCS( infoStyle.detail.strStyleName ).c_str();
}
else{
pCStage->idStyle = g_iSelectedStyleID;
if( pCStage->iMelodyStage>=COMPOSE_ENDING_1 ){
int iEnding = pCStage->iMelodyStage - COMPOSE_ENDING_1;
if( infoStyle.detail.aEndingBars[iEnding]>0 ){
pCStage->nStageBars = infoStyle.detail.aEndingBars[iEnding];
}
else{
pCStage->iMelodyStage = COMPOSE_ENDING_1;
pCStage->nStageBars = infoStyle.detail.aEndingBars[0];
}
}
else if( pCStage->iMelodyStage>=COMPOSE_INTRO_1 ){
int iIntro = pCStage->iMelodyStage - COMPOSE_INTRO_1;
if( infoStyle.detail.aIntroBars[iIntro]>0 ){
pCStage->nStageBars = infoStyle.detail.aIntroBars[iIntro];
}
else{
pCStage->iMelodyStage = COMPOSE_INTRO_1;
pCStage->nStageBars = infoStyle.detail.aIntroBars[0];
}
}
iError = E_PROJ_INVALSTAGESTYLE;
}
}
int nFillNum;
fread(&nFillNum, sizeof(int), 1, pFile);
for (int j = 0; j < nFillNum; j++) {
DWORD dwFill;
fread(&dwFill, sizeof(DWORD), 1, pFile);
pCStage->aFills.push_back(dwFill);
}
g_lstComposeStages.push_back(pCStage);
}
// 全曲录音信息
fread(&g_iComposeKey, sizeof(int), 1, pFile);
if(!bAutoSave) //add by tj 2013/12/31
PostMessage(hNotifyWnd, MSG_OPERATE_PERCENT, 10 + nextRange, 0);
if (lSongSize > 0) {
// 全曲小节音量
fread(&nCompleteBarNum, sizeof(int), 1, pFile);
for (int i = 0; i < nCompleteBarNum; i++) {
BARVOLS * pBVols = new BARVOLS;
pBVols->bRecording = false;
fread(pBVols->aVols, sizeof(DWORD), POINTS_PER_BAR, pFile);
g_lstCompleteVols.push_back(pBVols);
}
posBegin = ftell(pFile);
posSongBegin = posBegin;
if(!bAutoSave) //add by tj 2013/12/31
PostMessage(hNotifyWnd, MSG_OPERATE_NEXTRANGE, 10 + nextRange, 0);
nSize = f_MM_LoadSongMP3(hNotifyWnd, strProjectName, posSongBegin, dwVersion );
if (nSize > sizeof(long)+sizeof(int)) {
g_bSongLoaded = true;
g_bSongNeedSave = true;
posBegin += nSize +sizeof(long);
fsetpos(pFile, &posBegin);
}
else {
ClearGlobalVars(LIST_COMPLETEVOLS);
}
}
// 所处页面
fread(&g_iCurrentPage, sizeof(int), 1, pFile);
//音效
bool bResetAudioEffect = true;
if( wMinVersion>=5 ){
memset( g_aAudioEffects, 0, MAX_FX_NUM*sizeof(int) );
int nFxNum;
fread( &nFxNum, sizeof(int), 1, pFile );
if( nFxNum>0 ){
fread( g_aAudioEffects, sizeof(int), nFxNum, pFile );
for( int i=0; i<nFxNum; i++ ){
f_MM_SetFxPreset( g_aAudioEffectTypes[i], g_aAudioEffects[i] );
}
bResetAudioEffect = false;
}
}
if( bResetAudioEffect ){
ResetAudioEffects();
}
return iError;
}
void UpdateRecentProject(wstring wstrProj)//add by tj 2013/12/31
{
// 更新最近工程列表
wchar_t strTemp[MAX_PATH];
wstring strLowerProjName, strLowerCompName;
wcscpy(strTemp, wstrProj.c_str());
strLowerProjName = _wcslwr(strTemp);
BOOL bInList = FALSE;
for (int i = 0; i < g_lstRecentProject.size(); i++) {
wcscpy(strTemp, g_lstRecentProject[i].c_str());
strLowerCompName = _wcslwr(strTemp);
if (strLowerProjName.compare(strLowerCompName) == 0) {
if (i > 0) {
vector<wstring>::iterator iterStr =
g_lstRecentProject.begin() + i;
g_lstRecentProject.erase(iterStr);
g_lstRecentProject.insert(g_lstRecentProject.begin(),
wstrProj);
}
bInList = TRUE;
break;
}
}
if (!bInList) {
g_lstRecentProject.insert(g_lstRecentProject.begin(),
wstrProj);
}
}
BOOL HasProjectModified(int idStyle)
{
if( g_lstMelodyBars.empty() )
return false;
if( g_bProjStylePaid )
return TRUE;
if (idStyle == -1) {
idStyle = g_iSelectedStyleID;
}
// 基本信息
if (g_iMelodyKey_SVD != g_iMelodyKey
|| g_iComposeKey_SVD != g_iComposeKey
&& (g_iComposeKey_SVD != -1 || g_iComposeKey != g_iMelodyKey)
|| g_iSelectedStyleID_SVD != idStyle
|| g_fAudioVolume_SVD != g_fAudioVolume
|| g_fMusicVolume_SVD != g_fMusicVolume ){
return TRUE;
}
if( g_strProjectName.length()>0 && ( g_fRecordVolume_SVD != g_fRecordVolume
|| g_fSpeakerVolume_SVD != g_fSpeakerVolume
|| g_strFontFile_SVD.compare(g_strFontFile) )){
return TRUE;
}
// 旋律小节
if (g_lstMelodyBars_SVD.size() != g_lstMelodyBars.size()) {
return TRUE;
}
else {
for (int i = 0; i < g_lstMelodyBars.size(); i++) {
PMELODYBAR pSvdBar = g_lstMelodyBars_SVD[i], pMBar =
g_lstMelodyBars[i];
if (pSvdBar->iChords[0] != pMBar->iChords[0] ||
pSvdBar->iChords[1] != pMBar->iChords[1] ||
pSvdBar->iFill != pMBar->iFill ||
pSvdBar->tBarVol.bRecording != pMBar->tBarVol.bRecording ||
pSvdBar->tBarVol.bInvalid != pMBar->tBarVol.bInvalid) {
return TRUE;
}
else {
for (int j = 0; j < POINTS_PER_BAR; j++) {
if (pSvdBar->tBarVol.aVols[j] != pMBar->tBarVol.aVols[j]) {
return TRUE;
}
}
}
}
}
// 旋律分段
if (g_lstMelodyStages_SVD.size() != g_lstMelodyStages.size()) {
return TRUE;
}
else {
for (int i = 0; i < g_lstMelodyStages.size(); i++) {
PMELODYSTAGE pSvdStage = g_lstMelodyStages_SVD[i], pMStage =
g_lstMelodyStages[i];
if (pSvdStage->iFirstBar != pMStage->iFirstBar ||
pSvdStage->iLastBar != pMStage->iLastBar ||
pSvdStage->iVar != pMStage->iVar) {
return TRUE;
}
}
}
// 曲式分段
if (g_lstComposeStages_SVD.size() != g_lstComposeStages.size()) {
return TRUE;
}
else {
for (int i = 0; i < g_lstComposeStages.size(); i++) {
PCOMPOSESTAGE pSvdStage = g_lstComposeStages_SVD[i], pCStage =
g_lstComposeStages[i];
if (pSvdStage->iMelodyStage != pCStage->iMelodyStage ||
pSvdStage->nStageBars != pCStage->nStageBars ||
pSvdStage->iVar != pCStage->iVar ||
pSvdStage->idStyle != pCStage->idStyle ||
pSvdStage->aFills.size() != pCStage->aFills.size()) {
return TRUE;
}
else {
for (int j = 0; j < pCStage->aFills.size(); j++) {
if (pSvdStage->aFills[j] != pCStage->aFills[j]) {
return TRUE;
}
}
}
}
}
// 全曲音频
if (g_bSongNeedSave) {
// 全曲小节音量
if (g_lstCompleteVols_SVD.size() != g_lstCompleteVols.size()) {
return TRUE;
}
else {
for (int i = 0; i < g_lstCompleteVols.size(); i++) {
PBARVOLS pSvdBV = g_lstCompleteVols_SVD[i], pBV =
g_lstCompleteVols[i];
if (pSvdBV->bRecording != pBV->bRecording ||
pSvdBV->bInvalid != pBV->bInvalid) {
return TRUE;
}
else {
for (int j = 0; j < POINTS_PER_BAR; j++) {
if (pSvdBV->aVols[j] != pBV->aVols[j]) {
return TRUE;
}
}
}
}
}
}
//音效
for( int i=0; i<MAX_FX_NUM; i++ ){
if( g_aAudioEffects[i]!=g_aAudioEffects_SVD[i] ){
return TRUE;
}
}
// g_bUserSaved = TRUE;
return FALSE;
}
void SetInitVar(BOOL bClose) {
HKEY hComposerKey;
DWORD dwDisposition;
long lResult;
lResult = RegCreateKeyEx(HKEY_CURRENT_USER, (TCHAR*)REGKEY_SOFTWARE, 0,
NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hComposerKey,
&dwDisposition);
if (lResult == ERROR_SUCCESS) {
/* if (bClose) {
DWORD dwValue = TRUE;
lResult = RegSetValueEx(hComposerKey, L"NormalClosed", 0, REG_DWORD,
(LPBYTE) & dwValue, sizeof(DWORD));
}
*/
lResult = RegSetValueEx(hComposerKey, L"FontName", 0, REG_SZ,
(LPBYTE)g_strFontFile.c_str(),
g_strFontFile.length()*sizeof(WCHAR) + 1);
lResult = RegSetValueEx(hComposerKey, L"TimeSignature", 0, REG_DWORD,
(LPBYTE) & g_iMelodyTimeSignature, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"Tempo", 0, REG_DWORD,
(LPBYTE) & g_nMelodyTempo, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"PlaybackDevice", 0, REG_DWORD,
(LPBYTE) & g_iPlaybackDevice, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"PlaybackOutput", 0, REG_DWORD,
(LPBYTE) & g_iPlaybackOutput, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"PlaybackDeviceName", 0, REG_SZ,
(LPBYTE)g_strPlaybackDevice, strlen(g_strPlaybackDevice)+1);
lResult = RegSetValueEx(hComposerKey, L"RecordDevice", 0, REG_DWORD,
(LPBYTE) & g_iRecordDevice, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"RecordInput", 0, REG_DWORD,
(LPBYTE) & g_iRecordInput, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"RecordDeviceName", 0, REG_SZ,
(LPBYTE)g_strRecordDevice, strlen(g_strRecordDevice)+1);
lResult = RegSetValueEx(hComposerKey, L"RecordAutoAdjust", 0, REG_DWORD,
(LPBYTE) & g_bRecordAutoAdjust, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"RecordVolume", 0, REG_BINARY,
(LPBYTE) & g_fRecordVolume, sizeof(float));
lResult = RegSetValueEx(hComposerKey, L"SpeakerVolume", 0, REG_BINARY,
(LPBYTE) & g_fSpeakerVolume, sizeof(float));
lResult = RegSetValueEx(hComposerKey, L"LastSaveOption", 0, REG_DWORD,
(LPBYTE) & g_iLastSaveOption, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"WindowState", 0, REG_DWORD,
(LPBYTE) & g_iWindowState, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"LastSaveType", 0, REG_DWORD,
(LPBYTE) & g_iLastSaveType, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"LastSaveFile", 0, REG_SZ,
(LPBYTE)g_strLastSaveFile.c_str(), g_strLastSaveFile.length()*sizeof(WCHAR) + 1);
DWORD dwRegValue = g_bShowRecordHint ? 1 : 0;
lResult = RegSetValueEx(hComposerKey, L"ShowRecordHint", 0, REG_DWORD,
(LPBYTE) &dwRegValue, sizeof(DWORD));
dwRegValue = g_iShowType ? 1 : 0;
lResult = RegSetValueEx(hComposerKey, L"ChordFontType", 0, REG_DWORD,
(LPBYTE) &dwRegValue, sizeof(DWORD));
dwRegValue = g_bAutoOpenProject ? 1 : 0;
lResult = RegSetValueEx(hComposerKey, L"AutoOpenProject", 0, REG_DWORD,
(LPBYTE) &dwRegValue, sizeof(DWORD));
dwRegValue = g_bAutoOpenProjectEnable ? 1 : 0;
lResult = RegSetValueEx(hComposerKey, L"AutoOpenProjectEnable", 0, REG_DWORD,
(LPBYTE) &dwRegValue, sizeof(DWORD));
dwRegValue = g_bAutoDownloadStyle ? 1 : 0;
lResult = RegSetValueEx(hComposerKey, L"AutoDownloadStyle", 0, REG_DWORD,
(LPBYTE) &dwRegValue, sizeof(DWORD));
dwRegValue = g_bShowProtectMsg ? 1 : 0;
lResult = RegSetValueEx(hComposerKey, L"ShowProtectMessage", 0, REG_DWORD,
(LPBYTE) &dwRegValue, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"PreStageMode", 0, REG_DWORD,
(LPBYTE) &g_iPreStageDefault, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"PreStyleSort", 0, REG_DWORD,
(LPBYTE) &g_iPreStyleSort, sizeof(DWORD));
dwRegValue = g_bPrebeat ? 1 : 0;
lResult = RegSetValueEx(hComposerKey, L"Prebeat", 0, REG_DWORD,
(LPBYTE) &dwRegValue, sizeof(DWORD));
/* dwRegValue = g_bAPRActive ? 1 : 0;
lResult = RegSetValueEx(hComposerKey, L"APRActive", 0, REG_DWORD,
(LPBYTE) &dwRegValue, sizeof(DWORD));
*/
int index;
for (index = 0; index < g_lstRecentProject.size() && index <
MAX_RECENT_PROJECT; index++) {
wstring strValueName = L"RecentProject";
strValueName += IntToStr(index + 1).c_str();
lResult = RegSetValueEx(hComposerKey, strValueName.c_str(), 0,
REG_SZ, (LPBYTE)g_lstRecentProject[index].c_str(),
g_lstRecentProject[index].length()*sizeof(WCHAR) + 1);
}
// 删除多余的工程文件
for (; index < MAX_RECENT_PROJECT; index++) {
wstring strValueName = L"RecentProject";
strValueName += IntToStr(index + 1).c_str();
if (ERROR_SUCCESS == RegQueryValueEx(hComposerKey,
strValueName.c_str(), NULL, NULL, NULL, NULL)) {
RegDeleteValue(hComposerKey, strValueName.c_str());
}
}
// mac address
dwRegValue = g_lstMacAddress.size();// + g_lstMacAddressNew.size();
lResult = RegSetValueEx(hComposerKey, L"deviceNum", 0, REG_DWORD,
(LPBYTE) &dwRegValue, sizeof(DWORD));
for(int i=0; i<g_lstMacAddress.size(); i++) {
String strDeviece = L"device";
strDeviece += IntToStr(i);
lResult = RegSetValueEx(hComposerKey, strDeviece.c_str(), 0, REG_BINARY,
g_lstMacAddress[i], 6);
}
// for( int indexOld=0; indexOld<g_lstMacAddress.size(); indexOld++) {
// String strDeviece = L"device";
// strDeviece += IntToStr(indexDev);
//
// lResult = RegSetValueEx(hComposerKey, strDeviece.c_str(), 0, REG_BINARY,
// g_lstMacAddress[indexOld], 6);
//
// indexDev++;
// }
RegCloseKey(hComposerKey);
}
}
void GetInitVar() {
HKEY hComposerKey;
DWORD dwDisposition;
long lResult;
lResult = RegCreateKeyEx(HKEY_CURRENT_USER, REGKEY_SOFTWARE, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hComposerKey,
&dwDisposition);
if (lResult == ERROR_SUCCESS) {
if (dwDisposition == REG_OPENED_EXISTING_KEY) {
DWORD dwSize = MAX_PATH, dwType;
BYTE szBuffer[MAX_PATH];
lResult = RegQueryValueEx(hComposerKey, L"FontName", NULL, NULL,
szBuffer, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 1) {
g_strFontFile = (TCHAR*)szBuffer;
}
dwSize = MAX_PATH;
lResult = RegQueryValueEx(hComposerKey, L"LastSaveFile", NULL, NULL,
szBuffer, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 1) {
g_strLastSaveFile = (TCHAR*)szBuffer;
}
dwSize = MAX_PATH;
lResult = RegQueryValueEx(hComposerKey, L"ExtFontsDir", NULL, NULL,
szBuffer, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 1) {
g_strExtFontsPath = (TCHAR*)szBuffer;
}
int nValue;
dwSize = sizeof(int);
//add by tj 2013/12/30
lResult = RegQueryValueEx(hComposerKey, L"AutoSave", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_bAutoSave = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"AutoOpenProject", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_bAutoOpenProject = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"AutoOpenProjectEnable", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_bAutoOpenProjectEnable = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"AutoDownloadStyle", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_bAutoDownloadStyle = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"Prebeat", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_bPrebeat = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"PreStageMode", NULL,
&dwType, (LPBYTE) &nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
if( (0<=nValue) && (nValue<=2) ){
g_iPreStageDefault = nValue;
}else{
g_iPreStageDefault= 2;
}
}
lResult = RegQueryValueEx(hComposerKey, L"PreStyleSort", NULL,
&dwType, (LPBYTE) &nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0)
{
if( ( ( 0 <= (nValue&0xffff) ) &&
( (nValue&0xffff) <= 2 ) ) &&
( ( 0 <= ( (nValue&0xffff0000)>>16 ) ) &&
( ( (nValue&0xffff0000)>>16) <= 1) ) )
{
g_iPreStyleSort = nValue;
}else{
g_iPreStyleSort = STYLESORT_TIME | (STYLESORT_DOWN<<16);
}
}
lResult = RegQueryValueEx(hComposerKey, L"TimeSignature", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
if( nValue<0 || nValue>3 )
nValue = 0;
// SetMelodyTS( nValue );
g_iMelodyTimeSignature = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"Tempo", NULL, &dwType,
(LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
if( nValue<50 || nValue>200 )
nValue = 75;
// SetMelodyTempo( nValue );
g_nMelodyTempo = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"PlaybackDevice", NULL, &dwType,
(LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_iPlaybackDevice = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"PlaybackOutput", NULL, &dwType,
(LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_iPlaybackOutput = nValue;
}
dwSize = MAX_PATH;
lResult = RegQueryValueEx(hComposerKey, L"PlaybackDeviceName", NULL, NULL,
szBuffer, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 1) {
strcpy( g_strPlaybackDevice, szBuffer );
}
lResult = RegQueryValueEx(hComposerKey, L"RecordDevice", NULL, &dwType,
(LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_iRecordDevice = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"RecordInput", NULL, &dwType,
(LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_iRecordInput = nValue;
}
dwSize = MAX_PATH;
lResult = RegQueryValueEx(hComposerKey, L"RecordDeviceName", NULL, NULL,
szBuffer, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 1) {
strcpy( g_strRecordDevice, szBuffer );
}
lResult = RegQueryValueEx(hComposerKey, L"RecordAutoAdjust", NULL, &dwType,
(LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_bRecordAutoAdjust = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"LastSaveOption", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_iLastSaveOption = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"WindowState", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_iWindowState = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"LastSaveType", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_iLastSaveType = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"ShowRecordHint", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_bShowRecordHint = nValue ? true : false;
}
/*
lResult = RegQueryValueEx(hComposerKey, L"APRActive", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_bAPRActive = nValue ? true : false;
}
*/
lResult = RegQueryValueEx(hComposerKey, L"ShowProtectMessage", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_bShowProtectMsg = nValue;
}
lResult = RegQueryValueEx(hComposerKey, L"ChordFontType", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
g_iShowType = nValue ? true : false;
}
float fValue;
dwSize = sizeof(float);
lResult = RegQueryValueEx(hComposerKey, L"RecordVolume", NULL,
&dwType, (LPBYTE) & fValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
if( fValue<0 || fValue>1 )
fValue = 1;
g_fRecordVolume = fValue;
}
lResult = RegQueryValueEx(hComposerKey, L"SpeakerVolume", NULL,
&dwType, (LPBYTE) & fValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
if( fValue<0 || fValue>1 )
fValue = 1;
g_fSpeakerVolume = fValue;
}
for (int i = 0; i < MAX_RECENT_PROJECT; i++) {
wstring strValueName = L"RecentProject";
strValueName += IntToStr(i + 1).c_str();
dwSize = MAX_PATH;
lResult = RegQueryValueEx(hComposerKey, strValueName.c_str(),
NULL, NULL, szBuffer, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 1) {
g_lstRecentProject.push_back((LPCTSTR)szBuffer);
}
}
//mac address
lResult = RegQueryValueEx(hComposerKey, L"deviceNum", NULL,
&dwType, (LPBYTE) & nValue, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize>0 && nValue>0) {
for(int index=0; index<nValue; index++) {
BYTE *szBuffer = new char[6];
dwSize = 6;
String strDeviece = L"device";
strDeviece += IntToStr(index);
lResult = RegQueryValueEx(hComposerKey, strDeviece.c_str(), NULL, NULL, szBuffer, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0 && szBuffer[0]!=0) {
g_lstMacAddress.push_back(szBuffer);
}else{
SAFE_DELETE(szBuffer)
}
}
}
}
RegCloseKey(hComposerKey);
}
}
void SetAutoLogin(bool bAuto, LPCSTR strName, LPCSTR strPwd) {
HKEY hComposerKey;
DWORD dwDisposition;
long lResult;
lResult = RegCreateKeyEx(HKEY_CURRENT_USER, REGKEY_SOFTWARE, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hComposerKey,
&dwDisposition);
if (lResult == ERROR_SUCCESS) {
BYTE strText[100];
int nNameLen = strlen(strName), nRegLen = nNameLen + 1;
strText[0] = nNameLen;
for (int i = 0; i < nNameLen; i++) {
strText[i + 1] = strName[i] - 0x63;
}
strText[nNameLen + 1] = '\0';
if (bAuto) {
int nMaxPwdLen = 16, nPwdLen = strlen(strPwd);
strText[nNameLen + 1] = nPwdLen;
for (int i = 0; i < nMaxPwdLen; i++) {
if (i < nPwdLen)
strText[i + nNameLen + 2] = strPwd[i] - 0x4B;
else
strText[i + nNameLen + 2] = Random(256);
}
strText[nNameLen + nMaxPwdLen + 2] = '\0';
nRegLen += 17;
}
lResult = RegSetValueEx(hComposerKey, REGKEY_AUTOLOG, 0, REG_BINARY,
strText, nRegLen);
RegCloseKey(hComposerKey);
}
}
bool GetAutoLogin(char* strName, char* strPwd) {
HKEY hComposerKey;
DWORD dwDisposition;
bool bAuto = false;
strName[0] = strPwd[0] = 0;
long lResult = RegCreateKeyEx(HKEY_CURRENT_USER, REGKEY_SOFTWARE, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hComposerKey,
&dwDisposition);
if (lResult == ERROR_SUCCESS) {
DWORD dwSize;
BYTE szBuffer[MAX_PATH];
if (dwDisposition == REG_OPENED_EXISTING_KEY) {
dwSize = MAX_PATH;
lResult = RegQueryValueEx(hComposerKey, REGKEY_AUTOLOG, NULL, NULL,
szBuffer, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 0) {
int nTextLen = dwSize;
int nNameLen = szBuffer[0];
for (int i = 0; i < nNameLen; i++) {
strName[i] = szBuffer[i + 1] + 0x63;
}
strName[nNameLen] = '\0';
if (nNameLen == nTextLen - 18) {
bAuto = true;
int nPwdLen = szBuffer[nNameLen + 1];
for (int i = 0; i < nPwdLen; i++) {
strPwd[i] = szBuffer[i + nNameLen + 2] + 0x4B;
}
strPwd[nPwdLen] = '\0';
}
}
}
RegCloseKey(hComposerKey);
}
return bAuto;
}
void GetAutoSaveReg()
{
HKEY hComposerKey;
DWORD dwDisposition;
long lResult;
lResult = RegCreateKeyEx(HKEY_CURRENT_USER, REGKEY_SOFTWARE, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hComposerKey,
&dwDisposition);
if (lResult == ERROR_SUCCESS) {
if (dwDisposition == REG_OPENED_EXISTING_KEY) {
DWORD dwSize = MAX_PATH;
BYTE szBuffer[MAX_PATH];
lResult = RegQueryValueEx(hComposerKey, L"AutoSaveProj",
NULL, NULL, szBuffer, &dwSize);
if (lResult == ERROR_SUCCESS && dwSize > 1) {
g_strProjectName = (TCHAR*)szBuffer;
}
}
RegCloseKey(hComposerKey);
}
}
void SetAutoSaveReg()
{
HKEY hComposerKey;
DWORD dwDisposition;
long lResult;
lResult = RegCreateKeyEx(HKEY_CURRENT_USER, (TCHAR*)REGKEY_SOFTWARE, 0,
NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hComposerKey,
&dwDisposition);
if (lResult == ERROR_SUCCESS) {
DWORD dwValue = g_bAutoSave;
lResult = RegSetValueEx(hComposerKey, L"AutoSave", 0, REG_DWORD,
(LPBYTE) & dwValue, sizeof(DWORD));
lResult = RegSetValueEx(hComposerKey, L"AutoSaveProj", 0, REG_SZ,
(LPBYTE)g_strProjectName.c_str(),
g_strProjectName.length()*sizeof(WCHAR) + 1);
RegCloseKey(hComposerKey);
}
}
void ClearAutoProj()
{
g_bAutoSave = false;//add by tj 2014/02/27
SetAutoSaveReg();
if( FileExists( g_strAutoProjName.c_str() ) )
DeleteFile( g_strAutoProjName.c_str() );
DebugPrint("delete auto Save project file....");
}
void SaveAutoProj()
{
DebugPrint("auto Save project....");
// String strPath = g_strExecutePath.c_str();
// strPath += _T(AUTOSAVE_FILENAME);
if( HasProjectModified() ){
AnsiString strProjectName = g_strAutoProjName.c_str();
SaveProject( strProjectName.c_str(), PROJ_MODE_AUTO);
}
}
bool ReloadBaseCompose()
{
bool bRet = true;
BOOL bModified = g_bkMelody.CheckModified();
if( bModified ){
bRet = GenerateBaseCompose();
if( bRet ){
g_bkMelody.Backup();
}
}
return bRet;
}
bool GenerateBaseCompose()
{
HRESULT hr = S_FALSE;
int nBufferLength, nStageNum = 0, nChordsNum = 0, nFillNum = 0,
nMelodyBarNum = g_lstMelodyBars.size();
int(*aStages)[2], (*aChords)[2], (*aFills)[2];
aFills = new int[nMelodyBarNum][2];
aChords = new int[nMelodyBarNum * 2][2];
for (int i = 0; i < nMelodyBarNum; i++) {
MELODYBAR *pBar = g_lstMelodyBars[i];
if (pBar->iFill != -1) {
aFills[nFillNum][0] = i;
aFills[nFillNum][1] = pBar->iFill;
nFillNum++;
}
if (pBar->iChords[0] != -1) {
aChords[nChordsNum][0] =
((pBar->iChords[0] / CHORD_TYPE_NUM + g_iMelodyKey) % KEY_NUM)
* CHORD_TYPE_NUM + pBar->iChords[0] % CHORD_TYPE_NUM;
aChords[nChordsNum][1] = 0;
if (pBar->iChords[1] == -1) {
aChords[nChordsNum][1] = 1;
}
else {
nChordsNum++;
aChords[nChordsNum][0] =
((pBar->iChords[1] / CHORD_TYPE_NUM + g_iMelodyKey)
% KEY_NUM) * CHORD_TYPE_NUM +
pBar->iChords[1] % CHORD_TYPE_NUM;
aChords[nChordsNum][1] = 0;
}
nChordsNum++;
}
}
DebugPrint("//////////////////和弦输出/////////////////////");
for (int i = 0; i < nChordsNum; i++) {
DebugPrint(" %d %d", aChords[i][0], aChords[i][1]);
}
DebugPrint("//////////////////分段输出/////////////////////");
nStageNum = g_lstMelodyStages.size();
if (nStageNum > 0) {
aStages = new int[nStageNum][2];
for (int i = 0; i < nStageNum; i++) {
MELODYSTAGE* pStage = g_lstMelodyStages[i];
aStages[i][0] = pStage->iLastBar;
aStages[i][1] = pStage->iVar;
DebugPrint(" %d - %d", aStages[i][0], aStages[i][1]);
}
}
else {
aStages = new int[nMelodyBarNum][2];
}
DebugPrint("MF_Basecompose StyleID=%d", g_iSelectedStyleID);
BYTE * pBuffer = new BYTE[1000000];
nBufferLength = 1000000;
int ret = f_SM_BaseCompose(g_iMelodyKey, &nBufferLength, pBuffer, &nStageNum,
aStages, &nChordsNum, aChords, &nFillNum, aFills, g_iSelectedStyleID);
if (ret==0) {
DebugPrint("Basecompose return buffer size = %d.\n", nBufferLength);
if (g_lstMelodyStages.size() == 0) {
DebugPrint("//////////////////分段输入/////////////////////");
if (nStageNum > 0) {
int iFirstStageBar = 0;
for (int i = 0; i < nStageNum; i++) {
MELODYSTAGE* pStage = new MELODYSTAGE;
pStage->iFirstBar = iFirstStageBar;
pStage->iLastBar = aStages[i][0];
pStage->iVar = aStages[i][1];
g_lstMelodyStages.push_back(pStage);
iFirstStageBar = aStages[i][0] + 1;
DebugPrint(" %d - %d", aStages[i][0], aStages[i][1]);
}
}
}
if (nFillNum > 0) {
for (int i = 0; i < nFillNum; i++) {
MELODYBAR *pBar = g_lstMelodyBars[aFills[i][0]];
pBar->iFill = aFills[i][1];
}
}
DebugPrint("//////////////////和弦输入/////////////////////");
if (nChordsNum > 0) {
int index = 0;
for (int i = 0; i < nChordsNum; i++) {
int iKey = aChords[i][0] / CHORD_TYPE_NUM;
if (iKey >= g_iMelodyKey)
iKey -= g_iMelodyKey;
else
iKey += KEY_NUM - g_iMelodyKey;
MELODYBAR *pBar = g_lstMelodyBars[index];
pBar->iChords[0] = iKey * CHORD_TYPE_NUM +
aChords[i][0] % CHORD_TYPE_NUM;
if (aChords[i][1] == CHORD_WHOLE_BAR) {
pBar->iChords[1] = -1;
}
else {
i++;
iKey = aChords[i][0] / CHORD_TYPE_NUM;
if (iKey >= g_iMelodyKey)
iKey -= g_iMelodyKey;
else
iKey += KEY_NUM - g_iMelodyKey;
pBar->iChords[1] = iKey * CHORD_TYPE_NUM +
aChords[i][0] % CHORD_TYPE_NUM;
}
index++;
DebugPrint(" %d %d", pBar->iChords[0], pBar->iChords[1]);
}
}
hr = f_MM_LoadBaseCompose(pBuffer, nBufferLength);
if (FAILED(hr)) {
DebugPrint("Load base compose error. errcode = %x\n", hr);
}
else {
f_MM_SetStreamVolume(3, g_fMusicVolume);
DebugPrint("Load base compose complete.\n");
g_bBaseComposeLoaded = true;
SaveAutoProj();
}
}
else {
DebugPrint("Base compose error.\n");
}
SAFE_DELETE_ARRAY(pBuffer);
SAFE_DELETE_ARRAY(aFills);
SAFE_DELETE_ARRAY(aChords);
SAFE_DELETE_ARRAY(aStages);
return hr == S_OK;
}
bool UpdateStageBars()
{
bool bBarChanged = false;
for( int i=0; i<g_lstComposeStages.size(); i++ ){
COMPOSESTAGE* pCStage = g_lstComposeStages[i];
if( pCStage->idStyle==g_iSelectedStyleID ){
if( pCStage->iMelodyStage>=COMPOSE_ENDING_1 ){
int iEnding = pCStage->iMelodyStage - COMPOSE_ENDING_1;
if( pCStage->nStageBars!=g_arrEndingBarNum[iEnding] ){
bBarChanged = true;
if( g_arrEndingBarNum[iEnding]<=0 ){
pCStage->iMelodyStage = COMPOSE_ENDING_1;
}
pCStage->nStageBars = g_arrEndingBarNum[iEnding];
}
}
else if( pCStage->iMelodyStage>=COMPOSE_INTRO_1 ){
int iIntro = pCStage->iMelodyStage - COMPOSE_INTRO_1;
if( pCStage->nStageBars!=g_arrIntroBarNum[iIntro] ){
bBarChanged = true;
if( g_arrIntroBarNum[iIntro]<=0 ){
pCStage->iMelodyStage = COMPOSE_INTRO_1;
}
pCStage->nStageBars = g_arrIntroBarNum[iIntro];
}
}
}
}
return bBarChanged;
}
bool UpdateSegmentBars()
{
bool bStyleChanged = ( g_iLastStyleID!=g_iSelectedStyleID );
if( bStyleChanged ){
memset( g_arrIntroBarNum, 0, MAX_INTRO_NUM*sizeof(int) );
memset( g_arrEndingBarNum, 0, MAX_ENDING_NUM*sizeof(int) );
bool bUseful = f_SM_CheckStyle( g_iSelectedStyleID );
if( bUseful ){
for( int i=0; i<MAX_INTRO_NUM; i++ ){
g_arrIntroBarNum[i] = f_SM_GetSegmentBarNum( COMPOSE_INTRO_1+i, g_iSelectedStyleID );
}
for( int i=0; i<MAX_ENDING_NUM; i++ ){
g_arrEndingBarNum[i] = f_SM_GetSegmentBarNum( COMPOSE_ENDING_1+i, g_iSelectedStyleID );
}
for( int i=0; i<g_lstComposeStages.size(); i++ ){
COMPOSESTAGE* pCStage = g_lstComposeStages[i];
if( pCStage->idStyle==g_iLastStyleID ){
pCStage->idStyle = g_iSelectedStyleID;
}
}
g_iLastStyleID = g_iSelectedStyleID;
}
}
return bStyleChanged;
}
void InitComposeStage()
{
MELODYSTAGE *pMStage = NULL;
COMPOSESTAGE* pCStage = NULL;
//初始化曲式段落，缺省为 Intro1 + 全部旋律段 + Intro2 + 全部旋律段 + Ending1
bool bWeakupBar = g_bWeakup && ( g_lstMelodyStages[0]->iLastBar==0 );
int iFirstStage = bWeakupBar ? 1 : 0;
int nCount = g_iPreStageDefault;
for( int i=0; i<nCount; i++ ){
//Intro1, Intro2
if( g_iPreStageDefault && g_arrIntroBarNum[i]>0 ){
pCStage = new COMPOSESTAGE;
pCStage->iMelodyStage = COMPOSE_INTRO_1 + i;
pCStage->nStageBars = g_arrIntroBarNum[i];
pCStage->idStyle = g_iSelectedStyleID;
g_lstComposeStages.push_back( pCStage );
}
for( int j=iFirstStage; j<g_lstMelodyStages.size(); j++ ){
pMStage = g_lstMelodyStages[j];
pCStage = new COMPOSESTAGE;
pCStage->iMelodyStage = j;
pCStage->nStageBars = pMStage->iLastBar - pMStage->iFirstBar + 1;
pCStage->iVar = pMStage->iVar;
pCStage->idStyle = g_iSelectedStyleID;
for( int k=pMStage->iFirstBar; k<=pMStage->iLastBar; k++ ){
MELODYBAR *pMBar = g_lstMelodyBars[k];
if( pMBar->iFill!=-1 ){
DWORD dwFill = MAKELONG( k - pMStage->iFirstBar, pMBar->iFill );
pCStage->aFills.push_back( dwFill );
}
else if( k==pMStage->iLastBar ){
DWORD dwFill = k - pMStage->iFirstBar;
pCStage->aFills.push_back( dwFill );
}
}
g_lstComposeStages.push_back( pCStage );
}
// if( i==nCount-1 ) break;
}
if( g_iPreStageDefault && g_arrEndingBarNum[0]>0 ){
pCStage = new COMPOSESTAGE;
pCStage->iMelodyStage = COMPOSE_ENDING_1;
pCStage->nStageBars = g_arrEndingBarNum[0];
pCStage->idStyle = g_iSelectedStyleID;
g_lstComposeStages.push_back( pCStage );
}
}
int GetComposeData( COMPOSESTAGELIST lstComposeStages, int iKey, int& nDataSize, LPBYTE lpData,
bool bCombineSong, int& nTimeSet, double (*aTimeSet)[2] )
{
int nMelodyStageNum = 0, nChordsNum = 0, nComposeStageNum =
0, nFillNum = 0, nComplementNum = 0, nVolSetNum = 0, nInsSetNum = 0;
int(*aMelodyStages)[2] = NULL, (*aComposeStages)[2] = NULL, (*aChords)[2] =
NULL, *aStyleID = NULL, (*aFills)[2] = NULL, (*aComplements)[2] = NULL,
(*aVolSets)[3] = NULL, (*aInsSets)[3] = NULL;
DebugPrint("//////////////////曲式分段输出/////////////////////");
vector<DWORD>arrFillPos, arrFillType, arrComplementCPos, arrComplementMPos;
nComposeStageNum = lstComposeStages.size();
if (nComposeStageNum > 0) {
int iFirstBar = 0;
aComposeStages = new int[nComposeStageNum][2];
aStyleID = new int[nComposeStageNum];
for (int i = 0; i < nComposeStageNum; i++) {
COMPOSESTAGE* pComposeStage = lstComposeStages[i];
aComposeStages[i][0] = pComposeStage->iMelodyStage;
aComposeStages[i][1] = pComposeStage->iVar;
if (bCombineSong) {
// 拼接旋律///////////////////////////////////////
if (pComposeStage->iMelodyStage < COMPOSE_INTRO_1) {
MELODYSTAGE * pMStage = g_lstMelodyStages[pComposeStage->iMelodyStage];
aTimeSet[nTimeSet][0] = pMStage->iFirstBar;
}
else {
aTimeSet[nTimeSet][0] = -1;
}
if( nTimeSet>0 && aTimeSet[nTimeSet-1][0]>=0
&& lstComposeStages[i-1]->iMelodyStage
==pComposeStage->iMelodyStage-1 ){
aTimeSet[nTimeSet-1][1] += pComposeStage->nStageBars;
}
else if( nTimeSet>0 && g_bWeakup && pComposeStage->iMelodyStage==1
&& aTimeSet[nTimeSet-1][0]==-1 ){
aTimeSet[nTimeSet - 1][1] -= 0.5;
aTimeSet[nTimeSet][0] -= 0.5;
aTimeSet[nTimeSet][1] = pComposeStage->nStageBars + 0.5;
nTimeSet++;
}
else {
aTimeSet[nTimeSet][1] = pComposeStage->nStageBars;
nTimeSet++;
}
/////////////////////////////////////////////////
}
aStyleID[i] = pComposeStage->idStyle;
for (int j = 0; j < pComposeStage->aFills.size(); j++) {
int iPos = LOWORD(pComposeStage->aFills[j]),
iType = HIWORD(pComposeStage->aFills[j]);
arrFillPos.push_back(iPos + iFirstBar);
arrFillType.push_back(iType);
}
if (pComposeStage->iMelodyStage >=COMPOSE_INTRO_1 && pComposeStage->iVar == 1) { // 补足主旋律
arrComplementCPos.push_back(iFirstBar);
arrComplementMPos.push_back(
g_lstMelodyStages[lstComposeStages[i-1]->iMelodyStage+1]->iFirstBar);
}
iFirstBar += pComposeStage->nStageBars;
DebugPrint(" %x - %d - %d", aComposeStages[i][0],
aComposeStages[i][1], aStyleID[i]);
}
}
DebugPrint("//////////////////补足主旋律输出/////////////////////");
nComplementNum = arrComplementCPos.size();
if (nComplementNum > 0) {
aComplements = new int[nComplementNum][2];
for (int i = 0; i < nComplementNum; i++) {
aComplements[i][0] = arrComplementCPos[i];
aComplements[i][1] = arrComplementMPos[i];
DebugPrint(" %d - %d", aComplements[i][0], aComplements[i][1]);
}
}
DebugPrint("//////////////////加花输出/////////////////////////");
nFillNum = arrFillPos.size();
if (nFillNum > 0) {
aFills = new int[nFillNum][2];
for (int i = 0; i < nFillNum; i++) {
aFills[i][0] = arrFillPos[i];
aFills[i][1] = arrFillType[i];
DebugPrint(" %d - %d", aFills[i][0], aFills[i][1]);
}
}
DebugPrint("//////////////////旋律分段输出/////////////////////");
nMelodyStageNum = g_lstMelodyStages.size();
if (nMelodyStageNum > 0) {
aMelodyStages = new int[nMelodyStageNum][2];
for (int i = 0; i < nMelodyStageNum; i++) {
MELODYSTAGE* pMelodyStage = g_lstMelodyStages[i];
aMelodyStages[i][0] = pMelodyStage->iLastBar;
aMelodyStages[i][1] = pMelodyStage->iVar;
DebugPrint(" %d - %d", aMelodyStages[i][0], aMelodyStages[i][1]);
}
}
DebugPrint("//////////////////和弦输出/////////////////////");
int nMelodyBarNum = g_lstMelodyBars.size();
aChords = new int[nMelodyBarNum * 2][2];
for (int i = 0; i < nMelodyBarNum; i++) {
MELODYBAR *pBar = g_lstMelodyBars[i];
if (pBar->iChords[0] != -1) {
aChords[nChordsNum][0] =
((pBar->iChords[0] / CHORD_TYPE_NUM + iKey) % KEY_NUM)
* CHORD_TYPE_NUM + pBar->iChords[0] % CHORD_TYPE_NUM;
aChords[nChordsNum][1] = 0;
if (pBar->iChords[1] == -1) {
aChords[nChordsNum][1] = 1;
}
else {
nChordsNum++;
aChords[nChordsNum][0] =
((pBar->iChords[1] / CHORD_TYPE_NUM + iKey) % KEY_NUM)
* CHORD_TYPE_NUM + pBar->iChords[1] % CHORD_TYPE_NUM;
aChords[nChordsNum][1] = 0;
}
nChordsNum++;
}
}
for (int i = 0; i < nChordsNum; i++) {
DebugPrint(" %d %d", aChords[i][0], aChords[i][1]);
}
int ret = f_SM_Compose(iKey, &nDataSize, lpData,
nMelodyStageNum, aMelodyStages,
nChordsNum, aChords,
nComposeStageNum, aComposeStages,
aStyleID,
nFillNum, aFills,
nComplementNum, aComplements,
nVolSetNum, aVolSets,
nInsSetNum, aInsSets);
DebugPrint("Compose return buffer size = %d.\n", nDataSize);
SAFE_DELETE_ARRAY(aStyleID);
SAFE_DELETE_ARRAY(aMelodyStages);
SAFE_DELETE_ARRAY(aComposeStages);
SAFE_DELETE_ARRAY(aChords);
SAFE_DELETE_ARRAY(aFills);
SAFE_DELETE_ARRAY(aComplements);
SAFE_DELETE_ARRAY(aVolSets);
SAFE_DELETE_ARRAY(aInsSets);
return ret;
}
bool IsProtected()
{
if( g_bLogon && g_infoUser.accountInfo.vipPeriod!=0 )
return false;
//未付费风格检测
vector<UINT> aStyleID;
for( int i=0; i<g_lstComposeStages.size(); i++ ){
COMPOSESTAGE* pStage = g_lstComposeStages[i];
bool bChecked = false;
for( int j=0; j<aStyleID.size(); j++ ){
if( aStyleID[j]==pStage->idStyle ){
bChecked = true;
break;
}
}
if( !bChecked ){
bool bPaied = false;
if( g_bLogon ){
for( int k=0; k<g_infoUser.ownStyleNum; k++ ){
if( g_infoUser.arrStyleId[k]==pStage->idStyle ){
bPaied = true;
break;
}
}
}
if( !bPaied ){
TSTYLEINFO infoStyle;
f_SM_GetStyleInfo( pStage->idStyle, &infoStyle );
if( infoStyle.cost>0 ){
return true;
}
}
aStyleID.push_back( pStage->idStyle );
}
}
return false;
}
bool ReloadCompose(int iKey)
{
bool bRet = true;
BOOL bModified = g_bkCompose.CheckModified();
if( iKey!=g_bkCompose.m_iKey || bModified ){
bRet = GenerateCompose( iKey, !g_bSongNeedSave );
g_bkCompose.Backup( iKey );
//g_bSongSaved = false;
g_strMP3File = "";
}
return bRet;
}
bool GenerateCompose(int iKey, bool bCombineSong)
{
HRESULT hr;
int nTimeSet = 0;
double(*aTimeSet)[2] = new double[g_lstComposeStages.size()][2];
BYTE* pBuffer = new BYTE[2000000];
int nBufferLength = 2000000;
int ret = GetComposeData( g_lstComposeStages, iKey, nBufferLength, pBuffer,
bCombineSong, nTimeSet, aTimeSet );
if (ret==0) {
hr = f_MM_LoadCompose(pBuffer, nBufferLength);
if( hr==S_FALSE ) {
DebugPrint("Load compose error. errcode = %x\n", hr);
}
else {
g_bRecProtect = IsProtected();
f_MM_SetRecordProtect( g_bRecProtect );
f_MM_SetStreamVolume(4, g_fMusicVolume);
g_bComposeLoaded = true;
SaveAutoProj();
DebugPrint("Load compose complete.\n");
}
if (nTimeSet > 0) {
hr = f_MM_CombineSong( nTimeSet, aTimeSet );
if (hr != S_OK) {
DebugPrint("Load song error. errcode = %x\n", hr);
}
else {
f_MM_SetStreamVolume(5, g_fAudioVolume);
g_bSongLoaded = true;
}
}
}
else {
DebugPrint("Compose error.\n");
}
SAFE_DELETE_ARRAY(pBuffer);
SAFE_DELETE_ARRAY(aTimeSet);
return hr == S_OK;
}
void ResetAudioEffects()
{
//重置音效，混响/APR缺省开启
for( int i=0; i<MAX_FX_NUM; i++ ){
if( i==3 ){
if( g_aAudioEffects[3]!=2 ){
g_aAudioEffects_SVD[3] = g_aAudioEffects[3] = 2;
f_MM_SetFxPreset( g_aAudioEffectTypes[3], 2 );
}
}
else if( i==10 ){
if( g_aAudioEffects[10]!=1 ){
g_aAudioEffects_SVD[10] = g_aAudioEffects[10] = 0;
f_MM_SetFxPreset( g_aAudioEffectTypes[10], 0 );
}
}
else if( g_aAudioEffects[i]!=0 ){
g_aAudioEffects_SVD[i] = g_aAudioEffects[i] = 0;
f_MM_SetFxPreset( g_aAudioEffectTypes[i], 0 );
}
}
}
void SetTransparent( TComponent* pCtrl )
{
if( pCtrl->ClassNameIs( TLabel::ClassName() ) ){
TLabel* pC = (TLabel*)pCtrl;
pC->ControlStyle = pC->ControlStyle>>csOpaque;
}
else if( pCtrl->ClassNameIs( TCheckBox::ClassName() ) ){
((TCheckBox*)pCtrl)->Color = RGB(230, 204, 179);
}
else if( pCtrl->ClassNameIs( TRadioButton::ClassName() ) ){
((TRadioButton*)pCtrl)->Color = RGB(230, 204, 179);
}
else{
for( int i=0; i<pCtrl->ComponentCount; i++ ){
SetTransparent( pCtrl->Components[i] );
}
}
}
void UniDrawChord(TCanvas *Canvas, TRect rcDraw, int iMainKey, int iAjustKey, int iType)
{
String strMainKey, strAjustKey, strA, strN;
if( iAjustKey==1 ) strAjustKey = L"#";
else if( iAjustKey==-1 ) strAjustKey = L"b";
if( iType==1 || iType==3 ) strA = L"m";
if( iType==2 || iType==3 ) strN = L"7";
int iMKeyLeft, iATypeLeft, iNTypeLeft, wChord(0),
wMKey(12), wAKey(3), wType(8), wVKey(12), wIKey(6);
if( !g_iShowType ){ //罗马字母
if( iMainKey==0 ){
wMKey = iType>0 ? 6 : 8;
}
else if( iMainKey==1 ){
wMKey = iType>0 ? 12 : 16;
}
else if( iMainKey==2 ){
wIKey = 5;
wMKey = iType>0 ? 16 : 18;
}
else if( iMainKey==3 ){
wVKey = 11;
wMKey = iType>0 ? 15 : 18;
}
else if( iMainKey==4 ){
wMKey = iType>0 ? 10 : 16;
}
else if( iMainKey==5 ){
wVKey = 11;
wIKey = 5;
wMKey = iType>0 ? 17 : 20;
}
else if( iMainKey==6 ){
wVKey = 11;
wIKey = 5;
wMKey = iType>0 ? 22 : 26;
}
}
else{ //英文字母
if( iMainKey==5 ){ //A升降号靠近
wAKey = 1;
}
else if( iMainKey==3 ){ //F下标靠近
wMKey = 9;
}
}
wChord += wMKey;
if( iAjustKey!=0 ) wChord += wAKey;
if( strA.Length()>0 ) wChord += wType - 1;
if( strN.Length()>0 ) wChord += wType - 1;
int iLeft = rcDraw.Left + ( rcDraw.Width() - wChord ) / 2,
iOriTop = rcDraw.top + (rcDraw.Height() - 18) / 2;
TFont *fntOld = new TFont;
fntOld->Assign( Canvas->Font );
Canvas->Font->Name = "Times New Roman";
Canvas->Font->Quality = TFontQuality::fqClearTypeNatural;
Canvas->Font->Color = RGB(60,43,23);
Canvas->Font->Style = TFontStyles()<<fsItalic<<fsBold;
Canvas->Brush->Style = bsClear;
//绘制升降调
if( iAjustKey!=0 ){
int iTop = iOriTop-2;
if( iAjustKey==-1 || !g_iShowType && iMainKey==6 )
iTop++;
Canvas->Font->Size = g_szFont8; //升降字体大小
Canvas->TextOut( iLeft, iTop, strAjustKey );
iLeft += wAKey;
}
int iTop = iOriTop - 1;
Canvas->Font->Size = g_szFont16; //和弦字体大小
if( g_iShowType ){
strMainKey = u_strAlphaTable[iMainKey];
Canvas->TextOut( iLeft, iTop, strMainKey );
}
else{
int l = iLeft;
if( iMainKey<4 ){
strMainKey = L"I";
Canvas->TextOut( l, iTop, strMainKey );
l += wIKey;
if( iMainKey==3 ){
strMainKey = L"V";
Canvas->TextOut( l, iTop, strMainKey );
l += wVKey;
}
else if( iMainKey>0 ){
Canvas->TextOut( l, iTop, strMainKey );
l += wIKey;
if( iMainKey==2 ){
Canvas->TextOut( l, iTop, strMainKey );
l += wIKey;
}
}
}
else{
strMainKey = L"V";
Canvas->TextOut( l, iTop, strMainKey );
l += wVKey;
if( iMainKey>4 ){
strMainKey = L"I";
Canvas->TextOut( l, iTop, strMainKey );
l += wIKey;
if( iMainKey==6 ){
Canvas->TextOut( l, iTop, strMainKey );
l += wIKey;
}
}
}
}
iLeft += wMKey;
iTop = iOriTop + 6;
//绘制A
if( strA.Length()>0 ){
Canvas->Font->Size = g_szFont9;
Canvas->TextOut( iLeft+2, iTop, strA );
iLeft += wType;
}
//绘制N
if( strN.Length()>0 ){
iTop += g_szFont8==g_szFont9 ? 2 : 3;
Canvas->Font->Size = g_szFont8;
Canvas->Font->Style = TFontStyles();
Canvas->TextOut( iLeft+4, iTop, strN );
}
Canvas->Font->Assign( fntOld );
delete fntOld;
}
char* GetMacAdress()
{
//首先选择原用mac
if(!g_lstMacAddress.empty())
return g_lstMacAddress[0];
//查找本地mac
// PIP_ADAPTER_INFO pIpAdapterInfo = new IP_ADAPTER_INFO();
// unsigned long stSize = sizeof(IP_ADAPTER_INFO);
// int nRes = GetAdaptersInfo(pIpAdapterInfo, &stSize);
//
// if( ERROR_BUFFER_OVERFLOW==nRes ){
// SAFE_DELETE(pIpAdapterInfo)
// pIpAdapterInfo = (PIP_ADAPTER_INFO)new BYTE[stSize];
// nRes=GetAdaptersInfo(pIpAdapterInfo, &stSize);
// }
//
// if( ERROR_SUCCESS==nRes ){
// char zeroBuf[6] = {0};
// while( pIpAdapterInfo ){
// char *idDevice = new char[6];
// for(int index=0; index<pIpAdapterInfo->AddressLength; index++)
// idDevice[index] = pIpAdapterInfo->Address[index];
//
// if(memcmp(idDevice, zeroBuf, 6))
// g_lstMacAddressNew.push_back(idDevice);
//
// pIpAdapterInfo = pIpAdapterInfo->Next;
// }
// }
// SAFE_DELETE(pIpAdapterInfo)
// int nEqualIndex = -1;
// for(int indexNew=0; indexNew<g_lstMacAddressNew.size(); indexNew++){
// char *szBufferNew = g_lstMacAddressNew[indexNew];
//
// for(int indexOld=0; indexOld<g_lstMacAddress.size(); indexOld++) {
// char *szBufferOld = g_lstMacAddress[indexOld];
//
// bool bEqual = true;
// for(int i=0; i<6; i++)
// if(szBufferOld[i]!=szBufferNew[i]) bEqual = false;
//
// if( bEqual ) {
// nEqualIndex = indexOld;
// break;
// }
// }
//
// if( -1!=nEqualIndex ) break;
// }
//
// if( nEqualIndex>=0 ) {
// for(int i=0; i<g_lstMacAddressNew.size(); i++) {
// SAFE_DELETE(g_lstMacAddressNew[i])
// }
// g_lstMacAddressNew.clear();
//
// return g_lstMacAddress[nEqualIndex];
// }
// if(!g_lstMacAddressNew.empty())
// return g_lstMacAddressNew[0];
//生成随机数据
char *idDevice = new char[6];
*(UINT*)idDevice = time(NULL);
*(USHORT*)(idDevice+4) = Random(65536);
g_lstMacAddress.push_back(idDevice);
return g_lstMacAddress[0];
}
Reference in New Issue View Git Blame Copy Permalink