Friday, 24. April 2009, 07:59 Uhr

Windows Media ASF Stream Source DirectShow Filter

We made a trial version of our MontiVision ASF Stream Source DirectShow Filter available for download, so you can try out Windows Media File and Web Stream Playback and Play-Out, as described in these posts:

Capture Video from an ASF Stream as if it was a Video Device
Window Media ASF live Stream Play-Out to SDI

Please contact us if you need assistance or extended trial periods.

Download: MontiVision ASF Stream Source DirectShow Filter

Wednesday, 22. April 2009, 15:08 Uhr

DirectShow Filter for High Performance/High Quality Video De-Interlacing

We finished two new DirectShow Filters for Video De-Interlacing and De-Noising. These filters offer a range of algorithms for high performance or high quality video deinterlacing and denoising, depending on the usage scenario (e.g. live video processing versus video transcoding).

We put the filters online, so you can download them for testing. Please make sure to register DirectShow Filters using RegSvr32.exe as administrator. Since this sometimes causes trouble on Vista, this is the safe way: Right click the command line in the start menu and choose “Run As Administrator”, change directory to where the filters are located and run RegSvr32 “.\FilterName.ax”.

MontiVision Video Deinterlacer and Denoiser

Tuesday, 14. April 2009, 09:00 Uhr

Professional SD and HD Video Playout SDK

We made a trial version of the MontiVision Playout SDK for SD and HD Video available for Download. The SDK is a collection of DirectShow Filters for Playlist Playback, Image, Text and Video Real-Time Overlay, Audio Mixing and Video Scaling.

The central component is the MontiVision Playlist Source Ex DirectShow Filter, which is capable of seamless SD and HD Video playback, supporting the following audio and video formats: Mpeg-1/Mpeg-2 video and audio (MPEG PS or TS), Mpeg-4/h.264/Mpeg or AAC audio (mp4 or MPEG TS), DV, MJpeg (AVI).

There are two types of play lists, dynamic and static. Static play lists can be saved to a MontiVision play list file and can be looped. Dynamic play lists can play virtually endlessly, while new video files are constantly added at runtime and played files are released and removed from the play list.

Play lists not only support video files but static images as well as live video sources!

For Play-Out to SDI, the SDK was tested using the following devices: Blackmagic Design Decklink SD and HD, AJA Xena and Bluefish444 Single Link Pro.

The trial download includes a small Readme.txt file, which you should read before you install and try the package. The package does not include development files (IDL and .h), which we send out on request.

Finally, here’s the download: MontiVision Video Playout SDK

Wednesday, 08. April 2009, 10:15 Uhr

MontiVision DirectShow SDK ready for use in Microsoft WPF

We have finished the first version of our MontiVision WPF Controls, which allow the use of the proven MontiVision Controls in Windows Presentation Foundation Applications. The following sample application demonstrates how the new WPF Controls can be used to control DirectShow Filter Graphs (or MontiVision Filter Configurations – MVP), how to access Video Devices from within WPF and how to access MontiVison DirectShow filters.



Here you can download the whole project: MontiVision_WPF_Rotation_Demo.zip

Please extract the ZIP file to a new folder and run Install.reg in order to register controls and DirectShow Filters on your system. On Windows Vista, please make sure to run the installation batch file from a command line, which was opened with Administrator rights. You can directly run the MVWpfRotationDemo.exe application or open the sample project in Visual Studio 2008.

Contact us for updates and further information!

Friday, 03. April 2009, 16:47 Uhr

Broad Hardware Support for the MontiVision DirectShow SDK

People keep asking which hardware is supported by our DirectShow SDK, the MontiVision Development Kit. We frequently tell them that all devices providing WDM Streaming Drivers (WDM Stream Class Drivers) are supported. Also, a lot of hardware vendors provide custom DirectShow Filters for their devices, based on their vendor specific SDKs and developer APIs. I agree that this answer is not really satisfying. So finally, here is the list, including Video Capture Cards (Frame Grabbers), USB Cameras, FireWire Cameras, Gigabit Ethernet Cameras, Video Converters …

MontiVision Development Kit Hardware Support

Thursday, 05. March 2009, 16:14 Uhr

Catching MV Filter Events in a "No Smart Control" C++ Application (addition)

I uploaded the C++ files to our webserver:
FilterEventHandler

Thursday, 05. March 2009, 15:52 Uhr

Catching MV Filter Events in a "No Smart Control" C++ Application

Using MontiVision Filter Events is pretty simple when you utilize the MontiVision Smart ActiveX Control.

Sometimes customers don't want to use our Smart Control and build their graph "manually" using the DirectShow API in a C++ Application. In that case, COM Events handling becomes a bit more complicated.

Here is an example of a class, which handles the Event registration for you.


FilterEventHandler.h:

// Include MV.h for the COM event callback
#include


// Our Custom Window Message, sent to this class parent for notification
const UINT WM_FILTER_EVENT = WM_APP + 100;


class CFilterEventHandler : public CComObjectRoot
, public IMVFilterEvents
{
public:
CFilterEventHandler(void);
virtual ~CFilterEventHandler(void);

void FinalRelease()
{
}
// This helps us with the ConnectionPoint implementation
BEGIN_COM_MAP(CFilterEventHandler)
COM_INTERFACE_ENTRY(IMVFilterEvents)
END_COM_MAP()

// MontiVision IMVFilterEvents implementation
// This method is called when a filter fires and event
STDMETHOD(MVFilterMessage)(int iMessage );

void SetParent(CParentClass* pParent)
{
m_pParent = pParent;
}

HRESULT SetFilter(IUnknown* pUnknown);
void Reset();

protected:
// Our parent, which we send a Window Message when an event is called
CParentClass* m_pParent;

// A cookie identifying the MontiVision DirectShow filter
DWORD m_dwCookie;

// Our Connection Point
CComPtr m_pConnectionPoint;

// Critical Section for multithreading use
CCritSec m_csLock;
};


FilterEventHandler.cpp:

#include "FilterEventHandler.h"


CFilterEventHandler::CFilterEventHandler(void)
: m_dwCookie(0L)
, m_pParent(0L)
, m_pConnectionPoint(NULL)
{
}

CFilterEventHandler::~CFilterEventHandler(void)
{
CAutoLock Lock(&m_csLock);

// Unadvise the MontiVision DirectShow Filter
if(m_pConnectionPoint != 0L)
{
m_pConnectionPoint->Unadvise(m_dwCookie);
m_pConnectionPoint.Release();
m_pConnectionPoint = NULL;
}
m_dwCookie = 0;
}

void CFilterEventHandler::Reset()
{
CAutoLock Lock(&m_csLock);

// Unadvise the MontiVision DirectShow Filter
if(m_pConnectionPoint != 0L)
{
m_pConnectionPoint->Unadvise(m_dwCookie);
m_pConnectionPoint.Release();
m_pConnectionPoint = NULL;
}

m_dwCookie = 0;
}

STDMETHODIMP CFilterEventHandler::MVFilterMessage(int iMessage)
{
CAutoLock Lock(&m_csLock);

if(m_pParent != 0L)
{
// Send a notification message to our parent
m_pParent->SendMessage(WM_FILTER_EVENT, (WPARAM)this, (LPARAM)iMessage);
}

return S_OK;
}

HRESULT CFilterEventHandler::SetFilter(IUnknown* pUnknown)
{
CAutoLock Lock(&m_csLock);

HRESULT hr = E_INVALIDARG;

if(pUnk != 0L)
{
if(m_pConnectionPoint != 0L)
{
m_pConnectionPoint->Unadvise(m_dwCookie);
m_pConnectionPoint.Release();
m_pConnectionPoint = NULL;
}

m_dwCookie = 0;

CComPtr pConnectionPointContainer;

hr = pUnk->QueryInterface(IID_IConnectionPointContainer, (void**)&pConnectionPointContainer);
if(pConnectionPointContainer != 0L)
{
hr = pConnectionPointContainer->FindConnectionPoint(IID_IMVFilterEvents, &m_pConnectionPoint);
if(m_pConnectionPoint != 0L)
{
CComPtr pUnkHandler;

hr = QueryInterface(IID_IUnknown, (void**)&pUnkHandler);
if(pUnkHandler != 0L)
{
// Advise our MontiVision DirectShow Filter and get a Cookie for this connection
hr = m_pConnectionPoint->Advise(pUnkHandler, &m_dwCookie);
}
}
}
}

return hr;
}


We hope this helps!

Tuesday, 15. April 2008, 09:00 Uhr

Switching between Live Sources at Runtime

We have finished a new DirectShow Filter, which allows to switch between live sources while the graph is running. This was possible before when using a capture card with multiple inputs, in case it provides a DirectShow crossbar filter.

Switching between webcams or IP camera sources is not that simple. Therefore we developed MV Crossbar. MV Crossbar makes it possible to seamlessly switch between running live sources of similar video fromat.

The following DirectShow filter graph captures MJPEG video streams from four IP Cameras and allows to switch between them. The IP Cameras MJPEG streams are accessed through our MV IP Camera Source DirectShow Filter.



MV Crossbar is the key component in this setup. Of course it can be configured to standard COM interfaces, in this case through our new generic filter parameter interface, which allows to configure DirectShow filter properties through the properties name.



This example does two things. It displays the currently selected input video stream and it stores one frame to an AVI video file every second second. The MV Multi File Writer DirectShow Filter is used for the recording.

Friday, 28. September 2007, 11:23 Uhr

Setting the Resolution of a Video Capture Source in Code

The following VB.NET Pseudo-Code describes the way to set a certain video resolution when working with video capture hardware:


'The required Smart Control COM Interfaces
Dim Graph as MVSmartControl.IMVSCFilterGraph
Dim Format as MVSmartControl.IMVSCSetupVideoStream

Graph = YourSmartControl.GetOcx()
Format = YourSmartControl.GetOcx()

'Load the filter configuration
Graph.LoadConfig(„MyConfig.mvp“)

Dim lFormatIndex as Long
Dim lSizeIndex as Long
Dim lSizeCount as Long
Dim lWantedSizeIndex as Long

‘Get Current Video Format Index, Size Index and the number of
‘available Sizes for the current video format (e.g. RGB24)
‘Internally the Smart Control has a list of formats for every
‘video source looking like this example:
‘ RGB24 640 x 480 PAL
‘ RGB24 800 x 600 PAL
‘ …
‘ UYVY 720 x 576 PAL
‘ …
Format.GetCurrentVideoFormat(„VideoSource“, lFormatIndex, lSizeIndex)
Format.GetVideoSizeInfoCount(“VideoSource”, lSizeCount)

‘Now we are looking for the desired size, e.g. 1024x768
‘and remember the size index in case we find our resolution
For i = 0 to lSizeCount
Dim xRes as Long
Dim yRes as Long
Dim VideoStandard as Long

Format.GetVideoSizeInfo(“VideoSource”, lFormatindex, i, xRes, yRes, VideoStandard)
If xRes == 1024 and yRes == 768 then
lWantedSizeIndex = i
End If
Next

‘Set the new format
Format.SetVideoFormat(“VideoSource”, lFormatIndex, lWantedSizeIndex)

‘Start the graph
Graph.Start()


In the same way you can change the video format (RGB24, UYVY, YV12, etc) and the VideoStandard (PAL, NTSC, etc).

Monday, 03. April 2006, 12:00 Uhr

The Use of Filter Events for Synchronization and Graph Control

How do i know when a Video Frame was processed by a certain MontiVision MontiVision DirectShow Filter?
How do i know when MV Image Grabber finished writing a Captured Image to file.
When is the right time to ask MV Motion Detection whether it detected Motion in the current Video Frame?

Answer: Filters Events!

MontiVision DirectShow Filters fire Events in order to enable developers to synchronize the graph control. Please have a look at the Documentation to find out which Events a Filter supports.

Filter Events need to be enabled for a certain through the Smart Controls IMVSCFilterEvents COM interface. The following piece of C# Code enables Filter Events for MV Blob Counter after the configuration (MVP) was loaded by the Smart Control:

MVSmartControl.IMVSCFilterEvents FilterEvents;
int Cookie = 0;

try
{
    FilterEvents = (MVSmartControl.IMVSCFilterEvents)axMVSmartControl.GetOcx();
    Cookie = FilterEvents.Enable( "MV Blob Counter");
}
catch(Exception e)
{
    // Handle Exception ...
}

The returned Cookie is used to identify the MV Blob Counter in the Filter Events Handler.

In order to add the event handler for the Smart Control in C#, open the form containing the appropriate Smart ActiveX Control and select 'Events' in the ActiveX Properties (Menu -> View -> Properties Window). Double click 'FilterEvent' to add an Event Handler:


In the Event Handler, make sure to check the cookie to be sure the Event was called for the MV Blob Counter. In the following example the MV_ALGORITHM_END_EVENT is used to get the results of the blob detection performed by MV Blob Counter:

private void axMVSmartControl_FilterEvent(object sender, AxMVSmartControl._IMVSmartControlEvents_FilterEventEvent e)
{
    if( e.cookie == Cookie ) // MV Blob Counter
    {
        switch(e.eventCode)
        {
        case MV_ALGORITHM_END_EVENT:
            // Algorithm finished, get results from MV Blob Counter
            GetBlobCounterResults();
            break;
        }
    }
}

Please have a look at the MontiVision Smart Control Sample Applications for details in your preferred programming language.

« 1 2 3 4 »

Admin-Login