Event Tracing in DirectShow
[The feature associated with this page, DirectShow, is a legacy feature. It has been superseded by MediaPlayer, IMFMediaEngine, and Audio/Video Capture in Media Foundation. Those features have been optimized for Windows 10 and Windows 11. Microsoft strongly recommends that new code use MediaPlayer, IMFMediaEngine and Audio/Video Capture in Media Foundation instead of DirectShow, when possible. Microsoft suggests that existing code that uses the legacy APIs be rewritten to use the new APIs if possible.]
DirectShow supports Event Tracing for Windows (ETW), which can be used to create event logs for instrumentation or debugging. For more information about ETW, see the Windows SDK documentation. To consume ETW events in a DirectShow application, you must enable tracing and then process the trace events. Use the following steps.
Set the Necessary Registry Keys
To enable tracing on the user's computer, first set the following registry keys:
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\DirectX
GlitchInstrumentation = 0x00000001 (REG_DWORD)
HKEY_LOCAL_MACHINE\SOFTWARE\DEBUG\Quartz.dll
PERFLOG = 0x00000001 (REG_DWORD)
These keys apply to both release and debug binaries.
Enable Tracing in Your Application
To enable tracing in your application, perform the following steps:
- Call StartTrace to start a new tracing session.
- Call EnableTrace to enable tracing. The provider GUID for DirectShow is GUID_DSHOW_CTL.
- Before the application exits, call StopTrace to close the tracing session.
Process the Events
To process the events, perform the following steps:
- Call OpenTrace to open the trace for processing.
- Call ProcessTrace to process the events.
- In the ProcessTrace callback, use the event GUID to find the event type. The event GUID indicates the structure that is used for the event data. See Trace Event GUIDs.
- Call CloseTrace to close the trace handle.
Example Code
The following code shows a helper class that enables tracing. This code shows how to write events to a log file, which can be processed after the session completes. You can also process events in real time. For more information, refer to the ETW documentation in the Windows SDK.
#include <wmistr.h>
#include <evntrace.h>
#include <perfstruct.h>
// Event classes. These are defined in dxmperf.h.
#ifndef DXMPERF_VIDEOREND
#define DXMPERF_VIDEOREND 0x00000001
#endif
#ifndef AUDIOBREAK_BIT
#define AUDIOBREAK_BIT 0x00000010
#endif
// This structure extends the EVENT_TRACE_PROPERTIES by adding fields
// for the name of the WMI session name and the log file.
struct PERFMON_LOGGERINFO
{
EVENT_TRACE_PROPERTIES TraceProperties;
WCHAR wcSessionName[ MAX_PATH ]; // Session name.
WCHAR wcLogFileName[ MAX_PATH ]; // Log file.
};
// Helper class for DirectShow event tracing.
class CTrace
{
public:
CTrace() : m_SessionLogger((TRACEHANDLE) INVALID_HANDLE_VALUE)
{
ZeroMemory(&m_LogInfo, sizeof(&m_LogInfo));
}
// Start: Starts a trace session.
HRESULT Start(WCHAR *wszLogFile)
{
const WCHAR* wszSessionName = L"PerfMon_DirectShow";
HRESULT hr = S_OK;
ULONG result;
ZeroMemory(&m_LogInfo, sizeof(m_LogInfo));
EVENT_TRACE_PROPERTIES& prop = m_LogInfo.TraceProperties;
prop.Wnode.BufferSize = sizeof(m_LogInfo); // Size of the structure.
prop.Wnode.Flags = WNODE_FLAG_TRACED_GUID; // Must be this value.
// Use the QPC (high resolution timer).
prop.Wnode.ClientContext = 1;
prop.Wnode.Guid = GUID_DSHOW_CTL; // Event provider GUID.
prop.LogFileMode =
EVENT_TRACE_FILE_MODE_CIRCULAR | EVENT_TRACE_USE_PAGED_MEMORY;
prop.EnableFlags =
EVENT_TRACE_FLAG_PROCESS; // Process events.
// Set the offset from the start of the structure to the log file name.
prop.LogFileNameOffset =
sizeof(m_LogInfo.TraceProperties) + sizeof(m_LogInfo.wcSessionName);
// Set the offset from the start of the structure to the session name.
prop.LoggerNameOffset = sizeof(m_LogInfo.TraceProperties);
// Copy the names into the structure.
StringCchCopy(m_LogInfo.wcSessionName, MAX_PATH, wszSessionName);
StringCchCopy(m_LogInfo.wcLogFileName, MAX_PATH, wszLogFile);
// Start the trace.
result = StartTrace(
&m_SessionLogger,
m_LogInfo.wcSessionName,
&m_LogInfo.TraceProperties
);
if (result == ERROR_SUCCESS)
{
result = EnableTrace(
TRUE, // Enable.
AUDIOBREAK_BIT | DXMPERF_VIDEOREND, // Event classes.
TRACE_LEVEL_VERBOSE, // Trace level.
&GUID_DSHOW_CTL, // Event provider.
m_SessionLogger // Session handle.
);
}
if (result != ERROR_SUCCESS)
{
hr = __HRESULT_FROM_WIN32(result);
}
return hr;
}
HRESULT Stop()
{
HRESULT hr = S_OK;
// Stop the trace.
if (m_SessionLogger != (TRACEHANDLE)INVALID_HANDLE_VALUE)
{
LONG result = 0;
result = EnableTrace(FALSE, 0, 0, &GUID_DSHOW_CTL, m_SessionLogger);
if (result == ERROR_SUCCESS)
{
result = StopTrace(
m_SessionLogger,
m_LogInfo.wcSessionName,
&m_LogInfo.TraceProperties);
}
m_SessionLogger = (TRACEHANDLE)INVALID_HANDLE_VALUE;
if (result != ERROR_SUCCESS)
{
hr = __HRESULT_FROM_WIN32(result);
}
}
return hr;
}
protected:
TRACEHANDLE m_SessionLogger;
PERFMON_LOGGERINFO m_LogInfo;
};
The following code shows how to process the event log:
// Callback for event processing.
VOID WINAPI EventCallback(PEVENT_TRACE pEvent)
{
PERFINFO_DSHOW_STREAMTRACE *pStreamTrace = NULL;
PERFINFO_DSHOW_AVREND *pVideoRender = NULL;
PERFINFO_DSHOW_AUDIOBREAK *pAudioBreak = NULL;
if (pEvent->Header.Guid == GUID_STREAMTRACE)
{
pStreamTrace = (PPERFINFO_DSHOW_STREAMTRACE)pEvent->MofData;
switch (pStreamTrace->id)
{
// TODO: Handle the event.
}
}
else if(pEvent->Header.Guid == GUID_VIDEOREND)
{
pVideoRender = (PPERFINFO_DSHOW_AVREND)pEvent->MofData;
// TODO: Handle the event.
}
else if(pEvent->Header.Guid == GUID_AUDIOBREAK)
{
pAudioBreak = (PPERFINFO_DSHOW_AUDIOBREAK)pEvent->MofData;
// TODO: Handle the event.
}
}
void ProcessTraceEvents(WCHAR *wszLogFile)
{
ULONG result = 0;
EVENT_TRACE_LOGFILE logfile;
ZeroMemory(&logfile, sizeof(logfile));
logfile.LogFileName = wszLogFile;
logfile.EventCallback = EventCallback;
TRACEHANDLE handle = OpenTrace(&logfile);
if (handle != (TRACEHANDLE)INVALID_HANDLE_VALUE)
{
result = ProcessTrace(&handle, 1, NULL, NULL);
CloseTrace(handle);
}
}
Related topics