diff --git a/IDL/vpxdecoder.idl b/IDL/vpxdecoder.idl
new file mode 100644
index 0000000..669890b
--- /dev/null
+++ b/IDL/vpxdecoder.idl
@@ -0,0 +1,50 @@
+// Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+
+import "oaidl.idl";
+import "ocidl.idl";
+
+[
+  uuid(2C8C46D4-2E83-476A-ADE9-43CFDB830E48),
+  helpstring("VPX Decoder Filter Type Library"),
+  version(1.0)
+]
+
+library VPXDecoderLib {
+
+enum VP8PostProcessingFlags {
+  VP8None         = 0x00,
+  VP8Deblock      = 0x01,
+  VP8Demacroblock = 0x02,
+  VP8AddNoise     = 0x04
+};
+
+[
+  object,
+  uuid(EB6EBF79-29BC-4377-93FB-B2AD76952B0A),
+  helpstring("VP8 Decoder Post-Processing Interface")
+]
+interface IVP8PostProcessing : IUnknown {
+  HRESULT SetFlags([in] int PostProcessingFlags);
+  HRESULT GetFlags([out] int* pPostProcessingFlags);
+  HRESULT SetDeblockingLevel([in] int DeblockingLevel);
+  HRESULT GetDeblockingLevel([out] int* pDeblockingLevel);
+  HRESULT SetNoiseLevel([in] int NoiseLevel);
+  HRESULT GetNoiseLevel([out] int* pNoiseLevel);
+  HRESULT ApplyPostProcessing();
+}
+
+[
+  uuid(BDDB6A11-9D65-46D8-824E-F376D64E4A8A),
+  helpstring("VPX Decoder Filter Class")
+]
+coclass VPXDecoder {
+  [default] interface IVP8PostProcessing;
+}
+
+}  // library VPXDecoderLib
diff --git a/vpxdecoder/.gitignore b/vpxdecoder/.gitignore
new file mode 100644
index 0000000..e6ee719
--- /dev/null
+++ b/vpxdecoder/.gitignore
@@ -0,0 +1,3 @@
+*.aps
+*.TMP
+*.user
diff --git a/vpxdecoder/dllentry.cc b/vpxdecoder/dllentry.cc
new file mode 100644
index 0000000..2e7ff38
--- /dev/null
+++ b/vpxdecoder/dllentry.cc
@@ -0,0 +1,207 @@
+// Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#include <comdef.h>
+#include <strmif.h>
+#include <uuids.h>
+
+#include <cassert>
+
+#include "cfactory.h"
+#include "comreg.h"
+#include "graphutil.h"
+#include "vpxdecoderidl.h"
+#include "webmtypes.h"
+
+HMODULE g_hModule;
+static ULONG s_cLock;
+
+namespace VPXDecoderLib {
+
+HRESULT CreateInstance(IClassFactory*, IUnknown*, const IID&, void**);
+
+}  // namespace VPXDecoderLib
+
+namespace {
+
+CFactory factory(&s_cLock, &VPXDecoderLib::CreateInstance);
+
+}  // namespace
+
+BOOL APIENTRY DllMain(HINSTANCE hModule,
+                      DWORD dwReason,
+                      LPVOID /*lpReserved*/) {
+  switch (dwReason) {
+    case DLL_PROCESS_ATTACH:
+      g_hModule = hModule;
+      break;
+
+    case DLL_THREAD_ATTACH:
+    case DLL_THREAD_DETACH:
+    case DLL_PROCESS_DETACH:
+    default:
+      break;
+  }
+
+  return TRUE;
+}
+
+STDAPI DllCanUnloadNow() { return s_cLock ? S_FALSE : S_OK; }
+
+STDAPI DllGetClassObject(const CLSID& clsid, const IID& iid, void** ppv) {
+  if (clsid == CLSID_VPXDecoder)
+    return factory.QueryInterface(iid, ppv);
+
+  return CLASS_E_CLASSNOTAVAILABLE;
+}
+
+STDAPI DllUnregisterServer() {
+  const GraphUtil::IFilterMapper2Ptr pMapper(CLSID_FilterMapper2);
+  if (pMapper == NULL) {
+    assert(pMapper != NULL);
+    return E_FAIL;
+  }
+
+  HRESULT hr = pMapper->UnregisterFilter(&CLSID_LegacyAmFilterCategory, 0,
+                                         CLSID_VPXDecoder);
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+    return hr;
+  }
+
+  hr = ComReg::UnRegisterCoclass(CLSID_VPXDecoder);
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+    return hr;
+  }
+
+  std::wstring filename_;
+  hr = ComReg::ComRegGetModuleFileName(g_hModule, filename_);
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+    return hr;
+  }
+  if (filename_.empty()) {
+    assert(!filename_.empty());
+    return E_FAIL;
+  }
+
+  hr = ComReg::UnRegisterTypeLibResource(filename_.c_str());
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+  }
+
+  return hr;
+}
+
+STDAPI DllRegisterServer() {
+  std::wstring filename_;
+  HRESULT hr = ComReg::ComRegGetModuleFileName(g_hModule, filename_);
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+    return hr;
+  }
+  if (filename_.empty()) {
+    assert(!filename_.empty());
+    return E_FAIL;
+  }
+
+#if _DEBUG
+  const wchar_t friendlyname[] = L"WebM VPx Decoder Filter (Debug)";
+#else
+  const wchar_t friendlyname[] = L"WebM VPx Decoder Filter";
+#endif
+
+  hr = DllUnregisterServer();
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+    return hr;
+  }
+
+  hr = ComReg::RegisterTypeLibResource(filename_.c_str(), 0);
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+    return hr;
+  }
+
+  hr = ComReg::RegisterCoclass(
+      CLSID_VPXDecoder, friendlyname, filename_.c_str(), L"Webm.VPXDecoder",
+      L"Webm.VPXDecoder.1",
+      false,  // not insertable
+      false,  // not a control
+      ComReg::kBoth,  // DShow filters must support "both"
+      LIBID_VPXDecoderLib,  // typelib
+      0,  // no version specified
+      0);  // no toolbox bitmap
+
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+    return hr;
+  }
+
+  const GraphUtil::IFilterMapper2Ptr pMapper(CLSID_FilterMapper2);
+  if (pMapper == NULL) {
+    assert(pMapper != NULL);
+    return E_FAIL;
+  }
+
+  enum { cPins = 2 };
+  REGFILTERPINS pins[cPins];
+
+  REGFILTERPINS& inpin = pins[0];
+
+  enum { nInpinMediaTypes = 2 };
+  const REGPINTYPES inpinMediaTypes[nInpinMediaTypes] = {
+      {&MEDIATYPE_Video, &WebmTypes::MEDIASUBTYPE_VP80},
+      {&MEDIATYPE_Video, &WebmTypes::MEDIASUBTYPE_VP90}};
+
+  inpin.strName = 0;
+  inpin.bRendered = FALSE;
+  inpin.bOutput = FALSE;
+  inpin.bZero = FALSE;
+  inpin.bMany = FALSE;
+  inpin.clsConnectsToFilter = 0;
+  inpin.strConnectsToPin = 0;
+  inpin.nMediaTypes = nInpinMediaTypes;
+  inpin.lpMediaType = inpinMediaTypes;
+
+  REGFILTERPINS& outpin = pins[1];
+
+  enum { nOutpinMediaTypes = 7 };
+  const REGPINTYPES outpinMediaTypes[nOutpinMediaTypes] = {
+      {&MEDIATYPE_Video, &MEDIASUBTYPE_NV12},
+      {&MEDIATYPE_Video, &MEDIASUBTYPE_YV12},
+      {&MEDIATYPE_Video, &WebmTypes::MEDIASUBTYPE_I420},
+      {&MEDIATYPE_Video, &MEDIASUBTYPE_UYVY},
+      {&MEDIATYPE_Video, &MEDIASUBTYPE_YUY2},
+      {&MEDIATYPE_Video, &MEDIASUBTYPE_YUYV},
+      {&MEDIATYPE_Video, &MEDIASUBTYPE_YVYU}};
+
+  outpin.strName = 0;
+  outpin.bRendered = FALSE;
+  outpin.bOutput = TRUE;
+  outpin.bZero = FALSE;
+  outpin.bMany = FALSE;
+  outpin.clsConnectsToFilter = 0;
+  outpin.strConnectsToPin = 0;
+  outpin.nMediaTypes = nOutpinMediaTypes;
+  outpin.lpMediaType = outpinMediaTypes;
+
+  REGFILTER2 filter;
+  filter.dwVersion = 1;
+  filter.dwMerit = MERIT_NORMAL;
+  filter.cPins = cPins;
+  filter.rgPins = pins;
+
+  hr = pMapper->RegisterFilter(CLSID_VPXDecoder, friendlyname, 0,
+                               &CLSID_LegacyAmFilterCategory, 0, &filter);
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+  }
+
+  return hr;
+}
diff --git a/vpxdecoder/resource.h b/vpxdecoder/resource.h
new file mode 100644
index 0000000..b67bdcf
--- /dev/null
+++ b/vpxdecoder/resource.h
@@ -0,0 +1,14 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by vpxdecoder.rc
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        101
+#define _APS_NEXT_COMMAND_VALUE         40001
+#define _APS_NEXT_CONTROL_VALUE         1001
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/vpxdecoder/vpxdecoder.def b/vpxdecoder/vpxdecoder.def
new file mode 100644
index 0000000..f620ba2
--- /dev/null
+++ b/vpxdecoder/vpxdecoder.def
@@ -0,0 +1,5 @@
+EXPORTS
+	DllGetClassObject private
+	DllRegisterServer private
+	DllUnregisterServer private
+	DllCanUnloadNow private
diff --git a/vpxdecoder/vpxdecoder.rc b/vpxdecoder/vpxdecoder.rc
new file mode 100644
index 0000000..1901487
--- /dev/null
+++ b/vpxdecoder/vpxdecoder.rc
@@ -0,0 +1,98 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (United States) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE 
+BEGIN
+    "#include ""afxres.h\0"
+END
+
+3 TEXTINCLUDE 
+BEGIN
+    "\r\n"
+    "1 TYPELIB ""vpxdecoder.tlb\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 1,0,3,1
+ PRODUCTVERSION 1,0,3,1
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "CompanyName", "Google"
+            VALUE "FileDescription", "WebM VPX Decoder Filter"
+            VALUE "FileVersion", "1, 0, 3, 1"
+            VALUE "InternalName", "vpxdecoder"
+            VALUE "LegalCopyright", "Copyright (C) 2014"
+            VALUE "OriginalFilename", "vpxdecoder.dll"
+            VALUE "ProductName", "WebM VPX Decoder Filter"
+            VALUE "ProductVersion", "1, 0, 3, 1"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
+
+#endif    // English (United States) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+1 TYPELIB "vpxdecoder.tlb"
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/vpxdecoder/vpxdecoder.vcxproj b/vpxdecoder/vpxdecoder.vcxproj
new file mode 100644
index 0000000..0b22904
--- /dev/null
+++ b/vpxdecoder/vpxdecoder.vcxproj
@@ -0,0 +1,171 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C4A3A16F-C46B-41BA-A031-94391A535C00}</ProjectGuid>
+    <RootNamespace>vpxdecoder</RootNamespace>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectName>vpxdecoder</ProjectName>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <CharacterSet>Unicode</CharacterSet>
+    <PlatformToolset>v120</PlatformToolset>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup>
+    <_ProjectFileVersion>10.0.40219.1</_ProjectFileVersion>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)..\dll\webmdshow\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(SolutionDir)..\obj\$(SolutionName)\$(ProjectName)\$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</LinkIncremental>
+    <GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</GenerateManifest>
+    <OutDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)..\dll\webmdshow\$(Configuration)\</OutDir>
+    <IntDir Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(SolutionDir)..\obj\$(SolutionName)\$(ProjectName)\$(Configuration)\</IntDir>
+    <LinkIncremental Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</LinkIncremental>
+    <GenerateManifest Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</GenerateManifest>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">$(RootNamespace)</TargetName>
+    <TargetName Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">$(RootNamespace)</TargetName>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Midl>
+      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <TypeLibraryName>$(IntDir)%(Filename).tlb</TypeLibraryName>
+      <OutputDirectory>%(RootDir)%(Directory)</OutputDirectory>
+      <HeaderFileName>%(Filename)idl.h</HeaderFileName>
+      <InterfaceIdentifierFileName>%(Filename)idl.c</InterfaceIdentifierFileName>
+    </Midl>
+    <ClCompile>
+      <Optimization>Disabled</Optimization>
+      <AdditionalIncludeDirectories>$(SolutionDir)common;$(SolutionDir)IDL;$(SolutionDir)third_party\libvpx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_WINDOWS;_USRDLL;VPXDECODER_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <MinimalRebuild>false</MinimalRebuild>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level4</WarningLevel>
+      <DebugInformationFormat>OldStyle</DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>strmiids.lib;vpxmtd.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>$(TargetPath)</OutputFile>
+      <AdditionalLibraryDirectories>$(SolutionDir)third_party\libvpx\x86\debug;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ModuleDefinitionFile>vpxdecoder.def</ModuleDefinitionFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>NotSet</SubSystem>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+      <DataExecutionPrevention>
+      </DataExecutionPrevention>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Midl>
+      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <TypeLibraryName>$(IntDir)%(Filename).tlb</TypeLibraryName>
+      <OutputDirectory>%(RootDir)%(Directory)</OutputDirectory>
+      <HeaderFileName>%(Filename)idl.h</HeaderFileName>
+      <InterfaceIdentifierFileName>%(Filename)idl.c</InterfaceIdentifierFileName>
+    </Midl>
+    <ClCompile>
+      <AdditionalIncludeDirectories>$(SolutionDir)common;$(SolutionDir)IDL;$(SolutionDir)third_party\libvpx;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;VPXDECODER_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
+      <PrecompiledHeader>
+      </PrecompiledHeader>
+      <WarningLevel>Level4</WarningLevel>
+      <DebugInformationFormat>
+      </DebugInformationFormat>
+    </ClCompile>
+    <ResourceCompile>
+      <AdditionalIncludeDirectories>$(IntDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+    </ResourceCompile>
+    <Link>
+      <AdditionalDependencies>strmiids.lib;vpxmt.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <OutputFile>$(TargetPath)</OutputFile>
+      <AdditionalLibraryDirectories>$(SolutionDir)third_party\libvpx\x86\release;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <ModuleDefinitionFile>vpxdecoder.def</ModuleDefinitionFile>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <SubSystem>Windows</SubSystem>
+      <OptimizeReferences>true</OptimizeReferences>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <RandomizedBaseAddress>false</RandomizedBaseAddress>
+      <DataExecutionPrevention>
+      </DataExecutionPrevention>
+      <TargetMachine>MachineX86</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="..\common\cenumpins.cc" />
+    <ClCompile Include="..\common\cfactory.cc" />
+    <ClCompile Include="..\common\clockable.cc" />
+    <ClCompile Include="..\common\cmediasample.cc" />
+    <ClCompile Include="..\common\cmediatypes.cc" />
+    <ClCompile Include="..\common\cmemallocator.cc" />
+    <ClCompile Include="..\common\comreg.cc" />
+    <ClCompile Include="..\common\iidstr.cc" />
+    <ClCompile Include="..\common\mediatypeutil.cc" />
+    <ClCompile Include="..\common\webmtypes.cc" />
+    <ClCompile Include="..\IDL\vpxdecoderidl.c" />
+    <ClCompile Include="dllentry.cc" />
+    <ClCompile Include="vpxdecoderfilter.cc" />
+    <ClCompile Include="vpxdecoderinpin.cc" />
+    <ClCompile Include="vpxdecoderoutpin.cc" />
+    <ClCompile Include="vpxdecoderpin.cc" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common\cenumpins.h" />
+    <ClInclude Include="..\common\cfactory.h" />
+    <ClInclude Include="..\common\clockable.h" />
+    <ClInclude Include="..\common\cmediasample.h" />
+    <ClInclude Include="..\common\cmediatypes.h" />
+    <ClInclude Include="..\common\cmemallocator.h" />
+    <ClInclude Include="..\common\comreg.h" />
+    <ClInclude Include="..\common\iidstr.h" />
+    <ClInclude Include="..\common\mediatypeutil.h" />
+    <ClInclude Include="..\common\webmtypes.h" />
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="..\IDL\vpxdecoderidl.h" />
+    <ClInclude Include="vpxdecoderfilter.h" />
+    <ClInclude Include="vpxdecoderinpin.h" />
+    <ClInclude Include="vpxdecoderoutpin.h" />
+    <ClInclude Include="vpxdecoderpin.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <Midl Include="..\IDL\vpxdecoder.idl" />
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="vpxdecoder.rc" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/vpxdecoder/vpxdecoder.vcxproj.filters b/vpxdecoder/vpxdecoder.vcxproj.filters
new file mode 100644
index 0000000..f9e0721
--- /dev/null
+++ b/vpxdecoder/vpxdecoder.vcxproj.filters
@@ -0,0 +1,104 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Common Files">
+      <UniqueIdentifier>{b4b7c47c-e6d2-4246-b839-07cc0b21fe32}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="..\common\cenumpins.cc">
+      <Filter>Common Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common\cfactory.cc">
+      <Filter>Common Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common\clockable.cc">
+      <Filter>Common Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common\cmediasample.cc">
+      <Filter>Common Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common\cmediatypes.cc">
+      <Filter>Common Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common\cmemallocator.cc">
+      <Filter>Common Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common\comreg.cc">
+      <Filter>Common Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common\mediatypeutil.cc">
+      <Filter>Common Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\common\webmtypes.cc">
+      <Filter>Common Files</Filter>
+    </ClCompile>
+    <ClCompile Include="..\IDL\vpxdecoderidl.c">
+      <Filter>Resource Files</Filter>
+    </ClCompile>
+    <ClCompile Include="dllentry.cc" />
+    <ClCompile Include="vpxdecoderfilter.cc" />
+    <ClCompile Include="vpxdecoderinpin.cc" />
+    <ClCompile Include="vpxdecoderoutpin.cc" />
+    <ClCompile Include="vpxdecoderpin.cc" />
+    <ClCompile Include="..\common\iidstr.cc">
+      <Filter>Common Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\common\cenumpins.h">
+      <Filter>Common Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common\cfactory.h">
+      <Filter>Common Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common\clockable.h">
+      <Filter>Common Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common\cmediasample.h">
+      <Filter>Common Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common\cmediatypes.h">
+      <Filter>Common Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common\cmemallocator.h">
+      <Filter>Common Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common\comreg.h">
+      <Filter>Common Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common\mediatypeutil.h">
+      <Filter>Common Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\common\webmtypes.h">
+      <Filter>Common Files</Filter>
+    </ClInclude>
+    <ClInclude Include="resource.h">
+      <Filter>Resource Files</Filter>
+    </ClInclude>
+    <ClInclude Include="..\IDL\vpxdecoderidl.h">
+      <Filter>Resource Files</Filter>
+    </ClInclude>
+    <ClInclude Include="vpxdecoderfilter.h" />
+    <ClInclude Include="vpxdecoderinpin.h" />
+    <ClInclude Include="vpxdecoderoutpin.h" />
+    <ClInclude Include="vpxdecoderpin.h" />
+    <ClInclude Include="..\common\iidstr.h">
+      <Filter>Common Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <Midl Include="..\IDL\vpxdecoder.idl">
+      <Filter>Resource Files</Filter>
+    </Midl>
+  </ItemGroup>
+  <ItemGroup>
+    <ResourceCompile Include="vpxdecoder.rc">
+      <Filter>Resource Files</Filter>
+    </ResourceCompile>
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/vpxdecoder/vpxdecoderfilter.cc b/vpxdecoder/vpxdecoderfilter.cc
new file mode 100644
index 0000000..f16d368
--- /dev/null
+++ b/vpxdecoder/vpxdecoderfilter.cc
@@ -0,0 +1,636 @@
+// Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#include "vpxdecoderfilter.h"
+
+#include <strmif.h>
+#include <uuids.h>
+#include <vfwmsgs.h>
+
+#include <cassert>
+#include <new>
+
+#include "cenumpins.h"
+#include "vpxdecoderidl.h"
+#include "webmtypes.h"
+
+#ifdef _DEBUG
+#include "iidstr.h"
+#include "odbgstream.h"
+using std::endl;
+using std::hex;
+using std::dec;
+#endif
+
+using std::wstring;
+
+namespace VPXDecoderLib {
+
+HRESULT CreateInstance(IClassFactory* pClassFactory, IUnknown* pOuter,
+                       const IID& iid, void** ppv) {
+  if (ppv == 0)
+    return E_POINTER;
+
+  *ppv = 0;
+
+  if ((pOuter != 0) && (iid != __uuidof(IUnknown)))
+    return E_INVALIDARG;
+
+  Filter* p = new (std::nothrow) Filter(pClassFactory, pOuter);
+
+  if (p == 0)
+    return E_OUTOFMEMORY;
+
+  assert(p->m_nondelegating.m_cRef == 0);
+
+  const HRESULT hr = p->m_nondelegating.QueryInterface(iid, ppv);
+
+  if (SUCCEEDED(hr)) {
+    assert(*ppv);
+    assert(p->m_nondelegating.m_cRef == 1);
+
+    return S_OK;
+  }
+
+  assert(*ppv == 0);
+  assert(p->m_nondelegating.m_cRef == 0);
+
+  delete p;
+  p = 0;
+
+  return hr;
+}
+
+//
+// Filter::CNondelegating
+//
+HRESULT Filter::CNondelegating::QueryInterface(const IID& iid, void** ppv) {
+  if (ppv == 0)
+    return E_POINTER;
+
+  IUnknown*& pUnk = reinterpret_cast<IUnknown*&>(*ppv);
+
+  if (iid == __uuidof(IUnknown)) {
+    pUnk = this;  // must be nondelegating
+  } else if (iid == __uuidof(IBaseFilter) ||
+             iid == __uuidof(IMediaFilter) ||
+             iid == __uuidof(IPersist)) {
+    pUnk = static_cast<IBaseFilter*>(m_pFilter);
+  } else if (iid == __uuidof(IVP8PostProcessing)) {
+    pUnk = static_cast<IVP8PostProcessing*>(m_pFilter);
+  } else {
+#if _DEBUG
+    wodbgstream os;
+    os << "vpxdec::filter::QI: iid=" << IIDStr(iid) << std::endl;
+#endif
+
+    pUnk = 0;
+    return E_NOINTERFACE;
+  }
+
+  pUnk->AddRef();
+  return S_OK;
+}
+
+ULONG Filter::CNondelegating::AddRef() {
+  return InterlockedIncrement(&m_cRef);
+}
+
+ULONG Filter::CNondelegating::Release() {
+  const LONG n = InterlockedDecrement(&m_cRef);
+
+#if _DEBUG
+  odbgstream os;
+  os << "vpxdec::filter::Release: n=" << n << endl;
+#endif
+
+  if (n > 0)
+    return n;
+
+  delete m_pFilter;
+  return 0;
+}
+
+//
+// Filter
+//
+#pragma warning(disable : 4355)  // 'this' ptr in member init list
+Filter::Filter(IClassFactory* pClassFactory, IUnknown* pOuter)
+    : m_pClassFactory(pClassFactory),
+      m_nondelegating(this),
+      m_pOuter(pOuter ? pOuter : &m_nondelegating),
+      m_clock(0),
+      m_state(kStateStopped),
+      m_inpin(this),
+      m_outpin(this) {
+  m_pClassFactory->LockServer(TRUE);
+
+  const HRESULT hr = CLockable::Init();
+  hr;
+  assert(SUCCEEDED(hr));
+
+  m_info.pGraph = 0;
+  m_info.achName[0] = L'\0';
+
+  // TODO: these need to be read from and written to the .grf stream.
+  m_cfg.flags = 0;
+  m_cfg.deblock = 0;
+  m_cfg.noise = 0;
+
+#ifdef _DEBUG
+  odbgstream os;
+  os << "vpxdec::filter::ctor" << endl;
+#endif
+}
+#pragma warning(default : 4355)
+
+Filter::~Filter() {
+#ifdef _DEBUG
+  odbgstream os;
+  os << "vpxdec::filter::dtor" << endl;
+#endif
+
+  m_pClassFactory->LockServer(FALSE);
+}
+
+HRESULT Filter::QueryInterface(const IID& iid, void** ppv) {
+  return m_pOuter->QueryInterface(iid, ppv);
+}
+
+ULONG Filter::AddRef() {
+  return m_pOuter->AddRef();
+}
+
+ULONG Filter::Release() {
+  return m_pOuter->Release();
+}
+
+HRESULT Filter::GetClassID(CLSID* p) {
+  if (p == 0)
+    return E_POINTER;
+
+  *p = CLSID_VPXDecoder;
+  return S_OK;
+}
+
+HRESULT Filter::Stop() {
+  // Stop is a synchronous operation: when it completes,
+  // the filter is stopped.
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  // odbgstream os;
+  // os << "mkvsplit::Filter::Stop" << endl;
+
+  switch (m_state) {
+    case kStatePaused:
+    case kStatePausedWaitingForKeyframe:
+    case kStateRunning:
+    case kStateRunningWaitingForKeyframe:
+      m_state = kStateStopped;
+      OnStop();  // decommit outpin's allocator
+      break;
+
+    case kStateStopped:
+      break;
+
+    default:
+      assert(false);
+      break;
+  }
+
+  return S_OK;
+}
+
+HRESULT Filter::Pause() {
+  // Unlike Stop(), Pause() can be asynchronous (that's why you have
+  // GetState()).
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  // odbgstream os;
+  // os << "mkvsplit::Filter::Pause" << endl;
+
+  switch (m_state) {
+    case kStateStopped:
+      OnStart();  // commit outpin's allocator
+      m_state = kStatePausedWaitingForKeyframe;
+      break;
+
+    case kStateRunning:
+      m_state = kStatePaused;
+      break;
+
+    case kStateRunningWaitingForKeyframe:
+      m_state = kStatePausedWaitingForKeyframe;
+      break;
+
+    case kStatePausedWaitingForKeyframe:
+    case kStatePaused:
+      break;
+
+    default:
+      assert(false);
+      break;
+  }
+
+  return S_OK;
+}
+
+HRESULT Filter::Run(REFERENCE_TIME start) {
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  // odbgstream os;
+  // os << "mkvsplit::Filter::Run" << endl;
+
+  switch (m_state) {
+    case kStateStopped:
+      OnStart();
+      m_state = kStateRunningWaitingForKeyframe;
+      break;
+
+    case kStatePausedWaitingForKeyframe:
+      m_state = kStateRunningWaitingForKeyframe;
+      break;
+
+    case kStatePaused:
+      m_state = kStateRunning;
+      break;
+
+    case kStateRunningWaitingForKeyframe:
+    case kStateRunning:
+      break;
+
+    default:
+      assert(false);
+      break;
+  }
+
+  m_start = start;
+  return S_OK;
+}
+
+HRESULT Filter::GetState(DWORD, FILTER_STATE* p) {
+  if (p == 0)
+    return E_POINTER;
+
+  Lock lock;
+
+  const HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  *p = GetStateLocked();
+  return S_OK;
+}
+
+HRESULT Filter::SetSyncSource(IReferenceClock* clock) {
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (m_clock)
+    m_clock->Release();
+
+  m_clock = clock;
+
+  if (m_clock)
+    m_clock->AddRef();
+
+  return S_OK;
+}
+
+HRESULT Filter::GetSyncSource(IReferenceClock** pclock) {
+  if (pclock == 0)
+    return E_POINTER;
+
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  IReferenceClock*& clock = *pclock;
+
+  clock = m_clock;
+
+  if (clock)
+    clock->AddRef();
+
+  return S_OK;
+}
+
+HRESULT Filter::EnumPins(IEnumPins** pp) {
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  IPin* pins[2];
+
+  pins[0] = &m_inpin;
+  pins[1] = &m_outpin;
+
+  return CEnumPins::CreateInstance(pins, 2, pp);
+}
+
+HRESULT Filter::FindPin(LPCWSTR id1, IPin** pp) {
+  if (pp == 0)
+    return E_POINTER;
+
+  IPin*& p = *pp;
+  p = 0;
+
+  if (id1 == 0)
+    return E_INVALIDARG;
+
+  Pin* pPin = &m_inpin;
+
+  if (wcscmp(id1, pPin->m_id.c_str()) == 0) {
+    p = pPin;
+    p->AddRef();
+
+    return S_OK;
+  }
+
+  pPin = &m_outpin;
+
+  if (wcscmp(id1, pPin->m_id.c_str()) == 0) {
+    p = pPin;
+    p->AddRef();
+
+    return S_OK;
+  }
+
+  return VFW_E_NOT_FOUND;
+}
+
+HRESULT Filter::QueryFilterInfo(FILTER_INFO* p) {
+  if (p == 0)
+    return E_POINTER;
+
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  enum { size = sizeof(p->achName) / sizeof(WCHAR) };
+  const errno_t e = wcscpy_s(p->achName, size, m_info.achName);
+  assert(e == 0);
+  if (e != 0)
+    return E_FAIL;
+
+  p->pGraph = m_info.pGraph;
+
+  if (p->pGraph)
+    p->pGraph->AddRef();
+
+  return S_OK;
+}
+
+HRESULT Filter::JoinFilterGraph(IFilterGraph* pGraph, LPCWSTR name) {
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  // NOTE:
+  // No, do not adjust reference counts here!
+  // Read the docs for the reasons why.
+  // ENDNOTE.
+
+  m_info.pGraph = pGraph;
+
+  if (name == 0) {
+    m_info.achName[0] = L'\0';
+  } else {
+    enum { size = sizeof(m_info.achName) / sizeof(WCHAR) };
+    const errno_t e = wcscpy_s(m_info.achName, size, name);
+    e;
+    assert(e == 0);  // TODO
+  }
+
+  return S_OK;
+}
+
+HRESULT Filter::QueryVendorInfo(LPWSTR* pstr) {
+  if (pstr == 0)
+    return E_POINTER;
+
+  wchar_t*& str = *pstr;
+
+  str = 0;
+  return E_NOTIMPL;
+}
+
+HRESULT Filter::SetFlags(int Flags) {
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (Flags & ~0x07)
+    return E_INVALIDARG;
+
+  m_cfg.flags = Flags;
+
+  return S_OK;
+}
+
+HRESULT Filter::SetDeblockingLevel(int level) {
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (level < 0)
+    return E_INVALIDARG;
+
+  if (level > 16)
+    return E_INVALIDARG;
+
+  m_cfg.deblock = level;
+
+  return S_OK;
+}
+
+HRESULT Filter::SetNoiseLevel(int level) {
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (level < 0)
+    return E_INVALIDARG;
+
+  if (level > 16)
+    return E_INVALIDARG;
+
+  m_cfg.noise = level;
+
+  return S_OK;
+}
+
+HRESULT Filter::GetFlags(int* pFlags) {
+  if (pFlags == 0)
+    return E_POINTER;
+
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  *pFlags = m_cfg.flags;
+
+  return S_OK;
+}
+
+HRESULT Filter::GetDeblockingLevel(int* pLevel) {
+  if (pLevel == 0)
+    return E_POINTER;
+
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  *pLevel = m_cfg.deblock;
+
+  return S_OK;
+}
+
+HRESULT Filter::GetNoiseLevel(int* pLevel) {
+  if (pLevel == 0)
+    return E_POINTER;
+
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  *pLevel = m_cfg.noise;
+
+  return S_OK;
+}
+
+HRESULT Filter::ApplyPostProcessing() {
+  Lock lock;
+
+  HRESULT hr = lock.Seize(this);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (m_state != State_Paused)
+    return VFW_E_NOT_PAUSED;
+
+  return m_inpin.OnApplyPostProcessing();
+}
+
+void Filter::OnStart() {
+  HRESULT hr = m_inpin.Start();
+  assert(SUCCEEDED(hr));  // TODO
+
+  hr = m_outpin.Start();
+  assert(SUCCEEDED(hr));  // TODO
+}
+
+void Filter::OnStop() {
+  m_outpin.Stop();
+  m_inpin.Stop();
+}
+
+FILTER_STATE Filter::GetStateLocked() const {
+  switch (m_state) {
+    case kStateStopped:
+      return State_Stopped;
+
+    case kStateRunning:
+    case kStateRunningWaitingForKeyframe:
+      return State_Running;
+
+    case kStatePaused:
+    case kStatePausedWaitingForKeyframe:
+      return State_Paused;
+
+    default:
+      assert(false);
+      return State_Stopped;
+  }
+}
+
+HRESULT Filter::OnDecodeFailureLocked() {
+  switch (m_state) {
+    case kStateRunning:
+      m_state = kStateRunningWaitingForKeyframe;
+      break;
+
+    case kStatePaused:
+      m_state = kStatePausedWaitingForKeyframe;
+      break;
+
+    default:
+      break;
+  }
+
+  return S_OK;  // continue accepting frames
+}
+
+void Filter::OnDecodeSuccessLocked(bool is_key) {
+  switch (m_state) {
+    case kStateRunningWaitingForKeyframe:
+      if (is_key)
+        m_state = kStateRunning;
+      break;
+
+    case kStatePausedWaitingForKeyframe:
+      if (is_key)
+        m_state = kStatePaused;
+      break;
+
+    default:
+      break;
+  }
+}
+
+}  // namespace VPXDecoderLib
diff --git a/vpxdecoder/vpxdecoderfilter.h b/vpxdecoder/vpxdecoderfilter.h
new file mode 100644
index 0000000..7d65821
--- /dev/null
+++ b/vpxdecoder/vpxdecoderfilter.h
@@ -0,0 +1,115 @@
+// Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef WEBMDSHOW_VPXDECODER_VPXDECODERFILTER_H_
+#define WEBMDSHOW_VPXDECODER_VPXDECODERFILTER_H_
+
+#include <strmif.h>
+
+#include <string>
+
+#include "clockable.h"
+#include "vpxdecoderidl.h"
+#include "vpxdecoderinpin.h"
+#include "vpxdecoderoutpin.h"
+
+namespace VPXDecoderLib {
+
+class Filter : public IBaseFilter, public IVP8PostProcessing, public CLockable {
+ public:
+  struct Config {
+    int flags;
+    int deblock;
+    int noise;
+  };
+
+  // IUnknown
+  HRESULT STDMETHODCALLTYPE QueryInterface(const IID&, void**);
+  ULONG STDMETHODCALLTYPE AddRef();
+  ULONG STDMETHODCALLTYPE Release();
+
+  // IBaseFilter
+  HRESULT STDMETHODCALLTYPE GetClassID(CLSID*);
+  HRESULT STDMETHODCALLTYPE Stop();
+  HRESULT STDMETHODCALLTYPE Pause();
+  HRESULT STDMETHODCALLTYPE Run(REFERENCE_TIME);
+  HRESULT STDMETHODCALLTYPE GetState(DWORD, FILTER_STATE*);
+  HRESULT STDMETHODCALLTYPE SetSyncSource(IReferenceClock*);
+  HRESULT STDMETHODCALLTYPE GetSyncSource(IReferenceClock**);
+  HRESULT STDMETHODCALLTYPE EnumPins(IEnumPins**);
+  HRESULT STDMETHODCALLTYPE FindPin(LPCWSTR, IPin**);
+  HRESULT STDMETHODCALLTYPE QueryFilterInfo(FILTER_INFO*);
+  HRESULT STDMETHODCALLTYPE JoinFilterGraph(IFilterGraph*, LPCWSTR);
+  HRESULT STDMETHODCALLTYPE QueryVendorInfo(LPWSTR*);
+
+  // IVP8PostProcessing
+  HRESULT STDMETHODCALLTYPE SetFlags(int);
+  HRESULT STDMETHODCALLTYPE SetDeblockingLevel(int);
+  HRESULT STDMETHODCALLTYPE SetNoiseLevel(int);
+  HRESULT STDMETHODCALLTYPE GetFlags(int*);
+  HRESULT STDMETHODCALLTYPE GetDeblockingLevel(int*);
+  HRESULT STDMETHODCALLTYPE GetNoiseLevel(int*);
+  HRESULT STDMETHODCALLTYPE ApplyPostProcessing();
+
+  // local classes and methods
+  FILTER_STATE GetStateLocked() const;
+  HRESULT OnDecodeFailureLocked();
+  void OnDecodeSuccessLocked(bool is_key);
+
+  // public members
+  FILTER_INFO m_info;
+  Inpin m_inpin;
+  Outpin m_outpin;
+  Config m_cfg;
+
+ private:
+  class CNondelegating : public IUnknown {
+   public:
+    explicit CNondelegating(Filter* f) : m_pFilter(f), m_cRef(0) {}
+    virtual ~CNondelegating() {}
+
+    HRESULT STDMETHODCALLTYPE QueryInterface(const IID&, void**);
+    ULONG STDMETHODCALLTYPE AddRef();
+    ULONG STDMETHODCALLTYPE Release();
+
+    Filter* const m_pFilter;
+    LONG m_cRef;
+
+   private:
+    CNondelegating(const CNondelegating&);
+    CNondelegating& operator=(const CNondelegating&);
+  };
+
+  enum State {
+    kStateStopped,
+    kStatePausedWaitingForKeyframe,
+    kStatePaused,
+    kStateRunning,
+    kStateRunningWaitingForKeyframe
+  };
+
+  friend HRESULT CreateInstance(IClassFactory*, IUnknown*, const IID&, void**);
+
+  void OnStop();
+  void OnStart();
+
+  Filter(IClassFactory*, IUnknown*);
+  virtual ~Filter();
+  Filter(const Filter&);
+  Filter& operator=(const Filter&);
+
+  IClassFactory* const m_pClassFactory;
+  CNondelegating m_nondelegating;
+  IUnknown* const m_pOuter;
+  REFERENCE_TIME m_start;
+  IReferenceClock* m_clock;
+  State m_state;
+};
+
+}  // namespace VPXDecoderLib
+
+#endif  // WEBMDSHOW_VPXDECODER_VPXDECODERFILTER_H_
\ No newline at end of file
diff --git a/vpxdecoder/vpxdecoderinpin.cc b/vpxdecoder/vpxdecoderinpin.cc
new file mode 100644
index 0000000..5f2026e
--- /dev/null
+++ b/vpxdecoder/vpxdecoderinpin.cc
@@ -0,0 +1,985 @@
+// Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+
+// Disable MSVC warning advising use of _s variants of library functions.
+#pragma warning(disable:4996)
+
+// TODO(tomfinegan): Get rid of this warning.
+#pragma warning( once : 4505 )  // unreferenced local function has been removed
+
+#include "vpxdecoderinpin.h"
+
+#include <amvideo.h>
+#include <dvdmedia.h>
+#include <evcode.h>
+#include <uuids.h>
+#include <vfwmsgs.h>
+
+#include <cassert>
+
+#include "vpx/vp8dx.h"
+
+#include "graphutil.h"
+#include "mediatypeutil.h"
+#include "vpxdecoderfilter.h"
+#include "vpxdecoderoutpin.h"
+#include "webmtypes.h"
+
+#ifdef _DEBUG
+#include <iomanip>
+#include "odbgstream.h"
+using std::endl;
+using std::hex;
+using std::dec;
+using std::fixed;
+using std::setprecision;
+#endif
+
+namespace {
+
+const wchar_t kVP8PinName[] = L"VP80";
+const wchar_t kVP9PinName[] = L"VP90";
+
+}  // namespace
+
+namespace VPXDecoderLib {
+
+Inpin::Inpin(Filter* p)
+    : Pin(p, PINDIR_INPUT, L"input"), m_bEndOfStream(false), m_bFlush(false) {
+  AM_MEDIA_TYPE mt;
+
+  mt.majortype = MEDIATYPE_Video;
+  mt.subtype = WebmTypes::MEDIASUBTYPE_VP80;
+  mt.bFixedSizeSamples = FALSE;
+  mt.bTemporalCompression = TRUE;
+  mt.lSampleSize = 0;
+  mt.formattype = GUID_NULL;
+  mt.pUnk = 0;
+  mt.cbFormat = 0;
+  mt.pbFormat = 0;
+
+  m_preferred_mtv.Add(mt);
+}
+
+HRESULT Inpin::QueryInterface(const IID& iid, void** ppv) {
+  if (ppv == 0)
+    return E_POINTER;
+
+  IUnknown*& pUnk = reinterpret_cast<IUnknown*&>(*ppv);
+
+  if (iid == __uuidof(IUnknown)) {
+    pUnk = static_cast<IPin*>(this);
+  } else if (iid == __uuidof(IPin)) {
+    pUnk = static_cast<IPin*>(this);
+  } else if (iid == __uuidof(IMemInputPin)) {
+    pUnk = static_cast<IMemInputPin*>(this);
+  } else {
+    pUnk = 0;
+    return E_NOINTERFACE;
+  }
+
+  pUnk->AddRef();
+  return S_OK;
+}
+
+ULONG Inpin::AddRef() {
+  return m_pFilter->AddRef();
+}
+
+ULONG Inpin::Release() {
+  return m_pFilter->Release();
+}
+
+HRESULT Inpin::Connect(IPin*, const AM_MEDIA_TYPE*) {
+  return E_UNEXPECTED;  // for output pins only
+}
+
+HRESULT Inpin::QueryInternalConnections(IPin** pa, ULONG* pn) {
+  if (pn == 0)
+    return E_POINTER;
+
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  const ULONG m = 1;  // number of output pins
+
+  ULONG& n = *pn;
+
+  if (n == 0) {
+    if (pa == 0) {
+      // query for required number
+      n = m;
+      return S_OK;
+    }
+
+    return S_FALSE;  // means "insufficient number of array elements"
+  }
+
+  if (n < m) {
+    n = 0;
+    return S_FALSE;  // means "insufficient number of array elements"
+  }
+
+  if (pa == 0) {
+    n = 0;
+    return E_POINTER;
+  }
+
+  IPin*& pin = pa[0];
+
+  pin = &m_pFilter->m_outpin;
+  pin->AddRef();
+
+  n = m;
+  return S_OK;
+}
+
+HRESULT Inpin::ReceiveConnection(IPin* pin, const AM_MEDIA_TYPE* pmt) {
+  if (pin == 0)
+    return E_INVALIDARG;
+
+  if (pmt == 0)
+    return E_INVALIDARG;
+
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (m_pFilter->GetStateLocked() != State_Stopped)
+    return VFW_E_NOT_STOPPED;
+
+  if (bool(m_pPinConnection))
+    return VFW_E_ALREADY_CONNECTED;
+
+  m_connection_mtv.Clear();
+
+  hr = QueryAccept(pmt);
+
+  if (hr != S_OK)
+    return VFW_E_TYPE_NOT_ACCEPTED;
+
+  const AM_MEDIA_TYPE& mt = *pmt;
+
+  hr = m_connection_mtv.Add(mt);
+
+  if (FAILED(hr))
+    return hr;
+
+  m_pPinConnection = pin;
+
+  // TODO: init decompressor here?
+
+  m_pFilter->m_outpin.OnInpinConnect(mt);
+
+  return S_OK;
+}
+
+HRESULT Inpin::EndOfStream() {
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (!bool(m_pPinConnection))
+    return VFW_E_NOT_CONNECTED;
+
+  m_bEndOfStream = true;
+
+  if (IPin* pPin = m_pFilter->m_outpin.m_pPinConnection) {
+    lock.Release();
+
+#ifdef _DEBUG
+    odbgstream os;
+    os << "vpxdecoder::inpin::EOS: calling pin->EOS" << endl;
+#endif
+
+    const HRESULT hr = pPin->EndOfStream();
+
+#ifdef _DEBUG
+    os << "vpxdecoder::inpin::EOS: called pin->EOS; hr=0x" << hex << hr << dec
+       << endl;
+#endif
+
+    return hr;
+  }
+
+  return S_OK;
+}
+
+HRESULT Inpin::BeginFlush() {
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (!bool(m_pPinConnection))
+    return VFW_E_NOT_CONNECTED;
+
+#if _DEBUG
+    odbgstream os;
+    os << "vpxdecoder::inpin::beginflush" << endl;
+#endif
+
+  m_bFlush = true;
+
+  if (IPin* pPin = m_pFilter->m_outpin.m_pPinConnection) {
+    lock.Release();
+
+    const HRESULT hr = pPin->BeginFlush();
+    return hr;
+  }
+
+  return S_OK;
+}
+
+HRESULT Inpin::EndFlush() {
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (!bool(m_pPinConnection))
+    return VFW_E_NOT_CONNECTED;
+
+#if _DEBUG
+    odbgstream os;
+    os << "vpxdecoder::inpin::endflush" << endl;
+#endif
+
+  m_bFlush = false;
+  m_bEndOfStream = false;
+
+  if (IPin* pPin = m_pFilter->m_outpin.m_pPinConnection) {
+    lock.Release();
+
+    const HRESULT hr = pPin->EndFlush();
+    return hr;
+  }
+
+  return S_OK;
+}
+
+HRESULT Inpin::NewSegment(REFERENCE_TIME start_time,
+                          REFERENCE_TIME stop_time,
+                          double rate) {
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (!bool(m_pPinConnection))
+    return VFW_E_NOT_CONNECTED;
+
+  if (IPin* pPin = m_pFilter->m_outpin.m_pPinConnection) {
+    lock.Release();
+
+    const HRESULT hr = pPin->NewSegment(start_time, stop_time, rate);
+    return hr;
+  }
+
+  return S_OK;
+}
+
+HRESULT Inpin::QueryAccept(const AM_MEDIA_TYPE* pmt) {
+  if (pmt == 0)
+    return E_INVALIDARG;
+
+  const AM_MEDIA_TYPE& mt = *pmt;
+
+  if (mt.majortype != MEDIATYPE_Video)
+    return S_FALSE;
+
+  if (mt.subtype != WebmTypes::MEDIASUBTYPE_VP80 &&
+      mt.subtype != WebmTypes::MEDIASUBTYPE_VP90)
+    return S_FALSE;
+
+  if (mt.formattype != FORMAT_VideoInfo)  // TODO: liberalize
+    return S_FALSE;
+
+  if (mt.pbFormat == 0)
+    return S_FALSE;
+
+  if (mt.cbFormat < sizeof(VIDEOINFOHEADER))
+    return S_FALSE;
+
+  const VIDEOINFOHEADER& vih = (VIDEOINFOHEADER&)(*mt.pbFormat);
+  const BITMAPINFOHEADER& bmih = vih.bmiHeader;
+
+  if (bmih.biSize != sizeof(BITMAPINFOHEADER))  // TODO: liberalize
+    return S_FALSE;
+
+  if (bmih.biWidth <= 0)
+    return S_FALSE;
+
+  if (bmih.biHeight <= 0)
+    return S_FALSE;
+
+  // Confirm that four CCs match.
+  if (bmih.biCompression != WebmTypes::MEDIASUBTYPE_VP80.Data1 &&
+      bmih.biCompression != WebmTypes::MEDIASUBTYPE_VP90.Data1) {
+    return S_FALSE;
+  }
+
+  return S_OK;
+}
+
+HRESULT Inpin::GetAllocator(IMemAllocator** p) {
+  if (p)
+    *p = 0;
+
+  return VFW_E_NO_ALLOCATOR;
+}
+
+HRESULT Inpin::NotifyAllocator(IMemAllocator* pAllocator, BOOL) {
+  if (pAllocator == 0)
+    return E_INVALIDARG;
+
+  ALLOCATOR_PROPERTIES props;
+  const HRESULT hr = pAllocator->GetProperties(&props);
+
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+    return hr;
+  }
+
+#ifdef _DEBUG
+  wodbgstream os;
+  os << "vpxdec::inpin::NotifyAllocator allocator props: \n"
+     << "  cBuffers=" << props.cBuffers << "\n"
+     << "  cbBuffer=" << props.cbBuffer << "\n"
+     << "  cbAlign=" << props.cbAlign << "\n"
+     << "  cbPrefix=" << props.cbPrefix << "\n";
+#endif
+
+  return S_OK;
+}
+
+HRESULT Inpin::GetAllocatorRequirements(ALLOCATOR_PROPERTIES* pp) {
+  if (pp == NULL)
+    return E_POINTER;
+
+  return S_OK;
+}
+
+HRESULT Inpin::Receive(IMediaSample* pInSample) {
+  if (pInSample == 0)
+    return E_INVALIDARG;
+
+//#define DEBUG_RECEIVE
+
+#ifdef DEBUG_RECEIVE
+  __int64 start_reftime, stop_reftime;
+  const HRESULT hr_debug = pInSample->GetTime(&start_reftime, &stop_reftime);
+
+  odbgstream os;
+  os << "vpxdec::inpin::receive: ";
+
+  os << std::fixed << std::setprecision(3);
+
+  if (hr_debug == S_OK) {
+    os << "start[ms]=" << double(start_reftime) / 10000
+        << "; stop[ms]=" << double(stop_reftime) / 10000
+        << "; dt[ms]=" << double(stop_reftime - start_reftime) / 10000;
+  } else if (hr_debug == VFW_S_NO_STOP_TIME) {
+    os << "start[ms]=" << double(start_reftime) / 10000;
+  }
+
+  os << endl;
+#endif  // DEBUG_RECEIVE
+
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+#ifdef DEBUG_RECEIVE
+  wodbgstream os;
+  os << L"vpxdec::inpin::Receive: THREAD=0x"
+      << std::hex << GetCurrentThreadId() << std::dec
+      << endl;
+#endif  // DEBUG_RECEIVE
+
+  if (!bool(m_pPinConnection))
+    return VFW_E_NOT_CONNECTED;
+
+  Outpin& outpin = m_pFilter->m_outpin;
+
+  if (!bool(outpin.m_pPinConnection))
+    return S_FALSE;
+
+  if (!bool(outpin.m_pAllocator))
+    return VFW_E_NO_ALLOCATOR;
+
+  if (m_pFilter->GetStateLocked() == State_Stopped)
+    return VFW_E_NOT_RUNNING;
+
+  if (m_bEndOfStream)
+    return VFW_E_SAMPLE_REJECTED_EOS;
+
+  if (m_bFlush)
+    return S_FALSE;
+
+  BYTE* buf;
+
+  hr = pInSample->GetPointer(&buf);
+  assert(SUCCEEDED(hr));
+  assert(buf);
+
+  const long len = pInSample->GetActualDataLength();
+  assert(len >= 0);
+
+  const vpx_codec_err_t err = vpx_codec_decode(&m_ctx, buf, len, 0, 0);
+
+  if (err != VPX_CODEC_OK)
+    return m_pFilter->OnDecodeFailureLocked();
+
+  hr = pInSample->IsSyncPoint();
+
+  m_pFilter->OnDecodeSuccessLocked(hr == S_OK);
+
+  if (pInSample->IsPreroll() == S_OK)
+    return S_OK;
+
+  lock.Release();
+
+  GraphUtil::IMediaSamplePtr pOutSample;
+
+  hr = outpin.m_pAllocator->GetBuffer(&pOutSample, 0, 0, 0);
+
+  if (FAILED(hr))
+    return S_FALSE;
+
+  assert(bool(pOutSample));
+
+  hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (m_pFilter->GetStateLocked() == State_Stopped)
+    return VFW_E_NOT_RUNNING;
+
+  if (!bool(outpin.m_pPinConnection))  // should never happen
+    return S_FALSE;
+
+  if (!bool(outpin.m_pInputPin))  // should never happen
+    return S_FALSE;
+
+  vpx_codec_iter_t iter = 0;
+
+  vpx_image_t* const f = vpx_codec_get_frame(&m_ctx, &iter);
+
+  if (f == 0)
+    return S_OK;
+
+  AM_MEDIA_TYPE* pmt;
+
+  hr = pOutSample->GetMediaType(&pmt);
+
+  if (SUCCEEDED(hr) && (pmt != 0)) {
+    hr = outpin.QueryAccept(pmt);
+
+    if (hr != S_OK) {
+      assert(hr == S_OK);
+      return hr;
+    }
+
+    outpin.m_connection_mtv.Clear();
+    outpin.m_connection_mtv.Add(*pmt);
+
+    MediaTypeUtil::Free(pmt);
+    pmt = 0;
+  }
+
+  const AM_MEDIA_TYPE& mt = outpin.m_connection_mtv[0];
+
+  const BITMAPINFOHEADER* bmih_ptr;
+  const RECT* rc_ptr;
+
+  if (mt.formattype == FORMAT_VideoInfo) {
+    assert(mt.cbFormat >= sizeof(VIDEOINFOHEADER));
+    assert(mt.pbFormat);
+
+    const VIDEOINFOHEADER& vih_out = (VIDEOINFOHEADER&)(*mt.pbFormat);
+    const RECT& rc_out = vih_out.rcSource;
+    const BITMAPINFOHEADER& bmih_out = vih_out.bmiHeader;
+
+    bmih_ptr = &bmih_out;
+    rc_ptr = &rc_out;
+  } else if (mt.formattype == FORMAT_VideoInfo2) {
+    assert(mt.cbFormat >= sizeof(VIDEOINFOHEADER2));
+    assert(mt.pbFormat);
+
+    const VIDEOINFOHEADER2& vih2_out = (VIDEOINFOHEADER2&)(*mt.pbFormat);
+    const RECT& rc_out = vih2_out.rcSource;
+    const BITMAPINFOHEADER& bmih_out = vih2_out.bmiHeader;
+
+    bmih_ptr = &bmih_out;
+    rc_ptr = &rc_out;
+  } else {
+    return E_FAIL;
+  }
+
+  if (mt.subtype == MEDIASUBTYPE_NV12)
+    CopyToPlanar(f, pOutSample, mt.subtype, *bmih_ptr);
+
+  else if (mt.subtype == MEDIASUBTYPE_YV12)
+    CopyToPlanar(f, pOutSample, mt.subtype, *bmih_ptr);
+
+  else if (mt.subtype == WebmTypes::MEDIASUBTYPE_I420)
+    CopyToPlanar(f, pOutSample, mt.subtype, *bmih_ptr);
+
+  else if (mt.subtype == MEDIASUBTYPE_UYVY)
+    CopyToPacked(f, pOutSample, mt.subtype, *rc_ptr, *bmih_ptr);
+
+  else if (mt.subtype == MEDIASUBTYPE_YUY2)
+    CopyToPacked(f, pOutSample, mt.subtype, *rc_ptr, *bmih_ptr);
+
+  else if (mt.subtype == MEDIASUBTYPE_YUYV)
+    CopyToPacked(f, pOutSample, mt.subtype, *rc_ptr, *bmih_ptr);
+
+  else if (mt.subtype == MEDIASUBTYPE_YVYU)
+    CopyToPacked(f, pOutSample, mt.subtype, *rc_ptr, *bmih_ptr);
+
+  else
+    return E_FAIL;
+
+  __int64 st, sp;
+
+  hr = pInSample->GetTime(&st, &sp);
+
+  if (FAILED(hr)) {
+    hr = pOutSample->SetTime(0, 0);
+    assert(SUCCEEDED(hr));
+  } else if (hr == S_OK) {
+    hr = pOutSample->SetTime(&st, &sp);
+    assert(SUCCEEDED(hr));
+  } else {
+    hr = pOutSample->SetTime(&st, 0);
+    assert(SUCCEEDED(hr));
+  }
+
+  hr = pOutSample->SetSyncPoint(TRUE);
+  assert(SUCCEEDED(hr));
+
+  hr = pOutSample->SetPreroll(FALSE);
+  assert(SUCCEEDED(hr));
+
+  hr = pInSample->IsDiscontinuity();
+  hr = pOutSample->SetDiscontinuity(hr == S_OK);
+
+  hr = pOutSample->SetMediaTime(0, 0);
+
+#if 0
+    __int64 st, sp;
+    hr = pOutSample->GetTime(&st, &sp);
+    assert(SUCCEEDED(hr));
+
+    odbgstream os;
+    os << "V: " << fixed << setprecision(3) << (double(st)/10000000.0) << endl;
+#endif
+
+  lock.Release();
+
+  return outpin.m_pInputPin->Receive(pOutSample);
+}
+
+HRESULT Inpin::ReceiveMultiple(IMediaSample** pSamples,
+                               long n,  // in
+                               long* pm)  { // out
+  if (pm == 0)
+    return E_POINTER;
+
+  long& m = *pm;  // out
+  m = 0;
+
+  if (n <= 0)
+    return S_OK;  // weird
+
+  if (pSamples == 0)
+    return E_INVALIDARG;
+
+  for (long i = 0; i < n; ++i) {
+    IMediaSample* const pSample = pSamples[i];
+    assert(pSample);
+
+    const HRESULT hr = Receive(pSample);
+
+    if (hr != S_OK)
+      return hr;
+
+    ++m;
+  }
+
+  return S_OK;
+}
+
+void Inpin::CopyToPlanar(const vpx_image_t* f, IMediaSample* pOutSample,
+                         const GUID& subtype_out,
+                         const BITMAPINFOHEADER& bmih_out) {
+  // Y
+
+  const BYTE* pInY = f->planes[VPX_PLANE_Y];
+  assert(pInY);
+
+  unsigned int width_in = f->d_w;
+  unsigned int height_in = f->d_h;
+
+  BYTE* pOutBuf;
+
+  HRESULT hr = pOutSample->GetPointer(&pOutBuf);
+  assert(SUCCEEDED(hr));
+  assert(pOutBuf);
+
+  BYTE* pOut = pOutBuf;
+
+  const int strideInY = f->stride[VPX_PLANE_Y];
+
+  LONG strideOut = bmih_out.biWidth;
+  assert(strideOut);
+  assert((strideOut % 2) == 0);
+
+  for (unsigned int y = 0; y < height_in; ++y) {
+    memcpy(pOut, pInY, width_in);
+    pInY += strideInY;
+    pOut += strideOut;
+  }
+
+  width_in = (width_in + 1) / 2;
+  height_in = (height_in + 1) / 2;
+
+  const BYTE* pInV = f->planes[VPX_PLANE_V];
+  assert(pInV);
+
+  const int strideInV = f->stride[VPX_PLANE_V];
+
+  const BYTE* pInU = f->planes[VPX_PLANE_U];
+  assert(pInU);
+
+  const int strideInU = f->stride[VPX_PLANE_U];
+
+  if (subtype_out == MEDIASUBTYPE_NV12) {
+    // Note that while NV12 is considered a planar format,
+    // the chroma plane packs the UV samples.
+
+    // UV
+
+    for (unsigned int y = 0; y < height_in; ++y) {
+      const BYTE* u = pInU;
+      const BYTE* v = pInV;
+      BYTE* uv = pOut;
+
+      for (unsigned int idx = 0; idx < width_in; ++idx) {
+        *uv++ = *u++;
+        *uv++ = *v++;
+      }
+
+      pInU += strideInU;
+      pInV += strideInV;
+      pOut += strideOut;
+    }
+  } else if (subtype_out == MEDIASUBTYPE_YV12) {
+    strideOut /= 2;
+
+    // V
+
+    for (unsigned int y = 0; y < height_in; ++y) {
+      memcpy(pOut, pInV, width_in);
+      pInV += strideInV;
+      pOut += strideOut;
+    }
+
+    // U
+
+    for (unsigned int y = 0; y < height_in; ++y) {
+      memcpy(pOut, pInU, width_in);
+      pInU += strideInU;
+      pOut += strideOut;
+    }
+  } else {
+    assert(subtype_out == WebmTypes::MEDIASUBTYPE_I420);
+    strideOut /= 2;
+
+    // U
+
+    for (unsigned int y = 0; y < height_in; ++y) {
+      memcpy(pOut, pInU, width_in);
+      pInU += strideInU;
+      pOut += strideOut;
+    }
+
+    // V
+
+    for (unsigned int y = 0; y < height_in; ++y) {
+      memcpy(pOut, pInV, width_in);
+      pInV += strideInV;
+      pOut += strideOut;
+    }
+  }
+
+  const ptrdiff_t lenOut_ = pOut - pOutBuf;
+  const long lenOut = static_cast<long>(lenOut_);
+
+  hr = pOutSample->SetActualDataLength(lenOut);
+  assert(SUCCEEDED(hr));
+}
+
+void Inpin::CopyToPacked(const vpx_image_t* f, IMediaSample* pOutSample,
+                         const GUID& subtype_out, const RECT& rc_out,
+                         const BITMAPINFOHEADER& bmih_out) {
+  const LONG rect_width_out = rc_out.right - rc_out.left;
+  assert(rect_width_out >= 0);
+
+  const LONG width_out =
+      (rect_width_out > 0) ? rect_width_out : bmih_out.biWidth;
+  assert(width_out > 0);
+
+  const LONG rect_height_out = rc_out.bottom - rc_out.top;
+  assert(rect_height_out >= 0);
+
+  const LONG height_out =
+      (rect_height_out > 0) ? rect_height_out : labs(bmih_out.biHeight);
+
+  const BYTE* pInY_base = f->planes[VPX_PLANE_Y];
+  assert(pInY_base);
+
+  const int strideInY = f->stride[VPX_PLANE_Y];
+
+  const BYTE* pInV_base = f->planes[VPX_PLANE_V];
+  assert(pInV_base);
+
+  const int strideInV = f->stride[VPX_PLANE_V];
+
+  const BYTE* pInU_base = f->planes[VPX_PLANE_U];
+  assert(pInU_base);
+
+  const int strideInU = f->stride[VPX_PLANE_U];
+
+  const unsigned int width_in = f->d_w;
+  assert(LONG(width_in) == width_out);
+
+  const unsigned int height_in = f->d_h;
+  assert(LONG(height_in) == height_out);
+
+  BYTE* pOutBuf;
+
+  HRESULT hr = pOutSample->GetPointer(&pOutBuf);
+  assert(SUCCEEDED(hr));
+  assert(pOutBuf);
+
+  const LONG strideOut_ = 2 * width_in;
+  LONG strideOut;
+
+  if (bmih_out.biWidth < strideOut_)
+    strideOut = strideOut_;
+  else
+    strideOut = bmih_out.biWidth;
+
+  const LONG uv_width = width_in / 2;
+  const LONG uv_height = height_in / 2;
+
+  int u_off, v_off, y_off;
+
+  if (subtype_out == MEDIASUBTYPE_UYVY) {
+    u_off = 0;
+    v_off = 2;
+    y_off = 1;
+  } else if ((subtype_out == MEDIASUBTYPE_YUY2) ||
+             (subtype_out == MEDIASUBTYPE_YUYV)) {
+    u_off = 1;
+    v_off = 3;
+    y_off = 0;
+  } else {
+    assert(subtype_out == MEDIASUBTYPE_YVYU);
+
+    u_off = 3;
+    v_off = 1;
+    y_off = 0;
+  }
+
+  BYTE* pOut = pOutBuf;
+
+  for (LONG hdx = 0; hdx < uv_height; ++hdx) {
+    BYTE* const pOut0 = pOut;
+    pOut += strideOut;
+
+    BYTE* const pOut1 = pOut;
+    pOut += strideOut;
+
+    BYTE* pOutU0 = pOut0 + u_off;
+    BYTE* pOutU1 = pOut1 + u_off;
+
+    BYTE* pOutV0 = pOut0 + v_off;
+    BYTE* pOutV1 = pOut1 + v_off;
+
+    BYTE* pOutY0 = pOut0 + y_off;
+    BYTE* pOutY1 = pOut1 + y_off;
+
+    const BYTE* pInU = pInU_base;
+    pInU_base += strideInU;
+
+    const BYTE* pInV = pInV_base;
+    pInV_base += strideInV;
+
+    const BYTE* pInY0 = pInY_base;
+    pInY_base += strideInY;
+
+    const BYTE* pInY1 = pInY_base;
+    pInY_base += strideInY;
+
+    for (LONG wdx = 0; wdx < uv_width; ++wdx) {
+      *pOutU0 = *pInU;
+      *pOutU1 = *pInU;
+
+      pOutU0 += 4;
+      pOutU1 += 4;
+
+      ++pInU;
+
+      *pOutV0 = *pInV;
+      *pOutV1 = *pInV;
+
+      pOutV0 += 4;
+      pOutV1 += 4;
+
+      ++pInV;
+
+      *pOutY0 = *pInY0;
+      *pOutY1 = *pInY1;
+
+      pOutY0 += 2;
+      pOutY1 += 2;
+
+      ++pInY0;
+      ++pInY1;
+
+      *pOutY0 = *pInY0;
+      *pOutY1 = *pInY1;
+
+      pOutY0 += 2;
+      pOutY1 += 2;
+
+      ++pInY0;
+      ++pInY1;
+    }
+  }
+
+  const ptrdiff_t lenOut_ = pOut - pOutBuf;
+  const long lenOut = static_cast<long>(lenOut_);
+
+  hr = pOutSample->SetActualDataLength(lenOut);
+  assert(SUCCEEDED(hr));
+}
+
+HRESULT Inpin::ReceiveCanBlock() {
+  Filter::Lock lock;
+
+  const HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return S_OK;  //?
+
+  if (IMemInputPin* pPin = m_pFilter->m_outpin.m_pInputPin) {
+    lock.Release();
+    return pPin->ReceiveCanBlock();
+  }
+
+  return S_FALSE;
+}
+
+HRESULT Inpin::OnDisconnect() {
+  return m_pFilter->m_outpin.OnInpinDisconnect();
+}
+
+HRESULT Inpin::GetName(PIN_INFO& info) const {
+  const wchar_t* name = L"No connection";
+  if (m_connection_mtv.Empty() == false) {
+    if (m_connection_mtv[0].subtype == WebmTypes::MEDIASUBTYPE_VP80)
+      name = kVP8PinName;
+    else  // (m_connection_mtv[0].subtype == WebmTypes::MEDIASUBTYPE_VP90)
+      name = kVP9PinName;
+  }
+
+  wcscpy(info.achName, name);
+  return S_OK;
+}
+
+HRESULT Inpin::Start() {
+  m_bEndOfStream = false;
+  m_bFlush = false;
+
+  vpx_codec_iface_t* vpx = NULL;
+  int flags = 0;
+
+  if (m_connection_mtv[0].subtype == WebmTypes::MEDIASUBTYPE_VP80) {
+    // TODO(tomfinegan): Do we really want post proc? VP8Decoder always enabled
+    // it, so here it remains.
+    flags = VPX_CODEC_USE_POSTPROC;
+    vpx = &vpx_codec_vp8_dx_algo;
+  } else if (m_connection_mtv[0].subtype == WebmTypes::MEDIASUBTYPE_VP90) {
+    vpx = &vpx_codec_vp9_dx_algo;
+  } else {
+    return E_FAIL;
+  }
+
+  const vpx_codec_err_t err = vpx_codec_dec_init(&m_ctx, vpx, 0, flags);
+  if (err == VPX_CODEC_MEM_ERROR)
+    return E_OUTOFMEMORY;
+
+  if (err != VPX_CODEC_OK)
+    return E_FAIL;
+
+  if (m_connection_mtv[0].subtype == WebmTypes::MEDIASUBTYPE_VP80) {
+    const HRESULT hr = OnApplyPostProcessing();
+
+    if (FAILED(hr)) {
+      Stop();
+      return hr;
+    }
+  }
+
+  return S_OK;
+}
+
+void Inpin::Stop() {
+  const vpx_codec_err_t err = vpx_codec_destroy(&m_ctx);
+  err;
+  assert(err == VPX_CODEC_OK);
+}
+
+HRESULT Inpin::OnApplyPostProcessing() {
+  const Filter::Config& src = m_pFilter->m_cfg;
+  vp8_postproc_cfg_t tgt;
+
+  tgt.post_proc_flag = src.flags;
+  tgt.deblocking_level = src.deblock;
+  tgt.noise_level = src.noise;
+
+  const vpx_codec_err_t err = vpx_codec_control(&m_ctx, VP8_SET_POSTPROC, &tgt);
+
+  return (err == VPX_CODEC_OK) ? S_OK : E_FAIL;
+}
+
+}  // namespace VPXDecoderLib
diff --git a/vpxdecoder/vpxdecoderinpin.h b/vpxdecoder/vpxdecoderinpin.h
new file mode 100644
index 0000000..5873364
--- /dev/null
+++ b/vpxdecoder/vpxdecoderinpin.h
@@ -0,0 +1,80 @@
+// Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef WEBMDSHOW_VPXDECODER_VPXDECODERINPIN_H_
+#define WEBMDSHOW_VPXDECODER_VPXDECODERINPIN_H_
+
+#include <amvideo.h>
+
+#include "vpx/vpx_decoder.h"
+
+#include "graphutil.h"
+#include "vpxdecoderpin.h"
+
+namespace VPXDecoderLib {
+
+class Inpin : public Pin, public IMemInputPin {
+ public:
+  explicit Inpin(Filter*);
+
+  // IUnknown interface:
+  HRESULT STDMETHODCALLTYPE QueryInterface(const IID&, void**);
+  ULONG STDMETHODCALLTYPE AddRef();
+  ULONG STDMETHODCALLTYPE Release();
+
+  // IPin interface:
+  HRESULT STDMETHODCALLTYPE QueryAccept(const AM_MEDIA_TYPE*);
+  HRESULT STDMETHODCALLTYPE Connect(IPin*, const AM_MEDIA_TYPE*);
+
+  // HRESULT STDMETHODCALLTYPE Disconnect();
+  HRESULT STDMETHODCALLTYPE ReceiveConnection(IPin*, const AM_MEDIA_TYPE*);
+  HRESULT STDMETHODCALLTYPE QueryInternalConnections(IPin**, ULONG*);
+  HRESULT STDMETHODCALLTYPE EndOfStream();
+  HRESULT STDMETHODCALLTYPE BeginFlush();
+  HRESULT STDMETHODCALLTYPE EndFlush();
+  HRESULT STDMETHODCALLTYPE NewSegment(REFERENCE_TIME, REFERENCE_TIME, double);
+
+  // IMemInputPin
+  HRESULT STDMETHODCALLTYPE GetAllocator(IMemAllocator**);
+  HRESULT STDMETHODCALLTYPE NotifyAllocator(IMemAllocator*, BOOL);
+  HRESULT STDMETHODCALLTYPE GetAllocatorRequirements(ALLOCATOR_PROPERTIES*);
+  HRESULT STDMETHODCALLTYPE Receive(IMediaSample*);
+  HRESULT STDMETHODCALLTYPE ReceiveMultiple(IMediaSample**, long, long*);
+  HRESULT STDMETHODCALLTYPE ReceiveCanBlock();
+
+  // local functions
+  HRESULT Start();  // from stopped to running/paused
+  void Stop();  // from running/paused to stopped
+  HRESULT OnApplyPostProcessing();
+
+ protected:
+  HRESULT GetName(PIN_INFO&) const;
+  HRESULT OnDisconnect();
+
+ private:
+  HRESULT PopulateSample(IMediaSample*, const vpx_image_t*);
+
+  static void CopyToPlanar(const vpx_image_t* image, IMediaSample* sample,
+                           const GUID& subtype_out,
+                           const BITMAPINFOHEADER& bmih_out);
+
+  static void CopyToPacked(const vpx_image_t* image, IMediaSample* sample,
+                           const GUID& subtype_out, const RECT& rc_out,
+                           const BITMAPINFOHEADER& bmih_out);
+
+  // Manual DISALLOW_COPY_AND_ASSIGN.
+  Inpin(const Inpin&);
+  Inpin& operator=(const Inpin&);
+
+  bool m_bEndOfStream;
+  bool m_bFlush;
+  vpx_codec_ctx_t m_ctx;
+};
+
+}  // namespace VPXDecoderLib
+
+#endif  // WEBMDSHOW_VPXDECODER_VPXDECODERINPIN_H_
diff --git a/vpxdecoder/vpxdecoderoutpin.cc b/vpxdecoder/vpxdecoderoutpin.cc
new file mode 100644
index 0000000..629893d
--- /dev/null
+++ b/vpxdecoder/vpxdecoderoutpin.cc
@@ -0,0 +1,944 @@
+// Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+
+#include "vpxdecoderoutpin.h"
+
+#include <amvideo.h>
+#include <dvdmedia.h>
+#include <strmif.h>
+#include <uuids.h>
+#include <vfwmsgs.h>
+
+#include <cassert>
+
+#include "cmediasample.h"
+#include "mediatypeutil.h"
+#include "vpxdecoderfilter.h"
+#include "webmtypes.h"
+
+#ifdef _DEBUG
+#include "odbgstream.h"
+#include "iidstr.h"
+#endif
+
+using std::wstring;
+
+namespace VPXDecoderLib {
+
+Outpin::Outpin(Filter* pFilter) : Pin(pFilter, PINDIR_OUTPUT, L"output") {
+  SetDefaultMediaTypes();
+}
+
+Outpin::~Outpin() {
+  assert(!bool(m_pAllocator));
+  assert(!bool(m_pInputPin));
+}
+
+HRESULT Outpin::Start()  // transition from stopped
+{
+  if (m_pPinConnection == 0)
+    return S_FALSE;  // nothing we need to do
+
+  assert(bool(m_pAllocator));
+  assert(bool(m_pInputPin));
+
+  const HRESULT hr = m_pAllocator->Commit();
+  hr;
+  assert(SUCCEEDED(hr));  // TODO
+
+  return S_OK;
+}
+
+void Outpin::Stop()  // transition to stopped
+{
+  if (m_pPinConnection == 0)
+    return;  // nothing was done
+
+  assert(bool(m_pAllocator));
+  assert(bool(m_pInputPin));
+
+  const HRESULT hr = m_pAllocator->Decommit();
+  hr;
+  assert(SUCCEEDED(hr));
+}
+
+HRESULT Outpin::QueryInterface(const IID& iid, void** ppv) {
+  if (ppv == 0)
+    return E_POINTER;
+
+  IUnknown*& pUnk = reinterpret_cast<IUnknown*&>(*ppv);
+
+  if (iid == __uuidof(IUnknown)) {
+    pUnk = static_cast<IPin*>(this);
+  } else if (iid == __uuidof(IPin)) {
+    pUnk = static_cast<IPin*>(this);
+  } else if (iid == __uuidof(IMediaSeeking)) {
+    pUnk = static_cast<IMediaSeeking*>(this);
+  } else {
+#if _DEBUG
+    wodbgstream os;
+    os << "vpxdec::outpin::QI: iid=" << IIDStr(iid) << std::endl;
+#endif
+
+    pUnk = 0;
+    return E_NOINTERFACE;
+  }
+
+  pUnk->AddRef();
+  return S_OK;
+}
+
+ULONG Outpin::AddRef() {
+  return m_pFilter->AddRef();
+}
+
+ULONG Outpin::Release() {
+  return m_pFilter->Release();
+}
+
+HRESULT Outpin::Connect(IPin* pin, const AM_MEDIA_TYPE* pmt) {
+  if (pin == 0)
+    return E_POINTER;
+
+  GraphUtil::IMemInputPinPtr pInputPin;
+
+  HRESULT hr = pin->QueryInterface(&pInputPin);
+
+  if (hr != S_OK)
+    return hr;
+
+  Filter::Lock lock;
+
+  hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (m_pFilter->GetStateLocked() != State_Stopped)
+    return VFW_E_NOT_STOPPED;
+
+  if (bool(m_pPinConnection))
+    return VFW_E_ALREADY_CONNECTED;
+
+  if (!bool(m_pFilter->m_inpin.m_pPinConnection))
+    return VFW_E_NO_TYPES;  // VFW_E_NOT_CONNECTED?
+
+  m_connection_mtv.Clear();
+
+  if (pmt) {
+    hr = QueryAccept(pmt);
+
+    if (hr != S_OK)
+      return VFW_E_TYPE_NOT_ACCEPTED;
+
+    if ((pmt->formattype == FORMAT_VideoInfo) ||
+        (pmt->formattype == FORMAT_VideoInfo2)) {
+      hr = pin->ReceiveConnection(this, pmt);
+
+      if (FAILED(hr))
+        return hr;
+
+      m_connection_mtv.Add(*pmt);
+    } else  { // partial media type
+      const ULONG n = m_preferred_mtv.Size();
+      LONG idx = -1;
+
+      for (ULONG i = 0; i < n; ++i) {
+        const AM_MEDIA_TYPE& mt = m_preferred_mtv[i];
+
+        if (pmt->subtype == mt.subtype) {
+          idx = i;
+          break;
+        }
+      }
+
+      if (idx < 0)  // weird
+        return VFW_E_TYPE_NOT_ACCEPTED;
+
+      const AM_MEDIA_TYPE& mt = m_preferred_mtv[idx];
+
+      hr = pin->ReceiveConnection(this, &mt);
+
+      if (FAILED(hr))
+        return hr;
+
+      m_connection_mtv.Add(mt);
+    }
+  } else {
+    ULONG i = 0;
+    const ULONG j = m_preferred_mtv.Size();
+
+    while (i < j) {
+      const AM_MEDIA_TYPE& mt = m_preferred_mtv[i];
+
+      hr = pin->ReceiveConnection(this, &mt);
+
+      if (SUCCEEDED(hr))
+        break;
+
+      ++i;
+    }
+
+    if (i >= j)
+      return VFW_E_NO_ACCEPTABLE_TYPES;
+
+    const AM_MEDIA_TYPE& mt = m_preferred_mtv[i];
+
+    m_connection_mtv.Add(mt);
+  }
+
+  GraphUtil::IMemAllocatorPtr pAllocator;
+  hr = pInputPin->GetAllocator(&pAllocator);
+  if (FAILED(hr))
+    hr = CMediaSample::CreateAllocator(&pAllocator);
+
+  if (FAILED(hr) || pAllocator == NULL) {
+    assert(SUCCEEDED(hr));
+    assert(pAllocator != NULL);
+    return VFW_E_NO_ALLOCATOR;
+  }
+
+  ALLOCATOR_PROPERTIES props = {0};
+  hr = pInputPin->GetAllocatorRequirements(&props);
+
+  if (props.cBuffers <= 0)
+    props.cBuffers = 1;
+
+  LONG w, h;
+  GetConnectionDimensions(w, h);
+
+  const long cbBuffer = 2 * w * h;
+
+  if (props.cbBuffer < cbBuffer)
+    props.cbBuffer = cbBuffer;
+
+  if (props.cbAlign <= 0)
+    props.cbAlign = 1;
+
+  if (props.cbPrefix < 0)
+    props.cbPrefix = 0;
+
+  ALLOCATOR_PROPERTIES actual = {0};
+  hr = pAllocator->SetProperties(&props, &actual);
+
+#if _DEBUG
+  wodbgstream os;
+  os << "vpxdec::outpin::Connect alloc props, requested first:\n"
+     << "  cBuffers=" << props.cBuffers << "  " << actual.cBuffers << "\n"
+     << "  cbBuffer=" << props.cbBuffer << "  " << actual.cbBuffer << "\n"
+     << "  cbAlign=" << props.cbAlign << "  " << actual.cbAlign << "\n"
+     << "  cbPrefix=" << props.cbPrefix << "  " << actual.cbPrefix << "\n";
+#endif
+
+  if (FAILED(hr)) {
+    assert(SUCCEEDED(hr));
+    return hr;
+  }
+
+  hr = pInputPin->NotifyAllocator(pAllocator, 0);  // allow writes
+  if (FAILED(hr) && hr != E_NOTIMPL)
+    return hr;
+
+  m_pPinConnection = pin;
+  m_pAllocator = pAllocator;
+  m_pInputPin = pInputPin;
+
+  return S_OK;
+}
+
+HRESULT Outpin::OnDisconnect() {
+  m_pInputPin = 0;
+  m_pAllocator = 0;
+
+  return S_OK;
+}
+
+HRESULT Outpin::ReceiveConnection(IPin*, const AM_MEDIA_TYPE*) {
+  return E_UNEXPECTED;  // for input pins only
+}
+
+HRESULT Outpin::QueryAccept(const AM_MEDIA_TYPE* pmt_query) {
+  if (pmt_query == 0)
+    return E_INVALIDARG;
+
+  const AM_MEDIA_TYPE& mt_query = *pmt_query;
+
+  if (mt_query.majortype != MEDIATYPE_Video)
+    return S_FALSE;
+
+
+  if (mt_query.subtype != MEDIASUBTYPE_NV12 &&
+      mt_query.subtype != MEDIASUBTYPE_YV12 &&
+      mt_query.subtype != WebmTypes::MEDIASUBTYPE_I420 &&
+      mt_query.subtype != MEDIASUBTYPE_UYVY &&
+      mt_query.subtype != MEDIASUBTYPE_YVYU &&
+      mt_query.subtype != MEDIASUBTYPE_YUY2 &&
+      mt_query.subtype != MEDIASUBTYPE_YUYV) {
+    return S_FALSE;
+  }
+
+  Filter::Lock lock;
+  const HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return S_FALSE;
+
+  const Inpin& inpin = m_pFilter->m_inpin;
+
+  if (!bool(inpin.m_pPinConnection))
+    return S_FALSE;
+
+  if (mt_query.formattype == FORMAT_None)
+    return S_OK;
+
+  if (mt_query.formattype == GUID_NULL)
+    return S_OK;
+
+  const AM_MEDIA_TYPE& mt_in = inpin.m_connection_mtv[0];
+
+  if (mt_query.formattype == FORMAT_VideoInfo)
+    return QueryAcceptVideoInfo(mt_in, mt_query);
+
+  if (mt_query.formattype == FORMAT_VideoInfo2)
+    return QueryAcceptVideoInfo2(mt_in, mt_query);
+
+  return S_FALSE;
+}
+
+HRESULT Outpin::QueryAcceptVideoInfo(const AM_MEDIA_TYPE& mt_in,
+                                     const AM_MEDIA_TYPE& mt_out) {
+  assert(mt_in.formattype == FORMAT_VideoInfo);
+  assert(mt_in.pbFormat);
+  assert(mt_in.cbFormat >= sizeof(VIDEOINFOHEADER));
+  assert(mt_out.formattype == FORMAT_VideoInfo);
+
+  if (mt_out.pbFormat == 0)
+    return S_FALSE;
+
+  if (mt_out.cbFormat < sizeof(VIDEOINFOHEADER))
+    return S_FALSE;
+
+  const VIDEOINFOHEADER& vih_in =
+      reinterpret_cast<VIDEOINFOHEADER&>(*mt_in.pbFormat);
+
+  const VIDEOINFOHEADER& vih_out =
+      reinterpret_cast<VIDEOINFOHEADER&>(*mt_out.pbFormat);
+
+  const BITMAPINFOHEADER& bmih_out = vih_out.bmiHeader;
+
+  if (!VetBMIH(vih_in, mt_out.subtype, vih_out.rcSource, bmih_out))
+    return S_FALSE;
+
+  return S_OK;
+}
+
+HRESULT Outpin::QueryAcceptVideoInfo2(const AM_MEDIA_TYPE& mt_in,
+                                      const AM_MEDIA_TYPE& mt_out) {
+  assert(mt_in.formattype == FORMAT_VideoInfo);
+  assert(mt_in.pbFormat);
+  assert(mt_in.cbFormat >= sizeof(VIDEOINFOHEADER));
+  assert(mt_out.formattype == FORMAT_VideoInfo2);
+
+  if (mt_out.pbFormat == 0)
+    return S_FALSE;
+
+  if (mt_out.cbFormat < sizeof(VIDEOINFOHEADER2))
+    return S_FALSE;
+
+  const VIDEOINFOHEADER& vih_in =
+      reinterpret_cast<VIDEOINFOHEADER&>(*mt_in.pbFormat);
+
+  const VIDEOINFOHEADER2& vih2_out =
+      reinterpret_cast<VIDEOINFOHEADER2&>(*mt_out.pbFormat);
+
+  const BITMAPINFOHEADER& bmih_out = vih2_out.bmiHeader;
+
+  if (vih2_out.dwInterlaceFlags & AMINTERLACE_UNUSED)
+    return S_FALSE;
+
+  if (vih2_out.dwCopyProtectFlags & ~AMCOPYPROTECT_RestrictDuplication)
+    return S_FALSE;
+
+  if (vih2_out.dwReserved2)
+    return S_FALSE;
+
+  if (!VetBMIH(vih_in, mt_out.subtype, vih2_out.rcSource, bmih_out))
+    return S_FALSE;
+
+  return S_OK;
+}
+
+bool Outpin::VetBMIH(const VIDEOINFOHEADER& vih_in, const GUID& subtype_out,
+                     const RECT& rc_out, const BITMAPINFOHEADER& bmih_out) {
+  if (bmih_out.biSize != sizeof(BITMAPINFOHEADER))  // TODO: liberalize
+    return false;
+
+  if (bmih_out.biCompression != subtype_out.Data1)
+    return false;
+
+  const LONG stride_out = bmih_out.biWidth;
+
+  if (stride_out <= 0)
+    return false;
+
+  if (stride_out % 2)
+    return false;
+
+  const LONG height_out = labs(bmih_out.biHeight);  // yes, negative OK
+
+  const BITMAPINFOHEADER& bmih_in = vih_in.bmiHeader;
+
+  const LONG width_in = bmih_in.biWidth;
+  assert(width_in >= 0);
+
+  const LONG height_in = bmih_in.biHeight;
+  assert(height_in >= 0);
+
+  if (stride_out < width_in)
+    return false;
+
+  if (height_out != height_in)
+    return false;
+
+  const LONG width_out = rc_out.right - rc_out.left;
+
+  if (width_out == 0) {
+    if (stride_out != width_in)
+      return false;
+  } else if (width_out != width_in) {
+    return false;
+  }
+
+  return true;
+}
+
+HRESULT Outpin::QueryInternalConnections(IPin** pa, ULONG* pn) {
+  if (pn == 0)
+    return E_POINTER;
+
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  ULONG& n = *pn;
+
+  if (n == 0) {
+    if (pa == 0) { // query for required number
+      n = 1;
+      return S_OK;
+    }
+
+    return S_FALSE;  // means "insufficient number of array elements"
+  }
+
+  if (n < 1) {
+    n = 0;
+    return S_FALSE;  // means "insufficient number of array elements"
+  }
+
+  if (pa == 0) {
+    n = 0;
+    return E_POINTER;
+  }
+
+  IPin*& pPin = pa[0];
+
+  pPin = &m_pFilter->m_inpin;
+  pPin->AddRef();
+
+  n = 1;
+  return S_OK;
+}
+
+HRESULT Outpin::EndOfStream() {
+  return E_UNEXPECTED;  // for inpins only
+}
+
+HRESULT Outpin::NewSegment(REFERENCE_TIME, REFERENCE_TIME, double) {
+  return E_UNEXPECTED;
+}
+
+HRESULT Outpin::BeginFlush() {
+  return E_UNEXPECTED;
+}
+
+HRESULT Outpin::EndFlush() {
+  return E_UNEXPECTED;
+}
+
+HRESULT Outpin::GetCapabilities(DWORD* pdw) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->GetCapabilities(pdw);
+
+  if (pdw == 0)
+    return E_POINTER;
+
+  DWORD& dw = *pdw;
+  dw = 0;
+
+  return S_OK;
+}
+
+HRESULT Outpin::CheckCapabilities(DWORD* pdw) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->CheckCapabilities(pdw);
+
+  if (pdw == 0)
+    return E_POINTER;
+
+  DWORD& dw = *pdw;
+
+  const DWORD dwRequested = dw;
+
+  if (dwRequested == 0)
+    return E_INVALIDARG;
+
+  return E_FAIL;
+}
+
+HRESULT Outpin::IsFormatSupported(const GUID* p) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->IsFormatSupported(p);
+
+  if (p == 0)
+    return E_POINTER;
+
+  const GUID& g = *p;
+
+  if (g == TIME_FORMAT_MEDIA_TIME)
+    return S_OK;
+
+  return S_FALSE;
+}
+
+HRESULT Outpin::QueryPreferredFormat(GUID* p) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->QueryPreferredFormat(p);
+
+  if (p == 0)
+    return E_POINTER;
+
+  *p = TIME_FORMAT_MEDIA_TIME;
+  return S_OK;
+}
+
+HRESULT Outpin::GetTimeFormat(GUID* p) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->GetTimeFormat(p);
+
+  if (p == 0)
+    return E_POINTER;
+
+  *p = TIME_FORMAT_MEDIA_TIME;
+  return S_OK;
+}
+
+HRESULT Outpin::IsUsingTimeFormat(const GUID* p) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->IsUsingTimeFormat(p);
+
+  if (p == 0)
+    return E_INVALIDARG;
+
+  return (*p == TIME_FORMAT_MEDIA_TIME) ? S_OK : S_FALSE;
+}
+
+HRESULT Outpin::SetTimeFormat(const GUID* p) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->SetTimeFormat(p);
+
+  if (p == 0)
+    return E_INVALIDARG;
+
+  if (*p == TIME_FORMAT_MEDIA_TIME)
+    return S_OK;
+
+  return E_INVALIDARG;
+}
+
+HRESULT Outpin::GetDuration(LONGLONG* p) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->GetDuration(p);
+
+  if (p == 0)
+    return E_POINTER;
+
+  return E_FAIL;
+}
+
+HRESULT Outpin::GetStopPosition(LONGLONG* p) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->GetStopPosition(p);
+
+  if (p == 0)
+    return E_POINTER;
+
+  return E_FAIL;
+}
+
+HRESULT Outpin::GetCurrentPosition(LONGLONG* p) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->GetCurrentPosition(p);
+
+  if (p == 0)
+    return E_POINTER;
+
+  return E_FAIL;
+}
+
+HRESULT Outpin::ConvertTimeFormat(LONGLONG* ptgt, const GUID* ptgtfmt,
+                                  LONGLONG src, const GUID* psrcfmt) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->ConvertTimeFormat(ptgt, ptgtfmt, src, psrcfmt);
+
+  if (ptgt == 0)
+    return E_POINTER;
+
+  LONGLONG& tgt = *ptgt;
+
+  const GUID& tgtfmt = ptgtfmt ? *ptgtfmt : TIME_FORMAT_MEDIA_TIME;
+  const GUID& srcfmt = psrcfmt ? *psrcfmt : TIME_FORMAT_MEDIA_TIME;
+
+  if (tgtfmt != TIME_FORMAT_MEDIA_TIME)
+    return E_INVALIDARG;
+
+  if (srcfmt != TIME_FORMAT_MEDIA_TIME)
+    return E_INVALIDARG;
+
+  tgt = src;
+  return S_OK;
+}
+
+HRESULT Outpin::SetPositions(LONGLONG* pCurr, DWORD dwCurr, LONGLONG* pStop,
+                             DWORD dwStop) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->SetPositions(pCurr, dwCurr, pStop, dwStop);
+
+  return E_FAIL;
+}
+
+HRESULT Outpin::GetPositions(LONGLONG* pCurrPos, LONGLONG* pStopPos) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->GetPositions(pCurrPos, pStopPos);
+
+  return E_FAIL;
+}
+
+HRESULT Outpin::GetAvailable(LONGLONG* pEarliest, LONGLONG* pLatest) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->GetAvailable(pEarliest, pLatest);
+
+  return E_FAIL;
+}
+
+HRESULT Outpin::SetRate(double r) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->SetRate(r);
+
+  return E_FAIL;
+}
+
+HRESULT Outpin::GetRate(double* p) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->GetRate(p);
+
+  return E_FAIL;
+}
+
+HRESULT Outpin::GetPreroll(LONGLONG* p) {
+  const Inpin& inpin = m_pFilter->m_inpin;
+  const GraphUtil::IMediaSeekingPtr pSeek(inpin.m_pPinConnection);
+
+  if (bool(pSeek))
+    return pSeek->GetPreroll(p);
+
+  return E_FAIL;
+}
+
+HRESULT Outpin::GetName(PIN_INFO& info) const {
+  wstring name;
+
+  if (!bool(m_pPinConnection)) {
+    name = L"YUV";
+  } else {
+    const AM_MEDIA_TYPE& mt = m_connection_mtv[0];
+    const char* p = (const char*)&mt.subtype.Data1;
+    const char* const q = p + 4;
+
+    while (p != q) {
+      const char c = *p++;
+      name += wchar_t(c);  //?
+    }
+  }
+
+  const wchar_t* const name_ = name.c_str();
+
+#if _MSC_VER >= 1400
+  enum { namelen = sizeof(info.achName) / sizeof(WCHAR) };
+  const errno_t e = wcscpy_s(info.achName, namelen, name_);
+  e;
+  assert(e == 0);
+#else
+  wcscpy(info.achName, name_);
+#endif
+
+  return S_OK;
+}
+
+void Outpin::OnInpinConnect(const AM_MEDIA_TYPE& mtIn) {
+  assert(mtIn.cbFormat >= sizeof(VIDEOINFOHEADER));
+  assert(mtIn.pbFormat);
+
+  const VIDEOINFOHEADER& vihIn = (VIDEOINFOHEADER&)(*mtIn.pbFormat);
+  const BITMAPINFOHEADER& bmihIn = vihIn.bmiHeader;
+
+  const LONG w = bmihIn.biWidth;
+  assert(w > 0);
+
+  const LONG h = bmihIn.biHeight;
+  assert(h > 0);
+
+  m_preferred_mtv.Clear();
+
+  // planar
+
+  DWORD dwBitCount = 12;
+  DWORD dwSizeImage = w * h + 2 * ((w + 1) / 2 * (h + 1) / 2);
+
+  AddPreferred(MEDIASUBTYPE_NV12, vihIn.AvgTimePerFrame, w, h, dwBitCount,
+               dwSizeImage);
+
+  AddPreferred(MEDIASUBTYPE_YV12, vihIn.AvgTimePerFrame, w, h, dwBitCount,
+               dwSizeImage);
+
+  AddPreferred(WebmTypes::MEDIASUBTYPE_I420, vihIn.AvgTimePerFrame, w, h,
+               dwBitCount, dwSizeImage);
+
+  // packed
+
+  dwBitCount = 16;
+  dwSizeImage = 2 * w * h;
+
+  AddPreferred(MEDIASUBTYPE_UYVY, vihIn.AvgTimePerFrame, w, h, dwBitCount,
+               dwSizeImage);
+
+  AddPreferred(MEDIASUBTYPE_YUY2, vihIn.AvgTimePerFrame, w, h, dwBitCount,
+               dwSizeImage);
+
+  AddPreferred(MEDIASUBTYPE_YUYV, vihIn.AvgTimePerFrame, w, h, dwBitCount,
+               dwSizeImage);
+
+  AddPreferred(MEDIASUBTYPE_YVYU, vihIn.AvgTimePerFrame, w, h, dwBitCount,
+               dwSizeImage);
+}
+
+HRESULT Outpin::OnInpinDisconnect() {
+  if (bool(m_pPinConnection)) {
+    IFilterGraph* const pGraph = m_pFilter->m_info.pGraph;
+    assert(pGraph);
+
+    HRESULT hr = pGraph->Disconnect(m_pPinConnection);
+    assert(SUCCEEDED(hr));
+
+    hr = pGraph->Disconnect(this);
+    assert(SUCCEEDED(hr));
+
+    assert(!bool(m_pPinConnection));
+  }
+
+  SetDefaultMediaTypes();
+
+  return S_OK;
+}
+
+void Outpin::SetDefaultMediaTypes() { m_preferred_mtv.Clear(); }
+
+void Outpin::GetConnectionDimensions(LONG& w, LONG& h) const {
+  assert(!m_connection_mtv.Empty());
+  const AM_MEDIA_TYPE& mt = m_connection_mtv[0];
+
+  if (mt.formattype == FORMAT_VideoInfo) {
+    assert(mt.cbFormat >= sizeof(VIDEOINFOHEADER));
+    assert(mt.pbFormat);
+
+    const VIDEOINFOHEADER& vih = (VIDEOINFOHEADER&)(*mt.pbFormat);
+    const BITMAPINFOHEADER& bmih = vih.bmiHeader;
+
+    w = bmih.biWidth;
+    assert(w > 0);
+
+    h = labs(bmih.biHeight);
+    assert(h > 0);
+  } else {
+    assert(mt.formattype == FORMAT_VideoInfo2);
+    assert(mt.cbFormat >= sizeof(VIDEOINFOHEADER2));
+    assert(mt.pbFormat);
+
+    const VIDEOINFOHEADER2& vih2 = (VIDEOINFOHEADER2&)(*mt.pbFormat);
+    const BITMAPINFOHEADER& bmih = vih2.bmiHeader;
+
+    w = bmih.biWidth;
+    assert(w > 0);
+
+    h = labs(bmih.biHeight);
+    assert(h > 0);
+  }
+}
+
+void Outpin::AddPreferred(const GUID& subtype, REFERENCE_TIME AvgTimePerFrame,
+                          LONG width, LONG height, DWORD dwBitCount,
+                          DWORD dwSizeImage) {
+  AddVIH2(m_preferred_mtv, subtype, AvgTimePerFrame, width, height, dwBitCount,
+          dwSizeImage);
+
+  AddVIH(m_preferred_mtv, subtype, AvgTimePerFrame, width, height, dwBitCount,
+         dwSizeImage);
+}
+
+void Outpin::AddVIH(CMediaTypes& mtv, const GUID& subtype,
+                    REFERENCE_TIME AvgTimePerFrame, LONG width, LONG height,
+                    DWORD dwBitCount, DWORD dwSizeImage) {
+  AM_MEDIA_TYPE mt;
+
+  VIDEOINFOHEADER vih;
+  BITMAPINFOHEADER& bmih = vih.bmiHeader;
+
+  mt.majortype = MEDIATYPE_Video;
+  mt.subtype = subtype;
+  mt.bFixedSizeSamples = TRUE;
+  mt.bTemporalCompression = FALSE;
+  mt.lSampleSize = 0;
+  mt.formattype = FORMAT_VideoInfo;
+  mt.pUnk = 0;
+  mt.cbFormat = sizeof vih;
+  mt.pbFormat = (BYTE*)&vih;
+
+  SetRectEmpty(&vih.rcSource);
+  SetRectEmpty(&vih.rcTarget);
+  vih.dwBitRate = 0;
+  vih.dwBitErrorRate = 0;
+  vih.AvgTimePerFrame = AvgTimePerFrame;
+
+  bmih.biSize = sizeof bmih;
+  bmih.biWidth = width;
+  bmih.biHeight = height;
+  bmih.biPlanes = 1;  // because Microsoft says so
+  bmih.biBitCount = static_cast<WORD>(dwBitCount);
+  bmih.biCompression = subtype.Data1;
+  bmih.biSizeImage = dwSizeImage;
+  bmih.biXPelsPerMeter = 0;
+  bmih.biYPelsPerMeter = 0;
+  bmih.biClrUsed = 0;
+  bmih.biClrImportant = 0;
+
+  mtv.Add(mt);
+}
+
+void Outpin::AddVIH2(CMediaTypes& mtv, const GUID& subtype,
+                     REFERENCE_TIME AvgTimePerFrame, LONG width, LONG height,
+                     DWORD dwBitCount, DWORD dwSizeImage) {
+  AM_MEDIA_TYPE mt;
+
+  VIDEOINFOHEADER2 vih2;
+  BITMAPINFOHEADER& bmih = vih2.bmiHeader;
+
+  mt.majortype = MEDIATYPE_Video;
+  mt.subtype = subtype;
+  mt.bFixedSizeSamples = TRUE;
+  mt.bTemporalCompression = FALSE;
+  mt.lSampleSize = 0;
+  mt.formattype = FORMAT_VideoInfo2;
+  mt.pUnk = 0;
+  mt.cbFormat = sizeof vih2;
+  mt.pbFormat = (BYTE*)&vih2;
+
+  RECT& rc = vih2.rcSource;
+  rc.left = 0;
+  rc.top = 0;
+  rc.right = width;
+  rc.bottom = height;
+
+  vih2.rcTarget = rc;
+
+  vih2.dwBitRate = 0;
+  vih2.dwBitErrorRate = 0;
+  vih2.AvgTimePerFrame = AvgTimePerFrame;
+  vih2.dwInterlaceFlags = 0;
+  vih2.dwCopyProtectFlags = 0;
+  vih2.dwPictAspectRatioX = width;
+  vih2.dwPictAspectRatioY = height;
+  vih2.dwControlFlags = 0;
+  vih2.dwReserved2 = 0;
+
+  bmih.biSize = sizeof bmih;
+  bmih.biWidth = width;
+  bmih.biHeight = height;
+  bmih.biPlanes = 1;  // because Microsoft says so
+  bmih.biBitCount = static_cast<WORD>(dwBitCount);
+  bmih.biCompression = subtype.Data1;
+  bmih.biSizeImage = dwSizeImage;
+  bmih.biXPelsPerMeter = 0;
+  bmih.biYPelsPerMeter = 0;
+  bmih.biClrUsed = 0;
+  bmih.biClrImportant = 0;
+
+  mtv.Add(mt);
+}
+
+}  // namespace VPXDecoderLib
diff --git a/vpxdecoder/vpxdecoderoutpin.h b/vpxdecoder/vpxdecoderoutpin.h
new file mode 100644
index 0000000..d7edc74
--- /dev/null
+++ b/vpxdecoder/vpxdecoderoutpin.h
@@ -0,0 +1,112 @@
+// Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef WEBMDSHOW_VPXDECODER_VPXDECODEROUTPIN_H_
+#define WEBMDSHOW_VPXDECODER_VPXDECODEROUTPIN_H_
+
+#include <comdef.h>
+
+#include "graphutil.h"
+#include "vpxdecoderpin.h"
+
+namespace VPXDecoderLib {
+class Filter;
+
+class Outpin : public Pin, public IMediaSeeking {
+ public:
+  explicit Outpin(Filter*);
+  virtual ~Outpin();
+
+  // IUnknown interface:
+  HRESULT STDMETHODCALLTYPE QueryInterface(const IID&, void**);
+  ULONG STDMETHODCALLTYPE AddRef();
+  ULONG STDMETHODCALLTYPE Release();
+
+  // IPin interface:
+  HRESULT STDMETHODCALLTYPE Connect(IPin* pin, const AM_MEDIA_TYPE* media_type);
+  HRESULT STDMETHODCALLTYPE
+      ReceiveConnection(IPin* pin, const AM_MEDIA_TYPE* media_type);
+
+  HRESULT STDMETHODCALLTYPE QueryAccept(const AM_MEDIA_TYPE*);
+  HRESULT STDMETHODCALLTYPE QueryInternalConnections(IPin**, ULONG*);
+  HRESULT STDMETHODCALLTYPE EndOfStream();
+  HRESULT STDMETHODCALLTYPE BeginFlush();
+  HRESULT STDMETHODCALLTYPE EndFlush();
+  HRESULT STDMETHODCALLTYPE NewSegment(REFERENCE_TIME, REFERENCE_TIME, double);
+
+  // IMediaSeeking
+  HRESULT STDMETHODCALLTYPE GetCapabilities(DWORD*);
+  HRESULT STDMETHODCALLTYPE CheckCapabilities(DWORD*);
+  HRESULT STDMETHODCALLTYPE IsFormatSupported(const GUID*);
+  HRESULT STDMETHODCALLTYPE QueryPreferredFormat(GUID*);
+  HRESULT STDMETHODCALLTYPE GetTimeFormat(GUID*);
+  HRESULT STDMETHODCALLTYPE IsUsingTimeFormat(const GUID*);
+  HRESULT STDMETHODCALLTYPE SetTimeFormat(const GUID*);
+  HRESULT STDMETHODCALLTYPE GetDuration(LONGLONG*);
+  HRESULT STDMETHODCALLTYPE GetStopPosition(LONGLONG*);
+  HRESULT STDMETHODCALLTYPE GetCurrentPosition(LONGLONG*);
+
+  HRESULT STDMETHODCALLTYPE
+      ConvertTimeFormat(LONGLONG*, const GUID*, LONGLONG, const GUID*);
+
+  HRESULT STDMETHODCALLTYPE SetPositions(LONGLONG*, DWORD, LONGLONG*, DWORD);
+
+  HRESULT STDMETHODCALLTYPE GetPositions(LONGLONG*, LONGLONG*);
+
+  HRESULT STDMETHODCALLTYPE GetAvailable(LONGLONG*, LONGLONG*);
+
+  HRESULT STDMETHODCALLTYPE SetRate(double);
+  HRESULT STDMETHODCALLTYPE GetRate(double*);
+  HRESULT STDMETHODCALLTYPE GetPreroll(LONGLONG*);
+
+  // local functions
+  GraphUtil::IMemInputPinPtr m_pInputPin;
+  GraphUtil::IMemAllocatorPtr m_pAllocator;
+
+  void OnInpinConnect(const AM_MEDIA_TYPE&);
+  HRESULT OnInpinDisconnect();
+
+  HRESULT Start();  // from stopped to running/paused
+  void Stop();  // from running/paused to stopped
+
+ protected:
+  HRESULT OnDisconnect();
+  HRESULT GetName(PIN_INFO&) const;
+
+ private:
+  Outpin(const Outpin&);
+  Outpin& operator=(const Outpin&);
+
+  void SetDefaultMediaTypes();
+
+  static HRESULT QueryAcceptVideoInfo(const AM_MEDIA_TYPE& mt_in,
+                                      const AM_MEDIA_TYPE& mt_out);
+
+  static HRESULT QueryAcceptVideoInfo2(const AM_MEDIA_TYPE& mt_in,
+                                       const AM_MEDIA_TYPE& mt_out);
+
+  static bool VetBMIH(const VIDEOINFOHEADER& vih_in, const GUID& subtype_out,
+                      const RECT& rc_out, const BITMAPINFOHEADER& bmih_out);
+
+  void GetConnectionDimensions(LONG& w, LONG& h) const;
+
+  void AddPreferred(const GUID& subtype, REFERENCE_TIME AvgTimePerFrame,
+                    LONG width, LONG height, DWORD dwBitCount,
+                    DWORD dwSizeImage);
+
+  static void AddVIH(CMediaTypes&, const GUID& subtype,
+                     REFERENCE_TIME AvgTimePerFrame, LONG width, LONG height,
+                     DWORD dwBitCount, DWORD dwSizeImage);
+
+  static void AddVIH2(CMediaTypes&, const GUID& subtype,
+                      REFERENCE_TIME AvgTimePerFrame, LONG width, LONG height,
+                      DWORD dwBitCount, DWORD dwSizeImage);
+};
+
+}  // namespace VPXDecoderLib
+
+#endif  // WEBMDSHOW_VPXDECODER_VPXDECODEROUTPIN_H_
diff --git a/vpxdecoder/vpxdecoderpin.cc b/vpxdecoder/vpxdecoderpin.cc
new file mode 100644
index 0000000..505340e
--- /dev/null
+++ b/vpxdecoder/vpxdecoderpin.cc
@@ -0,0 +1,167 @@
+// Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#include "vpxdecoderpin.h"
+
+#include <cassert>
+
+#include <vfwmsgs.h>
+
+#include "vpxdecoderfilter.h"
+
+#ifdef _DEBUG
+#include "odbgstream.h"
+using std::endl;
+#endif
+
+namespace VPXDecoderLib {
+
+Pin::Pin(Filter* pFilter, PIN_DIRECTION dir, const wchar_t* id)
+    : m_pFilter(pFilter), m_dir(dir), m_id(id) {}
+
+Pin::~Pin() { assert(!bool(m_pPinConnection)); }
+
+HRESULT Pin::EnumMediaTypes(IEnumMediaTypes** pp) {
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+#if _DEBUG
+  wodbgstream os;
+  os << "vpxdec::pin[" << m_id << "]::EnumMediaTypes" << endl;
+#endif
+
+  return m_preferred_mtv.CreateEnum(this, pp);
+}
+
+HRESULT Pin::Disconnect() {
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (m_pFilter->GetStateLocked() != State_Stopped)
+    return VFW_E_NOT_STOPPED;
+
+  if (!bool(m_pPinConnection))
+    return S_FALSE;
+
+  hr = OnDisconnect();
+  assert(SUCCEEDED(hr));
+
+  m_pPinConnection = 0;
+  m_connection_mtv.Clear();
+
+  return S_OK;
+}
+
+HRESULT Pin::OnDisconnect() {
+  return S_OK;
+}
+
+HRESULT Pin::ConnectedTo(IPin** pp) {
+  if (pp == 0)
+    return E_POINTER;
+
+  IPin*& p = *pp;
+
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  p = m_pPinConnection;
+
+  if (p == 0)
+    return VFW_E_NOT_CONNECTED;
+
+  p->AddRef();
+  return S_OK;
+}
+
+HRESULT Pin::ConnectionMediaType(AM_MEDIA_TYPE* p) {
+  if (p == 0)
+    return E_POINTER;
+
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  if (!bool(m_pPinConnection))
+    return VFW_E_NOT_CONNECTED;
+
+  const CMediaTypes& mtv = m_connection_mtv;
+  assert(mtv.Size() == 1);
+
+  return mtv.Copy(0, *p);
+}
+
+HRESULT Pin::QueryPinInfo(PIN_INFO* p) {
+  if (p == 0)
+    return E_POINTER;
+
+  Filter::Lock lock;
+
+  HRESULT hr = lock.Seize(m_pFilter);
+
+  if (FAILED(hr))
+    return hr;
+
+  PIN_INFO& i = *p;
+
+  i.pFilter = static_cast<IBaseFilter*>(m_pFilter);
+  i.pFilter->AddRef();
+
+  i.dir = m_dir;
+
+  hr = GetName(i);
+  assert(SUCCEEDED(hr));
+
+  return S_OK;
+}
+
+HRESULT Pin::QueryDirection(PIN_DIRECTION* p) {
+  if (p == 0)
+    return E_POINTER;
+
+  *p = m_dir;
+  return S_OK;
+}
+
+HRESULT Pin::QueryId(LPWSTR* p) {
+  if (p == 0)
+    return E_POINTER;
+
+  wchar_t*& id = *p;
+
+  const size_t len = m_id.length();  // wchar strlen
+  const size_t buflen = len + 1;  // wchar strlen + wchar null
+  const size_t cb = buflen * sizeof(wchar_t);  // total bytes
+
+  id = (wchar_t*)CoTaskMemAlloc(cb);
+
+  if (id == 0)
+    return E_OUTOFMEMORY;
+
+  const errno_t e = wcscpy_s(id, buflen, m_id.c_str());
+  e;
+  assert(e == 0);
+
+  return S_OK;
+}
+
+}  // namespace VPXDecoderLib
diff --git a/vpxdecoder/vpxdecoderpin.h b/vpxdecoder/vpxdecoderpin.h
new file mode 100644
index 0000000..c9b0b55
--- /dev/null
+++ b/vpxdecoder/vpxdecoderpin.h
@@ -0,0 +1,53 @@
+// Copyright (c) 2014 The WebM project authors. All Rights Reserved.
+//
+// Use of this source code is governed by a BSD-style license
+// that can be found in the LICENSE file in the root of the source
+// tree. An additional intellectual property rights grant can be found
+// in the file PATENTS.  All contributing project authors may
+// be found in the AUTHORS file in the root of the source tree.
+#ifndef WEBMDSHOW_VPXDECODER_VPXDECODERPIN_H_
+#define WEBMDSHOW_VPXDECODER_VPXDECODERPIN_H_
+
+#include <amvideo.h>
+#include <strmif.h>
+
+#include <string>
+
+#include "cmediatypes.h"
+#include "graphutil.h"
+
+namespace VPXDecoderLib {
+class Filter;
+
+class Pin : public IPin {
+ public:
+  Filter* const m_pFilter;
+  const PIN_DIRECTION m_dir;
+  const std::wstring m_id;
+  CMediaTypes m_preferred_mtv;
+  CMediaTypes m_connection_mtv;  // only one of these
+  GraphUtil::IPinPtr m_pPinConnection;
+
+  // IPin interface:
+  HRESULT STDMETHODCALLTYPE Disconnect();
+  HRESULT STDMETHODCALLTYPE ConnectedTo(IPin** pPin);
+  HRESULT STDMETHODCALLTYPE ConnectionMediaType(AM_MEDIA_TYPE*);
+  HRESULT STDMETHODCALLTYPE QueryPinInfo(PIN_INFO*);
+  HRESULT STDMETHODCALLTYPE QueryDirection(PIN_DIRECTION*);
+  HRESULT STDMETHODCALLTYPE QueryId(LPWSTR*);
+  HRESULT STDMETHODCALLTYPE EnumMediaTypes(IEnumMediaTypes**);
+
+ protected:
+  Pin(Filter*, PIN_DIRECTION, const wchar_t*);
+  virtual ~Pin();
+
+  virtual HRESULT GetName(PIN_INFO&) const = 0;
+  virtual HRESULT OnDisconnect();
+
+ private:
+   Pin& operator=(const Pin&);
+};
+
+}  // namespace VPXDecoderLib
+
+#endif  // WEBMDSHOW_VPXDECODER_VPXDECODERPIN_H_
diff --git a/webmdshow.sln b/webmdshow.sln
index 0628ed6..e2d8528 100644
--- a/webmdshow.sln
+++ b/webmdshow.sln
@@ -35,6 +35,8 @@
 EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vp9decoder", "vp9decoder\vp9decoder.vcxproj", "{BC8E93B9-9062-4BC4-A351-3408604B8409}"
 EndProject
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "vpxdecoder", "vpxdecoder\vpxdecoder.vcxproj", "{C4A3A16F-C46B-41BA-A031-94391A535C00}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -185,6 +187,16 @@
 		{BC8E93B9-9062-4BC4-A351-3408604B8409}.Release|Mixed Platforms.Build.0 = Release|Win32
 		{BC8E93B9-9062-4BC4-A351-3408604B8409}.Release|Win32.ActiveCfg = Release|Win32
 		{BC8E93B9-9062-4BC4-A351-3408604B8409}.Release|Win32.Build.0 = Release|Win32
+		{C4A3A16F-C46B-41BA-A031-94391A535C00}.Debug|Any CPU.ActiveCfg = Debug|Win32
+		{C4A3A16F-C46B-41BA-A031-94391A535C00}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32
+		{C4A3A16F-C46B-41BA-A031-94391A535C00}.Debug|Mixed Platforms.Build.0 = Debug|Win32
+		{C4A3A16F-C46B-41BA-A031-94391A535C00}.Debug|Win32.ActiveCfg = Debug|Win32
+		{C4A3A16F-C46B-41BA-A031-94391A535C00}.Debug|Win32.Build.0 = Debug|Win32
+		{C4A3A16F-C46B-41BA-A031-94391A535C00}.Release|Any CPU.ActiveCfg = Release|Win32
+		{C4A3A16F-C46B-41BA-A031-94391A535C00}.Release|Mixed Platforms.ActiveCfg = Release|Win32
+		{C4A3A16F-C46B-41BA-A031-94391A535C00}.Release|Mixed Platforms.Build.0 = Release|Win32
+		{C4A3A16F-C46B-41BA-A031-94391A535C00}.Release|Win32.ActiveCfg = Release|Win32
+		{C4A3A16F-C46B-41BA-A031-94391A535C00}.Release|Win32.Build.0 = Release|Win32
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE