An application appears to be not working in Windows XP in a weird way: rebar control appeared to fail showing up.

Where the application is expected to look much nicer with rebar control as a container for menu (implemented as command bar WTL control) and toolbar with buttons:

A WTL sample project generated by a Visual Studio wizard would never give such effect, and the bug was a combination of factors:

1. An application built with a newer version of Windows SDK, which includes support for features (Windows Vista+ Common Controls) that are more recent than production environment (Windows XP); the application targets to Windows Vista+ environment too (_WIN32_WINNT >= 0×0600)
2. Compatibility issues of Common Controls library
3. WTL version (7.5), which did not yet include a workaround for the problem

The problem, which caused the bug directly was the REBARBANDINFO structure and its use as an argument with Common Controls API. As MSDN shows, the structure was amended twice with additional fields.

One of the way to support multiple versions of the structure definition, and to resolve compatibility issues, is to embed structure size into structure payload. In fact, REBARBANDINFO::cbSize member is there exactly for this reason.

The application is normally filling cbSize with the maximal known structure size and fills the rest of the fields respectively. The API is expected to be checking cbSize member and be detecting API version compatibility scenarios:

1. cbSize holds exactly the value the API expects (that is, the maximal value known/defined to the API) – the simplest scenario where the API and the application are on the same page, both are using the same versions of the “protocol”/interface.
2. cbSize is smaller than API can support – the API sees that it is dealing with a sort of legacy application which cannot utilize all available features, and the API acts respectively supporting the older part of the protocol, and keeping defaults or “old look” for the rest of implementation. This addresses backward compatibility: the newer API works with apps designed for older version of the API
3. cbSize is greater then API can support – the API sees that the application is already aware of newer version API and is possibly requesting some of the missing features. The API might be ignoring the unsupported part in assumption that API evolution tool place keeping some compatibility in mind, and still do the best it can with the existing implementation. Or, the API might just fail to work.

The latter item #3 is the scenario here with rebar control. The application is using Windows Vista version of REBARBANDINFO structure and Windows XP implementation choses to completely fail.

While it does not seem to be directly a bug, this attitude is definitely not developer friendly: there is no reason for the control to not work in its best and default way. Having API acting this way, each developer using the API needs to take care of the situation explicitly: whenever Windows Vista enabled application needs to be able to run in Windows XP system, the code around REBARBANDINFO would look like this:

REBARBANDINFO BandInformation = { sizeof BandInformation, RBBIM_LPARAM };
#if _WIN32_WINNT >= 0x0600
if(GetOsVersion() < 0x00060000 || GetCommCtrlVersion() < 0x00060000) // pre-Vista, Common Controls pre-6.0
    BandInformation.cbSize = REBARBANDINFO_V6_SIZE;
#endif// _WIN32_WINNT >= 0x0600
const BOOL bGetBandInfoResult = Rebar.GetBandInfo(0, &BandInformation);

If the API was nicer to developers, the code would be plain and simple:

REBARBANDINFO BandInformation = { sizeof BandInformation, RBBIM_LPARAM };
const BOOL bGetBandInfoResult = Rebar.GetBandInfo(0, &BandInformation);

To address this problem, WTL 8.0 comes up with RunTimeHelper namespace and its SizeOf_REBARBANDINFO function. It takes care of details for the developer choosing the proper size of the structure on runtime. The code is being taken back to a simpler shape:

REBARBANDINFO BandInformation = { RunTimeHelper::SizeOf_REBARBANDINFO(), RBBIM_LPARAM };
const BOOL bGetBandInfoResult = Rebar.GetBandInfo(0, &BandInformation);

All in all:

• be aware of compatibility issues (same scenario exists with other SDK structures: LVGROUP, LVTILEINFO, MCHITTESTINFO, NONCLIENTMETRICS and other).
• use latest version of WTL to have things worked around for you where Microsoft developers were not kid enough to provide perfect API
• be aware and take advantage of WTL’s RunTimeHelper class

This adds a small update to the recently published GPS Location/Coordinate Converter utility:

• Seconds in Degrees, Minutes & Seconds notation are shown and are accepted as floating point numbers
• More shortcuts to popular online map services (note that only Google Maps and Yandex Maps are still accepted as input via clipboard):
• Bing Maps
• Yahoo Maps
• Open Street Map
• WikiMapia

The latter makes the tool an easy to use converted between the services for a GPS POI.

A binary [Win32] and partial Visual C++ .NET 2010 partial source code are available from SVN.

RasterizeFont utility takes a font on the input (such as Windows .TTF – True-Type Font) and paints individual characters into bitmaps. Utility output includes separate bitmap (.BMP) files for requested characters and C++ source code of the bimap arrays (this was included into microcontroller project).

A configuration .INI file defines rasterizer parameters:

[General]
Width=48
Height=72
Horizontal Adjustment=1
Vertical Adjustment=0
Outline=1

[Font]
Face=Times New Roman
Height=48
Weight=1024

[Bitmaps]
PathTemplate=Character-%04x.bmp

And a list of characters of interest is passed as a command line argument.

const BYTE pnCharacter007a[] = // 0x007a z
{
    0x55, 0x55, 0x55,  // 01 01 01 01 01 01 01 01 01 01 01 01 
    0x55, 0x55, 0x55,  // 01 01 01 01 01 01 01 01 01 01 01 01 
    0x55, 0x55, 0x55,  // 01 01 01 01 01 01 01 01 01 01 01 01 
    0x54, 0x00, 0x05,  // 01 01 01 00 00 00 00 00 00 00 01 01 
    0x52, 0xaa, 0xa1,  // 01 01 00 10 10 10 10 10 10 10 00 01 
    0x52, 0x00, 0xa1,  // 01 01 00 10 00 00 00 00 10 10 00 01 
    0x54, 0x42, 0x85,  // 01 01 01 00 01 00 00 10 10 00 01 01 
    0x55, 0x2a, 0x15,  // 01 01 01 01 00 10 10 10 00 01 01 01 
    0x54, 0xa0, 0x45,  // 01 01 01 00 10 10 00 00 01 00 01 01 
    0x52, 0x80, 0x21,  // 01 01 00 10 10 00 00 00 00 10 00 01 
    0x52, 0xaa, 0xa1,  // 01 01 00 10 10 10 10 10 10 10 00 01 
    0x54, 0x00, 0x05,  // 01 01 01 00 00 00 00 00 00 00 01 01 
    0x55, 0x55, 0x55,  // 01 01 01 01 01 01 01 01 01 01 01 01 
    0x55, 0x55, 0x55,  // 01 01 01 01 01 01 01 01 01 01 01 01 
};

A binary [Win32] and Visual C++ .NET 2008 source code are available from SVN.

LogicalProcessorInformation is a fronend GUI around GetLogicalProcessorInformation API and reveals CPU configuration of the system. If you are fine tuning stuff, you might want to know what sort of CPUs are powering the applications:

• how many?
• fully featured cores or HyperThreading technology?
• mutli-processor configuration and how exactly physical processors are distributed over affinity mask

API and the application gets you the data as a user-friendly dump of GetLogicalProcessorInformation output and a summary of records at the bottom:

Logical Processors:

Mask: 0x00000003
Relationship: RelationProcessorCore (0x0)
ProcessorCore.Flags: 0x01

Mask: 0x00000003
Relationship: RelationCache (0x2)
Cache.Level: 1
Cache.Associativity: 8
Cache.LineSize: 64 (0x40)
Cache.Size: 32768 (0x8000)
Cache.Type: CacheData (0x2)

Mask: 0x00000003
Relationship: RelationCache (0x2)
Cache.Level: 1
Cache.Associativity: 4
Cache.LineSize: 64 (0x40)
Cache.Size: 32768 (0x8000)
Cache.Type: CacheInstruction (0x1)

Mask: 0x00000003
Relationship: RelationCache (0x2)
Cache.Level: 2
Cache.Associativity: 8
Cache.LineSize: 64 (0x40)
Cache.Size: 262144 (0x40000)
Cache.Type: CacheUnified (0x0)

Mask: 0x0000000c
Relationship: RelationProcessorCore (0x0)
ProcessorCore.Flags: 0x01

...

Mask: 0x000000ff
Relationship: RelationProcessorPackage (0x3)

...

Mask: 0x000000ff
Relationship: RelationNumaNode (0x1)
NumaNode.NodeNumber: 0x0

Record Count per Relationship:
 RelationProcessorCore (0x0): 4
 RelationNumaNode (0x1): 1
 RelationCache (0x2): 13
 RelationProcessorPackage (0x3): 1
 RelationGroup (0x4): 0

A binary [Win32, x64] and Visual C++ .NET 2010 source code are available from SVN.

It is as stupid as it sounds: you can add RBBS_NOGRIPPER flag to a rebar band to implement “lock controls” feature, but as soon as you start removing it – you miserably fail.

A related thread on WTL group is dated year 2006. You can find the same dated 2003. Now it’s 2011 and it’s still here.

OK, it might be some bug in controlling code etc, but here is Control Spy 2.0. Here you go:

• rebar
• RB_GETBANDINFO, RBBIM_STYLE
• add RBBS_NOGRIPPER, Send
• remove RBBS_NOGRIPPER, Send
• ouch!

WTL does a cool trick to fool the bastard:

void LockBands(bool bLock)
{
    int nBandCount = GetBandCount();
    for(int i =0; i < nBandCount; i++)
    {
        REBARBANDINFO rbbi = { RunTimeHelper::SizeOf_REBARBANDINFO() };
        rbbi.fMask = RBBIM_STYLE;
        BOOL bRet = GetBandInfo(i, &rbbi);
        ATLASSERT(bRet);

        if((rbbi.fStyle & RBBS_GRIPPERALWAYS) == 0)
        {
            rbbi.fStyle |= RBBS_GRIPPERALWAYS;
            bRet = SetBandInfo(i, &rbbi);
            ATLASSERT(bRet);
            rbbi.fStyle &= ~RBBS_GRIPPERALWAYS;
        }
        if(bLock)
            rbbi.fStyle |= RBBS_NOGRIPPER;
        else
            rbbi.fStyle &= ~RBBS_NOGRIPPER;

        bRet = SetBandInfo(i, &rbbi);
        ATLASSERT(bRet);
    }
}

Pretty cool and works… if you have one rebar only. If you have another one in the same window (e.g. mine is at bottom) – you fail again.

A nasty workaround is to nudge hosting window by resizing it, followed by a full cycle of internal layout updates:

CRect Position;
ATLVERIFY(GetWindowRect(Position));
Position.bottom++;
ATLVERIFY(MoveWindow(Position));
Position.bottom--;
ATLVERIFY(MoveWindow(Position));

ProcessSnapshot is a utility to take a snapshot of process call stacks, and the snapshot taken is written into a human friendly text file.

Additionally to this, the utility has been given a capability to create process minidump files, on user request. The minidump files can be used with debugger to analyze the context of the process using feature rich debug environment, esp. Microsoft Visual Studio. To create a minidump for a process, check a corresponding box and press “Take a Dump” button. A file named “<process-image-name> – <date> <time>.dmp” will be created in the directory of the utility executable.

See also:

• Minidump Files (MSDN)
• How to read the small memory dump files that Windows creates for debugging
• Post-Mortem Debugging Your Application with Minidumps and Visual Studio .NET
• How to View Windows Minidump Files

A binary [Win32, x64] and partial Visual C++ .NET 2008 source code are available from SVN.

Recently it was the time to sort out an issue with a video DMO, which outputs YV12 video and in the same time is capable of supporting extended video strides in order to efficiently make a direct connection to Video Mixing Renderer Filters.

From past experience, I already knew that some bugs are definitely involved but their effect was yet unexplored. For a testbed application, I took good old FrameRateSample02 application, which generates multiple video feeds and routes it to video renderers:

With new source video choices the application is capable of constructing filter graphs that use a private DMO (that is hosted inside the executable) wrapped with DMO Wrapper Filter, with a graph topology shown below:

The DMO does not do any processing, except support for extended strides while copying original data into buffer streamed to video renderer. Extended strides for a planar YUV format is a bit tricky. Are they supported at all? Yes, they are and video renderer might still request an extended stride and in which case origial MxN video needs to be copied into (M+P)xN buffer. Unlike packed pixel format, unused space is distributed in a bit different way but still very much similarly: output buffer is still a regular (M+P)xN rectangle, where the effective picture of size MxN should be copied into top left corner.

The problem I was aware of from past experience showed up immediately once the filters connected. After a dynamic format change initiated by the VMR, the filters report different connection media types. DMO Wrapper Filter still shows original connection time connection media type, while Video Mixing Renderer Filter shows media type it switched to.

This looks like DMO Wrapper Filter bug, but was yet to check if it still handles the new media type properly and passes the format change to the underlying DMO object. Taking into consideration the extent DMOs are used by Microsoft, it had to, thought I never met this in the MSDN documentation.

Further debugging revealed that DMO Wrapper Filter does handle the media type change and forward it to the DMO through IMediaObject::SetOutputType method. This happens when DMO already received its first input, and immediately before following IMediaObject::ProcessOutput method call:

rodmo.h(293) : CMediaObjectT<class CVideoDmo>::AllocateStreamingResources: ...
rodshow.h(2716) : CBaseFilterT<class CMainDialog::CSourceFilter>::Pause: ...
rodshow.h(2722) : CBaseFilterT<class CMainDialog::CSourceFilter>::Pause: m_State 0
rodshow.h(2730) : CBaseFilterT<class CMainDialog::CSourceFilter>::Pause: m_State 1
rodshow.h(2784) : CBaseFilterT<class CMainDialog::CSourceFilter>::GetState: nTimeout 0
rodmo.h(679) : CSimpleMediaObjectT<class CVideoDmo,1>::GetInputStatus: nInputStreamIndex 0
rodmo.h(702) : CSimpleMediaObjectT<class CVideoDmo,1>::ProcessInput: nInputStreamIndex 0, nFlags 0x1
rodmo.h(527) : CSimpleMediaObjectT<class CVideoDmo,1>::SetOutputType: nOutputStreamIndex 0, nFlags 0x0
rodmo.h(727) : CSimpleMediaObjectT<class CVideoDmo,1>::ProcessOutput: nFlags 0x1, nOutputBufferCount 1

So, the media type change is handled and the problem is only limited to reporting wrong (original) media type off the wrapper filter output pin.

Investigation of filter connection however brought up another interesting fact, memory allocator properties:

As the filters switched to a new media type, with extended strides, the memory allocator should obviously have been updated accordingly, in order to support larger buffer. However current memory allocator properties indicate old buffer size of 460,800 bytes, while new media type assumes 737,280 buffer size at the very least. The samples are however streamed fine, so the issue is also limited to incorrectly reported size.

This memory allocator is managed by the Video Mixing Renderer Filter, so the problem seems to be relating to it.

Good news however was that video was streamed and displayed correctly.

One thing that deserves special attention is making a DMO private. I already wrote another post on private DMOs some time ago, and this time the sample shows even a better way in case one does not need the DMO available for Intelligent Connect (in which case DMORegister call along with administrative privileges will be required),  just for a private instantiation. DMO is typically created by CoCreateInstance from inside the DMO Wrapper Filter, e.g. using IDMOWrapperFilter::Init method, so it is necessary to either register COM class, or… just register its class object for the process using CoRegisterClassObject.

There is no need for direct usage of API since ATL already wrapped the calls and we are to take advantage of what is already available. First of all, the DMO class requires certain CLSID, because we don’t have one typically declared in IDL. A good place for attaching CLSID is class declaration and __declspec keyword:

class __declspec(uuid("88B976BE-EEE6-45b1-A21B-42A941DF8819")) ATL_NO_VTABLE CVideoDmo :
    public CComObjectRootEx<CComMultiThreadModelNoCS>,
    public CComCoClass<CVideoDmo>,
    public CSimpleMediaObjectT<CVideoDmo, 1>
{

Further a COM class is typically referenced into module’s object map byan OBJECT_ENTRY_AUTO macro:

//OBJECT_ENTRY_AUTO(__uuidof(VideoDmo), CVideoDmo)

But we don’t need this this time as we don’t need standard COM registration for the class. We will register its class object manually and temporarily, at the time of DMO initialization:

CComQIPtr<IBaseFilter> pBaseFilter;
CVideoDmo* pVideoDmo;
{
    BEGIN_OBJECT_MAP(g_pObjectMap)
        OBJECT_ENTRY(__uuidof(CVideoDmo), CVideoDmo)
    END_OBJECT_MAP()
    ATLASSERT(DIM(g_pObjectMap) == 2 && !g_pObjectMap[1].pclsid);
    ATLENSURE_SUCCEEDED(g_pObjectMap[0].RegisterClassObject(CLSCTX_INPROC_SERVER, REGCLS_SINGLEUSE));
    _ATLTRY
    {
        CComPtr<IDMOWrapperFilter> pDmoWrapperFilter = ConstructDmoWrappedFilter(__uuidof(CVideoDmo), CVideoDmo::GetCategory());
        pBaseFilter = pDmoWrapperFilter;
        ATLENSURE_THROW(pBaseFilter, E_NOINTERFACE);
        CComQIPtr<IMediaObject> pMediaObject = pDmoWrapperFilter;
        ATLENSURE_THROW(pMediaObject, E_NOINTERFACE);
        pVideoDmo = static_cast<CVideoDmo*>((IMediaObject*) pMediaObject);
    }
    _ATLCATCHALL()
    {
        ATLVERIFY(SUCCEEDED(g_pObjectMap[0].RevokeClassObject()));
        _ATLRETHROW;
    }
    ATLVERIFY(SUCCEEDED(g_pObjectMap[0].RevokeClassObject()));
}
pVideoDmo->Initialize(CDmoMediaType(m_pMediaType), CopyYv12MediaBuffer);
ATLENSURE_SUCCEEDED(pGraphBuilder->AddFilter(pBaseFilter, CStringW(_T("Pass-Through DMO"))));
ATLENSURE_SUCCEEDED(pGraphBuilder->Connect(pOutputPin, _FilterGraphHelper::GetFilterPin(pBaseFilter, PINDIR_INPUT)));
pOutputPin = _FilterGraphHelper::GetFilterPin(pBaseFilter, PINDIR_OUTPUT)

What is being done in the code snippet above is:

• local object map with a single OBJECT_ENTRY item to have ATL manage class object registration/revokation for us
• registration of a private class/CLSID
• instantiation and initialization of a DMO Wrapper Filter which is to pick up our class
• cast back to native C++ pointer for easy further access (a private interface would be more accurate here)
• revokation for CLSID

For information, the interfaces queried from the DMO:

Find all "CVideoDmo::InternalQueryInterface", Hidden, Find Results 1, Current Document
CVideoDmo::InternalQueryInterface: Interface IMediaObject, Result 0x00000000
CVideoDmo::InternalQueryInterface: Interface IDMOQualityControl, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDMOVideoOutputOptimizations, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IMediaObject, Result 0x00000000
CVideoDmo::InternalQueryInterface: Interface IWMGetSecureChannel, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMOpenProgress, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMDeviceRemoval, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDirectVobSub, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDirectVobSub, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IDirectVobSub, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IMediaSeeking, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IMediaPosition, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMFilterMiscFlags, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IVideoWindow, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IBasicAudio, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMFilterMiscFlags, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IKsPropertySet, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IReferenceClock, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IWMCodecAMVideoAccelerator, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMDeviceRemoval, Result 0x80004002
CVideoDmo::InternalQueryInterface: Interface IAMOpenProgress, Result 0x80004002
Matching lines: 24

A Visual C++ .NET 2008 source code is available from SVN. Additional files will be required to compile, but binary is also incuded.

In order to obtain a reference audio source and especially useful for debugging purposes, including:

• audio input device unrelated to physical device, to avoid conditions when device is already in use by someone else
• non-zero audio signal which is independent of certain speaker or broadcasting service, including one that makes capture, transmission or rendering issues easily perceptible by human
• configurable to provide different audio media types, including through well known DirectShow interfaces, such as IAMStreamConfig
• configurable to present in system as both regular DirectShow Filter, and as an Audio Capture Source which can be enumerated by applications
• to be able to check how exactly other applications are accessing and configuring audio capture source

I added a new filter to the Media Tools library, a Tone Source Filter. The filter generates PCM Audio data, either infinite sine waveform, or interrupted signal  of requested parameters:

The filter accepts connection on PCM media types with flexible sampling rates in range 8 KHz through 200 KHz, 8-bit audio and 1 channel. Media type is also configurable through or, if not configured this way, the first enumerated media type off the Output pin is also configurable through property page and/or persistent setting accessible via private IDispatch derived interface property.

Additionally, the filter may configured as a system-wide available audio input device, such as for example available to VLC Media Player or Media Player Classic:

In order to configure the filter as such device, the library exports function DoToneSourceFilterDevicePropertySheetModal, which can be called using rundll32 utility (“rundll32 Acquisition.dll,DoToneSourceFilterDevicePropertySheetModal” from command line):

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
  • Tone Source Filter, to generate reference/debug audio data

Class Overview

Tone Source Filter

The filter generates uninterrupted or interrupted reference sine waveform in form of PCM audio data.

• Filter Executable: Acquisition.dll
• Filter CLSID: __uuidof(ToneSourceFilter) {8002935A-B2EC-40ef-968C-E0358E5DED10}
• Filter Property Page CLSID: __uuidof(ToneSourceFilterGeneralPropertyPage), {EBD8ABB2-6DD3-4c54-A7F1-9FE4DA283EDF}, ToneSourceFilterPreferedFormatPropertyPage, {EE224187-4FA3-4c3f-9D5D-492694CCFEB7}
• Filter Merit: MERIT_DO_NOT_USE
• Filter Category: CLSID_LegacyAmFilterCategory (also configurable as CLSID_AudioInputDeviceCategory)
• Filter Interfaces: IPersistStreamInit, IPersistStream, ISpecifyPropertyPages, IPersistPropertyBag, IBaseFilter, IMediaFilter, IPersist, IAMovieSetup, IAMFilterMiscFlags, IToneSourceFilter, IDispatch
• Filter Pins: single ouput pin (Ouput)
• Output Pin Media Types: MEDIATYPE_Audio/MEDIASUBTYPE_PCM
• Output Pin Interfaces: IPin, IMemInputPin, IAMPushSource, IAMLatency, IAMBufferNegotiation, IKsPropertySet, IAMStreamConfig

Remarks

The hosting library (DLL) exposes DoToneSourceFilterDevicePropertySheetModal function which provides GUI to configure the filter as one or more audio capture source device, which can be enumerated by System Device Enumerator.

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.

A good old task to easily minimize to system tray icon to not clog the application bar and without too much thinking about it. How To with WTL?

The key points are:

• manage NOTIFYICONDATA structure (obviously!), where non-zero .cbSize will be an indication of created icon
• create an icon in WM_SYSCOMMAND/SC_MINIMIZE handler and hide instead default minimization
• handle icon’s WM_LBUTTONDBLCLK to restore and WM_RBUTTONUP to pop up a menu
• use default dialog menu to avoid having private one, handle SC_RESTORE and SC_CLOSE system commands to restore and close from system tray icon popup menu

Relevant source code from application main window (dialog) class:

class CMainDialog :
...
{
public:

BEGIN_MSG_MAP_EX(CMainDialog)
...
    MSG_WM_INITDIALOG(OnInitDialog)
    MSG_WM_DESTROY(OnDestroy)
    MSG_WM_SYSCOMMAND(OnSysCommand)
    MESSAGE_HANDLER_EX(WM_SYSTEMTRAYICON, OnSystemTrayIcon)
    COMMAND_ID_HANDLER_EX(SC_RESTORE, OnScRestore)
    COMMAND_ID_HANDLER_EX(SC_CLOSE, OnScClose)
...
END_MSG_MAP()
...
    enum
    {
        WM_FIRST = WM_APP,
        WM_SYSTEMTRAYICON,
    };
...
private:
    NOTIFYICONDATA m_NotifyIconData;
...
public:
// CMainDialog
    CMainDialog() throw()
    {
        ZeroMemory(&m_NotifyIconData, sizeof m_NotifyIconData);
        ...
    }

// Window message handlers
    LRESULT OnInitDialog(HWND, LPARAM)
    {
        ZeroMemory(&m_NotifyIconData, sizeof m_NotifyIconData);
        ...
    }
    LRESULT OnDestroy()
    {
        if(m_NotifyIconData.cbSize)
        {
            Shell_NotifyIcon(NIM_DELETE, &m_NotifyIconData);
            ZeroMemory(&m_NotifyIconData, sizeof m_NotifyIconData);
        }
        ...
    }
    LRESULT OnSysCommand(UINT nCommand, CPoint)
    {
        switch(nCommand)
        {
        case SC_MINIMIZE:
            if(!m_NotifyIconData.cbSize)
            {
                m_NotifyIconData.cbSize = NOTIFYICONDATAA_V1_SIZE;
                m_NotifyIconData.hWnd = m_hWnd;
                m_NotifyIconData.uID = 1;
                m_NotifyIconData.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
                m_NotifyIconData.uCallbackMessage = WM_SYSTEMTRAYICON;
                m_NotifyIconData.hIcon = AtlLoadIconImage(IDI_MODULE, LR_DEFAULTCOLOR, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
                CString sWindowText;
                GetWindowText(sWindowText);
                _tcscpy_s(m_NotifyIconData.szTip, sWindowText);
                if(!Shell_NotifyIcon(NIM_ADD, &m_NotifyIconData))
                {
                    SetMsgHandled(FALSE);
                    return 0;
                }
            }
            ShowWindow(SW_HIDE);
            break;
        ...
        default:
            SetMsgHandled(FALSE);
        }
        return 0;
    }
    LRESULT OnSystemTrayIcon(UINT, WPARAM wParam, LPARAM lParam)
    {
        ATLASSERT(wParam == 1);
        switch(lParam)
        {
        case WM_LBUTTONDBLCLK:
            SendMessage(WM_COMMAND, SC_RESTORE);
            break;
        case WM_RBUTTONUP:
            {
                SetForegroundWindow(m_hWnd);
                CMenuHandle Menu = GetSystemMenu(FALSE);
                Menu.EnableMenuItem(SC_RESTORE, MF_BYCOMMAND | MF_ENABLED);
                Menu.EnableMenuItem(SC_MOVE, MF_BYCOMMAND | MF_GRAYED);
                Menu.EnableMenuItem(SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
                Menu.EnableMenuItem(SC_MINIMIZE, MF_BYCOMMAND | MF_GRAYED);
                Menu.EnableMenuItem(SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
                Menu.EnableMenuItem(SC_CLOSE, MF_BYCOMMAND | MF_ENABLED);
                CPoint Position;
                ATLVERIFY(GetCursorPos(&Position));
                Menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_BOTTOMALIGN, Position.x, Position.y, m_hWnd);
            }
            break;
        }
        return 0;
    }
    LRESULT OnScRestore(UINT, INT, HWND)
    {
        if(m_NotifyIconData.cbSize)
        {
            Shell_NotifyIcon(NIM_DELETE, &m_NotifyIconData);
            ZeroMemory(&m_NotifyIconData, sizeof m_NotifyIconData);
        }
        ShowWindow(SW_SHOW);
        BringWindowToTop();
        return 0;
    }
    LRESULT OnScClose(UINT, INT, HWND)
    {
        PostMessage(WM_COMMAND, IDCANCEL);
        return 0;
    }