Recent IP Video Source class/module is not limited to use via registration as a video input/capture/source device. The filter is also registered as a regular filter and can be used programmatically in a regular way: CoCreateInstance, AddFilter etc.

A C++ code snippet below shows how to import interface definition, create an instance of the filter, set it up and start video from a camera:

#include <dshow.h>
#pragma comment(lib, "strmiids.lib")

#import "libid:BDCE8B49-8895-4605-8278-E9A1FBC889AC" no_namespace raw_interfaces_only raw_dispinterfaces named_guids // IpVideoSource

// [...]

inline VOID ATLENSURE_INLINE_SUCCEEDED(HRESULT nResult)
{
    ATLENSURE_SUCCEEDED(nResult);
}

// [...]

CComPtr<IBaseFilter> pBaseFilter;
ATLENSURE_INLINE_SUCCEEDED(pBaseFilter.CoCreateInstance(CLSID_JpegVideoSourceFilter));
CComQIPtr<IJpegVideoSourceFilter> pJpegVideoSourceFilter = pBaseFilter;
ATLENSURE_THROW(pJpegVideoSourceFilter, E_NOINTERFACE);
ATLENSURE_INLINE_SUCCEEDED(pFilterGraph->AddFilter(pBaseFilter, L"Source"));

ATLENSURE_INLINE_SUCCEEDED(pJpegVideoSourceFilter->put_Location(CComBSTR(_T("http://p.viewnetcam.com:60001/nphMotionJpeg?Resolution=640x480&Quality=Standard"))));
ATLENSURE_INLINE_SUCCEEDED(pJpegVideoSourceFilter->put_Width(640));
ATLENSURE_INLINE_SUCCEEDED(pJpegVideoSourceFilter->put_Height(480));

#pragma region Render Output Pin
CComPtr<IEnumPins> pEnumPins;
ATLENSURE_INLINE_SUCCEEDED(pBaseFilter->EnumPins(&pEnumPins));
CComPtr<IPin> pPin;
ATLENSURE_THROW(pEnumPins->Next(1, &pPin, NULL) == S_OK, E_FAIL);
ATLASSERT(pPin);
ATLENSURE_INLINE_SUCCEEDED(pFilterGraph->Render(pPin));
#pragma endregion

This starts M-JPEG video from Panasonic BB-HCM381A camera available to public online at http://p.viewnetcam.com:60001/nphMotionJpeg?Resolution=640×480&Quality=Standard

UPDATE: ATLENSURE_SUCCEEDED macro in the snippet replaced with ATLENSURE_INLINE_SUCCEEDED – see additional post on this.

C#.NET code snippet will look like this (using DirectShowLib):

using DirectShowLib;
using AlaxInfoIpVideoSource;

// [...]

FilterGraph filterGraph = new FilterGraph();
IJpegVideoSourceFilter sourceFilter = Activator.CreateInstance(Type.GetTypeFromCLSID(new Guid("{A8DA2ECB-DEF6-414D-8CE2-E651640DBA4F}"))) as IJpegVideoSourceFilter;
IBaseFilter sourceBaseFilter = sourceFilter as IBaseFilter;
(filterGraph as IFilterGraph2).AddFilter(sourceBaseFilter, "Source");
sourceFilter.Location = @"http://p.viewnetcam.com:60001/nphMotionJpeg?Resolution=640x480&Quality=Standard";
sourceFilter.Width = 640;
sourceFilter.Height = 480;
IPin pin = DsFindPin.ByDirection(sourceBaseFilter, PinDirection.Output, 0);
(filterGraph as IFilterGraph2).Render(pin);
(filterGraph as IMediaControl).Run();
EventCode eventCode;
(filterGraph as IMediaEvent).WaitForCompletion(-1, out eventCode);

This does not update the software with new features, but there are a few simple things worth mentioning explicitly.

The first is that virtual DirectShow camera device can be set up with both M-JPEG and JPEG URLs. That is, IP cameras which do not implement M-JPEG, or implement it in a buggy way (there is a *huge* deal of such out there) can still be set up to send video as individual video frames/images as long as they implement JPEG snapshots. This is taking place often at a lower frame rate, but still works.

The driver will automatically detect type of URL (by response from the device) and will choose best access method for the given URL.

Second is that if you are looking for IP Video Source software version, such as to check against available updates, it is here on the UI (right click the caption):

The IP Video Source update provides several improvements to the driver:

• copy/paste feature to backup, restore, or synchronize installed devices between 32-bit and 64-bit versions
• 64-bit version and .MSI
• dynamic video resizing (via Video Resizer DSP)
• Adobe FMLE compatibility

Updates in greater detail follow.

Device Copy/Paste Feature

The video device management window is providing Copy and Paste buttons, which let user transfer device information, including name and settings, through clipboard for various purposes:

• save data in order to be able to restore devices later
• restore devices from saved list, or re-create from a list saved on another machine
• duplicate a device
• synchronize devices between 32-bit and 64-bit versions

The device data is a text, one line per device, lines in comma-separated values (CSV) format.

64-Bit Version

Software is available in both 32-bit and 64-bit versions. While most of multimedia software is still 32-bit, sometimes 64-bit version is really helpful to, for example:

• interface to “Any CPU” .NET code which executes in 64-bit on a 64-bit operating system
• go beyond 32-bit code boundaries, especially in part of multiple devices and virtual address space limit

64-bit version duplicates functionality available in 32-bit version, though 32- and 64-bit modules run in completely separated environments.

Dynamic Video Resizing

The source DirectShow filter is capable of connecting with media types different from original/camera media type in resolution part for decompressed video. The filter is internally taking advantage of Video Resizer DSP, and resizes decompressed video to format of interest.

As Video Resizer DSP is available starting with Windows Vista, the functionality availability is subject to the same conditions.

The feature is absolutely required for Adobe Flash Media Live Encoder software, as it make certain assumptions as for supported resolutions, and completely ignores the information the filter makes available in standard way.

Adobe Flash Media Live Encoder Friendliness

The update make the device much closer to interoperation with Adobe product. The software works around a handful of bugs, including as ridiculous as neglecting to provide correct BI_RGB value in BITMAPINFOHEADER::biCompression structure, yet researchers are still to resolve the remained ones.

FMLE would start perfect and stream video being run under debugger, otherwise in a regular run chances are that Adobe application would internally respond with E_UNEXPECTED failure for unknown reason, stop any encoding without giving a single little notice on the GUI.

After all, the encoding runs perfectly through web based encoder, and the driver is providing a good way to stream to video distribution sites such as http://ustream.tv, http://livestream.com from an IP camera or video encoder.

Download Information

• Download (32-bit): AlaxInfoIpVideoSourceSetup.msi
• Download (64-bit): AlaxInfoIpVideoSourceSetup-x64.msi
• License: This software is free to use

This implements a DirectShow driver/wrapper over a HTTP based JPEG/M-JPEG streamed video, widely available with IP cameras. Once installed, it provides a Start Menu shortcut to manage video capture devices, where a user can add/remove devices. The devices are automatically registered with DriectShow and are available to applications.

The compatibility list includes:

• Windows SDK AmCap Sample (reference)
• VideoLan VLC
• Skype (see below)
• Google Talk Video Chat
• Luxriot (as rather an example as Luxriot has its own generic JPEG/M-JPEG device driver, however this still demonstrates compatibility and interoperability of applications)
• GraphEdit, GraphStudio and similar tools

For a created device it is required to configure:

1. JPEG or M-JPEG resource URL on the device, where the driver will access video feed or sequential snapshots
2. Image/video size on the device

Resource URLs vary from device to device and there is no standard identifier. This has to be looked up for specific model in device API reference or SDK. For JPEG snapshots it is possible to copy image shortcut from web browser and paste address into device settings.

Note that some devices, especially low end IP cameras deliver non-compliant feed which can be decoded either by manufacturer’s ActiveX control or model-specific implementation which this driver does not convert and is unlikely to ever cover. The driver will only work with hardware which honors industry standards.

For example, Stardot NetCam SC cameras make the video feed accessible using /nph-mjpeg.cgi resource, so the full URL will consist of protocol prefix “http://”, optional username and password (see screenshot above), IP address or host name e.g. “demo2.stardotcams.com”, resource identifier on the device “/nph-mjpeg.cgi”.

Hence, http://demo2.stardotcams.com/nph-mjpeg.cgi

It is necessary to provide video size of the footage in advance so that the driver could negotiate content media types without accessing the device. Future versions of the driver might implement auto-detection.

Skype Compatibility

To make the device work with Skype, it is necessary to:

1. Configure the device (using its web interface) to work at resolution 640×480
2. Add/configure device with Alax.Info IP video Source as described above, including setting of 640 by 480 pixel resolution in device configuration

Internals

Software implements and registers video input/capture devices, listed under DirectShow CLSID_VideoInputDeviceCategory category. The applications access devices from the list and treat as a regular device such as web camera.

Windows SDK AmCap sample will create the following DirectShow graph where the source filter implemented by this software:

Internally, software creates a worker filter graph in order to stream data from the device:

To decode video, software uses stock MJPEG Decompressor Filter provided with operating system.

Download Information

• Download (32-bit): AlaxInfoIpVideoSourceSetup.msi
• Download (64-bit): To Be Done/On Request
• License: This software is free to use

Media Tools DirectShow Filters can be used to acquire, parse and decoder M-JPEG encoded video stream from an IP camera or a video server, however for a quick start it is necessary to properly register filters on system and create a DirectShow graph.

To register the filters, it is necessary to download DLLs from repository. While Acquisition.dll does not require special prerequisites installed, CodingI.dll is using Intel Integrated Performance Primitives (IPP) version 6.0.0 internally and requires its [at least] redistributables installed before DLLs are being registered using regsvr32.

Intel went further with new releases of IPP, which are incompatible with the version used to build CodingI.dll, so it is version 6.0.0 (in downloads on Intel website: version 6.0 build 0) has to be installed. Note that Intel DLLs from C:\Program Files\Intel\IPP\6.0.0.044\ia32\bin (version 6.0.0.062 is known to be also compatible) need to be on system search path, or copied to C:\Windows\system32 directory.

Once Intel IPP is prepared, it is required to register CodingI.dll using regsvr32. This registers filters and they are available in GraphEdit and for applications. It is important that on the way of constructing graph which renders video using standard video renderers it is required to specify correct resolution for video, or otherwise graph might fail to start with a message “The graph could not change state”, caused by video renderer failure to dynamically change to different (effective) resolution.

To create rendering graph, add Alax.Info HTTP Stream Source Filter from the filter list and provide camera URL in properties, e.g. http://cam15001.miemasu.net/nphMotionJPEG?Kind=1

Add more filters and provide proper resolution for video:

Complete graph construction with resolution set up:

Being run, the graph shows video:

Dynamic handling of resolution selection, configuration and change is also illustrated in sample application RenderHttpMjpegVideo01.

NOTE: The constructed graph .GRF file is available for download.

In order to better troubleshoot network cameras and other devices, I added a new DirectShow filter to write HTTP response headers and body into a single file, one file (actually a pairs of files, the second file contains UTF-8 formatted HTTP response headers) per HTTP response.

While troubleshootting JPEG artefact issue with I used the following graph:

which started M-JPEG streaming from a camera and had entire stream written into Response-01586228-0001-0001-Headers.txt (Headers) and Response-01586228-0001-0001.dat (Data) files, while parsed JPEG frames were also written into individual files and were available for comparison.

Other changes include:

• new HTTP Stream File Renderer Filter (details are below)
• attachable media types on internally used memory allocators, which enable filters to effectively reagree media types in running state
• workaround for Panasonic BL-C140 camera (may be also helpful for other models), details here

There also seems to be a bug in Intel IPP 6.0 JPEG decoder that leaves bottom right image block incorrectly decoded, only when a sequence of images is decoded and the frame is not the first in the sequence.

A partial Visual C++ .NET 2008 source code is available from SVN, release binary included.

File and Class Summary

Acqusition.dll

Acqusition.dll (download) hosts the following classes:

• DirectShow Filters
  • HTTP Stream File Renderer Filter, to write raw HTTP response headers and data into files

Class Overview

HTTP Stream File Renderer Filter

The filter renders input stream of one or more HTTP responses and write HTTP response headers and data into files, per HTTP response, into provided directory.

• Filter Executable: Acquisition.dll
• Filter CLSID: __uuidof(HttpStreamFileRendererFilter) {B02FDAEF-E851-4380-82D6-04772E33675D}
• Filter Property Page CLSID: __uuidof(HttpStreamFileRendererFilterDirectoryPropertyPage), {FAF31D20-842A-46b4-B6F8-E410FB0188A5}
• Filter Merit: MERIT_DO_NOT_USE
• Filter Category: CLSID_LegacyAmFilterCategory
• Filter Interfaces: IPersistStreamInit, IPersistStream, ISpecifyPropertyPages, IBaseFilter, IMediaFilter, IPersist, IAMovieSetup, IAMFilterMiscFlags, IHttpStreamFileRendererFilter, IDispatch, IFileSinkFilter2 (not available in graphedt.exe process), IFileSinkFilter (not available in graphedt.exe process)
• Filter Pins: single input pin (Input)
• Input Pin Media Types: MEDIATYPE_Stream/MEDIASUBTYPE_NULL
• Input Pin Interfaces: IPin, IMemInputPin

Remarks

None.

Provided that there already is a JPEG Multi File Source Filter that can act as a video source streaming video from local JPEG files, it looked to be useful to build a virtual camera on top of this filter. This is the main difference: an existing filter is generic and customizable: it requires to be provided a directory with the files, other settings may also apply. A virtual camera is the filter that has to work out of the box: a video enabled application, such as AMCap Sample, Media Player Classic, VideoLAN, Skype, Windows Media Encoder enumerates video capture sources, instantiate the one of the interest and it should already be ready to stream.

Implementation Details

The very first question is embedding of an existing filter into new filter. The two most common methods are:

• COM aggregation
• embedding a fully featured graph with a sink/renderer that intercepts media samples downstream and forwards to a higher level filter so that it streams them as a source filter

The COM aggregation methods is much easier in implementation but it is subject to a few constraints, the two most important of which are:

• embedded filter should support instantiation as an aggregated object
• it is the only underlying filter, not a chain of filters, which can produce required data

COM aggregation is quite fitting for the purpose, so the second embedding method is being left for another topic (with a certain luck to be appear very soon, a DirectShow video capture source filter for a real network/IP camera).

The next step is a check of sufficient implementation in an underlying filter. Obviously, a video source that pretends to be a live video capture source needs an endless stream of media samples, while original implementation streams JPEG files as media samples once only, we need an option to loop the streaming and automatically repeat the sequence.

Playback looping is added to the original JPEG Multi File Source Filter and its controlling private interface IJpegMultiFileSourceFilter received additional properties:

interface IJpegMultiFileSourceFilter : IDispatch
{
...
    [propget, id(2)] HRESULT AutoRepeat([out, retval] VARIANT_BOOL* pbAutoRepeat);
    [propput, id(2)] HRESULT AutoRepeat([in] VARIANT_BOOL bAutoRepeat);
    [propget, id(3)] HRESULT RepeatDelay([out, retval] LONG* pnRepeatDelay);
    [propput, id(3)] HRESULT RepeatDelay([in] LONG nRepeatDelay)

as well the new property page:

As soon as the underlying implementation is ready, it is the right time to get down to the immediate filter COM class. It will be require to implement certain interfaces, to expose certain interfaces of the aggregated object and possibly to hide certain interfaces of the aggregated object. However, the first thing to do is to instantiate aggregated object, for which the right place is ATLs’ FinalConstruct:

class ATL_NO_VTABLE CFilter :
...
{
...
DECLARE_PROTECT_FINAL_CONSTRUCT()

DECLARE_GET_CONTROLLING_UNKNOWN()
...
    CComPtr<IUnknown> m_pInnerUnknown;
    CComPtr<IBaseFilter> m_pInnerBaseFilter;
    CComPtr<IPersistStream> m_pInnerPersistStream;
...
    HRESULT FinalContruct()
    {
...
        __C(m_pInnerUnknown.CoCreateInstance(__uuidof(JpegMultiFileSourceFilter), GetControllingUnknown()));
        CComQIPtr<IJpegMultiFileSourceFilter> pJpegMultiFileSourceFilter = m_pInnerUnknown;
        __D(pJpegMultiFileSourceFilter, E_NOINTERFACE);
...
        __C(pJpegMultiFileSourceFilter->put_Directory(CComBSTR(sDirectory)));
        __C(pJpegMultiFileSourceFilter->put_AutoRepeat(ATL_VARIANT_TRUE));
        __C(pJpegMultiFileSourceFilter->put_RepeatDelay(nRepeatDelay));
...
        m_pInnerBaseFilter = CComQIPtr<IBaseFilter>(m_pInnerUnknown);
        m_pInnerPersistStream = CComQIPtr<IPersistStream>(m_pInnerUnknown);
        __D(m_pInnerBaseFilter, E_NOINTERFACE);

The aggregated (inner) object is created and its “main” IUnknown pointer is saved as lifetime reference (because for the COM aggregated object this is the only interface pointer which AddRef/Release has effect on internal reference counter – see COM Aggregation details). The object is pre-initialzed immediately after creation and the effective values will be taken from registry key “SOFTWARE\Alax.Info\Media Tools\JPEG MultiFile Video Capture Filter” (see below). It also makes sense to pre-query most used object’s interfaces to be able to use them directly without querying for them each time they are required.

Once the inner object is here, we need to sort out the list of interfaces to support. Video capture source filters have specific requirements (see Writing Capture Filters), including indication of pin category and implementation of IKsPropertySet interface; optional availability of preview pin, which we can omit from implementation and let Filter Graph Manager use Smart Tee Pin Filter to split stream into preview and capture.

Additionally, various software is expecting IAMStreamConfig interface on the output pin and would just fail to use the video capture device in case of its absence. We don’t have this interface implemented on the underlying filter, so we have to implement this on the wrapper. Since we need additional interfaces on the pin and the pin is an owned object of an inner aggregated object, it adds complexity to wrap original pin with a private pin class. An easy implementation of the latter point is not quite safe with COM aggregation, however a well written software that treats IPin interface as the “primary” pin’s interface and queries additional from it and holds the reference while using other interfaces will do just fine with a simple implementation on our side.

Another problem with the underlying filter which actually came up later but worth mentioning from the start. A JPEG Multi File Source Filter streams video media sample with an empty format structure attached to AM_MEDIA_TYPE media type. This assumes that an instance of JPEG Frame Decoder Filter will be added downstream and supply missing format by decoding JPEG data. While the filter is flexible enough to dynamically change media type along with JPEG data changes, this is not compatible with (not implemented by) most of the software. JPEG Frame Decoder Filter makes a first guess by settings resolution to 320×240. We need to set the right resolution immediately to avoid media type re-agreement.

To be able to do so we need to pass resolution information from original (inner) filter to the JPEG Frame Decoder Filter instance. It is also important that the filters might have other filters connected in between and in most cases there will be at least Smart Tee Pin Filter. To let the filters effectively communicate between each other and including in a reliable and documented way, available also to other/future filters, JPEG Frame Decoder Filter inroduces a new interface IJpegFrameDecoderFilterSource which, on its input pin connection, it looks for among the upstream filters. Iteratively walking through upstream connections up to developed video capture source filter it reaches our implementation and is capable of changing the default resolution to the effective resolution and exposed correct media type on its output pin right from the start.

So the interfaces on the filter:

• implemented on the filter:
  • IBaseFilter with IMediaFilter and IPersist to provide our own pin enumeration and supply a wrapper class for a pin object
  • IPersistStreamInit and IPersistStream to be friendly with persistence-enabled applications
  • IAMovieSetup to be able to be registered with DirectShow the way it is normally done
  • IFilter without IDispatch is the filters private interface with IDispatch not exposed directly to let the underlying filter expose his
  • IJpegFrameDecoderFilterSource to communicate to downstream JPEG Frame Decoder Filter and provide resolution information
• hidden implementation on the inner filter (other interfaces implemented by inner filter and not mentioned will be also available “outside”):
  • ISpecifyPropertyPages to hide inner property pages since the inner object is initialized internally
• implemented on the pin:
  • IPin to intercept method calls to possibly override media type enumeration and pin connection condition; while implementation of its methods (appeared to be not necessary, we still have to expose our private implementation of this interface since software will in most cases query additional interfaces from this interface pointer
  • IKsPropertySet per MSDN requirement
  • IAMStreamConfig to be compatible with wider range of software, specifically AMCap

Implementation details is available in reference implementation Filter.h in SVN.

An updated version of the dependent binaries Acquisition.dll and CodingI.dll is available from SVN.

A few points to mention explicitly:

• IKsPropertySet::Get marks the pin as a capture pin (PIN_CATEGORY_CAPTURE)
• IAMStreamConfig minimal implementation ignores media type in SetFormat; returns the only available media type in GetFormat using 300 fps frame rate value in order for it to be not zero and not very low to avoid collision of frames; returns one video capability in GetNumberOfCapabilities and GetStreamCaps – this should be sufficient provided that we actually don’t accept any cahnges/configuration on this interface
• IBaseFilter::EnumPins exposes a private wrapper pin class over original pin, so that we are capable of providing additional interfaces off the exposed output pin; we should have also provided an equal replacement through IBaseFilter::FindPin but this method is actually very rarely used and appears to be safe to omit, probably unless a compatibility issue arises later
• IJpegFrameDecoderFilterSource::GetDefaultExtent is the way JPEG Frame Decoder Filter obtains original video resolution.

On initialization the filter will query registry key “SOFTWARE\Alax.Info\Media Tools\JPEG MultiFile Video Capture Filter” for initialization values. Both HKEY_LOCAL_MACHINE and HKEY_CURRENT_USER might be used, HKEY_CURRENT_USER has the priority if present, unless HKEY_LOCAL_MACHINE has an additional non-zero REG_DWORD value named “Force”, in which case it takes priority over HKEY_CURRENT_USER. Initialization values are:

• “Directory” REG_SZ is the directory containing JPEG files to stream from
• “Repeat Delay” REG_DWORD is the pause in milliseconds between last and first frame when looping when playback
• “Video Width” and “Video Height” REG_DWORD is original video resolution and should match those of JPEG files

Another necessary implementation stroke is related to time stamps. The original inner JPEG Multi File Source Filter did not do any frame rate control at which the media samples are sent downstream. It was assumed that [video] renderer filter will enforce media sample presentation time and add necessary delay while playing video frames back. However, this approach does not work in a capture filter: when previewing video, a Smart Tee Pin Filter, which is inserted to make preview samples out of capture samples, is stripping time stamps and video renderer renders media samples at full possible rate. To address this issue, the JPEG Multi File Source Filter is received a new property Rate, which defaults to zero and implements uncontrolled sending of data downstream. With a Rate property value of 1.0, the filter does rate control and adds necessary delay as if the media samples are captured in real time.

Compatibility

Graph Edit and Graph Studio list, insert and are otherwise compatible with the new filter. They don’t have any assumptions on the filter implementation except the very basic, so they are quite capable of manipulating the new filter.

AMCap Sample recognizes the capture source and is rendering the filter through Capture Graph Builder, which automatically inserts Smart Tee Pin Filter. The application is properly showing the video from the new filter.

Media Player Classic‘s “Open Device…” menu command is capable of connecting to the new filter and the application is showing video.

VideoLAN [unexpectedly] failed to receive video from the new filter. It appears that the application is enumerating supported media types and is only capable of accepting those handled directly by the application. JPEG video with FOURCC code ‘AIJ0′ is not on that list and the application does not make any attempt, that a proper application would do, to render the filter through intermediate codecs using Intelligent Connect. The application won’t be able to receive video from the filter before the latter implements decoding into a well known pixel format, such as for example RGB or YUY2.

Skype beta 4.0.0.176 failed to receive video from the filter, though the filter is seen by the software as a video source. The logs don’t indicate the reason and it seems that the application does not like video capabilities and stops trying to get video from the device.

Summary

• Virtual DirectShow camera implemented
• Supported by Graph Edit, Monogram Graph Studio (one has to re-enter file directory from GUI when adding a filter), AMCap, Media Player Classic
• Does not integrate into VideoLAN because of its [unexpectedly] limited capabilities
• Does not integrate into Skype for whatever reason, probably just another of a number of bugs in a beta version

A partial reference Visual C++ .NET 2008 source code is available from SVN, release binary included.

I decided to gather DirectShow code and filters related to processing video from network/IP cameras and video servers into a library (in fact, a few libraries) so that it could be easily used for testing, research and other purposes. As time is going to permit, documentation and sample code will be provided, further development will be carried out.

This initial post publishes two libraries (DLLs) which host DirectShow filters to receive JPEG or M-JPEG video from network using HTTP based protocol, decode video with the help of Intel IPP 6.0 library (UMC version of the JPEG implementation), as well as perform additional helpful features, including writing series of frames into .JPG files and emulating video feed from saved .JPG files, conversion filters to obtain video in 24-bit and 32-bit RGB formats, YUY2 and YV12 formats.

File and Class Summary

Acqusition.dll

Acqusition.dll (download) hosts the following classes:

• DirectShow Filters
  • HTTP Stream Source Filter, to receive HTTP content and deliver into DirectShow environment through output pin
  • JPEG HTTP Stream Parser Filter, to parse HTTP content (typically received from HTTP Stream Source Filter) of image/jpeg and multipart/x-mixed-replace types and output JPEG frames
  • JPEG Multi File Renderer Filter, to write parsed JPEG frames (typically received from JPEG HTTP Stream Parser Filter) into files
  • JPEG Multi File Source Filter, to read JPEG files (typically written by JPEG Multi File Renderer Filter) and stream video into DirectShow environmentto emulate video feed

Acqusition.dll is dependent only on well known DLLs and does not require presence/redistribution of specific dependency files.

CodingI.dll

CodingI.dll (download) hosts the following classes:

• DirectShow Filters
  • JPEG Frame Decoder Filter, to parse JPEG data and pass frames downstream with a corresponding mediatype provided with VIDEOINFOHEADER format and correct resolution; in case of resolution changes the filter is capable of dynamically re-agreeing media type with downstream peer
  • JPEG Decoder Filter, to decode JPEG data into 24-bit/32-bit RGB (unfortunately Intel IPP codec has limited capabilities of decoding video into YUV pixel formats)
  • YUY2 Encoder Filter, to convert RGB data into YUY2 pixel format
  • YV12 Encoder Filter, to convert RGB data into YV12 pixel format
• Shell Extensions
  • JPEG File Resolution Shell Property Page, to provide additional information (such as sampling, color format, resolution) about .JPG and .JPEG files through a shell property page

CodingI.dll is dependent on Intel IPP 6.0 library DLLs and relies on availability of these dependencies in the system. For the CodingI.dll to be operationable, it is required to have a free, trial or registered version of Intel IPP library installed. In particular, the files that are sufficient to be present/redistributed are:

• libguide40.dll, libiomp5md.dll
• ippcore-6.0.dll
• ippi-6.0.dll, ippj-6.0.dll, ipps-6.0.dll, ippcc-6.0.dll, ippvc-6.0.dll
• ippipx-6.0.dll, ippjpx-6.0.dll, ippspx-6.0.dll, ippccpx-6.0.dll, ippvcpx-6.0.dll

Quick Usage Example

Given a M-JPEG compatible network camera on IP address 98.76.54.32, the graph constructed as shown below is capable to deliver video data and render it through standard Video Mixing Renderer Filter.

Assume the camera is StarDot NetCam SC series, with /jpeg.cgi HTTP request to query for JPEG image and /nph-mjpeg.cgi HTTP request to query for M-JPEG video feed.

To construct the graph in GraphEdit (GraphStudio), first it is required to manually add Alax.Info HTTP Stream Source Filter and provide HTTP URL for the request in the property page:

Then an Alax.Info JPEG HTTP Stream Parser Filter is added and connected downstream to the previously added source filter:

A this point it is possible to automatically render output pin and DirectShow intelligent connect will add the rest of required filters, Alax.Info JPEG Frame Decoder (I), Alax.Info JPEG Decoder (I) and Video Renderer.

However, in order for the graph to run in GraphEdit it is required to manually provide correct video resolution in the properties of JPEG Frame Decoder Filter and once applied reconnect all downstream connections up to video renderer in order to enforce new media type.

Running the graph will start streaming video.

Class Overview

HTTP Stream Source Filter

The filter sends one or series of HTTP requests to receive data from network location and stream received data into DirectShow environment.

• Filter Executable: Acquisition.dll
• Filter CLSID: __uuidof(HttpStreamSourceFilter) {943AC94A-3188-4ABC-9BD0-6CFF37CEBBCE}
• Filter Property Page CLSID: __uuidof(HttpStreamSourceFilterLocationPropertyPage), {91EF5CEC-30D1-4e2a-871D-F50A8CB4A7B1}
• Filter Merit: MERIT_UNLIKELY
• Filter Category: CLSID_LegacyAmFilterCategory
• Filter Interfaces: IPersistStreamInit, IPersistStream, ISpecifyPropertyPages, IBaseFilter, IMediaFilter, IPersist, IConnectionPointContainer, IAMovieSetup, IAMFilterMiscFlags, IHttpStreamSourceFilter, IDispatch, IFileSourceFilter (not available in graphedt.exe process)
• Filter Pins: single output pin (Output)
• Output Pin Media Types: MEDIATYPE_Stream/MEDIASUBTYPE_NULL
• Output Pin Interfaces: IPin, IAMPushSource, IAMLatency

Remarks

Filter is a live source and delivers raw data received from network HTTP request(s) in an endless manner. In case the HTTP response is of a finite Content-Length, filter will continuously repeat request. Each first media sample of a response is marked with AM_SAMPLE_DATADISCONTINUITY flag.

Filter exposes connection point and events for the top level application to be able to receive error events as well as callbacks to modify HTTP request verb and object name immediately before the request is sent to network.

Filter is using custom memory allocator through which is exposes IServiceProvider interface on the media samples through which downstream filters could gain access to IHttpStreamSourceHeaders interface and obtain HTTP response headers.

JPEG HTTP Stream Parser Filter

The filter takes data stream on the input and parses streams of image/jpeg and multipart/x-mixed-replace MIME content types into JPEG frames, so that each output media sample contains one JPEG frame.

• Filter Executable: Acquisition.dll
• Filter CLSID: __uuidof(JpegHttpStreamParserFilter) {805469B4-6F03-4532-88C1-7A07A7C8961C}
• Filter Property Page CLSID: N/A
• Filter Merit: MERIT_UNLIKELY
• Filter Category: CLSID_LegacyAmFilterCategory
• Filter Interfaces: IPersistStreamInit, IPersistStream, ISpecifyPropertyPages, IBaseFilter, IMediaFilter, IPersist, IAMovieSetup, IAMFilterMiscFlags, IJpegHttpStreamParserFilter, IDispatch
• Filter Pins: single input and single output pin (Input, Output)
• Input Pin Media Types: MEDIATYPE_Stream/MEDIASUBTYPE_NULL
• Input Pin Interfaces: IPin, IMemInputPin
• Output Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_JPEG (FOURCC ‘AIJ0′), MEDIATYPE_Stream/MEDIASUBTYPE_JPEG (FOURCC ‘AIJ0′)
• Output Pin Interfaces: IPin, IMediaSeeking, IMediaPosition, IDispatch

Remarks

Filter is using custom memory allocator through which is exposes IServiceProvider interface on the media samples through which downstream filters could gain access to IHttpStreamSourceHeaders interface and obtain HTTP response headers, both original response and subheaders of multipart Content-Type parts.

JPEG MultiFile Renderer Filter

The filter received JPEG frames and writes data into separate .JPG files, one per frame, into provided directory.

• Filter Executable: Acquisition.dll
• Filter CLSID: __uuidof(JpegMultiFileRendererFilter) {4194A70D-7FB0-4362-973E-B58EA5690FE6}
• Filter Property Page CLSID: __uuidof(JpegMultiFileRendererFilterDirectoryPropertyPage), {300AAAC6-9D89-4633-A7A8-CF7F22D5492F}
• Filter Merit: MERIT_DO_NOT_USE
• Filter Category: CLSID_LegacyAmFilterCategory
• Filter Interfaces: IPersistStreamInit, IPersistStream, ISpecifyPropertyPages, IBaseFilter, IMediaFilter, IPersist, IConnectionPointContainer, IAMovieSetup, IAMFilterMiscFlags, IJpegMultiFileRendererFilter, IDispatch, IFileSinkFilter2 (not available in graphedt.exe process), IFileSinkFilter (not available in graphedt.exe process)
• Filter Pins: single input pin (Input)
• Input Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_JPEG (FOURCC ‘AIJ0′)
• Input Pin Interfaces:�IPin, IMemInputPin

Remarks

None.

JPEG MultiFile Source Filter

The filter reads contents of provided directory and stream contained .JPG files emulating a video feed.

• Filter Executable: Acquisition.dll
• Filter CLSID: __uuidof(JpegMultiFileSourceFilter) {B749D696-E479-44dc-AF17-220EBEDFAAE8}
• Filter Property Page CLSID: __uuidof(JpegMultiFileSourceFilterDirectoryPropertyPage), {DE611B46-F6BA-4de5-A714-BEDE243A0BAC}
• Filter Merit: MERIT_DO_NOT_USE
• Filter Category: CLSID_LegacyAmFilterCategory
• Filter Interfaces: IPersistStreamInit, IPersistStream, ISpecifyPropertyPages, IBaseFilter, IMediaFilter, IPersist, IAMovieSetup, IAMFilterMiscFlags, IJpegMultiFileSourceFilter, IDispatch, IFileSourceFilter (not available in graphedt.exe process)
• Filter Pins: single output pin (Output)
• Output Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_JPEG (FOURCC ‘AIJ0′), MEDIATYPE_Stream/MEDIASUBTYPE_JPEG (FOURCC ‘AIJ0′)
• Output Pin Interfaces: IPin, IAMPushSource, IAMLatency

Remarks

The filter converts file time stamps into media sample time stamps to convert file write rate into DirectShow rendering/playback rate.

JPEG Frame Decoder Filter

The filter takes raw JPEG input media samples in the input, parses JPEG headers and outputs media samples supplied with valid VIDEOINFOHEADER format with correct resolution.

• Filter Executable: CodingI.dll
• Filter CLSID: __uuidof(JpegFrameDecoderFilter) {EA070483-8D39-4782-8C7B-489AD8B6177F}
• Filter Property Page CLSID: __uuidof(JpegFrameDecoderFilterResolutionPropertyPage), {E14A1F56-A683-4ec2-86B0-F7B6EABF7DC6}
• Filter Merit: MERIT_UNLIKELY – 1
  
• Filter Category: CLSID_LegacyAmFilterCategory
• Filter Interfaces: IPersistStreamInit, IPersistStream, ISpecifyPropertyPages, IBaseFilter, IMediaFilter, IPersist, IConnectionPointContainer, IAMovieSetup, IAMFilterMiscFlags, IJpegFrameDecoderFilter, IDispatch
• Filter Pins: single input and single output pin (Input, Output)
• Input Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_JPEG (FOURCC ‘AIJ0′)
• Input Pin Interfaces: IPin, IMemInputPin
• Output Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_JPEG (FOURCC ‘AIJ0′)/FORMAT_VideoInfo
• Output Pin Interfaces: IPin, IMediaSeeking, IMediaPosition, IDispatch

Remarks

Filter is attempting to dynamically re-agree media type with downstream filter in case media type changes. Initialially in absence of data about effective video resolution, the filter uses default resolution (320×240 or overridden through private interface IJpegFrameDecoderFilter.

Filter is attempting to share memory allocators on input and output pins to be able to pass media samples transparently without copying data.

Filter exposes connection point and events for the top level application to be able to receive resolution change events.

JPEG Decoder Filter

The filter decodes input media samples of JPEG� format and outputs 24-bit/32-bit RGB media samples.

• Filter Executable: CodingI.dll
• Filter CLSID: __uuidof(JpegFrameFilter) {28A8C753-363C-460a-9D99-74E534A5114F}
• Filter Property Page CLSID: N/A
• Filter Merit: MERIT_NORMAL + 0×10
  
• Filter Category: CLSID_LegacyAmFilterCategory
• Filter Interfaces: IPersistStreamInit, IPersistStream, ISpecifyPropertyPages, IBaseFilter, IMediaFilter, IPersist, IConnectionPointContainer, IAMovieSetup, IAMFilterMiscFlags, IJpegDecoderFilter, IDispatch
• Filter Pins: single input and single output pin (Input, Output)
• Input Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_JPEG (FOURCC ‘AIJ0′)/FORMAT_VideoInfo
• Input Pin Interfaces: IPin, IMemInputPin
• Output Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_RGB24/FORMAT_VideoInfo, MEDIATYPE_Video/MEDIASUBTYPE_RGB32/FORMAT_VideoInfo
• Output Pin Interfaces: IPin, IMediaSeeking, IMediaPosition, IDispatch

Remarks

Filter is attempting to re-agree media type on the output pin in case it receives a request to change media type on the input pin, in order to transparently support dynamic resolution change.

YUY2 Encoder Filter

The filter converts 24-bit and 32-bit RGB media samples into YUY2 pixel format.

• Filter Executable: CodingI.dll
• Filter CLSID: __uuidof(Yuy2EncoderFilter) {5302581E-A3B2-408b-BC23-71ECA8BC8885}
• Filter Property Page CLSID: N/A
• Filter Merit: MERIT_DO_NOT_USE + 0×10
  
• Filter Category: CLSID_LegacyAmFilterCategory
• Filter Interfaces: IBaseFilter, IMediaFilter, IPersist, IAMovieSetup, IAMFilterMiscFlags
• Filter Pins: single input and single output pin (Input, Output)
• Input Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_RGB24/FORMAT_VideoInfo, MEDIATYPE_Video/MEDIASUBTYPE_RGB32/FORMAT_VideoInfo
• Input Pin Interfaces: IPin, IMemInputPin
• Output Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_YUY2/FORMAT_VideoInfo,
• Output Pin Interfaces: IPin, IMediaSeeking, IMediaPosition, IDispatch

Remarks

Filter is attempting to re-agree media type on the output pin in case it receives a request to change media type on the input pin, in order to transparently support dynamic resolution change.

YV12 Encoder Filter

The filter converts 24-bit and 32-bit RGB media samples into YV12 pixel format.

• Filter Executable: CodingI.dll
• Filter CLSID: __uuidof(Yv12EncoderFilter) {CDC777A0-0DB0-4a01-9C42-F23F053F9F36}
• Filter Property Page CLSID: N/A
• Filter Merit: MERIT_DO_NOT_USE + 0×10
  
• Filter Category: CLSID_LegacyAmFilterCategory
• Filter Interfaces: IBaseFilter, IMediaFilter, IPersist, IAMovieSetup, IAMFilterMiscFlags
• Filter Pins: single input and single output pin (Input, Output)
• Input Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_RGB24/FORMAT_VideoInfo, MEDIATYPE_Video/MEDIASUBTYPE_RGB32/FORMAT_VideoInfo
• Input Pin Interfaces: IPin, IMemInputPin
• Output Pin Media Types: MEDIATYPE_Video/MEDIASUBTYPE_YV12/FORMAT_VideoInfo,
• Output Pin Interfaces: IPin, IMediaSeeking, IMediaPosition, IDispatch

Remarks

Filter is attempting to re-agree media type on the output pin in case it receives a request to change media type on the input pin, in order to transparently support dynamic resolution change.

An example to give an idea of how robust and reliable network cameras and video servers today are. Fl***h made video encoder hardware.

The request is http://***.***.***.***/cgi-bin/***.cgi?***, it informs on capabilities of the device.

...
SupportDigitalOutputCount=4
SupportDigitalIutputCount=4
...

That was a good one. Quality setting UI title vs. internal identifier on an IQeye705 camera:

• “superfine” = xlow
• “fine” = low
• “high” = medium
• “medium” = high