// Serialisieren/DeSerialisieren eines IUnknowns
// in diesem Falle ein IDataObject
HRESULT CreateStreamOnHGlobalFromIUnknown (
IUnknown *pIUnk, REFCLSID rClsID, IStream **ppIStream)
{
ASSERT(NULL != pIUnk);
ASSERT(NULL != ppIStream);
*ppIStream = NULL;
try {
// neuen Stream anlegen, kreiert eine neuen Memoryblock der Größe NULL
// wird selbstständig wieder freigegen (true)
WStream IStream;
THROW_FAILED_HRESULT(CreateStreamOnHGlobal (NULL, true, IStream.ppi()));
// den Enumerator wegschreiben
WPersistStream IPersStr (pIUnk); // throws hr
THROW_FAILED_HRESULT(OleSaveToStream (IPersStr, IStream));
// wieder zurück positionieren
LARGE_INTEGER li;
LISet32 (li, 0L);
THROW_FAILED_HRESULT(IStream -> Seek (li, STREAM_SEEK_SET, NULL));
*ppIStream = IStream.detach();
}
catch (_com_error &e)
{
return _COM_ERROR(e);
}
return S_OK;
}
int PolylineTest::writeFileMoniker()
{
ComPtr<IMoniker> moniker;
auto hr = CreateFileMoniker(kFileName, &moniker);
if (FAILED(hr)) {
return -1;
}
IBindCtx* pbc;
CreateBindCtx(0, &pbc);
ComPtr<IPolyline> polyline;
hr = moniker->BindToObject(pbc, NULL, IID_IPolyline, (void**)&polyline);
if (FAILED(hr)) {
return -1;
}
polyline->put_Color(RGB(0xff, 0x00, 0x00));
COLORREF value;
polyline->get_Color(&value);
assert(value == RGB(0xff, 0x00, 0x00));
ComPtr<IStorage> pStorage;
ComPtr<IStream> pStream;
hr = StgCreateStorageEx(kMonikerFileName, STGM_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE,
STGFMT_STORAGE, 0, NULL, 0, IID_IStorage, (void**)&pStorage);
if (FAILED(hr))
return hr;
hr = pStorage->CreateStream(kStreamName, STGM_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE,
0, 0, &pStream);
if (FAILED(hr))
return hr;
OleSaveToStream(moniker, pStream);
return 0;
}
int BookServerTest::createFileMoniker()
{
ComPtr<IMoniker> moniker;
auto hr = CreateFileMoniker(kFileName, &moniker);
if (FAILED(hr)) {
return -1;
}
IBindCtx* pbc;
CreateBindCtx(0, &pbc);
ComPtr<IBook> book;
hr = moniker->BindToObject(pbc, NULL, IID_IBook, (void**)&book);
if (FAILED(hr)) {
return -1;
}
ComPtr<IStorage> pStorage;
ComPtr<IStream> pStream;
hr = StgCreateStorageEx(kMonikerFileName, STGM_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE,
STGFMT_STORAGE, 0, NULL, 0, IID_IStorage, (void**)&pStorage);
if (FAILED(hr))
return hr;
hr = pStorage->CreateStream(kStreamName, STGM_WRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE,
0, 0, &pStream);
if (FAILED(hr))
return hr;
OleSaveToStream(moniker, pStream);
return 0;
}
void PropertySequence_cmd_Save (ebHTHREAD hThread, int iNumArgs, ebARGS lpArgs)
{
BASIC_OP_TRACE(PropertySequence_cmd_Save);
if (NULL != lpArgs[0]) // als Funktion gerufen
ebSetBool (lpArgs, 0, 0); // für alle Fälle
WPropertyActionSequence ISeq ((IPropertyActionSequence *)ebGetObject (lpArgs, 1));
HRESULT hr = E_FAIL;
// Versuchen aus SubStream einzulesen
try {
// SubStorage eröffnen/erzeugen
WStorage IStg;
hr = GetSubPropSeqStorage (IStg.ppi(), true);
if (FAILED(hr)) _com_issue_error(hr);
// Description geben lassen
char cbBuffer[_MAX_PATH];
hr = ISeq -> GetDescription (cbBuffer, _MAX_PATH, NULL);
if (FAILED(hr)) _com_issue_error(hr);
WStream IStm;
WPersistStream IPersistStm (ISeq); // throw hr
string strName = MakeStreamName(cbBuffer);
// Stream erzeugen
USES_CONVERSION;
hr = IStg -> CreateStream (A2OLE(strName.c_str()),
STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_CREATE,
0L, 0L, IStm.ppi());
if (FAILED(hr)) _com_issue_error(hr);
hr = OleSaveToStream (IPersistStm, IStm);
if (FAILED(hr)) _com_issue_error(hr);
hr = IStg -> Commit (STGC_DEFAULT);
if (FAILED(hr)) _com_issue_error(hr);
DEX_SetDirtyGeoDB(true);
} catch (...) {
TRACE("Couldn't OleSaveToStream for IPropertyActionSequence\n");
return; // Fehler
}
if (NULL != lpArgs[0]) // als Funktion gerufen
ebSetBool (lpArgs, 0, -1);
}
static HRESULT SavePropSeq (
LPCSTR pcDesc, IPropertyActionSequence *pISeq, IStorage *pIStg)
{
HRESULT hr = E_FAIL;
WStorage IStg (pIStg);
USES_CONVERSION;
if (NULL == pIStg) { // SubStorage anlegen, da es noch nicht existiert
WStorage IRootStg;
if (!DEX_GetProjectStorage(*IRootStg.ppv()))
return E_FAIL;
hr = IRootStg -> CreateStorage (A2OLE(g_cbPropertyChoices),
STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_TRANSACTED,
0L, 0L, IStg.ppi());
if (FAILED(hr)) return hr;
hr = WriteClassStg (IStg, CLSID_PropertyChoice);
if (FAILED(hr)) return hr;
}
try {
WStream IStm;
WPersistStream IPersistStm (pISeq); // throws hr
string strName = MakeStreamName(pcDesc);
// Stream erzeugen
hr = IStg -> CreateStream (A2OLE(strName.c_str()),
STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_CREATE,
0L, 0L, IStm.ppi());
if (FAILED(hr)) _com_issue_error(hr);
hr = OleSaveToStream (IPersistStm, IStm); // und wegschreiben
if (FAILED(hr)) _com_issue_error(hr);
hr = IStm -> Commit (STGC_DEFAULT);
if (FAILED(hr)) _com_issue_error(hr);
} catch (_com_error& hr) {
return _COM_ERROR(hr);
}
hr = IStg -> Commit (STGC_DEFAULT);
if (SUCCEEDED(hr))
DEX_SetDirtyGeoDB(true);
return hr;
}
// --------------------------------------------------------------------------------------------
// fClearDirty: Zustand im aktuellen Projekt und dessen Abspeicherung ist identisch (true) bzw.
// stimmt nicht überein (false); letzterer Fall tritt bei SaveAs() auf
STDMETHODIMP CRegOperatPropAct::Save (LPSTREAM pStm, BOOL fClearDirty)
{
// Bezeichner wegschreiben
HRESULT hr = CPropertyAction::Save (pStm, fClearDirty);
if (FAILED(hr)) return hr;
// Signatur und Version wegschreiben
DWORD dwSignature = REGOPERATPROPACT_SIGNATURE;
DWORD dwVersion = REGOPERATPROPACT_VERSION_1_0_2;
RETURN_FAILED_HRESULT (pStm->Write (&dwSignature, sizeof(DWORD), NULL));
RETURN_FAILED_HRESULT (pStm->Write (&dwVersion, sizeof(DWORD), NULL));
// dann selektierte Info der letzten Auswahl
// nachfolgende if-Bedingung für den Fall, daß m_pRegOperDlg-Seite "am Schluß" nicht oben
// lag, also BeginAction() und damit auch GetSelectedInfo() nicht ausgeführt wurden
if (m_pRegOperDlg)
m_pRegOperDlg->GetSelectedInfo (&m_caSelInfo, m_bIsDirty);
RETURN_FAILED_HRESULT (pStm->Write (&m_caSelInfo.bClassKey, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Write (&m_caSelInfo.bInter, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Write (&m_caSelInfo.bExter, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Write (&m_caSelInfo.bBound, sizeof(BOOL), NULL));
if (!m_mkOperOptions.IsValid() && m_wOperOptions.IsValid()) {
// ggf. Moniker geben lassen
RETURN_FAILED_HRESULT (MkGetMoniker(m_wOperOptions,
OLEGETMONIKER_FORCEASSIGN, OLEWHICHMK_OBJFULL, m_mkOperOptions.ppi()));
}
// und Moniker wegschreiben
BOOL fHasMoniker;
if (m_mkOperOptions.IsValid()) {
fHasMoniker = TRUE;
RETURN_FAILED_HRESULT (pStm->Write (&fHasMoniker, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (OleSaveToStream(WPersistStream(m_mkOperOptions), pStm));
}
else {
fHasMoniker = FALSE;
RETURN_FAILED_HRESULT (pStm->Write (&fHasMoniker, sizeof(BOOL), NULL));
}
if (fClearDirty) m_bIsDirty = false;
return S_OK;
} // Save
static HRESULT WINAPI IPersistStream_fnSave(IPersistStream* iface,
IStream* pStm, BOOL fClearDirty)
{
HRESULT r;
HlinkImpl *This = impl_from_IPersistStream(iface);
DWORD hdr[2];
IMoniker *moniker;
TRACE("(%p) Moniker(%p)\n", This, This->Moniker);
r = __GetMoniker(This, &moniker, HLINKGETREF_DEFAULT);
if (FAILED(r))
return r;
r = E_FAIL;
hdr[0] = HLINK_SAVE_MAGIC;
hdr[1] = 0;
if (moniker)
hdr[1] |= HLINK_SAVE_MONIKER_PRESENT;
if (This->absolute)
hdr[1] |= HLINK_SAVE_MONIKER_IS_ABSOLUTE;
if (This->Location)
hdr[1] |= HLINK_SAVE_LOCATION_PRESENT;
if (This->FriendlyName)
hdr[1] |= HLINK_SAVE_FRIENDLY_PRESENT | 4 /* FIXME */;
if (This->TargetFrameName)
hdr[1] |= HLINK_SAVE_TARGET_FRAME_PRESENT;
IStream_Write(pStm, hdr, sizeof(hdr), NULL);
if (This->TargetFrameName)
{
r = write_hlink_string(pStm, This->TargetFrameName);
if (FAILED(r)) goto end;
}
if (This->FriendlyName)
{
r = write_hlink_string(pStm, This->FriendlyName);
if (FAILED(r)) goto end;
}
if (moniker)
{
IPersistStream* monstream;
monstream = NULL;
IMoniker_QueryInterface(moniker, &IID_IPersistStream,
(LPVOID*)&monstream);
if (monstream)
{
r = OleSaveToStream(monstream, pStm);
IPersistStream_Release(monstream);
}
if (FAILED(r)) goto end;
}
if (This->Location)
{
r = write_hlink_string(pStm, This->Location);
if (FAILED(r)) goto end;
}
end:
if (moniker) IMoniker_Release(moniker);
TRACE("Save Result 0x%x\n", r);
return r;
}
static int
dshow_open_device(AVFormatContext *avctx, ICreateDevEnum *devenum,
enum dshowDeviceType devtype, enum dshowSourceFilterType sourcetype)
{
struct dshow_ctx *ctx = avctx->priv_data;
IBaseFilter *device_filter = NULL;
IGraphBuilder *graph = ctx->graph;
IPin *device_pin = NULL;
libAVPin *capture_pin = NULL;
libAVFilter *capture_filter = NULL;
ICaptureGraphBuilder2 *graph_builder2 = NULL;
int ret = AVERROR(EIO);
int r;
IStream *ifile_stream = NULL;
IStream *ofile_stream = NULL;
IPersistStream *pers_stream = NULL;
const wchar_t *filter_name[2] = { L"Audio capture filter", L"Video capture filter" };
if ( ((ctx->audio_filter_load_file) && (strlen(ctx->audio_filter_load_file)>0) && (sourcetype == AudioSourceDevice)) ||
((ctx->video_filter_load_file) && (strlen(ctx->video_filter_load_file)>0) && (sourcetype == VideoSourceDevice)) ) {
HRESULT hr;
char *filename = NULL;
if (sourcetype == AudioSourceDevice)
filename = ctx->audio_filter_load_file;
else
filename = ctx->video_filter_load_file;
hr = SHCreateStreamOnFile ((LPCSTR) filename, STGM_READ, &ifile_stream);
if (S_OK != hr) {
av_log(avctx, AV_LOG_ERROR, "Could not open capture filter description file.\n");
goto error;
}
hr = OleLoadFromStream(ifile_stream, &IID_IBaseFilter, (void **) &device_filter);
if (hr != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not load capture filter from file.\n");
goto error;
}
if (sourcetype == AudioSourceDevice)
av_log(avctx, AV_LOG_INFO, "Audio-");
else
av_log(avctx, AV_LOG_INFO, "Video-");
av_log(avctx, AV_LOG_INFO, "Capture filter loaded successfully from file \"%s\".\n", filename);
} else {
if ((r = dshow_cycle_devices(avctx, devenum, devtype, sourcetype, &device_filter)) < 0) {
ret = r;
goto error;
}
}
ctx->device_filter [devtype] = device_filter;
r = IGraphBuilder_AddFilter(graph, device_filter, NULL);
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not add device filter to graph.\n");
goto error;
}
if ((r = dshow_cycle_pins(avctx, devtype, sourcetype, device_filter, &device_pin)) < 0) {
ret = r;
goto error;
}
ctx->device_pin[devtype] = device_pin;
capture_filter = libAVFilter_Create(avctx, callback, devtype);
if (!capture_filter) {
av_log(avctx, AV_LOG_ERROR, "Could not create grabber filter.\n");
goto error;
}
ctx->capture_filter[devtype] = capture_filter;
if ( ((ctx->audio_filter_save_file) && (strlen(ctx->audio_filter_save_file)>0) && (sourcetype == AudioSourceDevice)) ||
((ctx->video_filter_save_file) && (strlen(ctx->video_filter_save_file)>0) && (sourcetype == VideoSourceDevice)) ) {
HRESULT hr;
char *filename = NULL;
if (sourcetype == AudioSourceDevice)
filename = ctx->audio_filter_save_file;
else
filename = ctx->video_filter_save_file;
hr = SHCreateStreamOnFile ((LPCSTR) filename, STGM_CREATE | STGM_READWRITE, &ofile_stream);
if (S_OK != hr) {
av_log(avctx, AV_LOG_ERROR, "Could not create capture filter description file.\n");
goto error;
}
hr = IBaseFilter_QueryInterface(device_filter, &IID_IPersistStream, (void **) &pers_stream);
if (hr != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Query for IPersistStream failed.\n");
goto error;
}
hr = OleSaveToStream(pers_stream, ofile_stream);
if (hr != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not save capture filter \n");
goto error;
}
hr = IStream_Commit(ofile_stream, STGC_DEFAULT);
if (S_OK != hr) {
av_log(avctx, AV_LOG_ERROR, "Could not commit capture filter data to file.\n");
goto error;
}
if (sourcetype == AudioSourceDevice)
av_log(avctx, AV_LOG_INFO, "Audio-");
else
av_log(avctx, AV_LOG_INFO, "Video-");
av_log(avctx, AV_LOG_INFO, "Capture filter saved successfully to file \"%s\".\n", filename);
}
r = IGraphBuilder_AddFilter(graph, (IBaseFilter *) capture_filter,
filter_name[devtype]);
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not add capture filter to graph\n");
goto error;
}
libAVPin_AddRef(capture_filter->pin);
capture_pin = capture_filter->pin;
ctx->capture_pin[devtype] = capture_pin;
r = CoCreateInstance(&CLSID_CaptureGraphBuilder2, NULL, CLSCTX_INPROC_SERVER,
&IID_ICaptureGraphBuilder2, (void **) &graph_builder2);
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not create CaptureGraphBuilder2\n");
goto error;
}
ICaptureGraphBuilder2_SetFiltergraph(graph_builder2, graph);
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not set graph for CaptureGraphBuilder2\n");
goto error;
}
r = ICaptureGraphBuilder2_RenderStream(graph_builder2, NULL, NULL, (IUnknown *) device_pin, NULL /* no intermediate filter */,
(IBaseFilter *) capture_filter); /* connect pins, optionally insert intermediate filters like crossbar if necessary */
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not RenderStream to connect pins\n");
goto error;
}
r = dshow_try_setup_crossbar_options(graph_builder2, device_filter, devtype, avctx);
if (r != S_OK) {
av_log(avctx, AV_LOG_ERROR, "Could not setup CrossBar\n");
goto error;
}
ret = 0;
error:
if (graph_builder2 != NULL)
ICaptureGraphBuilder2_Release(graph_builder2);
if (pers_stream)
IPersistStream_Release(pers_stream);
if (ifile_stream)
IStream_Release(ifile_stream);
if (ofile_stream)
IStream_Release(ofile_stream);
return ret;
}
/***********************************************************************
* HlinkClone (HLINK.@)
*/
HRESULT WINAPI HlinkClone(IHlink *hlink, REFIID riid, IHlinkSite *hls,
DWORD site_data, void **obj)
{
IMoniker *mk, *clone_mk = NULL;
WCHAR *loc, *name = NULL;
HRESULT hres;
if(!hlink || !riid || !obj)
return E_INVALIDARG;
*obj = NULL;
hres = IHlink_GetMonikerReference(hlink, HLINKGETREF_DEFAULT, &mk, &loc);
if(FAILED(hres))
return hres;
if(mk) {
IStream *strm;
LARGE_INTEGER lgint;
hres = CreateStreamOnHGlobal(NULL, TRUE, &strm);
if(FAILED(hres)) {
IMoniker_Release(mk);
goto cleanup;
}
hres = OleSaveToStream((IPersistStream*)mk, strm);
if(FAILED(hres)) {
IStream_Release(strm);
IMoniker_Release(mk);
goto cleanup;
}
IMoniker_Release(mk);
lgint.QuadPart = 0;
hres = IStream_Seek(strm, lgint, STREAM_SEEK_SET, NULL);
if(FAILED(hres)) {
IStream_Release(strm);
goto cleanup;
}
hres = OleLoadFromStream(strm, &IID_IMoniker, (void**)&clone_mk);
IStream_Release(strm);
if(FAILED(hres))
goto cleanup;
}
hres = IHlink_GetFriendlyName(hlink, HLFNAMEF_DEFAULT, &name);
if(FAILED(hres))
goto cleanup;
hres = HlinkCreateFromMoniker(clone_mk, loc, name, hls, site_data, NULL,
&IID_IHlink, obj);
cleanup:
if(clone_mk)
IMoniker_Release(clone_mk);
CoTaskMemFree(loc);
CoTaskMemFree(name);
return hres;
}
