BOOL CReadWriteASIC::ReadFromRegister( ULONG id, PLONG pValue )
{
IKsPropertySet* pKsPropertySet;
KSPROPERTY_CLIENT_PROP_S KsProperty;
ULONG ulRtnCode;
HRESULT hr;
//vivi 2005/5/9 source code protection
if(m_pSrcFilter == NULL) return FALSE;
hr = m_pSrcFilter->QueryInterface(IID_IKsPropertySet,(LPVOID*)&pKsPropertySet);
if (hr != NOERROR) return hr;
ZeroMemory(&KsProperty,sizeof(KSPROPERTY_CLIENT_PROP_S));
KsProperty.Property.Flags = KSPROPERTY_TYPE_GET;
// james 2007/01/03
hr = pKsPropertySet->Get(PROPSETID_CLIENT_PROP_UVC_LIKE,id,&KsProperty,
sizeof(KSPROPERTY_CLIENT_PROP_S),&KsProperty,
sizeof(KSPROPERTY_CLIENT_PROP_S),&ulRtnCode);
if(hr!=NOERROR)
{
hr = pKsPropertySet->Get(PROPSETID_CLIENT_PROP_ST50201,id,&KsProperty,
sizeof(KSPROPERTY_CLIENT_PROP_S),&KsProperty,
sizeof(KSPROPERTY_CLIENT_PROP_S),&ulRtnCode);
}
*pValue = KsProperty.value ;
pKsPropertySet->Release();
return hr;
}
int iKX::get_dsound_routing(void *sd,dword *routing,dword *xrouting)
{
LPDIRECTSOUNDBUFFER buff=(LPDIRECTSOUNDBUFFER)sd;
IKsPropertySet *property;
buff->QueryInterface(IID_IKsPropertySet,(void **)&property);
if(property)
{
voice_routing_req voice;
int ret=dsound_property(property,KX_PROP_VOICE_ROUTING|KX_PROP_GET,&voice,sizeof(voice));
if(ret==0)
{
if(routing)
*routing=voice.routing;
if(xrouting)
*xrouting=voice.xrouting;
}
property->Release();
return ret;
}
else
{
debug("iKX get_dsound_routing failed: query interface [%x]\n",GetLastError());
}
return -5;
}
GstCaps *
gst_dshowvideosrc_getcaps_from_capture_filter (IBaseFilter * filter,
GList ** pins_mediatypes)
{
IPin *capture_pin = NULL;
IEnumPins *enumpins = NULL;
HRESULT hres;
GstCaps *caps;
g_assert (filter);
caps = gst_caps_new_empty ();
/* get the capture pins supported types */
hres = filter->EnumPins (&enumpins);
if (SUCCEEDED (hres)) {
while (enumpins->Next (1, &capture_pin, NULL) == S_OK) {
IKsPropertySet *pKs = NULL;
hres =
capture_pin->QueryInterface (IID_IKsPropertySet, (LPVOID *) & pKs);
if (SUCCEEDED (hres) && pKs) {
DWORD cbReturned;
GUID pin_category;
RPC_STATUS rpcstatus;
hres =
pKs->Get (AMPROPSETID_Pin,
AMPROPERTY_PIN_CATEGORY, NULL, 0, &pin_category, sizeof (GUID),
&cbReturned);
/* we only want capture pins */
if (UuidCompare (&pin_category, (UUID *) & PIN_CATEGORY_CAPTURE,
&rpcstatus) == 0) {
GstCaps *caps2;
caps2 = gst_dshowvideosrc_getcaps_from_streamcaps (capture_pin,
pins_mediatypes);
if (caps2) {
gst_caps_append (caps, caps2);
} else {
caps2 = gst_dshowvideosrc_getcaps_from_enum_mediatypes (
capture_pin, pins_mediatypes);
if (caps2) {
gst_caps_append (caps, caps2);
}
}
}
pKs->Release ();
}
capture_pin->Release ();
}
enumpins->Release ();
}
GST_DEBUG ("Device supports these caps: %" GST_PTR_FORMAT, caps);
return caps;
}
HRESULT GetAMConfigForMultiPin(IUnknown* pUnk, PIN_DIRECTION direct, IAMStreamConfig** ppConfig)
{
IBaseFilter* pBaseFilter = NULL;
HRESULT hr = pUnk->QueryInterface(IID_IBaseFilter, (void**)&pBaseFilter);
if (SUCCEEDED(hr))
{
IEnumPins* pEnumPins = NULL;
hr = pBaseFilter->EnumPins(&pEnumPins);
if (SUCCEEDED(hr))
{
pEnumPins->Reset();
if (SUCCEEDED(hr))
{
IPin* pPin = NULL;
BOOL bFound = FALSE;
while ((pEnumPins->Next(1, &pPin, NULL) == S_OK) && !bFound)
{
PIN_DIRECTION fetchedDir;
hr = pPin->QueryDirection(&fetchedDir);
if (SUCCEEDED(hr) && (fetchedDir == direct))
{
IKsPropertySet* pPS;
hr = pPin->QueryInterface(IID_IKsPropertySet, (void**)&pPS);
if (SUCCEEDED(hr))
{
GUID guid = { 0 };
DWORD dwReturn = 0;
hr = pPS->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY, 0, 0, &guid, sizeof(guid), &dwReturn);
if (SUCCEEDED(hr) && ::IsEqualGUID(guid, PIN_CATEGORY_CAPTURE))
{
hr = pPin->QueryInterface(IID_IAMStreamConfig, (void**)ppConfig);
bFound = SUCCEEDED(hr);
}
pPS->Release();
}
}
pPin->Release();
}
}
pEnumPins->Release();
}
pBaseFilter->Release();
}
return hr;
}
HRESULT GetPinCategory(IPin *pPin, GUID *pPinCategory)
{
HRESULT hr;
IKsPropertySet *pKs;
hr = pPin->QueryInterface(IID_IKsPropertySet, (void **)&pKs);
if (FAILED(hr))
{
// The pin does not support IKsPropertySet.
return hr;
}
// Try to retrieve the pin category.
DWORD cbReturned;
hr = pKs->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY, NULL, 0,
pPinCategory, sizeof(GUID), &cbReturned);
// If this succeeded, pPinCategory now contains the category GUID.
pKs->Release();
return hr;
}
BOOL CReadWriteASIC::WriteToRegister( ULONG id , PLONG pValue , ULONG index, ULONG valueSize, ULONG common )
{
IKsPropertySet* lpKsPropertySet;
KSPROPERTY_CLIENT_PROP_S KsProperty;
HRESULT hr;
//vivi 2005/5/9 source code protection
if(m_pSrcFilter == NULL) return FALSE;
hr = m_pSrcFilter->QueryInterface(IID_IKsPropertySet,(LPVOID*)&lpKsPropertySet);
if (hr != NOERROR) return hr;
ZeroMemory(&KsProperty,sizeof(KSPROPERTY_CLIENT_PROP_S));
KsProperty.Property.Flags = KSPROPERTY_TYPE_SET;
KsProperty.index = index;
KsProperty.value = *pValue;
KsProperty.valueSize = valueSize;
KsProperty.common = common;
// james 2007/01/03
hr = lpKsPropertySet->Set(PROPSETID_CLIENT_PROP_UVC_LIKE,id,&KsProperty,
sizeof(KSPROPERTY_CLIENT_PROP_S),&KsProperty,
sizeof(KSPROPERTY_CLIENT_PROP_S));
TRACE("hr = %x", hr);
if(hr!=NOERROR)
{
hr = lpKsPropertySet->Set(PROPSETID_CLIENT_PROP_ST50201,id,&KsProperty,
sizeof(KSPROPERTY_CLIENT_PROP_S),&KsProperty,
sizeof(KSPROPERTY_CLIENT_PROP_S));
TRACE("hr = %x", hr);
}
lpKsPropertySet->Release();
return hr;
}
HRESULT SetVboxFrequency( JNIEnv *env, DShowCaptureInfo* pCapInfo, ULONG ulFrequency )
{
HRESULT hr;
DWORD dwSupported=0;
IEnumPins* pEnumPin;
IPin* pInputPin;
ULONG ulFetched;
PIN_INFO infoPin;
if ( pCapInfo->pBDATuner == NULL )
return E_FAIL;
if( ulFrequency == 0 )
{
slog( (env,"VOX tuner skips frequency 0\r\n") );
return S_OK;
}
IBaseFilter* pTunerDevice = pCapInfo->pBDATuner;
pTunerDevice->EnumPins(&pEnumPin);
if( SUCCEEDED( hr = pEnumPin->Reset() ) )
{
while((hr = pEnumPin->Next( 1, &pInputPin, &ulFetched )) == S_OK)
{
pInputPin->QueryPinInfo(&infoPin);
// Release AddRef'd filter, we don't need it
if( infoPin.pFilter != NULL )
infoPin.pFilter->Release();
if(infoPin.dir == PINDIR_INPUT)
break;
}
if(hr != S_OK)
{
slog( (env,"Vbox tuner input pin query failed \r\n") );
return hr;
}
}
else
{
slog( (env,"Vbox tuner reset failed \r\n") );
return E_FAIL;
}
IKsPropertySet *pKsPropertySet;
pInputPin->QueryInterface(&pKsPropertySet);
if (!pKsPropertySet)
{
slog( (env,"Vbox tuner input pin's QueryInterface failed \r\n") );
return E_FAIL;
}
KSPROPERTY_TUNER_MODE_CAPS_S ModeCaps;
KSPROPERTY_TUNER_FREQUENCY_S Frequency;
memset(&ModeCaps,0,sizeof(KSPROPERTY_TUNER_MODE_CAPS_S));
memset(&Frequency,0,sizeof(KSPROPERTY_TUNER_FREQUENCY_S));
ModeCaps.Mode = AMTUNER_MODE_TV;
// Check either the Property is supported or not by the Tuner drivers
hr = pKsPropertySet->QuerySupported(PROPSETID_TUNER,
KSPROPERTY_TUNER_MODE_CAPS,&dwSupported);
if(SUCCEEDED(hr) && dwSupported&KSPROPERTY_SUPPORT_GET)
{
DWORD cbBytes=0;
hr = pKsPropertySet->Get(PROPSETID_TUNER,KSPROPERTY_TUNER_MODE_CAPS,
INSTANCEDATA_OF_PROPERTY_PTR(&ModeCaps),
INSTANCEDATA_OF_PROPERTY_SIZE(ModeCaps),
&ModeCaps,
sizeof(ModeCaps),
&cbBytes);
}
else
{
SAFE_RELEASE(pKsPropertySet);
slog( (env,"Vbox tuner input pin's not support GET query \r\n") );
return E_FAIL;
}
Frequency.Frequency=ulFrequency; // in Hz
if(ModeCaps.Strategy==KS_TUNER_STRATEGY_DRIVER_TUNES)
Frequency.TuningFlags=KS_TUNER_TUNING_FINE;
else
Frequency.TuningFlags=KS_TUNER_TUNING_EXACT;
// Here the real magic starts
//if(ulFrequency>=ModeCaps.MinFrequency && ulFrequency<=ModeCaps.MaxFrequency)
{
hr = pKsPropertySet->Set(PROPSETID_TUNER,
KSPROPERTY_TUNER_FREQUENCY,
INSTANCEDATA_OF_PROPERTY_PTR(&Frequency),
INSTANCEDATA_OF_PROPERTY_SIZE(Frequency),
&Frequency,
sizeof(Frequency));
if(FAILED(hr))
{
slog( (env,"Vbox tuner input pin's set frequency %d failed hr=0x%x\r\n", Frequency.Frequency, hr ) );
SAFE_RELEASE(pKsPropertySet);
return E_FAIL;
}
}
// else
// {
//slog( (env,"Vbox tuning frequency %d is out of range (%d %d)\r\n",
// ulFrequency, ModeCaps.MinFrequency, ModeCaps.MaxFrequency ) );
// return E_FAIL;
// }
SAFE_RELEASE(pKsPropertySet);
slog( (env,"Vbox tuner tuning overider frequency %d successful. \r\n", ulFrequency) );
return S_OK;
}
QVector<VideoMode> DirectShow::getDeviceModes(QString devName)
{
QVector<VideoMode> modes;
IBaseFilter* devFilter = getDevFilter(devName);
if (!devFilter)
return modes;
// The outter loop tries to find a valid output pin
GUID category;
DWORD r2;
IEnumPins *pins = nullptr;
IPin *pin;
if (devFilter->EnumPins(&pins) != S_OK)
return modes;
while (pins->Next(1, &pin, nullptr) == S_OK)
{
IKsPropertySet *p = nullptr;
PIN_INFO info;
pin->QueryPinInfo(&info);
info.pFilter->Release();
if (info.dir != PINDIR_OUTPUT)
goto next;
if (pin->QueryInterface(IID_IKsPropertySet, (void**)&p) != S_OK)
goto next;
if (p->Get(AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,
nullptr, 0, &category, sizeof(GUID), &r2) != S_OK)
goto next;
if (!IsEqualGUID(category, PIN_CATEGORY_CAPTURE))
goto next;
// Now we can list the video modes for the current pin
// Prepare for another wall of spaghetti DIRECT SHOW QUALITY code
{
IAMStreamConfig *config = nullptr;
VIDEO_STREAM_CONFIG_CAPS *vcaps = nullptr;
int size, n;
if (pin->QueryInterface(IID_IAMStreamConfig, (void**)&config) != S_OK)
goto next;
if (config->GetNumberOfCapabilities(&n, &size) != S_OK)
goto pinend;
assert(size == sizeof(VIDEO_STREAM_CONFIG_CAPS));
vcaps = new VIDEO_STREAM_CONFIG_CAPS;
for (int i=0; i<n; ++i)
{
AM_MEDIA_TYPE* type = nullptr;
if (config->GetStreamCaps(i, &type, (BYTE*)vcaps) != S_OK)
goto nextformat;
if (!IsEqualGUID(type->formattype, FORMAT_VideoInfo)
&& !IsEqualGUID(type->formattype, FORMAT_VideoInfo2))
goto nextformat;
VideoMode mode;
mode.width = vcaps->MaxOutputSize.cx;
mode.height = vcaps->MaxOutputSize.cy;
mode.FPS = 1e7 / vcaps->MinFrameInterval;
if (!modes.contains(mode))
modes.append(std::move(mode));
nextformat:
if (type->pbFormat)
CoTaskMemFree(type->pbFormat);
CoTaskMemFree(type);
}
pinend:
config->Release();
delete vcaps;
}
next:
if (p)
p->Release();
pin->Release();
}
return modes;
}
static GstCaps *
gst_dshowaudiosrc_get_caps (GstBaseSrc * basesrc)
{
HRESULT hres = S_OK;
IBindCtx *lpbc = NULL;
IMoniker *audiom = NULL;
DWORD dwEaten;
GstDshowAudioSrc *src = GST_DSHOWAUDIOSRC (basesrc);
gunichar2 *unidevice = NULL;
if (src->device) {
g_free (src->device);
src->device = NULL;
}
src->device =
gst_dshow_getdevice_from_devicename (&CLSID_AudioInputDeviceCategory,
&src->device_name);
if (!src->device) {
GST_ERROR ("No audio device found.");
return NULL;
}
unidevice =
g_utf8_to_utf16 (src->device, strlen (src->device), NULL, NULL, NULL);
if (!src->audio_cap_filter) {
hres = CreateBindCtx (0, &lpbc);
if (SUCCEEDED (hres)) {
hres =
MkParseDisplayName (lpbc, (LPCOLESTR) unidevice, &dwEaten, &audiom);
if (SUCCEEDED (hres)) {
hres = audiom->BindToObject (lpbc, NULL, IID_IBaseFilter,
(LPVOID *) & src->audio_cap_filter);
audiom->Release ();
}
lpbc->Release ();
}
}
if (src->audio_cap_filter && !src->caps) {
/* get the capture pins supported types */
IPin *capture_pin = NULL;
IEnumPins *enumpins = NULL;
HRESULT hres;
hres = src->audio_cap_filter->EnumPins (&enumpins);
if (SUCCEEDED (hres)) {
while (enumpins->Next (1, &capture_pin, NULL) == S_OK) {
IKsPropertySet *pKs = NULL;
hres =
capture_pin->QueryInterface (IID_IKsPropertySet, (LPVOID *) & pKs);
if (SUCCEEDED (hres) && pKs) {
DWORD cbReturned;
GUID pin_category;
RPC_STATUS rpcstatus;
hres =
pKs->Get (AMPROPSETID_Pin,
AMPROPERTY_PIN_CATEGORY, NULL, 0, &pin_category, sizeof (GUID),
&cbReturned);
/* we only want capture pins */
if (UuidCompare (&pin_category, (UUID *) & PIN_CATEGORY_CAPTURE,
&rpcstatus) == 0) {
IAMStreamConfig *streamcaps = NULL;
if (SUCCEEDED (capture_pin->QueryInterface (IID_IAMStreamConfig,
(LPVOID *) & streamcaps))) {
src->caps =
gst_dshowaudiosrc_getcaps_from_streamcaps (src, capture_pin,
streamcaps);
streamcaps->Release ();
}
}
pKs->Release ();
}
capture_pin->Release ();
}
enumpins->Release ();
}
}
if (unidevice) {
g_free (unidevice);
}
if (src->caps) {
return gst_caps_ref (src->caps);
}
return NULL;
}
static GstCaps *
gst_dshowvideosrc_get_caps (GstBaseSrc * basesrc, GstCaps *filter)
{
HRESULT hres = S_OK;
IBindCtx *lpbc = NULL;
IMoniker *videom;
DWORD dwEaten;
GstDshowVideoSrc *src = GST_DSHOWVIDEOSRC (basesrc);
gunichar2 *unidevice = NULL;
if (src->caps) {
return gst_caps_ref (src->caps);
}
if (!src->device) {
src->device =
gst_dshow_getdevice_from_devicename (&CLSID_VideoInputDeviceCategory,
&src->device_name);
if (!src->device) {
GST_ERROR ("No video device found.");
return NULL;
}
}
unidevice =
g_utf8_to_utf16 (src->device, strlen (src->device), NULL, NULL, NULL);
if (!src->video_cap_filter) {
hres = CreateBindCtx (0, &lpbc);
if (SUCCEEDED (hres)) {
hres =
MkParseDisplayName (lpbc, (LPCOLESTR) unidevice, &dwEaten, &videom);
if (SUCCEEDED (hres)) {
hres = videom->BindToObject (lpbc, NULL, IID_IBaseFilter,
(LPVOID *) & src->video_cap_filter);
videom->Release ();
}
lpbc->Release ();
}
}
if (!src->caps) {
src->caps = gst_caps_new_empty ();
}
if (src->video_cap_filter && gst_caps_is_empty (src->caps)) {
/* get the capture pins supported types */
IPin *capture_pin = NULL;
IEnumPins *enumpins = NULL;
HRESULT hres;
hres = src->video_cap_filter->EnumPins (&enumpins);
if (SUCCEEDED (hres)) {
while (enumpins->Next (1, &capture_pin, NULL) == S_OK) {
IKsPropertySet *pKs = NULL;
hres =
capture_pin->QueryInterface (IID_IKsPropertySet, (LPVOID *) & pKs);
if (SUCCEEDED (hres) && pKs) {
DWORD cbReturned;
GUID pin_category;
RPC_STATUS rpcstatus;
hres =
pKs->Get (AMPROPSETID_Pin,
AMPROPERTY_PIN_CATEGORY, NULL, 0, &pin_category, sizeof (GUID),
&cbReturned);
/* we only want capture pins */
if (UuidCompare (&pin_category, (UUID *) & PIN_CATEGORY_CAPTURE,
&rpcstatus) == 0) {
{
GstCaps *caps =
gst_dshowvideosrc_getcaps_from_streamcaps (src, capture_pin);
if (caps) {
gst_caps_append (src->caps, caps);
} else {
caps = gst_dshowvideosrc_getcaps_from_enum_mediatypes (src, capture_pin);
if (caps)
gst_caps_append (src->caps, caps);
}
}
}
pKs->Release ();
}
capture_pin->Release ();
}
enumpins->Release ();
}
}
if (unidevice) {
g_free (unidevice);
}
if (src->caps) {
if (filter) {
return gst_caps_intersect_full (filter, src->caps,
GST_CAPS_INTERSECT_FIRST);
} else {
return gst_caps_ref (src->caps);
}
}
return NULL;
}
