The simplest way to add traces is to use the OutputDebugString function. OutputDebugString takes a single string as input:

void WINAPI OutputDebugString(
  __in_opt  LPCTSTR lpOutputString
);

Usually this function sends this string to a debugger. But when MFTrace traces a process, it hooks this function and adds the string to its log.

To make the OutputDebugString look more like printf, we can write a small wrapper which formats strings:

#include <windows.h>
#include <strsafe.h>

void CDECL Trace(PCSTR pszFormat, ...)
{
    CHAR szTrace[1024];

    va_list args;
    va_start(args, pszFormat);
    (void) StringCchVPrintfA(szTrace, ARRAYSIZE(szTrace), pszFormat, args);
    va_end(args);

    OutputDebugStringA(szTrace);
}

Now we can use this wrapper just like printf:

INT wmain(INT /*argc*/, PCWSTR /*argv*/[])
{
    Trace("MyTrace> Hello, world! Here is a pseudo-random number: %i", rand());
}

The traces are displayed both in the Visual Studio 2010 debugger and in the MFTrace logs.

However, there are two drawbacks to the Trace function shown here:

• String formatting is executed all of the time, regardless of whether the code is being traced. This affects performance.
• The format strings are stored inside the binaries. If you add a lot of traces (which is often needed in asynchronous programming), it fattens the binaries. Therefore, with this kind of tracing code, it is a good idea to use conditional compilation with #ifdef _DEBUG.

The performance issue can be addressed by using EventWriteString instead of OutputDebugString.

Tracing using EventWriteString

The EventWriteString function is similar to OutputDebugString. In addition to the trace string, this function takes a level, a keyword, and a handle:

ULONG EventWriteString(
  __in  REGHANDLE RegHandle,
  __in  UCHAR Level,
  __in  ULONGLONG Keyword,
  __in  PCWSTR String
);

The handle is initialized by calling EventRegister, and must be freed by calling EventUnregister. This makes EventWriteString slightly more complicated than OutputDebugString, but overall it is still fairly simple to use.

One interesting feature of the EventRegister function is that it takes a callback function of type PENABLECALLBACK. The callback function is called to let your code know whether it is being traced, and at which level and keyword.

Levels and keywords are used to filter out traces at runtime. Levels define the importance of each trace, and keywords define which part of the code each trace belongs to. For the sake of simplicity, we will ignore keywords.

A few standard levels are defined in evntrace.h:

#define TRACE_LEVEL_CRITICAL    1   // Abnormal exit or termination
#define TRACE_LEVEL_ERROR       2   // Severe errors that need logging
#define TRACE_LEVEL_WARNING     3   // Warnings such as allocation failure
#define TRACE_LEVEL_INFORMATION 4   // Includes non-error cases (e.g., Entry-Exit)
#define TRACE_LEVEL_VERBOSE     5   // Detailed traces from intermediate steps

Using this function, we can implement tracing with very little impact on performance when the code is not being traced.

#include <windows.h>
#include <wmistr.h>
#include <evntprov.h>
#include <evntrace.h>
#include <strsafe.h>

REGHANDLE g_ETWHandle = NULL;
BOOL g_bEnabled = FALSE;
UCHAR g_nLevel = 0;

void NTAPI EnableCallback(
    LPCGUID /*SourceId*/,
    ULONG IsEnabled,
    UCHAR Level,
    ULONGLONG /*MatchAnyKeyword*/,
    ULONGLONG /*MatchAllKeywords*/,
    PEVENT_FILTER_DESCRIPTOR /*FilterData*/,
    PVOID /*CallbackContext*/
)
{
    switch (IsEnabled) 
    {  
        case EVENT_CONTROL_CODE_ENABLE_PROVIDER:  
            g_bEnabled = TRUE;
            g_nLevel = Level;
            break;

        case EVENT_CONTROL_CODE_DISABLE_PROVIDER:  
            g_bEnabled = FALSE;
            g_nLevel = 0;
            break;
    }
}

void TraceInitialize()
{
    // Provider ID: {BAADC0DE-0D5E-42EC-A8EF-56F7DC7F7C82}
    // TODO: Generate a new unique provider ID. Do not reuse this GUID.
    static const GUID guidTrace = {0xbaadc0de, 0xd5e, 0x42ec, {0xa8, 0xef, 0x56, 0xf7, 0xdc, 0x7f, 0x7c, 0x82}};
    (void) EventRegister(&guidTrace, EnableCallback, NULL, &g_ETWHandle);
}

void TraceUninitialize()
{
    if (g_ETWHandle)
    {
        (void) EventUnregister(g_ETWHandle);
        g_ETWHandle = NULL;
        g_bEnabled = FALSE;
     g_nLevel = 0;
    }
}

void CDECL TraceFormat(UCHAR nLevel, PCWSTR pszFormat,  ...)
{
    if ((0 == g_nLevel) || (nLevel <= g_nLevel))
    {
        WCHAR szTrace[1024];

        va_list args;
        va_start(args, pszFormat);
        (void) StringCchVPrintfW(szTrace, ARRAYSIZE(szTrace), pszFormat, args);
        va_end(args);

        (void) EventWriteString(g_ETWHandle, nLevel, 0, szTrace);
    }
}

#define Trace(level, format, ...) if (g_bEnabled) TraceFormat(level, format, __VA_ARGS__);

Adding traces to your code then looks like
INT wmain(INT /*argc*/, PCWSTR /*argv*/[])
{
    TraceInitialize();

    Trace(TRACE_LEVEL_INFORMATION, L"MyTrace> Hello, world!");
    Trace(TRACE_LEVEL_ERROR, L"MyTrace> Something bad happened: %i", 42);
    
    TraceUninitialize();

    return 0;
}

This code is minimalist on purpose and could easily be expanded by adding other useful information, such as __FUNCTION__, the ‘this’ pointer, function scope (enter/exit), the returned HRESULT, or a trace header that is better than “MyTrace>” to make it easier to filter the traces.

For MFTrace to log the traces, it needs know which Provider ID (the GUID in TraceInitialize) to trace and which level and keyword to use. This is done by creating a small XML configuration file:

<?xml version='1.0' encoding='utf-8'?>
<providers>
    <provider level="5" ID="BAADC0DE-0D5E-42EC-A8EF-56F7DC7F7C82" >
        <keyword ID="0xFFFFFFFF"/>
    </provider> 
</providers>

Then add ‘-c config.xml’ to the command line of MFTrace (assuming the file is named config.xml).

The configuration file is documented on MSDN.

If you are writing a DLL instead of an EXE, TraceInitialize and TraceUninitialize should be called inside DllMain during DLL_PROCESS_ATTACH and DLL_PROCESS_DETACH respectively. It is usually a bad idea to do anything significant in DllMain, but EventRegister and EventUnregister are designed to be safe to call there.

Although tracing using EventWriteString is more efficient than OutputDebugString, Windows offer even more efficient APIs to do tracing: ETW and WPP. However, they are also more complex to set up.

Tracing using ETW/WPP

ETW and WPP optimize tracing one step further. They reduce the performance impact of tracing when tracing is enabled. Instead of formatting the trace messages inside the process being traced, they format them inside the process listening for traces. This way, tracing does not disturb the traced process as much.

WPP also reduces the size of binaries by storing format strings in PDB/TMF symbol files, rather than inside the binaries themselves. This provides a form of obfuscation, because traces can be logged without symbol files but are very difficult or even impossible to analyze without those symbol files. For that reason among others, WPP is better suited for internal traces which are not meant to be used by customers.

ETW on the other hand is better suited for traces which need to be public. Our first blog post on MF tracing showed how to capture ETW traces using the OS Event Viewer. ETW defines traces using manifests, and supports localization of the format strings.

Covering those two tracing systems would require several more blogs due to their complexity, so for more information please refer to MSDN.

That’s it for this series of blogs on tracing Media Foundation. Do not hesitate to post comments here, or questions on the Media Foundation forum.

Getting Started

First, install Perl, GraphViz, and Gnuplot. Then open a command prompt and add Gnuplot to your path. For example:

set PATH=%PATH%;C:\Program Files\gnuplot\binary

The exact path to Gnuplot on your machine might differ. The installers for Perl and GraphViz automatically add the path, so those two applications should already be in your path.

Next, download the following Perl scripts from MSDN Code Gallery:

• ParseTopologies.cmd
• ParseTimestamps.cmd
• ParseDirectShowGraphs.cmd

The scripts in the download package have a .txt file extension. Rename them to have a .cmd extension.

In the following, we assume that a log file was captured using MFTrace and saved to .\mf.log. If you need a refresher on MFTrace, please refer to our previous posts and to MSDN.

Drawing Topologies

Recall that Media Foundation takes various pipeline components (sources, decoders, sinks) and assembles them into a topology. It is hard to visualize a topology just by reading a trace log. A picture of a topology would be much easier to understand. That’s exactly what our first script does: It searches the log for traces that describe the topology, saves these in a format that GraphViz understands, and runs GraphViz to create an image.

Running the script is straightforward:

ParseTopologies.cmd mf.log

The script creates several images which represent the topology at different stages of topology resolution. The first topology is the input to the Media Session, and often looks like this:

Each node represents a component of the topology. Media types shared by two connected components are displayed along the line of the connection.

The node colors have the following meaning:

Activation objects are like placeholders that have been inserted into the topology in place of the components themselves. As the topology gets resolved, the actual components are instantiated and gradually replace the activation objects:

This topology represents the “ready” state. It contains two branches:

• A video branch, shown on the right. This branch is fairly straightforward. It contains just a source node, a decoder, and a sink node.
• An audio branch, shown on the left. This branch is a bit more complicated. It contains a source node, a decoder, several effects, a tee, another effect, and finally two sink nodes.

Plotting Sample Time Stamps

Just like topologies, time stamps are much simpler to analyze with some visual aid. This is what the second script creates, with the help of Gnuplot.

Again, running the script is straightforward:

ParseTopologies.cmd mf.log [-absolute]

By default, time stamps are plotted as the difference between the time stamp and wall-clock time. If you want to plot time stamps as a function of wall-clock time, add the “-absolute” command-line option.

For playback scenarios, the difference is usually more interesting, as it results in flat graphs when samples flow smoothly (i.e. real time). The “-absolute” option is geared toward transcoding scenarios, where you want the samples flow as fast as possible.

The script plots one graph per component. The time stamps from input samples are plotted in green, and the time stamps from output samples are plotted in blue. The gap between the two gives an idea of the latency of the component. However, tracing adds some latency to the measurements, so the gap should be viewed as an upper bound on the latency.

Here is an example of what you do not want to see in a playback scenario: two major glitches in an otherwise smooth playback.

The script also prints a few statistics at the command prompt about the components in the topology. This can be useful to quickly determine whether some components were not generating samples as they should have.

Drawing DirectShow graphs

Because MFTrace also captures some DirectShow traces, it is also possible to draw DirectShow graphs. Here is the graph for playing a WTV file.

ParseDirectShowGraphs.cmd mf.log

As you can see, WTV playback can be quite involved.

That’s all for now. Next time, we will see how to add custom traces from components or applications to the MFTrace logs. In the meantime, do not hesitate to post comments here, or questions on the Media Foundation forum.

TextAnalysisTool.NET

One (free) tool that we often use is TextAnalysilTool.NET. The tool itself is rather minimalist: It just loads log files and lets you enter string patterns to filter out or highlight traces. However, it is very effective at focusing on what matters. Installing TextAnalysisTool.NET is straightforward—just download and uncompress the zip file.

Starting where we left off in the previous post, let’s collect another trace from Windows Media Player. Open an elevated command prompt, add the SDK to your path (see the previous post), and run Windows Media Player under MFTrace:

MFTrace.exe -o mf.log "%PROGRAMFILES%\Windows Media Player\wmplayer.exe" "%PUBLIC%\Videos\Sample Videos\Wildlife.wmv"

Let the video play for a few seconds. Then close Windows Media Player. At this point, you should have a log file named “mf.log” in the current directory. Open this file with TextAnalysisTool.NET as follows:

TextAnalysisTool.NET.exe mf.log

TextAnalysisTool.NET will show two views. The traces appear in the top view. The bottom view contains string patterns that filter or highlight the traces.

To filter out traces, select Add new filter from the Filter menu, or type CTRL+N. In the Add Filter dialog, enter a string pattern and choose a highlight color:

You can also select whether the string is case-sensitive or uses a regular expression. When you click OK, traces that do not match the pattern will appear grayed out. To completely hide those traces, select Show only filtered lines from the View menu, or type CTRL+H.

This should be enough to get you started. For more details on how to use TextAnalysis, see the help file “TextAnalysisTool.NET.txt,” which is contained in the zip file.

Tips and tricks to analyze traces

One of the first filters to use on a trace is the string “fail”. Traces that contain this string are likely to indicate problems. For example, the following trace shows where a codec rejected a proposed media type:

00120 3992,B28 23:14:38.80074 CMFTransformDetours::SetInputType @00672C90 Failed MT: MF_MT_MAJOR_TYPE=MEDIATYPE_Video;MF_MT_SUBTYPE=MFVideoFormat_WMV3;MF_MT_FRAME_SIZE=3092376453600 (720,480);MF_MT_USER_DATA=4f d1 1a 01 ;MF_MT_AVG_BITRATE=1895000;MF_MT_FRAME_RATE=128849018881001 (30000,1001);MF_MT_PIXEL_ASPECT_RATIO=34359738377 (8,9);MF_MT_INTERLACE_MODE=2

Note that some failures may be benign. For example, the following trace just means that the codec needs another sample before it can produce some output:

00489 6072,10E4 16:23:07.47317 CMFTransformDetours::ProcessOutput @0357ED34 failed hr=0xC00D6D72 MF_E_TRANSFORM_NEED_MORE_INPUT

This error code is expected during normal streaming, unless all the calls to ProcessOutput return this error code. For example, this can happen if the H.264 decoder does not find a valid start code within the H.264 bitstream.

The log file can also tell you whether the topology was successfully resolved and how the pipeline components got connected (or not). To figure this out, filter traces that contain the string “TopologyHelpers”:

00248 6072,DC0 16:23:07.21976 CTopologyHelpers::Trace @02F21080 >>>>>>>>>>>>> ready topology
00249 6072,DC0 16:23:07.22002 CTopologyHelpers::TraceNode @ Node 0 @02EFC0D0 ID:17B800000007, 0 inputs, 1 outputs, type 1, {528E8D22-311F-4B88-BCE8-22A2374E8CFC}=1;MF_TOPONODE_SOURCE=@02EDBE48; (…)
00250 6072,DC0 16:23:07.22008 CTopologyHelpers::TraceObject @ Source @02EDBE48 {00000000-0000-0000-0000-000000000000} (C:\Windows\system32\MF.dll), MFMEDIASOURCE_CHARACTERISTICS=0x00000006
00251 6072,DC0 16:23:07.22018 CTopologyHelpers::TraceStream @ Output stream 0, connected to node @02EFC170 stream 0, MT: MF_MT_MAJOR_TYPE=MEDIATYPE_Audio; (…)
00252 6072,DC0 16:23:07.22040 CTopologyHelpers::TraceNode @ Node 1 @02EFC030 ID:17B800000009, 1 inputs, 0 outputs, type 0, (…)
00253 6072,DC0 16:23:07.22044 CTopologyHelpers::TraceObject @ Sink @02F1DF58 {D23E6476-B104-4707-81CB-E1CA19A07016} (C:\Windows\system32\MF.dll), (null)
00254 6072,DC0 16:23:07.22053 CTopologyHelpers::TraceStream @ Input stream 0, connected to node @02F19DA8 stream 0, MT: MF_MT_MAJOR_TYPE=MEDIATYPE_Audio;(…)
(…)
00293 6072,DC0 16:23:07.22528 CTopologyHelpers::Trace @02F21080 MF_TOPOLOGY_RESOLUTION_STATUS = 0
00294 6072,DC0 16:23:07.22529 CTopologyHelpers::Trace @02F21080 <<<<<<<<<<<<< ready topology

If everything went well, as is the case here, the resolution status is zero. The rest of the selected traces give details about each of the components in the topology and how they are connected to one another. Among other things, this information includes the media type of the connection.

Another useful filter is the object address, which allows you to focus on the lifetime of one object in particular. For instance, the following traces were selected by filtering with “0357ED34”. They show the first few calls on a Windows Media Player effect.

00149 6072,DC0 16:23:06.91749 CMFTransformDetours::SetInputType @0357ED34 Succeeded MT: MF_MT_MAJOR_TYPE=MEDIATYPE_Audio;(…)
00151 6072,DC0 16:23:06.91919 CMFTransformDetours::SetOutputType @0357ED34 Succeeded MT: MF_MT_MAJOR_TYPE=MEDIATYPE_Audio; (…)
00194 6072,DC0 16:23:07.18577 CTopologyHelpers::TraceObject @ MFT @0357ED34 {777D0CFF-0375-43B9-8532-FB04A4903593} (C:\Windows\System32\wmpeffects.dll), <NULL>
00230 6072,DC0 16:23:07.19396 CMFTransformDetours::ProcessMessage @0357ED34 Message type=0x10000000 MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, param=00000000
00473 6072,9B0 16:23:07.40790 CMFTransformDetours::ProcessMessage @0357ED34 Message type=0x10000003 MFT_MESSAGE_NOTIFY_START_OF_STREAM, param=00000000
00489 6072,10E4 16:23:07.47317 CMFTransformDetours::ProcessOutput @0357ED34 failed hr=0xC00D6D72 MF_E_TRANSFORM_NEED_MORE_INPUT
00508 6072,10E4 16:23:07.59281 CMFTransformDetours::ProcessInput @0357ED34 Stream ID 0, Sample @083C8720, Time 0ms, Duration 46ms, Buffers 1, Size 16384B, MFSampleExtension_CleanPoint=1;MFSampleExtension_Discontinuity=1;MFSampleExtension_SampleKeyID=1;MFSampleExtension_Token=@00000000
00509 6072,10E4 16:23:07.59628 CMFTransformDetours::ProcessOutput @0357ED34 Stream ID 0, Sample @083C8810, Time 0ms, Duration 46ms, Buffers 1, Size 16384B, MFSampleExtension_CleanPoint=0

In this sequence of calls, Windows Media Player sets the media types on the effect, notifies the effect that streaming is about to start, and processes one sample.

That’s all for now, but more examples are shown on the MSDN page dedicated to MFTrace. In the next post, we will share a few Perl scripts that automate trace analysis and use the power of GraphViz and GNUPlot to create graphical representations of topologies.

After installing the SDK, MFTrace is available in two flavors:

- 32b in %PROGRAMFILES%\Microsoft SDKs\Windows\v7.1\Bin

- 64b in %PROGRAMFILES%\Microsoft SDKs\Windows\v7.1\Bin\x64

The tool itself is made of three binaries (MFTrace.exe, MFDetours.dll, detoured.dll) and an optional configuration file (mftrace.xml). From the name of the binaries, it should not come as a surprise that the tool relies heavily on the Detours library to inject itself into the target process and intercept function calls.

The traces usually follow the pattern of a process and thread ID, followed by a timestamp, the name of the function called, and some function parameters:

In some cases, MFTrace goes one step further and does some deep inspection of the function parameters to gather more details—for instance, displaying entire topologies.

Collecting your first trace

As a first practice, let’s use our favorite guinea pig: Notepad. MFTrace can indeed target any application, not just those based on Media Foundation. As a matter of fact, MFTrace also intercepts some functions from COM, DirectShow, and DirectX.

First, open an elevated command prompt:

Then add the SDK to your path, if you haven’t already done so:

set PATH=%PATH%;“%PROGRAMFILES%\Microsoft SDKs\Windows\v7.1\Bin”

(add ‘x64’ at the end if using the 64b version of MFTrace)

Now run Notepad under MFTrace:

MFTrace.exe notepad.exe

MFTrace will start printing a few traces at the command prompt. To make things a little more interesting, try opening some file in Notepad. Right away you will see a large number of calls to CoCreateInstance:

To end tracing, just close Notepad or hit CTRL+C.

Note: 32-bit processes on 64-bit Windows

If you are using a 32-bit version of Windows, you can skip this warning. Otherwise, please read on. MFTrace comes in two flavors: 32-bit and 64-bit. Each version can only trace processes of the same kind, so if you want to trace a 32-bit process you need to use 32-bit MFTrace; and if you want to trace a 64-bit process, you need to use 64-bit MFTrace. Where it gets tricky is that some processes (such as Windows Media Player) run by default as 32-bit processes on 64-bit Windows.

One way to tell whether a process is 32- or 64-bit is to look at its path:

• 32-bit processes can be found under %PROGRAMFILES(X86)%
• 64-bit processes can be found under %PROGRAMFILES%

Usually these environment variable resolve to “c:\program files (x86)” for 32-bit, and “c:\program files” for 64-bit.

Another way is to open the Task Manager (CTRL+SHIFT+ESC) and look for ‘*32’ at the end of process names.

Collecting your first useful trace

Printing traces at the command prompt is nice, but too slow to handle the amount of traces that are generated by media applications. Instead, traces can be redirected to a file using the ‘-o’ command-line parameter.

Besides starting a new process, MFTrace can also attach to an existing process via the ‘-a’ command-line parameter. This parameter accepts either a process name or a process ID. One word of caution: MFTrace is only able to intercept function calls on objects which have been created after MFTrace attached itself. So if you start playing a video in Windows Media Player and then attach MFTrace to it, MFTrace will miss most of the action.

Armed with that knowledge, we can now start tracing something a bit more interesting: Windows Media Player. Open Windows Media Player and attach MFTrace with this command line:

mftrace.exe -a wmplayer.exe -o mf.log

Then open a media file in Windows Media Player (for example, "%PUBLIC%\Videos\Sample Videos\Wildlife.wmv"), let it play for a few seconds, exit MFTrace (CTRL+C), and open mf.log in your favorite text editor. You will have a detailed record of what Media Foundation and its components have been doing in the background to play the file.

Logs tend to contain a huge amount of data, which can be quite overwhelming at first. In the next installments of this blog series, we will try to make sense of them. We will also see how to add traces from your own components and applications, to get a fuller picture of what is going on.

In the meantime, for more help see ‘mftrace.exe -?’, the MSDN page dedicated to MFTrace, or post questions on the Media Foundation forum.

Without these traces, finding when and why a failure happened in Media Foundation can be very tricky, because:

• Media Foundation is asynchronous.
• Many components come into play when processing media data (the pipeline, codecs, sources, sinks, etc.).
• Some applications, such as Windows Media Player, use fallback mechanisms to be able to play as many files as possible.

This means that errors may get reported a long time after the failure actually took place, and the component that reports the error might not be related to the component that actually caused the failure.

Enabling Media Foundation traces in Event Viewer

Event Viewer can be found by typing ‘event’ in the search box of the Start menu:

To log Media Foundation traces, the verbosity of Event Viewer must be increased from its default. To do so, go to the View menu and select Show Analytic and Debug Logs:

The Media Foundation logs can be found in the left pane of Event Viewer, under Event Viewer (Local) > Applications and Services Logs > Microsoft > Windows. They are grouped into five categories:

• MediaFoundation
• MediaFoundation-MFReadWrite (Source Reader, Sink Writer)
• MediaFoundation-Performance
• MediaFoundation-Platform
• MediaFoundation-PlayAPI (MFPlay API)

Clicking on a log will show some options on the right pane of Event Viewer related to this log. Two of them are particularly useful: Enable Log starts collecting traces, and Refresh forces Event Viewer to display the traces received so far.

Analyzing traces

After traces have been collected, the next step is to figure out which ones are of interest and how to interpret them. As a starting point, the following FAQ lists some questions that can be answered by looking at the logs, and which traces to look for.

Which API did Windows Media Player use for playback?

Windows Media Player relies either on Media Foundation, DirectShow, or the Format SDK, depending on the type of content being processed. To figure out which API was used, view the log named ‘MediaFoundation-Platform > Media Foundation Platform,’ and look for:

Windows Media Player Playback URL=C:\Users\Public\Videos\Sample Videos\Wildlife.wmv Graph Type=3 hr=0x0

The graph type can be:

1. Media Foundation was run inside a secure Protected-Media-Path process (usually for DRM content).
2. Media Foundation was run inside a non-secure Protected-Media-Path process. This type of graph is used for increased reliability. If a component crashes, it does not crash the main process.
3. Media Foundation was run inside the main process.
4. The Format SDK was used.
5. DirectShow was used.

Was Media Foundation started or shut down?

In log named ‘MediaFoundation-Platform > Media Foundation Platform,’ look for:

MFStartup returned 0x0

Start MFShutdown

End MFShutdown - return code 0x0

Could the content be opened?

In the log named ‘MediaFoundation-Platform > Media Foundation Platform,’ look for events similar to the following:

Source Resolver Context(0x7318128) Resolve C:\Users\user1\Videos\Video1.45.wmv flags 0x21

Source Resolver Context(0x7318128) Trying Scheme Handler "File Scheme Handler"

Source Resolver Context(0x7318128) Trying Byte Scheme Handler CLSID("ASF Byte Stream Handler")

Source Resolver Context(0x7318128) SchemeHandler Result 0x0

Source Resolver Context(0x7318128) Byte stream Handler Result 0x0

Source Resolver Context(0x7318128) Resolving file:///C:/Users/user1/Videos/Video1.wmv returned 0x0

Were transforms found to decode/encode the content?

In the log named ‘MediaFoundation-Platform > Media Foundation Platform,’ look for events similar to the following:

MFTEnumEx flags 0x57, category {d6c02d4b-6833-45b4-971a-05a4b04bab91} for input type ({73646976-0000-0010-8000-00aa00389b71},{33564d57-0000-0010-8000-00aa00389b71}), output type ({00000000-0000-0000-0000-000000000000},{00000000-0000-0000-0000-000000000000})

Found matching software MFT "WMVideo Decoder DMO"

MFTEnumEx returned code 0x0, found 0 local MFTs, 0 hardware MFTs and 1 MFT CLSIDs

Did the topology resolution succeed?

In the log named ‘MediaFoundation > Media Foundation Pipeline,’ look for:

IMFTopoLoader::Load start

This event will be followed by

IMFTopoLoader::Load returned 0x0

in case of success, or

IMFTopoLoader::Load returned 0xc00d5212

in case of failure. (The exact error code may vary.)

Did the Media Session start?

In the log named ‘MediaFoundation-Performance > Media Foundation Performance,’ look for:

Media Session Begin Start Tag=MsBp Object=0x88cec88 Parameter=0x0

Did transforms process data?

In the log named ‘MediaFoundation-Performance > Media Foundation Performance,’ look for events similar to the following:

ProcessInput Tag=AfMs Object=0x62ddec0 Object Category=9 Sample=0x8686e28 Buffer Size=65536 Sample Time=0 Processing Time=149

ProcessOutput Tag=AfMs Object=0x62ddec0 Object Category=9 Sample=0x70efdd0 Buffer Size=62335 Sample Time=330000 Processing Time=17

That’s it. Do you find this article useful? Do you have questions on tracing your Media Foundation code? Please leave a comment.

Technologies Demonstrated

• IMFSourceReader – used to obtain raw video frames for display when the user is examining the video, and to read frames when MFDub is writing a new output file.
• IMFMediaSession – used to play the video normally so the user can preview what the video will actually look like in a media player.
• IMFSinkWriter – used to write the output file when the user is done editing.
• IMFTransform – video and audio effects are implemented as MF transforms. MFDub communicates with transforms directly to process video effects.

Setup

MFVE.exe is the main application. Just double click the MFVE.exe file to run it. MFVEUTIL.dll contains the video and audio effects that make MFVE.exe useful. MFDub would be pretty boring without any effects! Make sure to register MFVEUTIL.dll before using MFDub, by opening up an elevated command prompt window, navigating to the directory containing MFDub, and entering the command ‘regsvr32 MFVEUTIL.dll’. You can create an elevated command prompt window by going to the Start Menu, selecting All Programs, selecting Accessories, right clicking on ‘Command Prompt’ and selecting ‘Run as Administrator’.

How to Use MF Dub

When you start MFDub, the only thing you can do at first is open a file. Click on the Open button on the toolbar, and find a video file to work with. By default, MF supports .asf, .wmv, .mp4, .m4v, and some .avi files. MFDub should then look something like this:

Now let’s apply some video effects. Once you click the ‘Video MFTs’ button, a dialog box is displayed with a list of transforms. (You did register MFVEUTIL.dll as noted under setup, right?) You can click on the name of each transform to get a short description about what it does. I am going to go with the edge finder since it applies an obvious effect to the video:

Notice how the box labeled ‘edge finder’ has appeared in my list of transforms. If you do not like the effect, you can click and drag the box outside the transform list and drop it – MFDub will get rid of the transform. You can also add more than one transform at a time, if you like. Using the ‘unsharp mask’ transform with a gamma value of 3 really sharpens up the edges. You can switch the order of the transforms by clicking and dragging the transform box to where you would like it to be in the transform list. The order of the transforms can greatly affect the output video.

Since I really like transforms, I am just going to apply them all except for the resize and crop transform. Since I applied an audio transform, I used the play button to play the preview of the edited video to hear that I set the volume compression level to a reasonable value. Here’s what MFDub looks like right before I save the video:

I do not know exactly what I would do with such an output video. Maybe I could sell it as piece of cubist art. Anyway, the final step is to save the output video to a file. Click the save dialog and enter a file name for the output video. MFDub will automatically determine the file format for the output video based upon the extension. For example, a .wmv file will be an ASF format file, and an .mp4 file will be an MPEG4 format file. Since my input file was a .wmv, I will make the output file a .mp4 for a change. Once you click save, you will be informed of the encoding progress at the bottom of the window. Once encoding is complete, you can play back your video in any media player that supports the file format you selected. Here is my output video playing back in Windows Media Player:

Design Choices

MFDub brings a bunch of different MF components for different purposes. Part of the core functionality of MFDub is the ability to display individual video frames as the user seeks around the video using the track bar control. The source reader provides a simple and lightweight way for grabbing video frames from a media file. Then these video frames can be processed manually through a series of transforms. The media session does not easily allow for grabbing individual frames at a time, and also does not easily allow insertion and removal for transforms.

Playing the video presents a different set of problems. The source reader does not handle things like audio/video synchronization, and any rendering has to be done manually. The media session handles playing video very well, and hides many of the complexities of playback from the application. This made it a good choice for handling the preview playback.

For writing the output video, MFDub uses the sink writer. The sink writer presents an easy way to write raw video frames to a file. The transcode API provides a more configurable way of writing a new output file, but since MFDub already had the manual transform processing and did not require the extra customizability, the sink writer was used instead.

Interesting Code

• Transformapplier.cpp shows how an application can use an IMFTransform independently of any other MF components to process audio and video data.
• Mediatranscoder.cpp combines the source reader and the sink writer into a component that can be used to transcode an input file into an output file.
• Topologybuilder.cpp demonstrates how an application might build a topology for use in the MF media session.
• Sampleprovider.cpp uses the source reader to create a simple component for reading video frames.

In the dll directory, you can find the source code to all of the transforms that come with MFDub by default. MFDub uses a set of base classes for transforms to implement all of the common functionality, leaving just the data processing to be implemented for the actual transform object.

Limitations

Dragging the tracker around to seek around the video can be slow. MFDub uses a rather naïve implementation for grabbing samples from the source file. With some cleverness and creativity, the performance of ‘scrubbing’ the video using the tracker could be improved.

MFDub only has several transforms. Without more transforms, it is not terribly useful for video editing. Thankfully, the base classes make it pretty easy to create your own transforms!

Downloading the Sample

You can download MFDub from https://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=mfblog&DownloadId=9371.

Follow the instructions at https://code.msdn.microsoft.com/mfblog for tips and instructions to build the sample.

This posting is provided "AS IS" with no warranties and confers no rights.

This is a managed tool written in C# and XAML that converts files from one media format to another. The source code is provided to use as a reference on how to interop with source reader, sink writer and the transcode API from a managed environment.

The sample previews media files using WPF’s MediaElement object and a custom control that can be used to trim the output media.

Supported output formats:

• Windows Media (WMV with WMA)
• MPEG-4 (H.264 with AAC)

Technique

The tool converts media files using the basic functionality of new APIs introduced with Windows 7. Two different methods are implemented by the tool:

• Configure the media session using the high level transcode API.
• Use source reader and sink writer.

Since Media Foundation is built on COM the required interfaces and unmanaged calls were ported to C# using .NET interoperability capabilities.

The transcode API provides the following benefits:

• The media session controls the operation. Therefore, there is no need to manipulate the samples manually.
• Media samples are not brought to the managed environment which improves speed and memory usage.

Source reader and sink writer provide the following benefits:

• Media sample attributes can be edited individually which gives more control to the developer.
• The media sample raw data can be acquired from the buffers and used for other purposes (for example it is easy to copy the data from a video sample to a System.Drawing.Bitmap object).

Usage

When the application is executed the main window will show up (Figure 1).

Figure 1

1.  Select the media file you want to convert by clicking the “Browse…” button to the right of the “Source” text box. When you do this the source location will be automatically chosen as the output folder.
2.  Change the output folder by clicking the “Browse…” button to the right of the “Output folder” text box.
3.  Start playback by clicking on the media frame.
4.  Seek to different positions by moving the arrow located below the time bar.
5.  Convert only a selected portion of the media by moving the blue controls in the time bar to adjust the start and end times.
6.  Select the output media format from the “Format” dropdown list.
7.  Select the output video size from the “Video size” dropdown list.
8.  Bring up options for changing the audio codec, video codec, audio bit rate or video bit rate by clicking on “Advanced options” at the bottom-left corner of the window.
9.  Start the transcode operation by clicking continue. The progress window will show up and the conversion will begin (Figure 2).

Figure 2

   10. The conversion window (Figure 2) will be automatically closed when the conversion is complete.

Limitations

The sample is made using WPF so Visual Studio 2008 or later is required. If you don’t have Visual Studio 2008 the sample can be compiled using Visual C# 2008 Express Edition which can be downloaded for free from the Microsoft Website.

Only the COM interface methods used by the tool have been tested; marshaling of unused methods could be wrong or missing the correct enumerations or object definitions.

Project Structure

\MFManagedEncode.csproj

The main C# project generated by Visual Studio. It contains information about the platforms, configurations and project  features.

\MediaFoundation\Interop\Classes.cs

Definitions of the COM classes needed.

\MediaFoundation\Interop\Constants.cs

Media Foundation constants needed.

\MediaFoundation\Interop\Enums.cs

Media Foundation enumerations needed.

\MediaFoundation\Interop\Interfaces.cs

Definition of the Media Foundation COM interfaces needed to perform the format conversion.

\MediaFoundation\Interop\Structures.cs

Structures that help interoperating with Media Foundation COM objects.

\MediaFoundation\Interfaces\ISimpleEncode.cs

C# interface used by the encoding classes.

\MediaFoundation\Classes\SimpleFastEncode.cs

C# class that inherits ISimpleEncode and encodes content using the Windows 7 transcode API.

\MediaFoundation\Classes\SimpleSinklWriterEncode.cs

C# class that inherits ISimpleEncode and encodes content using source reader and sink writer.

\MediaFoundation\Classes\EncapsulatedSample.cs

C# class that keeps track of the unmanaged memory used by samples and simplifies garbage collection.

\MediaFoundation\Common\Classes.cs

Support classes used by the tool.

\MediaFoundation\Common\Helper.cs

Exports the required Media Foundation functions from mfplat.dll and mf.dll.

\App.xaml

Holds the attributes that control the startup behavior.

\App.xaml.cs

Interaction logic for App.xaml.

\GUI\Controls\VideoTrimmer.xaml

Graphic design and animations of the user control used to trim media content.

\GUI\Controls\VideoTrimmer.xaml.cs

Interaction logic for VideoTrimmer.xaml which handles user input and events such as resizing.

\GUI\Windows\MainWindow.xaml

The main application window used to load media files and set the conversion parameters.

\GUI\Windows\MainWindow.xaml.cs

Interaction logic for MainWindow.xaml.

\GUI\Windows\ProgressWindow.xaml

The window that is shown during format conversion and displays the progress and estimated remaining time.

\GUI\Windows\ProgressWindow.xaml.cs

Interaction logic for ProgressWindow.xaml.

Downloading the Sample

You can download MFManagedEncode from https://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=mfblog&DownloadId=9174

Follow the instruction at https://code.msdn.microsoft.com/mfblog for tips and instructions to build the sample.

This posting is provided "AS IS" with no warranties and confers no rights.

This is a command line tool showcasing the Windows 7 Media Foundation APIs to read media source attributes and metadata. It also shows how to leverage the Windows Media Format SDK to read DRM properties. The source code can be useful for learning about Media Foundation. The built executable can be useful for dumping media file properties for debugging, or simply to get information about a media file, such as the frame size, frame rate, bit rate, or sample rate.

This sample can display properties for any media file format that is supported by Media Foundation.

Media Foundation does not currently have support for reading DRM properties, so the legacy Format SDK is used for that reason in the sample. Using Format SDK is otherwise discouraged, as it supports only Windows Media file formats and has some other key disadvantages. Media Foundation supports a much wider set of media file formats.

Here’s a sample screenshot of MFMediaPropDump:

Figure 1. Dumping media properties of a WMV file using MFMediaPropDump

Techniques:

Media files contain numerous properties that apply to the file as a whole. Some properties specify the parameters with which the file was encoded (media source attributes), some contain descriptive information (metadata), and some contain information on usage restrictions (DRM properties).

Although metadata contains descriptive information for the media content, it might also contain information about the file encoding. Sometimes it’s faster to access file-encoding information through metadata than through media source attributes.

DRM properties are available only for a Windows Media DRM protected file and reside in the DRM license.

Examples of encoding parameters are encoding algorithm (media subtype), video frame size, video frame rate, audio bit rate, and audio sample rate. Encoding parameters are read using MF attributes.

Examples of metadata are title, artist, composer, genre, and movie director. There are two ways to read metadata: by using Media Foundation with the IMFMetadata interface (Media Foundation metadata), and by using the Windows Shell IPropertyStore interface (shell metadata). Media Foundation metadata and shell metadata complement each other. Shell metadata pertains not only to media files but to a much wider range of files on the system and the set of properties even for media files is richer than Media Foundation metadata. Media Foundation metadata on the other hand pertains only to media files and has support for per-stream metadata in a media file that shell metadata doesn’t have.

Examples of DRM properties are the number of allowed playbacks and the number of synchronizations to portable devices.

How to read media source attributes:

• Create a media source (IMFMediaSource) from the media content URL.
• Get the presentation descriptor (IMFPresentationDescriptor) from the media source.
  • Read presentation descriptor attributes (IMFAttributes).
• Get the stream descriptor (IMFStreamDescriptor) for each stream in presentation descriptor.
  • Read stream descriptor attributes (IMFAttributes).
• Get the media type (IMFMediaType) for each stream descriptor.
  • Read media type attributes (IMFAttributes).

How to read metadata:

• Create the media source (IMFMediaSource) from the media content URL.
• To read Media Foundation metadata, use the IMFGetService interface to get the IMFMetadata interface from the media source. Use the IMFMetadata interface to read the metadata.
• To read shell metadata, use IMFGetService to get the IPropertyStore interface from the media source. Use the IPropertyStore interface to read the metadata.

How to read DRM properties:

• Create the Format SDK metadata editor (IWMMetadataEditor) from the media content path.
• Get the DRM editor (IWMDRMEditor) from the metadata editor.
• Query the DRM editor for every DRM property.

To read more about presentation descriptors and stream descriptors: https://msdn.microsoft.com/en-us/library/ms698961(VS.85).aspx

To read more about media types: https://msdn.microsoft.com/en-us/library/bb530109(VS.85).aspx

To read more about media attributes: https://msdn.microsoft.com/en-us/library/dd206754(VS.85).aspx

To read more about media properties: https://msdn.microsoft.com/en-us/library/dd206755(VS.85).aspx

To read more about metadata: https://msdn.microsoft.com/en-us/library/aa368930(VS.85).aspx

To read more about reading DRM properties: https://msdn.microsoft.com/en-us/library/dd743976(VS.85).aspx

Project Structure:

MediaPropDump.vcproj

The main project file for VC++ projects generated using an Application Wizard. It contains information about the version of Visual C++ that generated the file, and information about the platforms, configurations, and project features selected with the Application Wizard.

wmain.cpp

Contains the application entry point, command line parsing, and error reporting.

MediaPropDump.cpp

Contains routines to display media type, metadata, and DRM properties.

SourceResolver.cpp

Contains a function that creates an IMFMediaSource instance from a from file path, by using the IMFSourceResolver interface.

MediaTypeDump.cpp

Displays media attributes from the presentation descriptor, stream descriptors, and media types exposed by a media source.

MetadataDump.cpp

Displays both Media Foundation metadata and shell metadata.

DRMDump.cpp

Displays DRM properties by using Format SDK.

Helper.cpp

Contains helper routines for output formatting.

Usage:

MFMediaPropDump.exe [-?] -f file

-?

Display usage information.

-f file

This is the path to a file with any media format supported by Media Foundation. List of supported media formats: https://msdn.microsoft.com/en-us/library/dd757927(VS.85).aspx

Examples:

Dump WMV file properties:

MFMediaPropDump.exe -f input.wmv

Dump MPEG-4 file properties:

MFMediaPropDump.exe -f input.mp4

Dump MP3 file properties:

MFMediaPropDump.exe -f input.mp3

Dump AVI file properties:

MFMediaPropDump.exe -f input.avi

Limitations:

1. For DRM properties in a file, the DRM license should be acquired first. This can be done simply by playing the file in Windows Media Player, which will trigger license acquisition (either silent or non-silent, which prompts the user to acquire the license). Once the license is acquired, you can use MFMediaPropDump to display DRM properties in the file.
2. The tool fails if the file format is not supported by Media Foundation.
3. For ASF files with multi-language Media Foundation metadata the tool currently dumps only the default language metadata.

Downloading the Sample

You can download MFMediaPropDump from https://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=mfblog&DownloadId=8757.

Follow the instructions at https://code.msdn.microsoft.com/mfblog for tips and instructions to build the sample.

This posting is provided "AS IS" with no warranties and confers no rights.

Techniques:

Transcoding is converting from one media format to another. The previous blog post described three mechanisms that Media Foundation provides to perform transcoding, taking a detailed look at the transcode API.

• Configure the Media Foundation media session directly.
• Use the higher level transcode API to configure the media session.
• Use source reader and sink writer.

Figure 1. Three ways to perform transcoding

We will now describe the source reader and sink writer objects, and how they can be used for transcoding.

Source Reader:

The source reader is a Media Foundation component that provides direct access to multimedia data. Applications can use the source reader to extract sample data in the native format (usually compressed, but not necessarily), or can request that the source reader decode the multimedia data and output uncompressed samples. The source reader provides a consistent API regardless or container or format. Since it is built on the Media Foundation platform, the source reader supports any of the media sources and codecs registered with the platform.

How to use the Source Reader:

• Create the reader object from either a URL, a byte stream, or an existing media source instance.
• Select or deselect streams.
• Configure the desired output format for the streams.
• Seek to the starting position if desired.
  • Process multimedia data by calling IMFSourceReader::ReadSample until reaching the end of the stream, or until you have processed as much data as you want. The source reader supports both synchronous and asynchronous processing.

To read more about the source reader: https://msdn.microsoft.com/en-us/library/dd389281(VS.85).aspx

Sink Writer:

The sink writer is a Media Foundation component that provides a simple way to generate multimedia files. The application configures the target container and format for each stream and then gives each sample received from the source reader to the writer object. Like the source reader, the sink writer provides a consistent API regardless of the destination container or format.

How to use the Sink Writer:

• Create the writer object from either a URL, a byte stream, or an existing media sink instance.
• Add output streams, specifying the format of the data that will be written to the file.
• Configure the input format, specifying the format of the data that will be passed to sink writer.
• Call IMFSinkWriter::BeginWriting.
• Process multimedia data by calling IMFSinkWriter::WriteSample until the end of the stream.Call IMFSinkWriter::Finalize to complete the file authoring process. This method can either block or call an asynchronous callback method when it completes.

To read more about the sink writer: https://msdn.microsoft.com/en-us/library/dd374642(VS.85).aspx

Project Structure:

MFCopy.vcproj

The Visual Studio project file

main.cpp

Contains the application entry point and all user interaction, including command-line parsing and progress notification.

mfcopy.cpp

Implements the copying engine that configures the source reader and sink writer and processes multimedia samples.

Usage:

mfcopy.exe [-?] [-a audio_format] [-nc num_channels] [-sr sample_rate] [-v video format] [-fs resolution] [-fr framerate] [-im interlace_mode] [-br video_bitrate] [-q] [-s milliseconds] [-d milliseconds] [-d milliseconds] [-hw] [-xa] [-xv] [-xo] [-xm] input_filename output_filename

-?
        Display usage information.
-a audio_format
        Set the output audio format.  Defaults to the native format from the input file.
        Examples:  AAC, WMAudioV8, WMAudioV9, WMAudio_Lossless
-nc num_channels
        Set the number of audio channels.
        Example:  2
-sr sample_rate
        Resample the audio to the specified rate.
        Examples: 44100, 48000
-v video_format
        Set the output video format.  Defaults to the native format from the input file.
        Examples:  H264, WMV2, WMV3, WVC1
-fs resolution
        Resize the video to the specified width and height.
        Example: 640x480
-fr framerate
        Convert the video frame rate to the specified rate.
        Example: 30:1
-im interlace_mode
        Set the video interlace mode.
        Example: Progressive
-br video_bitrate
        Set the average encoded bit rate for the video stream.
        Example: 5000000
-q
        Quiet mode.
-s milliseconds
        Specify a start position in milliseconds.
-d milliseconds
        Specify the duration to copy in milliseconds.
-hw
        Enable hardware transforms.
-xa
        Exclude audio streams.
-xv
        Exclude video streams.
-xo
        Exclude non audio/video streams (for example, text or script streams).
-xm
        Exclude metadata.
input_filename
        The path to the source file.
output_filename
        The path to the destination file.

Examples:

1. Copy 20 seconds of a WMV file without re-encoding: mfcopy.exe -d 20000 input.wmv output.wmv
2. Resize the video from a WMV file while preserving the original audio stream: mfcopy.exe -fs 320x240 input.wmv output.wmv
3. Transcode WMV to MP4 ensuring progressive video: mfcopy.exe -a AAC -v H264 -im Progressive input.wmv output.mp4
4. Extract the audio stream from a WMV clip: mfcopy.exe -xv input.wmv output.wma

Limitations:

1. The in-box Media Foundation file archive sinks support a maximum of one audio stream and one video stream in the output file.
2. The Media Foundation source reader and sink writer do not support DRM transcoding.
3. This tool cannot transcode to the MP3 format unless a third-party MP3 encoder MFT is installed. This is because the inbox MP3 encoder MFT is licensed for Microsoft applications only and will not work when loaded by third-party applications.
4. Remuxing to a different container type might fail due to the specific container requirements.

Downloading the Sample

You can download MFCopy from https://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=mfblog&DownloadId=8574

Follow the instruction at https://code.msdn.microsoft.com/mfblog for tips and instructions to build the sample.

This posting is provided "AS IS" with no warranties and confers no rights.

Techniques:

Transcoding is converting from one media format to another. Media Foundation provides three ways to perform transcoding:

• Configure the Media Foundation media session directly.
• Use the higher level transcode API to configure the media session.
• Use source reader and sink writer.

Figure 1. Three ways to perform transcoding

Configuring the media session directly is not straightforward. For example, you must understand the different encoders and media sinks to configure them properly. The transcode API provides a set of functions that makes it easier to build a transcode pipeline. It provides a simple profile to configure different encoders and sinks in the same way, and it automatically transfers metadata from the source file to the transcoded file.

Here is how to use the transcode API:

• Create a media source from a URL or bytestream via source resolver.
• Call MFCreateTranscodeProfile to create a transcode profile with output settings.
• Call MFCreateTranscodeTopology to create a transcode topology.
• Set the transcode topology on the media session.
• Start the transcode session by calling Start on the media session and wait for the session to fire the MESessionEnded event.

The transcode API is based on the media session, so you don’t need to manipulate the samples yourself, or understand the low-level details. However, if you need to manipulate the sample data – for example, to add effects to the samples before encoding them -- the source reader and sink writer might be a better choice. We will have some topics about the source reader and sink writer later in this series.

To read more about the transcode API: https://msdn.microsoft.com/en-us/library/dd317903(VS.85).aspx

Project Structure:

MFSimpleEncode.vcproj

The main project file for VC++ projects generated using an Application Wizard. It contains information about the version of Visual C++ that generated the file, and information about the platforms, configurations, and project features selected with the Application Wizard.

MFSimpleEncode.cpp

The main application source file.

EncodeEngine.cpp

This is the encoding engine that the application calls into.

EventHandler.cpp

This class handles asynchronous callbacks.

ProfileBuilder.cpp

This class is used to create the preferred output media types for transcoding.

SourceManager.cpp

This class is used to create a Media Foundation media source from a URL.

Usage:

MFSimpleEncode.exe -i INPUTFILE -o OUTPUTFILE [-p PROFILE] [-t DURATION] [-splitAudio CONTAINER] [-splitVideo CONTAINER] [-remux CONTAINER]

-i INPUTFILE

The path to the input file. The tool supports built-in input file formats: ASF, AVI, WAV, MPEG4, 3GP, MP3 and the registered 3^rd party MF sources.

- o OUTPUTFILE

The path to the output file. It is highly recommended that you include the correct file extension, based on the file container. The tool supports built-in output file formats: ASF, MPEG4, 3GP and MP3.

-p PROFILE

The path to the transcode profile file. Some example profiles are provided under .\profiles. They are in XML format, so that you can easily see the configuration or modify them for your own use. Several example profiles are included:

• TranscodeProfileASF.xml - Transcodes to an ASF file.
• TranscodeProfileMPEG4.xml - Transcodes to an MPEG-4 file.
• TranscodeProfileWMA_64k.xml - Transcode to a 64kbps WMA file.
• TranscodeProfileWMA_128k.xml - Transcode to a 128kbps WMA file.
• TranscodeProfileWMA_160k.xml - Transcode to a 160kbps WMA file.
• TranscodeProfileWMA_196k.xml - Transcode to a 196kbps WMA file.

-t DURATION

Specifies a stop time earlier than the end of file, in milliseconds. Use this parameter to get a segment of the original file.

- splitAudio CONTAINER

Splits the audio stream from the original file, without re-encoding.

- splitVideo CONTAINER

Splits the video stream from the original file, without re-encoding.

-remux CONTAINER

Remux the streams from the original file, without re-encoding.

CONTAINER specifies the file container type. Currently, the tool supports the following container name strings:

• “MPEG4”
• “ASF”
• “3GP”
• “MP3”

It is highly recommended keeping the same container type as the input file container for remuxing and splitting scenarios. For example, if the input file format is ASF/WMV/WMA, “ASF” will be the preferred CONTAINER name string.

The following options are mutually exclusive: -p, -splitAudio, -splitVideo, -remux.

Examples:

1. Transcode ASF to MPEG-4:

MFSimpleencode.exe –i Input.wmv –o output.mp4 –p TranscodeProfileMPEG4.xml

2. Transcode MPEG-4 to ASF:

MFSimpleencode.exe –i input.mp4 –o output.wmv –p TranscodeProfileASF.xml

3. Strip audio from ASF:

MFSimpleencode.exe –i input.wmv –o output.wma -splitAudio ASF

4. Strip video from MPEG-4:

MFSimpleencode.exe –i input.mp4 –o output.mp4 –splitVideo MPEG4

5. Get a 2-second segment from a WMA file:

MFSimpleencode.exe -i input.wma –o output.wma –remux ASF –t 2000

 Limitations:

1. The Media Foundation transcode API supports a maximum of one audio stream and one video stream in the output file.
2. This tool does not support DRM transcoding.
3. This tool cannot transcode to mp3 file format unless a 3^rd party mp3 encoder MFT is installed. This is because the inbox mp3 encoder MFT is licensed for Microsoft applications only and will not work when loaded by 3^rd party applications.
4. Remuxing/splitting to different containers might fail due to the specific container requirements.

Downloading the Sample

You can download MFSimpleEncode from https://code.msdn.microsoft.com/Project/Download/FileDownload.aspx?ProjectName=mfblog&DownloadId=8439.

Follow the instruction at https://code.msdn.microsoft.com/mfblog for tips and instructions to build the sample.

This posting is provided "AS IS" with no warranties and confers no rights.