void CSetDlgBasic::OnBnClickedButtonRecAdd()
{
// TODO: ここにコントロール通知ハンドラー コードを追加します。
UpdateData(TRUE);
if( recFolderPath.IsEmpty() == true ){
return ;
}
wstring addPath = recFolderPath.GetBuffer(0);
ChkFolderPath( addPath );
//同一フォルダがすでにあるかチェック
int iNum = recFolderList.GetCount();
BOOL findFlag = FALSE;
for( int i = 0; i < iNum; i++ ){
CString folder = L"";
recFolderList.GetText( i, folder );
wstring strPath = folder.GetBuffer(0);
ChkFolderPath( strPath );
if( CompareNoCase( addPath, strPath ) == 0 ){
findFlag = TRUE;
break;
}
}
if( findFlag == FALSE ){
recFolderList.AddString( addPath.c_str() );
}
UpdateData(FALSE);
}
void GetFileFolder(const wstring& strPath, wstring& strFolder)
{
WCHAR szPath[_MAX_DRIVE + _MAX_DIR + 8];
WCHAR szDrive[_MAX_DRIVE];
WCHAR szDir[_MAX_DIR];
_wsplitpath_s( strPath.c_str(), szDrive, _MAX_DRIVE, szDir, _MAX_DIR, NULL, 0, NULL, 0 );
_wmakepath_s( szPath, szDrive, szDir, NULL, NULL );
strFolder = szPath;
ChkFolderPath(strFolder);
return ;
}
void GetSettingPath(wstring& strPath)
{
strPath = L"";
wstring strIni = L"";
GetCommonIniPath(strIni);
WCHAR wPath[512]=L"";
GetPrivateProfileString( L"Set", L"DataSavePath", L"", wPath, 512, strIni.c_str() );
strPath = wPath;
if( strPath.empty() == true ){
GetDefSettingPath(strPath);
}
ChkFolderPath(strPath);
}
void GetFileFolder(wstring strPath, wstring& strFolder)
{
WCHAR szPath[512] = L"";
WCHAR szDrive[_MAX_DRIVE];
WCHAR szDir[_MAX_DIR];
WCHAR szFname[_MAX_FNAME];
WCHAR szExt[_MAX_EXT];
_wsplitpath_s( strPath.c_str(), szDrive, _MAX_DRIVE, szDir, _MAX_DIR, szFname, _MAX_FNAME, szExt, _MAX_EXT );
_wmakepath_s( szPath, _MAX_PATH, szDrive, szDir, NULL, NULL );
strFolder = szPath;
ChkFolderPath(strFolder);
return ;
}
void GetRecFolderPath(wstring& strPath)
{
wstring strIni = L"";
GetCommonIniPath(strIni);
WCHAR wPath[MAX_PATH + 8];
GetPrivateProfileString( L"Set", L"RecFolderPath0", L"", wPath, MAX_PATH + 8, strIni.c_str() );
strPath = wPath;
ChkFolderPath(strPath);
if( strPath.size() >= MAX_PATH ){
throw std::runtime_error("");
}
if( strPath.empty() || GetPrivateProfileInt(L"SET", L"RecFolderNum", 0, strIni.c_str()) <= 0 ){
GetSettingPath(strPath);
}
}
void GetModuleFolderPath(wstring& strPath)
{
WCHAR strExePath[MAX_PATH];
DWORD len = GetModuleFileName(NULL, strExePath, MAX_PATH);
if( len == 0 || len >= MAX_PATH ){
throw std::runtime_error("");
}
WCHAR szPath[_MAX_DRIVE + _MAX_DIR + 8];
WCHAR szDrive[_MAX_DRIVE];
WCHAR szDir[_MAX_DIR];
_wsplitpath_s( strExePath, szDrive, _MAX_DRIVE, szDir, _MAX_DIR, NULL, 0, NULL, 0 );
_wmakepath_s( szPath, szDrive, szDir, NULL, NULL );
strPath = szPath;
ChkFolderPath(strPath);
}
void GetSettingPath(wstring& strPath)
{
wstring strIni = L"";
GetCommonIniPath(strIni);
WCHAR wPath[MAX_PATH + 8];
GetPrivateProfileString( L"Set", L"DataSavePath", L"", wPath, MAX_PATH + 8, strIni.c_str() );
strPath = wPath;
ChkFolderPath(strPath);
if( strPath.size() >= MAX_PATH ){
throw std::runtime_error("");
}
if( strPath.empty() == true ){
GetDefSettingPath(strPath);
}
}
void GetModuleFolderPath(wstring& strPath)
{
WCHAR strExePath[512] = L"";
GetModuleFileName(NULL, strExePath, 512);
WCHAR szPath[_MAX_PATH]; // パス
WCHAR szDrive[_MAX_DRIVE];
WCHAR szDir[_MAX_DIR];
WCHAR szFname[_MAX_FNAME];
WCHAR szExt[_MAX_EXT];
_wsplitpath_s( strExePath, szDrive, _MAX_DRIVE, szDir, _MAX_DIR, szFname, _MAX_FNAME, szExt, _MAX_EXT );
_wmakepath_s( szPath, _MAX_PATH, szDrive, szDir, NULL, NULL );
int iLen = lstrlen(szPath);
szPath[iLen-1] = '\0';
strPath = L"";
strPath += szPath;
ChkFolderPath(strPath);
}
void CTunerBankCtrl::SaveProgramInfo(LPCWSTR recPath, const EPGDB_EVENT_INFO& info, bool append) const
{
wstring iniCommonPath;
GetCommonIniPath(iniCommonPath);
wstring infoFolder = GetPrivateProfileToString(L"SET", L"RecInfoFolder", L"", iniCommonPath.c_str());
ChkFolderPath(infoFolder);
wstring savePath;
if( infoFolder.empty() ){
savePath = recPath;
}else{
GetFileName(recPath, savePath);
savePath = infoFolder + L"\\" + savePath;
}
savePath += L".program.txt";
wstring serviceName;
for( size_t i = 0; i < this->chList.size(); i++ ){
if( this->chList[i].originalNetworkID == info.original_network_id &&
this->chList[i].transportStreamID == info.transport_stream_id &&
this->chList[i].serviceID == info.service_id ){
serviceName = this->chList[i].serviceName;
break;
}
}
wstring outTextW;
_ConvertEpgInfoText2(&info, outTextW, serviceName);
string outText;
WtoA(outTextW, outText);
HANDLE hFile = _CreateDirectoryAndFile(savePath.c_str(), GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ, NULL, append ? OPEN_ALWAYS : CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if( hFile != INVALID_HANDLE_VALUE ){
if( append ){
SetFilePointer(hFile, 0, NULL, FILE_END);
outText = "\r\n-----------------------\r\n" + outText;
}
DWORD dwWrite;
WriteFile(hFile, outText.c_str(), (DWORD)outText.size(), &dwWrite, NULL);
CloseHandle(hFile);
}
}
//保存サブフォルダから空きのあるフォルダパスを取得
//戻り値：
// TRUE（成功）、FALSE（失敗）
//引数：
// needFreeSize [IN]最低必要な空きサイズ
// freeFolderPath [OUT]見つかったフォルダ
BOOL CWriteTSFile::GetFreeFolder(
ULONGLONG needFreeSize,
wstring& freeFolderPath
)
{
BOOL ret = FALSE;
for( int i = 0; i < (int)this->saveFolderSub.size(); i++ ){
ULARGE_INTEGER stFree;
ULARGE_INTEGER stTotal;
ULARGE_INTEGER stTotalFree;
if( _GetDiskFreeSpaceEx( this->saveFolderSub[i].c_str(), &stFree, &stTotal, &stTotalFree ) == TRUE ){
if( stFree.QuadPart > (ULONGLONG)needFreeSize ){
freeFolderPath = this->saveFolderSub[i];
ChkFolderPath(freeFolderPath);
ret = TRUE;
break;
}
}
}
return ret;
}
int CHttpPublicFileSend::HttpRequest(string method, string uri, nocase::map<string, string>* headerList, SOCKET clientSock, HANDLE stopEvent)
{
int ret = 200;
string buff = "";
string path = "";
string rootA = "";
wstring filePath = L"";
wstring wbuff = L"";
map<string, wstring>::iterator itrVPath;
nocase::map<string, string>::iterator itrHead;
nocase::map<string, string> httpResHeader;
__int64 fileSize = 0;
string contentType = "";
__int64 offset = 0;
__int64 endPos = 0;
map<__int64, __int64> rangeList;
if( this->folderPath.size() == 0 || this->rootUri.size() == 0){
ret = 404;
goto Err_End;
}
if( CompareNoCase(method, "GET") != 0 ){
ret = 404;
goto Err_End;
}
WtoA(this->rootUri, rootA);
UrlDecode(uri.c_str(), (DWORD)uri.size(), buff);
//仮想パスから検索
for(itrVPath = this->virtualPathList.begin(); itrVPath != this->virtualPathList.end(); itrVPath++){
string key;
Format(key, "%s/%s/", rootA.c_str(), itrVPath->first.c_str());
if( buff.find(key) == 0 ){
Separate(buff, key, buff, path);
Replace(path, "/", "\\");
UTF8toW(path, wbuff);
filePath = itrVPath->second;
ChkFolderPath(filePath);
filePath += L"\\";
filePath += wbuff;
break;
}
}
if(filePath.size() == 0 ){
//通常のルート
Separate(buff, rootA, buff, path);
Replace(path, "/", "\\");
UTF8toW(path, wbuff);
filePath = this->folderPath;
ChkFolderPath(filePath);
filePath += L"\\";
filePath += wbuff;
}
if( PathFileExists(filePath.c_str()) == FALSE ){
ret = 404;
goto Err_End;
}
httpSend.GetContentType(filePath, contentType);
fileSize = httpSend.GetContentLength(filePath);
endPos = fileSize;
itrHead = headerList->find("Range");
if( itrHead == headerList->end() ){
//Rangeなし
Format(buff, "%I64d", fileSize);
httpResHeader.insert(pair<string, string>("Content-Length", buff));
httpResHeader.insert(pair<string, string>("Content-Type", contentType));
httpSend.SendResponseHeader(200, &httpResHeader, clientSock, stopEvent);
httpSend.SendFile(filePath, offset, endPos, clientSock, stopEvent);
}else{
if( httpSend.ParseRangeHeader(fileSize, itrHead->second, &rangeList) == FALSE ){
//Range指定が何かおかしい
Format(buff, "%I64d", fileSize);
httpResHeader.insert(pair<string, string>("Content-Length", buff));
httpResHeader.insert(pair<string, string>("Content-Type", contentType));
httpSend.SendResponseHeader(200, &httpResHeader, clientSock, stopEvent);
httpSend.SendFile(filePath, offset, endPos, clientSock, stopEvent);
}else{
httpResHeader.insert(pair<string, string>("Accept-Ranges", "bytes"));
if( rangeList.size() > 1 ){
//複数の場所指定
Format(buff, "multipart/byteranges; boundary=%s", MULTI_PART_BOUNDARY);
httpResHeader.insert(pair<string, string>("Content-Type", buff));
httpSend.SendResponseHeader(206, &httpResHeader, clientSock, stopEvent);
map<__int64, __int64>::iterator itr;
string boundary = "";
for( itr = rangeList.begin(); itr != rangeList.end(); itr++ ){
boundary = "--";
boundary += MULTI_PART_BOUNDARY;
boundary += "\r\n";
Format(buff, "Content-Type: %s\r\n", contentType);
boundary += buff;
Format(buff, "Content-Range: bytes %I64d-%I64d/%I64d\r\n", itr->first, itr->second, fileSize);
boundary += buff;
boundary += "\r\n";
if( httpSend.SendData((BYTE*)boundary.c_str(), (DWORD)boundary.size(), clientSock, stopEvent) != NO_ERR ){
goto End;
}
if( httpSend.SendFile(filePath, itr->first, itr->second+1, clientSock, stopEvent) != NO_ERR ){
goto End;
}
boundary = "\r\n";
httpSend.SendData((BYTE*)boundary.c_str(), (DWORD)boundary.size(), clientSock, stopEvent);
}
boundary = "--";
boundary += MULTI_PART_BOUNDARY;
boundary += "--\r\n";
httpSend.SendData((BYTE*)boundary.c_str(), (DWORD)boundary.size(), clientSock, stopEvent);
}else{
//一カ所のみ
map<__int64, __int64>::iterator itr;
itr = rangeList.begin();
httpResHeader.insert(pair<string, string>("Content-Type", contentType));
Format(buff, "bytes %I64d-%I64d/%I64d", itr->first, itr->second, fileSize);
httpResHeader.insert(pair<string, string>("Content-Range", buff));
Format(buff, "%I64d", itr->second-itr->first+1);
httpResHeader.insert(pair<string, string>("Content-Length", buff));
httpSend.SendResponseHeader(206, &httpResHeader, clientSock, stopEvent);
httpSend.SendFile(filePath, itr->first, itr->second+1, clientSock, stopEvent);
}
}
}
return ret;
Err_End:
httpSend.SendResponseHeader(ret, &httpResHeader, clientSock, stopEvent);
End:
return ret;
}
void CBonDriverUtil::SetBonDriverFolder(LPCWSTR bonDriverFolderPath)
{
CBlockLock lock(&this->utilLock);
this->loadDllFolder = bonDriverFolderPath;
ChkFolderPath(this->loadDllFolder);
}
BOOL CBatManager::CreateBatFile(BAT_WORK_INFO* info, wstring batSrcFilePath, wstring& batFilePath )
{
if( info == NULL ){
return FALSE;
}
GetModuleFolderPath(batFilePath);
batFilePath+=L"\\EpgTimer_Bon_RecEnd.bat";
//バッチの作成
HANDLE hRead = CreateFileW( batSrcFilePath.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
if( hRead == INVALID_HANDLE_VALUE ){
return FALSE;
}
HANDLE hWrite = _CreateFile2( batFilePath.c_str(), GENERIC_WRITE, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
if( hWrite == INVALID_HANDLE_VALUE ){
CloseHandle(hRead);
return FALSE;
}
DWORD dwRead=0;
DWORD dwL = GetFileSize(hRead, NULL);
char* pBuff = new char[dwL+1];
ZeroMemory(pBuff, dwL+1);
ReadFile(hRead, pBuff, dwL, &dwRead, NULL );
CloseHandle(hRead);
string strRead = "";
strRead = pBuff;
SAFE_DELETE_ARRAY(pBuff);
string strRecFilePath="";
string strFolderPath="";
string strFileName="";
string strTitle="";
string strSDYYYY="";
string strSDYY="";
string strSDMM="";
string strSDM="";
string strSDDD="";
string strSDD="";
string strSDW="";
string strSTHH="";
string strSTH="";
string strSTMM="";
string strSTM="";
string strSTSS="";
string strSTS="";
string strEDYYYY="";
string strEDYY="";
string strEDMM="";
string strEDM="";
string strEDDD="";
string strEDD="";
string strEDW="";
string strETHH="";
string strETH="";
string strETMM="";
string strETM="";
string strETSS="";
string strETS="";
string strONID10="";
string strTSID10="";
string strSID10="";
string strEID10="";
string strONID16="";
string strTSID16="";
string strSID16="";
string strEID16="";
string strServiceName="";
string strSDYYYY28="";
string strSDYY28="";
string strSDMM28="";
string strSDM28="";
string strSDDD28="";
string strSDD28="";
string strSDW28="";
string strSTHH28="";
string strSTH28="";
string strEDYYYY28="";
string strEDYY28="";
string strEDMM28="";
string strEDM28="";
string strEDDD28="";
string strEDD28="";
string strEDW28="";
string strETHH28="";
string strETH28="";
string strDUH="";
string strDUHH="";
string strDUM="";
string strDUMM="";
string strDUS="";
string strDUSS="";
string strTitle2="";
string strDrops="";
string strScrambles="";
string strResult="";
string strTitleF="";
string strTitle2F="";
string strAddKey="";
WtoA(info->recFileInfo.recFilePath, strRecFilePath);
WCHAR szDrive[_MAX_DRIVE];
WCHAR szDir[_MAX_DIR];
WCHAR szFname[_MAX_FNAME];
WCHAR szExt[_MAX_EXT];
WCHAR szPath[_MAX_PATH] = L"";
_tsplitpath_s( info->recFileInfo.recFilePath.c_str(), szDrive, _MAX_DRIVE, szDir, _MAX_DIR, szFname, _MAX_FNAME, szExt, _MAX_EXT );
_tmakepath_s( szPath, _MAX_PATH, szDrive, szDir, NULL, NULL );
wstring strFolder;
strFolder = szPath;
ChkFolderPath(strFolder);
WtoA(szFname, strFileName);
WtoA(strFolder, strFolderPath);
WtoA(info->recFileInfo.title, strTitle);
Format(strSDYYYY, "%04d", info->recFileInfo.startTime.wYear);
Format(strSDYY, "%02d", info->recFileInfo.startTime.wYear%100);
Format(strSDMM, "%02d", info->recFileInfo.startTime.wMonth);
Format(strSDM, "%d", info->recFileInfo.startTime.wMonth);
Format(strSDDD, "%02d", info->recFileInfo.startTime.wDay);
Format(strSDD, "%d", info->recFileInfo.startTime.wDay);
GetDayOfWeekString2(info->recFileInfo.startTime, strSDW);
Format(strSTHH, "%02d", info->recFileInfo.startTime.wHour);
Format(strSTH, "%d", info->recFileInfo.startTime.wHour);
Format(strSTMM, "%02d", info->recFileInfo.startTime.wMinute);
Format(strSTM, "%d", info->recFileInfo.startTime.wMinute);
Format(strSTSS, "%02d", info->recFileInfo.startTime.wSecond);
Format(strSTS, "%d", info->recFileInfo.startTime.wSecond);
SYSTEMTIME t28TimeS;
if( 0 <= info->recFileInfo.startTime.wHour && info->recFileInfo.startTime.wHour < 4 ){
GetSumTime(info->recFileInfo.startTime, -24*60*60, &t28TimeS);
GetDayOfWeekString2(t28TimeS, strSDW28);
t28TimeS.wHour+=24;
}else{
t28TimeS = info->recFileInfo.startTime;
GetDayOfWeekString2(t28TimeS, strSDW28);
}
Format(strSDYYYY28, "%04d", t28TimeS.wYear);
Format(strSDYY28, "%02d", t28TimeS.wYear%100);
Format(strSDMM28, "%02d", t28TimeS.wMonth);
Format(strSDM28, "%d", t28TimeS.wMonth);
Format(strSDDD28, "%02d", t28TimeS.wDay);
Format(strSDD28, "%d", t28TimeS.wDay);
Format(strSTHH28, "%02d", t28TimeS.wHour);
Format(strSTH28, "%d", t28TimeS.wHour);
SYSTEMTIME tEnd;
GetI64Time(info->recFileInfo.startTime, info->recFileInfo.durationSecond, NULL, NULL, &tEnd);
Format(strEDYYYY, "%04d", tEnd.wYear);
Format(strEDYY, "%02d", tEnd.wYear%100);
Format(strEDMM, "%02d", tEnd.wMonth);
Format(strEDM, "%d", tEnd.wMonth);
Format(strEDDD, "%02d", tEnd.wDay);
Format(strEDD, "%d", tEnd.wDay);
GetDayOfWeekString2(tEnd, strEDW);
Format(strETHH, "%02d", tEnd.wHour);
Format(strETH, "%d", tEnd.wHour);
Format(strETMM, "%02d", tEnd.wMinute);
Format(strETM, "%d", tEnd.wMinute);
Format(strETSS, "%02d", tEnd.wSecond);
Format(strETS, "%d", tEnd.wSecond);
SYSTEMTIME t28TimeE;
if( 0 <= tEnd.wHour && tEnd.wHour < 4 ){
GetSumTime(tEnd, -24*60*60, &t28TimeE);
GetDayOfWeekString2(t28TimeE, strEDW28);
t28TimeE.wHour+=24;
}else{
t28TimeE = tEnd;
GetDayOfWeekString2(tEnd, strEDW28);
}
Format(strEDYYYY28, "%04d", t28TimeE.wYear);
Format(strEDYY28, "%02d", t28TimeE.wYear%100);
Format(strEDMM28, "%02d", t28TimeE.wMonth);
Format(strEDM28, "%d", t28TimeE.wMonth);
Format(strEDDD28, "%02d", t28TimeE.wDay);
Format(strEDD28, "%d", t28TimeE.wDay);
Format(strETHH28, "%02d", t28TimeE.wHour);
Format(strETH28, "%d", t28TimeE.wHour);
Format(strONID10, "%d", info->recFileInfo.originalNetworkID);
Format(strTSID10, "%d", info->recFileInfo.transportStreamID);
Format(strSID10, "%d", info->recFileInfo.serviceID);
Format(strEID10, "%d", info->recFileInfo.eventID);
Format(strONID16, "%04X", info->recFileInfo.originalNetworkID);
Format(strTSID16, "%04X", info->recFileInfo.transportStreamID);
Format(strSID16, "%04X", info->recFileInfo.serviceID);
Format(strEID16, "%04X", info->recFileInfo.eventID);
WtoA(info->recFileInfo.serviceName, strServiceName);
Format(strDUHH, "%02d", info->recFileInfo.durationSecond/(60*60));
Format(strDUH, "%d", info->recFileInfo.durationSecond/(60*60));
Format(strDUMM, "%02d", (info->recFileInfo.durationSecond%(60*60))/60);
Format(strDUM, "%d", (info->recFileInfo.durationSecond%(60*60))/60);
Format(strDUSS, "%02d", info->recFileInfo.durationSecond%60);
Format(strDUS, "%d", info->recFileInfo.durationSecond%60);
wstring strTemp = info->recFileInfo.title;
while( (strTemp.find(L"[") != string::npos) && (strTemp.find(L"]") != string::npos) ){
wstring strSep1=L"";
wstring strSep2=L"";
Separate(strTemp, L"[", strSep1, strTemp);
Separate(strTemp, L"]", strSep2, strTemp);
strSep1 += strTemp;
strTemp = strSep1;
}
WtoA(strTemp, strTitle2);
Format(strDrops, "%I64d", info->recFileInfo.drops);
Format(strScrambles, "%I64d", info->recFileInfo.scrambles);
WtoA(info->recFileInfo.comment, strResult);
CheckFileName(strTitleF);
CheckFileName(strTemp);
WtoA(strTemp, strTitle2F);
strTemp = info->recFileInfo.title;
CheckFileName(strTemp);
WtoA(strTemp, strTitleF);
if( info->reserveInfo.comment.find(L"EPG自動予約(") != string::npos ){
WtoA(info->reserveInfo.comment, strAddKey);
Replace(strAddKey, "EPG自動予約(", "");
strAddKey.erase(strAddKey.length()-1, 1);
}
Replace(strRead, "$FilePath$", strRecFilePath);
Replace(strRead, "$FolderPath$", strFolderPath);
Replace(strRead, "$FileName$", strFileName);
Replace(strRead, "$Title$", strTitle);
Replace(strRead, "$SDYYYY$", strSDYYYY);
Replace(strRead, "$SDYY$", strSDYY);
Replace(strRead, "$SDMM$", strSDMM);
Replace(strRead, "$SDM$", strSDM);
Replace(strRead, "$SDDD$", strSDDD);
Replace(strRead, "$SDD$", strSDD);
Replace(strRead, "$SDW$", strSDW);
Replace(strRead, "$STHH$", strSTHH);
Replace(strRead, "$STH$", strSTH);
Replace(strRead, "$STMM$", strSTMM);
Replace(strRead, "$STM$", strSTM);
Replace(strRead, "$STSS$", strSTSS);
Replace(strRead, "$STS$", strSTS);
Replace(strRead, "$EDYYYY$", strEDYYYY);
Replace(strRead, "$EDYY$", strEDYY);
Replace(strRead, "$EDMM$", strEDMM);
Replace(strRead, "$EDM$", strEDM);
Replace(strRead, "$EDDD$", strEDDD);
Replace(strRead, "$EDD$", strEDD);
Replace(strRead, "$EDW$", strEDW);
Replace(strRead, "$ETHH$", strETHH);
Replace(strRead, "$ETH$", strETH);
Replace(strRead, "$ETMM$", strETMM);
Replace(strRead, "$ETM$", strETM);
Replace(strRead, "$ETSS$", strETSS);
Replace(strRead, "$ETS$", strETS);
Replace(strRead, "$ONID10$", strONID10);
Replace(strRead, "$TSID10$", strTSID10);
Replace(strRead, "$SID10$", strSID10);
Replace(strRead, "$EID10$", strEID10);
Replace(strRead, "$ONID16$", strONID16);
Replace(strRead, "$TSID16$", strTSID16);
Replace(strRead, "$SID16$", strSID16);
Replace(strRead, "$EID16$", strEID16);
Replace(strRead, "$ServiceName$", strServiceName);
Replace(strRead, "$SDYYYY28$", strSDYYYY28);
Replace(strRead, "$SDYY28$", strSDYY28);
Replace(strRead, "$SDMM28$", strSDMM28);
Replace(strRead, "$SDM28$", strSDM28);
Replace(strRead, "$SDDD28$", strSDDD28);
Replace(strRead, "$SDD28$", strSDD28);
Replace(strRead, "$SDW28$", strSDW28);
Replace(strRead, "$STHH28$", strSTHH28);
Replace(strRead, "$STH28$", strSTH28);
Replace(strRead, "$EDYYYY28$", strEDYYYY28);
Replace(strRead, "$EDYY28$", strEDYY28);
Replace(strRead, "$EDMM28$", strEDMM28);
Replace(strRead, "$EDM28$", strEDM28);
Replace(strRead, "$EDDD28$", strEDDD28);
Replace(strRead, "$EDD28$", strEDD28);
Replace(strRead, "$EDW28$", strEDW28);
Replace(strRead, "$ETHH28$", strETHH28);
Replace(strRead, "$ETH28$", strETH28);
Replace(strRead, "$DUHH$", strDUHH);
Replace(strRead, "$DUH$", strDUH);
Replace(strRead, "$DUMM$", strDUMM);
Replace(strRead, "$DUM$", strDUM);
Replace(strRead, "$DUSS$", strDUSS);
Replace(strRead, "$DUS$", strDUS);
Replace(strRead, "$Title2$", strTitle2);
Replace(strRead, "$Drops$", strDrops);
Replace(strRead, "$Scrambles$", strScrambles);
Replace(strRead, "$Result$", strResult);
Replace(strRead, "$TitleF$", strTitleF);
Replace(strRead, "$Title2F$", strTitle2F);
Replace(strRead, "$AddKey$", strAddKey);
DWORD dwWrite=0;
WriteFile(hWrite, strRead.c_str(), (DWORD)strRead.length(), &dwWrite, NULL );
CloseHandle(hWrite);
return TRUE;
}
void CCheckRecFile::CheckFreeSpace(map<DWORD, CReserveInfo*>* chkReserve, wstring defRecFolder, map<wstring, wstring>* protectFile)
{
if( this->chkFolder.size() == 0 || chkReserve == NULL || defRecFolder.size() == 0 ) {
return;
}
map<wstring, ULONGLONG> checkMap;
map<wstring, MOUNT_PATH_INFO> mountMap;
for( size_t i=0; i<this->chkFolder.size(); i++ ) {
wstring folder = this->chkFolder[i];
transform(folder.begin(), folder.end(), folder.begin(), toupper);
ChkFolderPath(folder);
checkMap.insert(pair<wstring, ULONGLONG>(folder, 0));
wstring mountPath = L"";
GetChkDrivePath(folder, mountPath);
transform(mountPath.begin(), mountPath.end(), mountPath.begin(), toupper);
ChkFolderPath(mountPath);
map<wstring, MOUNT_PATH_INFO>::iterator itr;
itr = mountMap.find(mountPath);
if( itr != mountMap.end() ) {
itr->second.folderPath.push_back(folder);
} else {
MOUNT_PATH_INFO item;
item.totalSize = 0;
item.folderPath.push_back(folder);
mountMap.insert(pair<wstring, MOUNT_PATH_INFO>(mountPath, item));
}
}
LONGLONG now = GetNowI64Time();
map<DWORD, CReserveInfo*>::iterator itrRes;
for( itrRes = chkReserve->begin(); itrRes != chkReserve->end(); itrRes++ ) {
wstring chkFolder = defRecFolder;
RESERVE_DATA data;
itrRes->second->GetData(&data);
if( data.recSetting.recMode == RECMODE_NO || data.recSetting.recMode == RECMODE_VIEW ) {
continue;
}
if( now + 2*60*60*I64_1SEC < ConvertI64Time(data.startTime) ) {
//2時間以上先
continue;
}
if( ConvertI64Time(data.startTime) < now ) {
//録画中
continue;
}
if( data.recSetting.recFolderList.size() > 0 ) {
//複数指定あり
for( size_t i=0; i< data.recSetting.recFolderList.size(); i++ ) {
chkFolder = data.recSetting.recFolderList[i].recFolder;
transform(chkFolder.begin(), chkFolder.end(), chkFolder.begin(), toupper);
ChkFolderPath(chkFolder);
map<wstring, ULONGLONG>::iterator itr;
itr = checkMap.find(chkFolder);
if( itr != checkMap.end() ) {
DWORD bitrate = 0;
_GetBitrate(data.originalNetworkID, data.transportStreamID, data.serviceID, &bitrate);
itr->second += ((ULONGLONG)(bitrate/8)*1000) * data.durationSecond;
}
wstring mountPath = L"";
GetChkDrivePath(chkFolder, mountPath);
transform(mountPath.begin(), mountPath.end(), mountPath.begin(), toupper);
ChkFolderPath(mountPath);
map<wstring, MOUNT_PATH_INFO>::iterator itrMount;
itrMount = mountMap.find(mountPath);
if( itrMount != mountMap.end() ) {
DWORD bitrate = 0;
_GetBitrate(data.originalNetworkID, data.transportStreamID, data.serviceID, &bitrate);
itrMount->second.totalSize += ((ULONGLONG)(bitrate/8)*1000) * data.durationSecond;
}
}
} else {
//デフォルト
transform(chkFolder.begin(), chkFolder.end(), chkFolder.begin(), toupper);
ChkFolderPath(chkFolder);
map<wstring, ULONGLONG>::iterator itr;
itr = checkMap.find(chkFolder);
if( itr != checkMap.end() ) {
DWORD bitrate = 0;
_GetBitrate(data.originalNetworkID, data.transportStreamID, data.serviceID, &bitrate);
itr->second += ((ULONGLONG)(bitrate/8)*1000) * data.durationSecond;
}
wstring mountPath = L"";
GetChkDrivePath(chkFolder, mountPath);
transform(mountPath.begin(), mountPath.end(), mountPath.begin(), toupper);
ChkFolderPath(mountPath);
map<wstring, MOUNT_PATH_INFO>::iterator itrMount;
itrMount = mountMap.find(mountPath);
if( itrMount != mountMap.end() ) {
DWORD bitrate = 0;
_GetBitrate(data.originalNetworkID, data.transportStreamID, data.serviceID, &bitrate);
itrMount->second.totalSize += ((ULONGLONG)(bitrate/8)*1000) * data.durationSecond;
}
}
}
//ドライブレベルでのチェック
map<wstring, MOUNT_PATH_INFO>::iterator itrMount;
for( itrMount = mountMap.begin(); itrMount != mountMap.end(); itrMount++ ) {
if( itrMount->second.totalSize > 0 ) {
ULARGE_INTEGER freeBytesAvailable;
ULARGE_INTEGER totalNumberOfBytes;
ULARGE_INTEGER totalNumberOfFreeBytes;
if( _GetDiskFreeSpaceEx(itrMount->first.c_str(), &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes ) == TRUE ) {
ULONGLONG free = freeBytesAvailable.QuadPart;
if( free > (ULONGLONG)itrMount->second.totalSize ) {
continue;
}
map<LONGLONG, TS_FILE_INFO> tsFileList;
for( size_t i=0; i<itrMount->second.folderPath.size(); i++ ) {
FindTsFileList(itrMount->second.folderPath[i], &tsFileList);
}
while( free < (ULONGLONG)itrMount->second.totalSize ) {
map<LONGLONG, TS_FILE_INFO>::iterator itrTS;
itrTS = tsFileList.begin();
if( itrTS != tsFileList.end() ) {
BOOL noDel = FALSE;
map<wstring, wstring>::iterator itrP;
itrP = protectFile->find(itrTS->second.filePath);
if( itrP != protectFile->end() ) {
noDel = TRUE;
}
if( noDel == FALSE ) {
DeleteFile( itrTS->second.filePath.c_str() );
_OutputDebugString(L"★Auto Delete2 : %s", itrTS->second.filePath.c_str());
for( size_t i=0 ; i<this->delExt.size(); i++ ) {
wstring delFile = L"";
wstring delFileName = L"";
GetFileFolder(itrTS->second.filePath, delFile);
GetFileTitle(itrTS->second.filePath, delFileName);
delFile += L"\\";
delFile += delFileName;
delFile += this->delExt[i];
DeleteFile( delFile.c_str() );
_OutputDebugString(L"★Auto Delete2 : %s", delFile.c_str());
}
free += itrTS->second.fileSize;
} else {
_OutputDebugString(L"★No Delete(Protected) : %s", itrTS->second.filePath.c_str());
}
tsFileList.erase(itrTS);
} else {
break;
}
}
}
}
}
}
//ファイル保存を開始する
//戻り値：
// TRUE（成功）、FALSE（失敗）
//引数：
// fileName [IN]保存ファイル名
// overWriteFlag [IN]同一ファイル名存在時に上書きするかどうか（TRUE：する、FALSE：しない）
// createSize [IN]ファイル作成時にディスクに予約する容量
// saveFolder [IN]使用するフォルダ一覧
// saveFolderSub [IN]HDDの空きがなくなった場合に一時的に使用するフォルダ
BOOL CWriteTSFile::StartSave(
wstring fileName,
BOOL overWriteFlag,
ULONGLONG createSize,
vector<REC_FILE_SET_INFO>* saveFolder,
vector<wstring>* saveFolderSub,
int maxBuffCount
)
{
if( Lock(L"StartSave") == FALSE ) return FALSE;
BOOL ret = TRUE;
this->exceptionErr = FALSE;
this->buffOverErr = FALSE;
this->maxBuffCount = maxBuffCount;
if( saveFolder->size() == 0 ){
UnLock();
_OutputDebugString(L"CWriteTSFile::StartSave Err saveFolder 0");
return FALSE;
}
if( this->outThread == NULL || this->fileList.size() == 0 ){
this->writeTotalSize = 0;
this->subRecFlag = FALSE;
this->saveFileName = fileName;
this->overWriteFlag = overWriteFlag;
this->saveFolder = *saveFolder;
this->saveFolderSub = *saveFolderSub;
BOOL firstFreeChek = TRUE;
for( size_t i=0; i<this->saveFolder.size(); i++ ){
SAVE_INFO* item = new SAVE_INFO;
if( this->saveFolder[i].writePlugIn.size() == 0 ){
this->saveFolder[i].writePlugIn = L"Write_Default.dll";
}
wstring plugInPath = L"";
GetModuleFolderPath(plugInPath);
plugInPath += L"\\Write\\";
plugInPath += this->saveFolder[i].writePlugIn.c_str();
item->writeUtil = new CWritePlugInUtil;
if(item->writeUtil->Initialize(plugInPath.c_str() ) == FALSE ){
_OutputDebugString(L"CWriteTSFile::StartSave Err 3");
SAFE_DELETE(item);
}else{
wstring folderPath = this->saveFolder[i].recFolder;
if( CompareNoCase(this->saveFolder[i].writePlugIn, L"Write_Default.dll" ) == 0 ){
//デフォルトの場合は空き容量をあらかじめチェック
if( createSize > 0 ){
if( ChkFreeFolder(createSize, this->saveFolder[i].recFolder) == FALSE ){
if( GetFreeFolder(createSize, folderPath) == TRUE ){
//空きなかったのでサブフォルダに録画
this->subRecFlag = TRUE;
}
}
}
}
ChkFolderPath(folderPath);
wstring recPath;
recPath = folderPath;
recPath += L"\\";
if( this->saveFolder[i].recFileName.size() == 0 ){
recPath += fileName;
item->recFileName = fileName;
}else{
recPath += this->saveFolder[i].recFileName;
item->recFileName = this->saveFolder[i].recFileName;
}
//開始
BOOL startRes = item->writeUtil->StartSave(recPath.c_str(), this->overWriteFlag, createSize);
if( startRes == FALSE ){
_OutputDebugString(L"CWriteTSFile::StartSave Err 2");
//エラー時サブフォルダでリトライ
if( GetFreeFolder(createSize, folderPath) == TRUE ){
//空きなかったのでサブフォルダに録画
this->subRecFlag = TRUE;
}
ChkFolderPath(folderPath);
recPath = folderPath;
recPath += L"\\";
if( this->saveFolder[i].recFileName.size() == 0 ){
recPath += fileName;
item->recFileName = fileName;
}else{
recPath += this->saveFolder[i].recFileName;
item->recFileName = this->saveFolder[i].recFileName;
}
startRes = item->writeUtil->StartSave(recPath.c_str(), this->overWriteFlag, createSize);
}
if( startRes == TRUE ){
WCHAR saveFilePath[512] = L"";
DWORD saveFilePathSize = 512;
item->writeUtil->GetSaveFilePath(saveFilePath, &saveFilePathSize);
item->recFilePath = saveFilePath;
item->freeChk = firstFreeChek;
item->overWriteFlag = overWriteFlag;
this->fileList.push_back(item);
if( i==0 ){
this->mainSaveFilePath = saveFilePath;
}
firstFreeChek = FALSE;
}else{
SAFE_DELETE(item);
}
}
}
if( this->fileList.size() > 0 ){
//受信スレッド起動
ResetEvent(this->outStopEvent);
this->outThread = (HANDLE)_beginthreadex(NULL, 0, OutThread, (LPVOID)this, CREATE_SUSPENDED, NULL);
SetThreadPriority( this->outThread, THREAD_PRIORITY_NORMAL );
ResumeThread(this->outThread);
}else{
_OutputDebugString(L"CWriteTSFile::StartSave Err fileList 0");
ret = FALSE;
}
}else{
_OutputDebugString(L"CWriteTSFile::StartSave Err 1");
ret = FALSE;
}
UnLock();
return ret;
}
