void CBaseMuxerFilter::AddInput() { POSITION pos = m_pInputs.GetHeadPosition(); while(pos) { CBasePin* pPin = m_pInputs.GetNext(pos); if(!pPin->IsConnected()) return; } CStringW name; name.Format(L"Input %d", m_pInputs.GetCount()+1); CBaseMuxerInputPin* pInputPin = NULL; if(FAILED(CreateInput(name, &pInputPin)) || !pInputPin) {ASSERT(0); return;} CAutoPtr<CBaseMuxerInputPin> pAutoPtrInputPin(pInputPin); name.Format(L"~Output %d", m_pRawOutputs.GetCount()+1); CBaseMuxerRawOutputPin* pRawOutputPin = NULL; if(FAILED(CreateRawOutput(name, &pRawOutputPin)) || !pRawOutputPin) {ASSERT(0); return;} CAutoPtr<CBaseMuxerRawOutputPin> pAutoPtrRawOutputPin(pRawOutputPin); pInputPin->SetRelatedPin(pRawOutputPin); pRawOutputPin->SetRelatedPin(pInputPin); m_pInputs.AddTail(pAutoPtrInputPin); m_pRawOutputs.AddTail(pAutoPtrRawOutputPin); }
bool Definition::GetAsTime(Time& t, StringMapW<float>& offset, StringMapW<float>* n2n, int default_id) { Definition& time = (*this)[L"time"]; CStringW id; if(time[L"id"].IsValue()) id = time[L"id"]; else id.Format(L"%d", default_id); float scale = time[L"scale"].IsValue() ? time[L"scale"] : 1.0f; if(time[L"start"].IsValue() && time[L"stop"].IsValue()) { time[L"start"].GetAsNumber(t.start, n2n); time[L"stop"].GetAsNumber(t.stop, n2n); if(t.start.unit.IsEmpty()) t.start.value *= scale; if(t.stop.unit.IsEmpty()) t.stop.value *= scale; float o = 0; offset.Lookup(id, o); if(t.start.sign != 0) t.start.value = o + t.start.value; if(t.stop.sign != 0) t.stop.value = t.start.value + t.stop.value; offset[id] = t.stop.value; return true; } return false; }
void InitPathes() { GetTempPath(MAX_PATH, m_workingFolder.GetBuffer(MAX_PATH)); m_workingFolder.ReleaseBuffer(); SYSTEMTIME st; GetLocalTime(&st); CStringW t; t.Format(L"%ls_%d.%d.%d.%d_%04d%02d%02d_%02d%02d%02d", (LPCWSTR)m_config.Prefix, m_config.V[0], m_config.V[1], m_config.V[2], m_config.V[3], (int)st.wYear, (int)st.wMonth, (int)st.wDay, (int)st.wHour, (int)st.wMinute, (int)st.wSecond); m_workingFolder += t; m_miniDumpFile = m_workingFolder + _T("\\") + t + _T(".mini.dmp"); m_miniDumpZipFile = m_workingFolder + _T("\\doctor_dump_mini.zip"); m_fullDumpFile = m_workingFolder + _T("\\") + t + _T(".full.dmp"); m_fullDumpZipFile = m_workingFolder + _T("\\doctor_dump_full.zip"); m_infoDll = m_workingFolder + _T("\\info.dll"); m_infoFile = m_workingFolder + _T("\\info.zip"); m_patch = m_workingFolder + _T("\\solution.exe"); if (!CreateDirectory(m_workingFolder, NULL) && GetLastError() != ERROR_ALREADY_EXISTS) throw std::runtime_error("failed to create temp directory"); }
HRESULT CStreamSwitcherFilter::CompleteConnect(PIN_DIRECTION dir, CBasePin* pPin, IPin* pReceivePin) { if (dir == PINDIR_INPUT) { CAutoLock cAutoLock(&m_csPins); int nConnected = GetConnectedInputPinCount(); if (nConnected == 1) { m_pInput = static_cast<CStreamSwitcherInputPin*>(pPin); } if ((size_t)nConnected == m_pInputs.GetCount()) { CStringW name; name.Format(L"Channel %d", ++m_PinVersion); HRESULT hr = S_OK; CStreamSwitcherInputPin* pPin = DEBUG_NEW CStreamSwitcherInputPin(this, &hr, name); if (!pPin || FAILED(hr)) { delete pPin; return E_FAIL; } m_pInputs.AddTail(pPin); } } return S_OK; }
LRESULT CMainDlg::OnPosChanged(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled) { WINDOWPOS* wp = (WINDOWPOS*)lParam; static BOOL bLastShow = FALSE; BOOL bIsShow = IsWindowVisible(); CStringW strMessage; strMessage.Format(L"Carer: OnPosChanged id:%s , bLastShow:%s\n", bIsShow ? L"True" :L"False", bLastShow ? L"True":L"False" ); OutputDebugString(strMessage); static HHOOK hHook = NULL; if(bIsShow && !bLastShow){ //show INT showLong = CConfig::Instance()->GetIntValue(CK_ShowLong, 30); BOOL bRet =::SetTimer(m_hWnd, TN_WindowHide, showLong*1000, TimerProc); ATLASSERT(bRet); OutputDebugString(L"SetTimer\n"); bLastShow = bIsShow; } else if(!bIsShow && bLastShow){ // hide BOOL bRet =::KillTimer(m_hWnd, TN_WindowHide); ATLASSERT(bRet); OutputDebugString(L"KillTimer\n"); bLastShow = bIsShow; } return 0; }
FontWrapper* FontCache::Create(HDC hDC, const LOGFONT& lf) { CStringW key; key.Format(L"%s,%d,%d,%d", CStringW(lf.lfFaceName), lf.lfHeight, lf.lfWeight, ((lf.lfItalic&1)<<2) | ((lf.lfUnderline&1)<<1) | ((lf.lfStrikeOut&1)<<0)); FontWrapper* pFW = NULL; if(m_key2obj.Lookup(key, pFW)) { return pFW; } HFONT hFont = CreateFontIndirect(&lf); if(!hFont) { ASSERT(0); return NULL; } pFW = DNew FontWrapper(hDC, hFont, key); Add(key, pFW, false); return pFW; }
int CTWScriptEdit::IsConstant(LPCWSTR lpszSymbol) { CStringW strSymbol; strSymbol.Format(L" %s ", lpszSymbol); if (!m_bCaseSensitive) strSymbol.MakeLower(); return m_strConstantsLower.Find(strSymbol); }
void SubtitleFile::Append(InputStream& s, float start, float stop, bool fSetTime) { Reference* pRootRef = GetRootRef(); ParseDefs(s, pRootRef); CAtlList<Definition*> defs; GetNewDefs(defs); POSITION pos = defs.GetHeadPosition(); while(pos) { Definition* pDef = defs.GetNext(pos); if(pDef->m_parent == pRootRef && pDef->m_type == L"subtitle" && (*pDef)[L"@"].IsValue()) { m_segments.Insert(start, stop, pDef); if(fSetTime) { try { Definition::Time time; StringMapW<float> offset; pDef->GetAsTime(time, offset); if(time.start.value == start && time.stop.value == stop) continue; } catch(Exception&) { } CStringW str; str.Format(L"%.3f", start); pDef->SetChildAsNumber(L"time.start", str, L"s"); str.Format(L"%.3f", stop); pDef->SetChildAsNumber(L"time.stop", str, L"s"); } } } Commit(); }
// ************************************************************* // RemoveStyle() // ************************************************************* bool OgrStyleHelper::RemoveStyle(GDALDataset* dataset, CStringW styleTableName, CStringW layerName, CStringW styleName) { USES_CONVERSION; CStringW sql; sql.Format(L"DELETE FROM %s WHERE layername = '%s' AND stylename = '%s'", styleTableName, layerName, styleName); CPLErrorReset(); OGRLayer* layer = dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL); dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL); return CPLGetLastErrorNo() == OGRERR_NONE; }
CStringW AbstractNewDialog::GetAuthor(void) { // Quote the author's name if it contains a period if (m_author.Find(L'.') != -1) { CStringW author; author.Format(L"\"%s\"",m_author); return author; } return m_author; }
CStringW CSySkin::A2CStringW(CString in_Str) { CStringW strResult; #ifndef _UNICODE CA2W a2w(in_Str); PWCHAR pszResult = (LPWSTR)a2w; strResult.Format( L"%s", pszResult); #else strResult = in_Str; #endif return strResult; }
// ************************************************************* // GerStyleTableName() // ************************************************************* CStringW OgrStyleHelper::GetStyleTableName(CStringW layerName) { CStringW name; USES_CONVERSION; if (m_globalSettings.useSchemesForStyles) { name.Format(L"%s%s", GetDbSchemeName(layerName, true), A2W(STYLES_TABLE_NAME)); } else { name = A2W(STYLES_TABLE_NAME); } return name; }
// ************************************************************* // SaveStyle() // ************************************************************* bool OgrStyleHelper::SaveStyle(GDALDataset* dataset, CStringW xml, CStringW layerName, CStringW styleName) { xml.Replace(L"\n", L""); xml.Replace(L"'", L"''''"); if (xml.GetLength() == 0) return false; CStringW sql; sql.Format(L"INSERT INTO %s(layername, stylename, style) VALUES ('%s', '%s', '%s')", GetStyleTableName(layerName), layerName, styleName, xml); CPLErrorReset(); OGRLayer* layer = dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL); return CPLGetLastErrorNo() == OGRERR_NONE; }
// ************************************************************* // CreateStyleTable() // ************************************************************* int OgrStyleHelper::CreateStyleTable(GDALDataset* dataset, CStringW layerName) { if (OgrHelper::IsPostGisDatasource(dataset)) { CPLErrorReset(); CStringW schemaName = GetDbSchemeName(layerName, true); CStringW sql; sql.Format(L"CREATE Table %s (StyleId serial primary key, LayerName varchar(128), StyleName varchar(128), Style text, CONSTRAINT layer_style_unique UNIQUE (LayerName,StyleName));", GetStyleTableName()); OGRLayer* lyr = dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL); return CPLGetLastErrorNo() == OGRERR_NONE ? tkNO_ERROR : tkOGR_FAILED_TO_CREATE_STYLE_TABLE; } else { return tkOGR_NO_STYLE_TABLE_CREATION; } }
// ************************************************************* // HasStyleTable() // ************************************************************* bool OgrStyleHelper::HasStyleTable(GDALDataset* dataset, CStringW layerName) { USES_CONVERSION; CStringW sql; sql.Format(L"SELECT COUNT(*) FROM %s", A2W(STYLES_TABLE_NAME)); // we are checking the presence; it's normal to receive an error; no need to report it to user m_globalSettings.suppressGdalErrors = true; OGRLayer* lyr = dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL); m_globalSettings.suppressGdalErrors = false; bool hasTable = lyr != NULL; if (lyr) dataset->ReleaseResultSet(lyr); else CPLErrorReset(); return hasTable; }
VOID CALLBACK CMainDlg::TimerProc( _In_ HWND hwnd, _In_ UINT uMsg, _In_ UINT_PTR idEvent, _In_ DWORD dwTime ) { CStringW strMessage; strMessage.Format(L"Carer: TimerProc id:%d\n", idEvent); OutputDebugString(strMessage); static UINT_PTR m_TimerID = 0; if (TN_Remind == idEvent) { ::SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, m_rectScreen.right, m_rectScreen.bottom, SWP_SHOWWINDOW); ::SetActiveWindow(hwnd); } else if(TN_WindowHide == idEvent) { ::ShowWindow(hwnd, SW_HIDE); } }
CStringW DebugBasicSerialize( LuaObject& obj ) { if ( obj.Type() == LUA_TNUMBER ) { CStringW str; str.Format( L"%.16g", obj.GetNumber() ); return str; } else if ( obj.Type() == LUA_TBOOLEAN ) { return obj.GetBoolean() ? L"true" : L"false"; } else if (obj.Type() == LUA_TSTRING) { CString str = obj.GetString(); if ( str == "!!!NIL!!!" ) return L"nil"; else if ( str == "!!!FUNCTION!!!" ) return L"{function}"; else if ( str == "!!!CFUNCTION!!!" ) return L"{cfunction}"; else if ( str == "!!!USERDATA!!!" ) return L"{userdata}"; else if ( str == "!!!TABLE!!!" ) return L"{table}"; return CStringW(str); } #if LUA_WIDESTRING else if (obj.Type() == LUA_TWSTRING) { return CStringW((wchar_t*)obj.GetWString()); } #endif // LUA_WIDESTRING else return _T("Unknown"); }
CStringW CFormData::GetMime(LPCTSTR __szExt) { HKEY hkey; DWORD dwType, dwSize; wchar_t buffer[255]; ZeroMemory(&buffer, sizeof(buffer)); CStringW s; s.Format(L"\\.%s", __szExt); if(RegOpenKeyEx(HKEY_CLASSES_ROOT, s, 0, KEY_QUERY_VALUE, &hkey) == ERROR_SUCCESS) { dwType = REG_SZ; dwSize = sizeof(buffer); RegQueryValueEx(hkey, TEXT("Content Type"), 0, &dwType, (LPBYTE)&buffer, &dwSize); RegCloseKey(hkey); } return CStringW(buffer); }
void CmDxBase::OnGUIEvent(UINT nEvent, int nControlID, CDXUTControl* pControl) { switch( nControlID ) { case IDC_TOGGLEFULLSCREEN: DXUTToggleFullScreen(); break; case IDC_TOGGLEREF: DXUTToggleREF(); break; case IDC_TOGGLEWARP: DXUTToggleWARP(); break; case IDC_CHANGEDEVICE: _SettingsDlg.SetActive( !_SettingsDlg.IsActive() ); break; case IDC_SLIDER: CStringW str; str.Format(L"S=%d", _SampleUI.GetSlider(IDC_SLIDER)->GetValue()); _SampleUI.GetStatic(IDC_SLIDER_STATIC)->SetText(str); break; } }
void CStaffManageView::OnBnClickedAddreco() { // TODO: 在此添加控件通知处理程序代码 static bool bAdd = true; if (bAdd) { UpdateCtrlReadOnlyState(FALSE); GetDlgItem(IDC_SET_PHOTO)->ShowWindow(SW_SHOW); m_pSet->m_strSort = "职工编号"; m_pSet->Requery(); m_pSet->MoveLast(); int iID = m_pSet->m_iStaffID + 1; m_pSet->AddNew(); UpdateData(FALSE); CStringW strText = _T(""); strText.Format(_T("%d"),iID); SetDlgItemText(IDC_EDITZGBH,strText); bAdd = false; SetDlgItemText(IDC_ADDRECO,_T("保存记录")); } else { SetDlgItemText(IDC_ADDRECO,_T("增加记录")); GetDlgItem(IDC_SET_PHOTO)->ShowWindow(SW_HIDE); UpdateData(TRUE); m_pSet->Update(); bAdd = true; AfxMessageBox(_T("增加记录成功!")); UpdateCtrlReadOnlyState(TRUE); m_pSet->MoveLast(); } }
// ************************************************************* // LoadStyle() // ************************************************************* CStringW OgrStyleHelper::LoadStyle(GDALDataset* dataset, CStringW styleTableName, CStringW layerName, CStringW styleName) { USES_CONVERSION; CStringW sql; sql.Format(L"SELECT style FROM %s WHERE layername = '%s' AND stylename = '%s'", styleTableName, layerName, styleName); CStringW xml = L""; bool found = false; CPLErrorReset(); OGRLayer* layer = dataset->ExecuteSQL(OgrHelper::String2OgrString(sql), NULL, NULL); if (layer) { OGRFeature* ft = layer->GetNextFeature(); if (ft) { const char* s = ft->GetFieldAsString(0); if (s) { xml = OgrHelper::OgrString2Unicode(s); } OGRFeature::DestroyFeature(ft); } dataset->ReleaseResultSet(layer); } return xml; }
HRESULT CSubtitleStream::FillBuffer(IMediaSample* pSample) { HRESULT hr; { CAutoLock cAutoLockShared(&m_cSharedState); BYTE* pData = NULL; if (FAILED(hr = pSample->GetPointer(&pData)) || !pData) { return S_FALSE; } AM_MEDIA_TYPE* pmt; if (SUCCEEDED(pSample->GetMediaType(&pmt)) && pmt) { CMediaType mt(*pmt); SetMediaType(&mt); DeleteMediaType(pmt); } int len = 0; REFERENCE_TIME rtStart, rtStop; if (m_mt.majortype == MEDIATYPE_Video && m_mt.subtype == MEDIASUBTYPE_ARGB32) { rtStart = (REFERENCE_TIME)((m_nPosition*_ATPF - m_rtStart) / m_dRateSeeking); rtStop = (REFERENCE_TIME)(((m_nPosition+1)*_ATPF - m_rtStart) / m_dRateSeeking); if (m_rtStart+rtStart >= m_rtDuration) { return S_FALSE; } BITMAPINFOHEADER& bmi = ((VIDEOINFOHEADER*)m_mt.pbFormat)->bmiHeader; SubPicDesc spd; spd.w = _WIDTH; spd.h = _HEIGHT; spd.bpp = 32; spd.pitch = bmi.biWidth*4; spd.bits = pData; len = spd.h*spd.pitch; for (int y = 0; y < spd.h; y++) { memsetd((DWORD*)(pData + spd.pitch*y), 0xff000000, spd.w*4); } RECT bbox; m_rts.Render(spd, m_nPosition*_ATPF, 10000000.0/_ATPF, bbox); for (int y = 0; y < spd.h; y++) { DWORD* p = (DWORD*)(pData + spd.pitch*y); for (int x = 0; x < spd.w; x++, p++) { *p = (0xff000000-(*p&0xff000000))|(*p&0xffffff); } } } else if (m_mt.majortype == MEDIATYPE_Video && m_mt.subtype == MEDIASUBTYPE_RGB32) { const STSSegment* stss = m_rts.GetSegment(m_nPosition); if (!stss) { return S_FALSE; } BITMAPINFOHEADER& bmi = ((VIDEOINFOHEADER*)m_mt.pbFormat)->bmiHeader; SubPicDesc spd; spd.w = _WIDTH; spd.h = _HEIGHT; spd.bpp = 32; spd.pitch = bmi.biWidth*4; spd.bits = pData; len = spd.h*spd.pitch; for (int y = 0; y < spd.h; y++) { DWORD c1 = 0xff606060, c2 = 0xffa0a0a0; if (y&32) { c1 ^= c2, c2 ^= c1, c1 ^= c2; } DWORD* p = (DWORD*)(pData + spd.pitch*y); for (int x = 0; x < spd.w; x+=32, p+=32) { memsetd(p, (x&32) ? c1 : c2, min(spd.w-x,32)*4); } } RECT bbox; m_rts.Render(spd, 10000i64*(stss->start+stss->end)/2, 10000000.0/_ATPF, bbox); rtStart = (REFERENCE_TIME)((10000i64*stss->start - m_rtStart) / m_dRateSeeking); rtStop = (REFERENCE_TIME)((10000i64*stss->end - m_rtStart) / m_dRateSeeking); } else { if ((size_t)m_nPosition >= m_rts.GetCount()) { return S_FALSE; } STSEntry& stse = m_rts[m_nPosition]; if (stse.start >= m_rtStop/10000) { return S_FALSE; } if (m_mt.majortype == MEDIATYPE_Subtitle && m_mt.subtype == MEDIASUBTYPE_UTF8) { CStringA str = UTF16To8(m_rts.GetStrW(m_nPosition, false)); memcpy((char*)pData, str, len = str.GetLength()); } else if (m_mt.majortype == MEDIATYPE_Subtitle && (m_mt.subtype == MEDIASUBTYPE_SSA || m_mt.subtype == MEDIASUBTYPE_ASS)) { CStringW line; line.Format(L"%d,%d,%s,%s,%d,%d,%d,%s,%s", stse.readorder, stse.layer, CStringW(stse.style), CStringW(stse.actor), stse.marginRect.left, stse.marginRect.right, (stse.marginRect.top+stse.marginRect.bottom)/2, CStringW(stse.effect), m_rts.GetStrW(m_nPosition, true)); CStringA str = UTF16To8(line); memcpy((char*)pData, str, len = str.GetLength()); } else if (m_mt.majortype == MEDIATYPE_Text && m_mt.subtype == MEDIASUBTYPE_NULL) { CStringA str = m_rts.GetStrA(m_nPosition, false); memcpy((char*)pData, str, len = str.GetLength()); } else { return S_FALSE; } rtStart = (REFERENCE_TIME)((10000i64*stse.start - m_rtStart) / m_dRateSeeking); rtStop = (REFERENCE_TIME)((10000i64*stse.end - m_rtStart) / m_dRateSeeking); } pSample->SetTime(&rtStart, &rtStop); pSample->SetActualDataLength(len); m_nPosition++; } pSample->SetSyncPoint(TRUE); if (m_bDiscontinuity) { pSample->SetDiscontinuity(TRUE); m_bDiscontinuity = FALSE; } return S_OK; }
BOOL CALLBACK UpdateProc(DWORD_PTR dwParam,CallingReason crReason,UpdateError ueCode,CDatabaseUpdater* pUpdater) { switch (crReason) { case StartedDatabase: if (!nQuiet) { CStringW msg; msg.Format(IDS_UPDATEDB32UPDATINGDATABASE,pUpdater->GetCurrentDatabaseName(),pUpdater->GetCurrentDatabaseFile()); if (pUpdater->IsIncrementUpdate()) msg.AddString(IDS_UPDATEDB32INCREMENTALUPDATE); _putws(msg); } break; case RootChanged: if (!nQuiet) { if (pUpdater->GetCurrentRoot()!=NULL) wprintf(ID2W(IDS_UPDATEDB32SCANNING),(LPCWSTR)pUpdater->GetCurrentRoot()->m_Path); else wprintf(L"%s %s\n",(LPCWSTR)ID2W(IDS_UPDATEDB32WRITINGDB),pUpdater->GetCurrentDatabaseName()); } break; case ErrorOccured: if (!nQuiet) { switch (ueCode) { case ueAlloc: fwprintf(stderr,ID2W(IDS_UPDATEDB32ALLOCATEMEM)); break; case ueOpen: case ueCreate: fwprintf(stderr,ID2W(IDS_UPDATEDB32CANNOTCREATEFILE),(LPCSTR)pUpdater->GetCurrentDatabaseFile()); break; case ueWrite: fwprintf(stderr,ID2W(IDS_UPDATEDB32CANNOTWRITE),(LPCSTR)pUpdater->GetCurrentDatabaseFile()); break; case ueUnknown: fwprintf(stderr,ID2W(IDS_UPDATEDB32ALLOCATEMEM)); break; case ueFolderUnavailable: fwprintf(stderr,ID2W(IDS_UPDATEDB32ROOTUNAVAILABLE), pUpdater->GetCurrentRootPath()!=NULL?pUpdater->GetCurrentRootPath():L"(NULL)"); break; case ueWrongCharset: { int ch; do { fwprintf(stderr,ID2W(IDS_UPDATEDB32WRONGCHARSETINDB),pUpdater->GetCurrentDatabaseFile()); ch=getc(stdin); } while (ch!='Y' && ch!='y' && ch!='N' && ch!='n'); if (ch!='Y' && ch!='y') return FALSE; return TRUE; } case ueCannotIncrement: { int ch; do { fwprintf(stderr,ID2W(IDS_UPDATEDB32CANNOTUPDATEINCREMENTALLY),pUpdater->GetCurrentDatabaseFile()); ch=getc(stdin); } while (ch!='Y' && ch!='y' && ch!='N' && ch!='n'); if (ch!='Y' && ch!='y') return FALSE; return TRUE; } break; } } if (ueCode==ueSuccess) return 0; break; case ClassShouldDelete: { DWORD dwRunning=0; if (ppUpdaters==NULL) return TRUE; // One thread mode for (int i=0;ppUpdaters[i]!=NULL;i++) { if (ppUpdaters[i]==pUpdater) ppUpdaters[i]=UPDATER_EXITED(ueCode); else if (!IS_UPDATER_EXITED(ppUpdaters[i])) dwRunning++; } delete pUpdater; if (dwRunning==0) { delete[] ppUpdaters; ppUpdaters=NULL; } break; } } return TRUE; }
CStringW NodeFactory::GenName() { CStringW name; name.Format(L"%I64d", m_counter++); return name; }
BOOL SetupWizard::OnInitDialog () { BOOL ret = CPropertySheet::OnInitDialog(); try { SetIcon (AfxGetApp()->LoadIcon(IDR_MAINFRAME), TRUE); CStringW title; if (theApp.isMiKTeXDirect) { title.Format (T_(_T("MiKTeX %s Setup (%d-bit)")), static_cast<LPCTSTR>(UW_(MIKTEX_FULL_VERSION_STR)), static_cast<int>(sizeof(void*)) * 8); } else if (theApp.pSetupService->GetOptions().IsPrefabricated) { PathName configFile (theApp.GetLocalPackageRepository()); configFile += "pr.ini"; SmartPointer<Cfg> pConfig (Cfg::Create()); pConfig->Read (configFile); CString prefix; CString version (MIKTEXTEXT(MIKTEX_SERIES_STR)); version += MIKTEXTEXT('.'); version += UT_(pConfig->GetValue("repository", "version").c_str()); switch (theApp.GetPackageLevel().Get()) { case PackageLevel::Essential: prefix = T_("Essential "); break; case PackageLevel::Basic: prefix = T_("Basic "); break; case PackageLevel::Complete: prefix = ""; break; default: MIKTEX_ASSERT (false); __assume (false); break; } title.Format (T_(_T("%sMiKTeX %s Installer (%d-bit)")), static_cast<LPCTSTR>(prefix), static_cast<LPCTSTR>(version), static_cast<int>(sizeof(void*)) * 8); } else { title.Format (T_(_T("MiKTeX %s Net Installer (%d-bit)")), static_cast<LPCTSTR>(UW_(MIKTEX_VERSION_STR)), static_cast<int>(sizeof(void*)) * 8); } SetTitle (title); SetActivePage (&m_License); } catch (const MiKTeXException & e) { ReportError (e); } catch (const exception & e) { ReportError (e); } return (ret); }
void TabDoc::DecodeHTML(const char* filename, int scheme) { // Open the file CFile htmlFile; if (htmlFile.Open(filename,CFile::modeRead) == 0) return; // Read it into memory CString htmlText; int len = (int)htmlFile.GetLength(); htmlFile.Read(htmlText.GetBuffer(len),len); htmlText.ReleaseBuffer(len); // Convert from UTF-8 to Unicode CStringW html = TextFormat::UTF8ToUnicode(htmlText); // Get the body text int body1 = html.Find(L"<body"); if (body1 == -1) return; body1 = html.Find(L">",body1); if (body1 == -1) return; int body2 = html.Find(L"</body>"); if (body2 <= body1) return; CStringW bodyHtml = html.Mid(body1+1,body2-body1-1); // Create a DocText instance for this file DocText* mainDocText = new DocText(); mainDocText->file = filename; mainDocText->colourScheme = scheme; m_docTexts.Add(mainDocText); // Reserve space for the main text len = bodyHtml.GetLength(); mainDocText->body.Preallocate(len); // Scan the text, removing markup DocText* docText = mainDocText; bool ignore = false; bool white = false; const wchar_t* p1 = bodyHtml; const wchar_t* p2 = p1+len; while (p1 < p2) { // Look for a markup element if ((*p1 == L'<') && (iswalpha(*(p1+1)) || (*(p1+1) == L'/'))) { // Check for a closing markup element bool closing = false; if (*(p1+1) == L'/') { closing = true; p1++; } // Scan for a known markup element bool found = false; int i = 0; while (!found && (i < sizeof tags / sizeof tags[0])) { if (wcsncmp(p1+1,tags[i].name,tags[i].len) == 0) found = true; if (!found) i++; } ASSERT(found); // Remove the markup if (found && tags[i].remove) { ASSERT(!closing); // Remove everything until the closing element CStringW search; search.Format(L"</%s>",tags[i].name); p1 = wcsstr(p1,search); if (p1 != NULL) p1 += search.GetLength()-1; else p1 = p2; } else { // Remove just the element while ((p1 < p2) && (*p1 != L'>')) p1++; } ASSERT(*p1 == L'>'); // Add a carriage return for appropriate markup if (found && !closing && tags[i].cr && !ignore) docText->AddToBody(L'\n'); white = false; } else if ((*p1 == L'<') && (*(p1+1) == L'!')) { // Extract metadata from comments wchar_t meta1[256], meta2[256]; if (swscanf(p1,L"<!-- SEARCH TITLE \"%[^\"]",meta1) == 1) docText->title = meta1; else if (swscanf(p1,L"<!-- SEARCH SECTION \"%[^\"]",meta1) == 1) docText->section = meta1; else if (swscanf(p1,L"<!-- SEARCH SORT \"%[^\"]",meta1) == 1) docText->sort = meta1; else if (swscanf(p1,L"<!-- START EXAMPLE \"%[^\"]\" \"%[^\"]",meta1,meta2) == 2) { docText = new DocText(); docText->file = mainDocText->file + "#" + CStringA(meta2); docText->colourScheme = mainDocText->colourScheme; docText->title = "Example " + CStringA(meta1); docText->section = mainDocText->section; docText->sort = mainDocText->sort; docText->body.Preallocate(len/2); m_docTexts.Add(docText); } else if (wcsncmp(p1,L"<!-- END EXAMPLE -->",20) == 0) docText = mainDocText; else if (wcsncmp(p1,L"<!-- START IGNORE ",18) == 0) ignore = true; else if (wcsncmp(p1,L"<!-- END IGNORE -->",19) == 0) ignore = false; p1 = wcsstr(p1,L"-->"); if (p1 != NULL) p1 += 2; else p1 = p2; } else if (*p1 == L'&') { // Scan for a known literal bool found = false; int i = 0; while (!found && (i < sizeof literals / sizeof literals[0])) { if (wcsncmp(p1+1,literals[i].name,literals[i].len) == 0) found = true; if (!found) i++; } // Replace the literal if (found) { if (!ignore) docText->AddToBody(literals[i].replace); p1 += literals[i].len; } else { ASSERT(FALSE); if (!ignore) docText->AddToBody(*p1); } white = false; } else if (iswspace(*p1)) { if (!white && !ignore) docText->AddToBody(L' '); white = true; } else { if (!ignore) docText->AddToBody(*p1); white = false; } p1++; } /* CString bodyA(docText->body); AfxMessageBox(bodyA); */ }
ULONG CFormData::ProcessForm() { CStringA startPart = "--" + CStringA(m_sBoundary) + "\r\n"; Append(startPart); BOOL bHasFields = FALSE; //STLOG_WRITE("%s(%d): Ponto de apoio", __FUNCTION__, __LINE__); // Varrer os fields primeiro POSITION p1 = m_items.GetStartPosition(); while(p1) { CStringW key1; CFormItem *pAttr; m_items.GetNextAssoc(p1, key1, pAttr); if(!pAttr->m_bFile) { bHasFields = TRUE; CStringW s; s.Format(FIELD_BOUND, pAttr->m_name, pAttr->m_value); Append(CStringA(s)); } if(p1 != NULL) { startPart = "--" + CStringA(m_sBoundary) + "\r\n"; Append(startPart); } } //STLOG_WRITE("%s(%d): Ponto de apoio", __FUNCTION__, __LINE__); BOOL bFirst = TRUE; // Varrer os files p1 = m_items.GetStartPosition(); while(p1) { CStringW key1; CFormItem *pAttr; m_items.GetNextAssoc(p1, key1, pAttr); if(pAttr->m_bFile) { if(bFirst && bHasFields) { startPart = "--" + CStringA(m_sBoundary) + "\r\n"; Append(startPart); bFirst = FALSE; } CStringW sFileName = pAttr->m_value; if(sFileName.Find('\\') >= 0 || sFileName.Find('/') >= 0) { int pos = sFileName.ReverseFind('\\'); if(pos < 0) pos = sFileName.ReverseFind('/'); sFileName = sFileName.Mid(pos+1); } CStringW s; s.Format(FILE_BOUND, pAttr->m_name, sFileName, pAttr->m_mime); Append(CStringA(s)); Append("\r\n"); AppendFile(pAttr->m_value); Append("\r\n"); if(p1 != NULL) { startPart = "--" + CStringA(m_sBoundary) + "\r\n"; Append(startPart); } } } startPart = "--" + CStringA(m_sBoundary) + "--\r\n"; Append(startPart); //STLOG_WRITE("%s(%d): Ponto de apoio", __FUNCTION__, __LINE__); //STLOG_WRITE("%s(%d): Buffer: %s", __FUNCTION__, __LINE__, m_buffer.GetData()); return m_buffer.GetCount(); }
void LogViewRE::Log(LogFacility logType, LPCWSTR aName, SAFEARRAY* pVals, LPDISPATCH pOptions) { LogIntro(logType, aName); ATLASSERT(0 == pVals->rgsabound[0].lLbound); VARIANT* pVariants = (VARIANT*)pVals->pvData; // see if we can do a printf ULONG valueCount = pVals->rgsabound[0].cElements; ULONG currentValueIndex = 0; if ((valueCount > 1) && (VT_BSTR == pVariants[0].vt)) { ++currentValueIndex; CStringW sIn(pVariants[0].bstrVal), sOut; int pos = sIn.Find(L'%'); int posLast = 0; int sInLength = sIn.GetLength(); while((-1 != pos) && (pos < sInLength-1) && (currentValueIndex < valueCount)) { // add everything before sOut += sIn.Mid(posLast, (pos - posLast)); ++pos; wchar_t format = sIn[pos]; CComVariant vt(pVariants[currentValueIndex]); HRESULT hr = E_FAIL; switch(format) { case L's': // a string: change to string type and log as it is hr = vt.ChangeType(VT_BSTR); if (SUCCEEDED(hr)) { sOut += vt.bstrVal; } ++currentValueIndex; ++pos; break; case L'd': case L'i': // an integer number // check for type, set "undefined" if empty, "NaN" if can't be converted to a number { CStringW s; switch (vt.vt) { case VT_I1: case VT_I2: case VT_I4: case VT_INT: s.Format(L"%i", vt.lVal); break; case VT_UI1: case VT_UI2: case VT_UI4: case VT_UINT: s.Format(L"%u", vt.ulVal); break; case VT_EMPTY: s = L"-undefined-"; break; default: if (SUCCEEDED(vt.ChangeType(VT_UI4))) { s.Format(L"%u", vt.ulVal); } else if (SUCCEEDED(vt.ChangeType(VT_I4))) { s.Format(L"%u", vt.lVal); } else { s = L"NaN"; } break; } ++currentValueIndex; sOut += s; } ++pos; break; case L'f': // a float number // check for type, set "undefined" if empty, "NaN" if can't be converted to a number { CStringW s; switch (vt.vt) { case VT_R4: s.Format(L"%f", vt.fltVal); break; case VT_R8: s.Format(L"%f", vt.dblVal); break; case VT_EMPTY: s = L"-undefined-"; break; default: if (SUCCEEDED(vt.ChangeType(VT_R8))) { s.Format(L"%f", vt.dblVal); } else { s = L"NaN"; } break; } ++currentValueIndex; sOut += s; } ++pos; break; case L'o': // an object // check for type, set "undefined" if empty, "NaO" if can't be converted to string representation if (VT_DISPATCH == vt.vt) { CStringW s, s2; s2.Format(L"[Object at 0x%%0%ix]", sizeof(vt.pdispVal) * 2); s.Format(s2, (IUnknown*)(vt.pdispVal)); sOut += s; } else if (VT_EMPTY == vt.vt) { sOut += L"-undefined-"; } else if (SUCCEEDED(vt.ChangeType(VT_BSTR))) { sOut += vt.bstrVal; } else { sOut += L"NaO"; } ++currentValueIndex; ++pos; break; default: // all other cases: not a format spec, take it as it is sOut += L'%'; sOut += format; ++pos; break; } posLast = pos; pos = sIn.Find(L'%', pos); } // append the rest sOut += sIn.Mid(posLast); LogVariant(CComVariant(sOut)); AppendText(_T(" ")); } // log all the rest for(ULONG n = currentValueIndex; n < pVals->rgsabound[0].cElements; n++) { LogVariant(pVariants[n]); AppendText(_T(" ")); } LogExtro(); }
HRESULT CMatroskaSplitterFilter::CreateOutputs(IAsyncReader* pAsyncReader) { CheckPointer(pAsyncReader, E_POINTER); HRESULT hr = E_FAIL; m_pFile.Free(); m_pTrackEntryMap.RemoveAll(); m_pOrderedTrackArray.RemoveAll(); CAtlArray<CMatroskaSplitterOutputPin*> pinOut; CAtlArray<TrackEntry*> pinOutTE; m_pFile.Attach(DNew CMatroskaFile(pAsyncReader, hr)); if(!m_pFile) return E_OUTOFMEMORY; if(FAILED(hr)) {m_pFile.Free(); return hr;} m_rtNewStart = m_rtCurrent = 0; m_rtNewStop = m_rtStop = m_rtDuration = 0; int iVideo = 1, iAudio = 1, iSubtitle = 1; POSITION pos = m_pFile->m_segment.Tracks.GetHeadPosition(); while(pos) { Track* pT = m_pFile->m_segment.Tracks.GetNext(pos); POSITION pos2 = pT->TrackEntries.GetHeadPosition(); while(pos2) { TrackEntry* pTE = pT->TrackEntries.GetNext(pos2); bool isSub = false; if(!pTE->Expand(pTE->CodecPrivate, ContentEncoding::TracksPrivateData)) continue; CStringA CodecID = pTE->CodecID.ToString(); CStringW Name; Name.Format(L"Output %I64d", (UINT64)pTE->TrackNumber); CMediaType mt; CAtlArray<CMediaType> mts; mt.SetSampleSize(1); if(pTE->TrackType == TrackEntry::TypeVideo) { Name.Format(L"Video %d", iVideo++); mt.majortype = MEDIATYPE_Video; if(CodecID == "V_MS/VFW/FOURCC") { mt.formattype = FORMAT_VideoInfo; VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)mt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER) + pTE->CodecPrivate.GetCount() - sizeof(BITMAPINFOHEADER)); memset(mt.Format(), 0, mt.FormatLength()); memcpy(&pvih->bmiHeader, pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetCount()); mt.subtype = FOURCCMap(pvih->bmiHeader.biCompression); switch(pvih->bmiHeader.biCompression) { case BI_RGB: case BI_BITFIELDS: mt.subtype = pvih->bmiHeader.biBitCount == 1 ? MEDIASUBTYPE_RGB1 : pvih->bmiHeader.biBitCount == 4 ? MEDIASUBTYPE_RGB4 : pvih->bmiHeader.biBitCount == 8 ? MEDIASUBTYPE_RGB8 : pvih->bmiHeader.biBitCount == 16 ? MEDIASUBTYPE_RGB565 : pvih->bmiHeader.biBitCount == 24 ? MEDIASUBTYPE_RGB24 : pvih->bmiHeader.biBitCount == 32 ? MEDIASUBTYPE_ARGB32 : MEDIASUBTYPE_NULL; break; // case BI_RLE8: mt.subtype = MEDIASUBTYPE_RGB8; break; // case BI_RLE4: mt.subtype = MEDIASUBTYPE_RGB4; break; } mts.Add(mt); } else if(CodecID == "V_UNCOMPRESSED") { } else if(CodecID.Find("V_MPEG4/ISO/AVC") == 0 && pTE->CodecPrivate.GetCount() >= 6) { BYTE sps = pTE->CodecPrivate[5] & 0x1f; std::vector<BYTE> avcC; for(int i = 0, j = pTE->CodecPrivate.GetCount(); i < j; i++) avcC.push_back(pTE->CodecPrivate[i]); std::vector<BYTE> sh; unsigned jj = 6; while (sps--) { if (jj + 2 > avcC.size()) goto avcfail; unsigned spslen = ((unsigned)avcC[jj] << 8) | avcC[jj+1]; if (jj + 2 + spslen > avcC.size()) goto avcfail; unsigned cur = sh.size(); sh.resize(cur + spslen + 2, 0); std::copy(avcC.begin() + jj, avcC.begin() + jj + 2 + spslen,sh.begin() + cur); jj += 2 + spslen; } if (jj + 1 > avcC.size()) continue; unsigned pps = avcC[jj++]; while (pps--) { if (jj + 2 > avcC.size()) goto avcfail; unsigned ppslen = ((unsigned)avcC[jj] << 8) | avcC[jj+1]; if (jj + 2 + ppslen > avcC.size()) goto avcfail; unsigned cur = sh.size(); sh.resize(cur + ppslen + 2, 0); std::copy(avcC.begin() + jj, avcC.begin() + jj + 2 + ppslen, sh.begin() + cur); jj += 2 + ppslen; } goto avcsuccess; avcfail: continue; avcsuccess: CAtlArray<BYTE> data; data.SetCount(sh.size()); std::copy(sh.begin(), sh.end(), data.GetData()); mt.subtype = FOURCCMap('1CVA'); mt.formattype = FORMAT_MPEG2Video; MPEG2VIDEOINFO* pm2vi = (MPEG2VIDEOINFO*)mt.AllocFormatBuffer(FIELD_OFFSET(MPEG2VIDEOINFO, dwSequenceHeader) + data.GetCount()); memset(mt.Format(), 0, mt.FormatLength()); pm2vi->hdr.bmiHeader.biSize = sizeof(pm2vi->hdr.bmiHeader); pm2vi->hdr.bmiHeader.biWidth = (LONG)pTE->v.PixelWidth; pm2vi->hdr.bmiHeader.biHeight = (LONG)pTE->v.PixelHeight; pm2vi->hdr.bmiHeader.biCompression = '1CVA'; pm2vi->hdr.bmiHeader.biPlanes = 1; pm2vi->hdr.bmiHeader.biBitCount = 24; pm2vi->dwProfile = pTE->CodecPrivate[1]; pm2vi->dwLevel = pTE->CodecPrivate[3]; pm2vi->dwFlags = (pTE->CodecPrivate[4] & 3) + 1; BYTE* pSequenceHeader = (BYTE*)pm2vi->dwSequenceHeader; memcpy(pSequenceHeader, data.GetData(), data.GetCount()); pm2vi->cbSequenceHeader = data.GetCount(); mts.Add(mt); } else if(CodecID.Find("V_MPEG4/") == 0) { mt.subtype = FOURCCMap('V4PM'); mt.formattype = FORMAT_MPEG2Video; MPEG2VIDEOINFO* pm2vi = (MPEG2VIDEOINFO*)mt.AllocFormatBuffer(FIELD_OFFSET(MPEG2VIDEOINFO, dwSequenceHeader) + pTE->CodecPrivate.GetCount()); memset(mt.Format(), 0, mt.FormatLength()); pm2vi->hdr.bmiHeader.biSize = sizeof(pm2vi->hdr.bmiHeader); pm2vi->hdr.bmiHeader.biWidth = (LONG)pTE->v.PixelWidth; pm2vi->hdr.bmiHeader.biHeight = (LONG)pTE->v.PixelHeight; pm2vi->hdr.bmiHeader.biCompression = 'V4PM'; pm2vi->hdr.bmiHeader.biPlanes = 1; pm2vi->hdr.bmiHeader.biBitCount = 24; BYTE* pSequenceHeader = (BYTE*)pm2vi->dwSequenceHeader; memcpy(pSequenceHeader, pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetCount()); pm2vi->cbSequenceHeader = pTE->CodecPrivate.GetCount(); mts.Add(mt); } else if(CodecID.Find("V_REAL/RV") == 0) { mt.subtype = FOURCCMap('00VR' + ((CodecID[9]-0x30)<<16)); mt.formattype = FORMAT_VideoInfo; VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)mt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER) + pTE->CodecPrivate.GetCount()); memset(mt.Format(), 0, mt.FormatLength()); memcpy(mt.Format() + sizeof(VIDEOINFOHEADER), pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetCount()); pvih->bmiHeader.biSize = sizeof(pvih->bmiHeader); pvih->bmiHeader.biWidth = (LONG)pTE->v.PixelWidth; pvih->bmiHeader.biHeight = (LONG)pTE->v.PixelHeight; pvih->bmiHeader.biCompression = mt.subtype.Data1; mts.Add(mt); } else if(CodecID == "V_DIRAC") { mt.subtype = MEDIASUBTYPE_DiracVideo; mt.formattype = FORMAT_DiracVideoInfo; DIRACINFOHEADER* dvih = (DIRACINFOHEADER*)mt.AllocFormatBuffer(FIELD_OFFSET(DIRACINFOHEADER, dwSequenceHeader) + pTE->CodecPrivate.GetCount()); memset(mt.Format(), 0, mt.FormatLength()); dvih->hdr.bmiHeader.biSize = sizeof(dvih->hdr.bmiHeader); dvih->hdr.bmiHeader.biWidth = (LONG)pTE->v.PixelWidth; dvih->hdr.bmiHeader.biHeight = (LONG)pTE->v.PixelHeight; dvih->hdr.dwPictAspectRatioX = dvih->hdr.bmiHeader.biWidth; dvih->hdr.dwPictAspectRatioY = dvih->hdr.bmiHeader.biHeight; BYTE* pSequenceHeader = (BYTE*)dvih->dwSequenceHeader; memcpy(pSequenceHeader, pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetCount()); dvih->cbSequenceHeader = pTE->CodecPrivate.GetCount(); mts.Add(mt); } else if(CodecID == "V_MPEG2") { BYTE* seqhdr = pTE->CodecPrivate.GetData(); DWORD len = pTE->CodecPrivate.GetCount(); int w = pTE->v.PixelWidth; int h = pTE->v.PixelHeight; if(MakeMPEG2MediaType(mt, seqhdr, len, w, h)) mts.Add(mt); } else if(CodecID == "V_THEORA") { BYTE* thdr = pTE->CodecPrivate.GetData() + 3; mt.majortype = MEDIATYPE_Video; mt.subtype = FOURCCMap('OEHT'); mt.formattype = FORMAT_MPEG2_VIDEO; MPEG2VIDEOINFO* vih = (MPEG2VIDEOINFO*)mt.AllocFormatBuffer(sizeof(MPEG2VIDEOINFO) + pTE->CodecPrivate.GetCount()); memset(mt.Format(), 0, mt.FormatLength()); vih->hdr.bmiHeader.biSize = sizeof(vih->hdr.bmiHeader); vih->hdr.bmiHeader.biWidth = *(WORD*)&thdr[10] >> 4; vih->hdr.bmiHeader.biHeight = *(WORD*)&thdr[12] >> 4; vih->hdr.bmiHeader.biCompression = 'OEHT'; vih->hdr.bmiHeader.biPlanes = 1; vih->hdr.bmiHeader.biBitCount = 24; int nFpsNum = (thdr[22]<<24)|(thdr[23]<<16)|(thdr[24]<<8)|thdr[25]; int nFpsDenum = (thdr[26]<<24)|(thdr[27]<<16)|(thdr[28]<<8)|thdr[29]; if(nFpsNum) vih->hdr.AvgTimePerFrame = (REFERENCE_TIME)(10000000.0 * nFpsDenum / nFpsNum); vih->hdr.dwPictAspectRatioX = (thdr[14]<<16)|(thdr[15]<<8)|thdr[16]; vih->hdr.dwPictAspectRatioY = (thdr[17]<<16)|(thdr[18]<<8)|thdr[19]; mt.bFixedSizeSamples = 0; vih->cbSequenceHeader = pTE->CodecPrivate.GetCount(); memcpy (&vih->dwSequenceHeader, pTE->CodecPrivate.GetData(), vih->cbSequenceHeader); mts.Add(mt); } else if(CodecID.Find("V_VP8") == 0) { mt.subtype = FOURCCMap('08PV'); mt.formattype = FORMAT_VideoInfo; VIDEOINFOHEADER* pvih = (VIDEOINFOHEADER*)mt.AllocFormatBuffer(sizeof(VIDEOINFOHEADER) + pTE->CodecPrivate.GetCount()); memset(mt.Format(), 0, mt.FormatLength()); memcpy(mt.Format() + sizeof(VIDEOINFOHEADER), pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetCount()); pvih->bmiHeader.biSize = sizeof(pvih->bmiHeader); pvih->bmiHeader.biWidth = (LONG)pTE->v.PixelWidth; pvih->bmiHeader.biHeight = (LONG)pTE->v.PixelHeight; pvih->bmiHeader.biCompression = mt.subtype.Data1; mts.Add(mt); } /* else if(CodecID == "V_DSHOW/MPEG1VIDEO") // V_MPEG1 { mt.majortype = MEDIATYPE_Video; mt.subtype = MEDIASUBTYPE_MPEG1Payload; mt.formattype = FORMAT_MPEGVideo; MPEG1VIDEOINFO* pm1vi = (MPEG1VIDEOINFO*)mt.AllocFormatBuffer(pTE->CodecPrivate.GetCount()); memcpy(pm1vi, pTE->CodecPrivate.GetData(), pTE->CodecPrivate.GetCount()); mt.SetSampleSize(pm1vi->hdr.bmiHeader.biWidth*pm1vi->hdr.bmiHeader.biHeight*4); mts.Add(mt); } */ REFERENCE_TIME AvgTimePerFrame = 0; if(pTE->v.FramePerSec > 0) AvgTimePerFrame = (REFERENCE_TIME)(10000000i64 / pTE->v.FramePerSec); else if(pTE->DefaultDuration > 0) AvgTimePerFrame = (REFERENCE_TIME)pTE->DefaultDuration / 100; if(AvgTimePerFrame) { for(int i = 0; i < mts.GetCount(); i++) { if(mts[i].formattype == FORMAT_VideoInfo || mts[i].formattype == FORMAT_VideoInfo2 || mts[i].formattype == FORMAT_MPEG2Video) { ((VIDEOINFOHEADER*)mts[i].Format())->AvgTimePerFrame = AvgTimePerFrame; } } } if(pTE->v.DisplayWidth != 0 && pTE->v.DisplayHeight != 0) { for(int i = 0; i < mts.GetCount(); i++) { if(mts[i].formattype == FORMAT_VideoInfo) { DWORD vih1 = FIELD_OFFSET(VIDEOINFOHEADER, bmiHeader); DWORD vih2 = FIELD_OFFSET(VIDEOINFOHEADER2, bmiHeader); DWORD bmi = mts[i].FormatLength() - FIELD_OFFSET(VIDEOINFOHEADER, bmiHeader); mt.formattype = FORMAT_VideoInfo2; mt.AllocFormatBuffer(vih2 + bmi); memcpy(mt.Format(), mts[i].Format(), vih1); memset(mt.Format() + vih1, 0, vih2 - vih1); memcpy(mt.Format() + vih2, mts[i].Format() + vih1, bmi); ((VIDEOINFOHEADER2*)mt.Format())->dwPictAspectRatioX = (DWORD)pTE->v.DisplayWidth; ((VIDEOINFOHEADER2*)mt.Format())->dwPictAspectRatioY = (DWORD)pTE->v.DisplayHeight; mts.InsertAt(i++, mt); } else if(mts[i].formattype == FORMAT_MPEG2Video) { ((MPEG2VIDEOINFO*)mts[i].Format())->hdr.dwPictAspectRatioX = (DWORD)pTE->v.DisplayWidth; ((MPEG2VIDEOINFO*)mts[i].Format())->hdr.dwPictAspectRatioY = (DWORD)pTE->v.DisplayHeight; } } } }
HBITMAP CDpiHelper::CreateDeviceFromLogicalImage(HBITMAP _In_ hImage, ImageScalingMode scalingMode, Color clrBackground) { IfNullAssertRetNull(hImage, "No image given to convert"); // Instead of doing HBITMAP resizing with StretchBlt from one memory DC into other memory DC and HALFTONE StretchBltMode // which uses nearest neighbor resize algorithm (fast but results in pixelation), we'll use a GdiPlus image to do the resize, // which allows specifying the interpolation mode for the resize resulting in smoother result. VsUI::GdiplusImage gdiplusImage; // Attaching the bitmap uses Bitmap.FromHBITMAP which does not take ownership of the HBITMAP passed as argument. // DeleteObject still needs to be used on the hImage but that should happen after the Bitmap object is deleted or goes out of scope. // The caller will have to DeleteObject both the HBITMAP they passed in this function and the new HBITMAP we'll be returning when we detach the GDI+ Bitmap gdiplusImage.Attach(hImage); #ifdef DEBUG static bool fDebugDPIHelperScaling = false; WCHAR rgTempFolder[MAX_PATH]; static int imgIndex = 1; CStringW strFileName; CPath pathTempFile; if (fDebugDPIHelperScaling) { if (!GetTempPath(_countof(rgTempFolder), rgTempFolder)) *rgTempFolder = '\0'; strFileName.Format(_T("DPIHelper_%05d_Before.png"), imgIndex); pathTempFile.Combine(rgTempFolder, strFileName); gdiplusImage.Save(pathTempFile); } #endif Bitmap* pBitmap = gdiplusImage.GetBitmap(); PixelFormat format = pBitmap->GetPixelFormat(); const Color *pclrActualBackground = &clrBackground; InterpolationMode interpolationMode = GetInterpolationMode(scalingMode); ImageScalingMode actualScalingMode = GetActualScalingMode(scalingMode); if (actualScalingMode != ImageScalingMode::NearestNeighbor) { // Modify the image. If the image is 24bpp or lower, convert to 32bpp so we can use alpha values if (format != PixelFormat32bppARGB) { pBitmap->ConvertFormat(PixelFormat32bppARGB, DitherTypeNone, PaletteTypeCustom, nullptr/*ColorPalette*/, 0 /*alphaThresholdPercent - all opaque*/); } // Now that we have 32bpp image, let's play with the pixels // Detect magenta or near-green in the image and use that as background VsUI::GdiplusImage::ProcessBitmapBits(pBitmap, [&](ARGB * pPixelData) { if (clrBackground.GetValue() != TransparentColor.GetValue()) { if (*pPixelData == clrBackground.GetValue()) { *pPixelData = TransparentHaloColor.GetValue(); pclrActualBackground = &clrBackground; } } else { if (*pPixelData == MagentaColor.GetValue()) { *pPixelData = TransparentHaloColor.GetValue(); pclrActualBackground = &MagentaColor; } else if (*pPixelData == NearGreenColor.GetValue()) { *pPixelData = TransparentHaloColor.GetValue(); pclrActualBackground = &MagentaColor; } } }); } // Convert the GdiPlus image if necessary LogicalToDeviceUnits(&gdiplusImage, scalingMode, TransparentHaloColor); // Get again the bitmap, after the resize pBitmap = gdiplusImage.GetBitmap(); if (actualScalingMode != ImageScalingMode::NearestNeighbor) { // Now that the bitmap is scaled up, convert back the pixels. // Anything that is not fully opaque, make it clrActualBackground VsUI::GdiplusImage::ProcessBitmapBits(pBitmap, [&](ARGB * pPixelData) { if ((*pPixelData & ALPHA_MASK) != 0xFF000000) { *pPixelData = pclrActualBackground->GetValue(); } }); // Convert back to original format if (format != PixelFormat32bppARGB) { pBitmap->ConvertFormat(format, DitherTypeNone, PaletteTypeCustom, nullptr/*ColorPalette*/, 0 /*alphaThresholdPercent - all opaque*/); } } #ifdef DEBUG if (fDebugDPIHelperScaling) { strFileName.Format(_T("DPIHelper_%05d_After.png"), imgIndex++); pathTempFile.Combine(rgTempFolder, strFileName); gdiplusImage.Save(pathTempFile); } #endif // Get the converted image handle - this returns a new HBITMAP that will need to be deleted when no longer needed // Detach using TransparentColor (transparent-black). If the result bitmap is to be used with AlphaBlend, that function // keeps the background if the transparent pixels are black HBITMAP hBmpResult = gdiplusImage.Detach( TransparentColor ); // When the image has 32bpp RGB format, when we call GDI+ to return an HBITMAP for the image, the result is actually // an ARGB bitmap (with alpha bytes==0xFF instead of reserved=0x00). Many GDI functions work with it fine, but // adding it to an imagelist with ImageList_AddMasked will produce the wrong result, because the clrTransparent color // won't match any background pixels due to the alpha byte value. So we need to zero-out out those bytes... // If the bitmap was scaled with a bicubic/bilinear interpolation, the colors are interpolated with the clrBackground // which may be transparent, so the resultant image will have alpha channel of interest, and we'll return the image as is. if (format == PixelFormat32bppRGB) { BITMAP bmp = {0}; if (GetObject(hBmpResult, sizeof(bmp), &bmp) == sizeof(bmp) && bmp.bmBits != nullptr) { RGBQUAD* pPixels = reinterpret_cast<RGBQUAD*>(bmp.bmBits); for (int i=0; i< bmp.bmWidth * bmp.bmHeight; i++) { pPixels[i].rgbReserved = 0; } } } // Return the created image return hBmpResult; }