src/apps/mplayerc/IPinHook.cpp

   1 /*
   2  *      Copyright (C) 2003-2006 Gabest
   3  *      http://www.gabest.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GNU Make; see the file COPYING.  If not, write to
  17  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *  http://www.gnu.org/copyleft/gpl.html
  19  *
  20  */
  21
  22 #include "stdafx.h"
  23 #include "IPinHook.h"
  24 #include "DX9AllocatorPresenter.h"
  25
  26 REFERENCE_TIME g_tSegmentStart = 0;
  27 REFERENCE_TIME g_tSampleStart = 0;
  28
  29 static HRESULT (STDMETHODCALLTYPE * NewSegmentOrg)(IPinC * This, /* [in] */ REFERENCE_TIME tStart, /* [in] */ REFERENCE_TIME tStop, /* [in] */ double dRate) = NULL;
  30
  31 static HRESULT STDMETHODCALLTYPE NewSegmentMine(IPinC * This, /* [in] */ REFERENCE_TIME tStart, /* [in] */ REFERENCE_TIME tStop, /* [in] */ double dRate)
  32 {
  33         g_tSegmentStart = tStart;
  34         return NewSegmentOrg(This, tStart, tStop, dRate);
  35 }
  36
  37 static HRESULT ( STDMETHODCALLTYPE *ReceiveOrg )( IMemInputPinC * This, IMediaSample *pSample) = NULL;
  38
  39 static HRESULT STDMETHODCALLTYPE ReceiveMineI(IMemInputPinC * This, IMediaSample *pSample)
  40 {
  41         REFERENCE_TIME rtStart, rtStop;
  42         if(pSample && SUCCEEDED(pSample->GetTime(&rtStart, &rtStop)))
  43                 g_tSampleStart = rtStart;
  44         return ReceiveOrg(This, pSample);
  45 }
  46
  47 static HRESULT STDMETHODCALLTYPE ReceiveMine(IMemInputPinC * This, IMediaSample *pSample)
  48 {
  49         // Support ffdshow queueing.
  50         // To avoid black out on pause, we have to lock g_ffdshowReceive to synchronize with CMainFrame::OnPlayPause.
  51         if(queueu_ffdshow_support)
  52         {
  53                 CAutoLock lck(&g_ffdshowReceive);
  54                 return ReceiveMineI(This,pSample);
  55         }
  56         return ReceiveMineI(This,pSample);
  57 }
  58
  59 bool HookNewSegmentAndReceive(IPinC* pPinC, IMemInputPinC* pMemInputPinC)
  60 {
  61         if(!pPinC || !pMemInputPinC || (GetVersion()&0x80000000))
  62                 return false;
  63
  64         g_tSegmentStart = 0;
  65         g_tSampleStart = 0;
  66
  67         BOOL res;
  68         DWORD flOldProtect = 0;
  69         DWORD flSetProtect = 0;
  70
  71         res = VirtualProtect(pPinC->lpVtbl, sizeof(IPinCVtbl /*IPinC*/), PAGE_WRITECOPY, &flOldProtect);
  72         flSetProtect = flOldProtect;
  73         if(NewSegmentOrg == NULL) NewSegmentOrg = pPinC->lpVtbl->NewSegment;
  74         pPinC->lpVtbl->NewSegment = NewSegmentMine;
  75         res = VirtualProtect(pPinC->lpVtbl, sizeof(IPinCVtbl /*IPinC*/), flSetProtect /* PAGE_EXECUTE */, &flOldProtect);
  76
  77         flOldProtect = 0;
  78         res = VirtualProtect(pMemInputPinC->lpVtbl, sizeof(IMemInputPinCVtbl /*IMemInputPinC*/), PAGE_WRITECOPY, &flOldProtect);
  79         flSetProtect = flOldProtect;
  80
  81         if(ReceiveOrg == NULL) ReceiveOrg = pMemInputPinC->lpVtbl->Receive;
  82         pMemInputPinC->lpVtbl->Receive = ReceiveMine;
  83         res = VirtualProtect(pMemInputPinC->lpVtbl, sizeof(IMemInputPinCVtbl /*IMemInputPinC*/), flSetProtect /*PAGE_EXECUTE*/, &flOldProtect);
  84
  85         return true;
  86 }
  87
  88 static HRESULT ( STDMETHODCALLTYPE *GetVideoAcceleratorGUIDsOrg )( IAMVideoAcceleratorC * This,/* [out][in] */ LPDWORD pdwNumGuidsSupported,/* [out][in] */ LPGUID pGuidsSupported) = NULL;
  89 static HRESULT ( STDMETHODCALLTYPE *GetUncompFormatsSupportedOrg )( IAMVideoAcceleratorC * This,/* [in] */ const GUID *pGuid,/* [out][in] */ LPDWORD pdwNumFormatsSupported,/* [out][in] */ LPDDPIXELFORMAT pFormatsSupported) = NULL;
  90 static HRESULT ( STDMETHODCALLTYPE *GetInternalMemInfoOrg )( IAMVideoAcceleratorC * This,/* [in] */ const GUID *pGuid,/* [in] */ const AMVAUncompDataInfo *pamvaUncompDataInfo,/* [out][in] */ LPAMVAInternalMemInfo pamvaInternalMemInfo) = NULL;
  91 static HRESULT ( STDMETHODCALLTYPE *GetCompBufferInfoOrg )( IAMVideoAcceleratorC * This,/* [in] */ const GUID *pGuid,/* [in] */ const AMVAUncompDataInfo *pamvaUncompDataInfo,/* [out][in] */ LPDWORD pdwNumTypesCompBuffers,/* [out] */ LPAMVACompBufferInfo pamvaCompBufferInfo) = NULL;
  92 static HRESULT ( STDMETHODCALLTYPE *GetInternalCompBufferInfoOrg )( IAMVideoAcceleratorC * This,/* [out][in] */ LPDWORD pdwNumTypesCompBuffers,/* [out] */ LPAMVACompBufferInfo pamvaCompBufferInfo) = NULL;
  93 static HRESULT ( STDMETHODCALLTYPE *BeginFrameOrg )( IAMVideoAcceleratorC * This,/* [in] */ const AMVABeginFrameInfo *amvaBeginFrameInfo) = NULL;
  94 static HRESULT ( STDMETHODCALLTYPE *EndFrameOrg )( IAMVideoAcceleratorC * This,/* [in] */ const AMVAEndFrameInfo *pEndFrameInfo) = NULL;
  95 static HRESULT ( STDMETHODCALLTYPE *GetBufferOrg )( IAMVideoAcceleratorC * This,/* [in] */ DWORD dwTypeIndex,/* [in] */ DWORD dwBufferIndex,/* [in] */ BOOL bReadOnly,/* [out] */ LPVOID *ppBuffer,/* [out] */ LONG *lpStride) = NULL;
  96 static HRESULT ( STDMETHODCALLTYPE *ReleaseBufferOrg )( IAMVideoAcceleratorC * This,/* [in] */ DWORD dwTypeIndex,/* [in] */ DWORD dwBufferIndex) = NULL;
  97 static HRESULT ( STDMETHODCALLTYPE *ExecuteOrg )( IAMVideoAcceleratorC * This,/* [in] */ DWORD dwFunction,/* [in] */ LPVOID lpPrivateInputData,/* [in] */ DWORD cbPrivateInputData,/* [in] */ LPVOID lpPrivateOutputDat,/* [in] */ DWORD cbPrivateOutputData,/* [in] */ DWORD dwNumBuffers,/* [in] */ const AMVABUFFERINFO *pamvaBufferInfo) = NULL;
  98 static HRESULT ( STDMETHODCALLTYPE *QueryRenderStatusOrg )( IAMVideoAcceleratorC * This,/* [in] */ DWORD dwTypeIndex,/* [in] */ DWORD dwBufferIndex,/* [in] */ DWORD dwFlags) = NULL;
  99 static HRESULT ( STDMETHODCALLTYPE *DisplayFrameOrg )( IAMVideoAcceleratorC * This,/* [in] */ DWORD dwFlipToIndex,/* [in] */ IMediaSample *pMediaSample) = NULL;
 100
 101 static void LOG(LPCTSTR fmt, ...)
 102 {
 103         va_list args;
 104         va_start(args, fmt);
 105         if(TCHAR* buff = new TCHAR[_vsctprintf(fmt, args) + 1])
 106         {
 107                 _vstprintf(buff, fmt, args);
 108                 if(FILE* f = _tfopen(_T("c:\\dxva.log"), _T("at")))
 109                 {
 110                         fseek(f, 0, 2);
 111                         _ftprintf(f, _T("%s\n"), buff);
 112                         fclose(f);
 113                 }
 114                 delete [] buff;
 115         }
 116         va_end(args);
 117 }
 118
 119 static void LOGPF(LPCTSTR prefix, const DDPIXELFORMAT* p, int n)
 120 {
 121         for(int i = 0; i < n; i++)
 122         {
 123                 LOG(_T("%s[%d].dwSize = %d"), prefix, i, p[i].dwSize);
 124                 LOG(_T("%s[%d].dwFlags = %08x"), prefix, i, p[i].dwFlags);
 125                 LOG(_T("%s[%d].dwFourCC = %4.4hs"), prefix, i, &p[i].dwFourCC);
 126                 LOG(_T("%s[%d].dwRGBBitCount = %08x"), prefix, i, &p[i].dwRGBBitCount);
 127                 LOG(_T("%s[%d].dwRBitMask = %08x"), prefix, i, &p[i].dwRBitMask);
 128                 LOG(_T("%s[%d].dwGBitMask = %08x"), prefix, i, &p[i].dwGBitMask);
 129                 LOG(_T("%s[%d].dwBBitMask = %08x"), prefix, i, &p[i].dwBBitMask);
 130                 LOG(_T("%s[%d].dwRGBAlphaBitMask = %08x"), prefix, i, &p[i].dwRGBAlphaBitMask);
 131         }
 132 }
 133
 134 static void LOGUDI(LPCTSTR prefix, const AMVAUncompDataInfo* p, int n)
 135 {
 136         for(int i = 0; i < n; i++)
 137         {
 138                 LOG(_T("%s[%d].dwUncompWidth = %d"), prefix, i, p[i].dwUncompWidth);
 139                 LOG(_T("%s[%d].dwUncompHeight = %d"), prefix, i, p[i].dwUncompHeight);
 140
 141                 CString prefix2;
 142                 prefix2.Format(_T("%s[%d]"), prefix, i);
 143                 LOGPF(prefix2, &p[i].ddUncompPixelFormat, 1);
 144         }
 145 }
 146
 147 static HRESULT STDMETHODCALLTYPE GetVideoAcceleratorGUIDsMine(
 148         IAMVideoAcceleratorC * This,
 149         /* [out][in] */ LPDWORD pdwNumGuidsSupported,
 150         /* [out][in] */ LPGUID pGuidsSupported)
 151 {
 152         LOG(_T("\nGetVideoAcceleratorGUIDs"));
 153
 154         if(pdwNumGuidsSupported)
 155         {
 156                 LOG(_T("[in] *pdwNumGuidsSupported = %d"), *pdwNumGuidsSupported);
 157         }
 158
 159         HRESULT hr = GetVideoAcceleratorGUIDsOrg(This, pdwNumGuidsSupported, pGuidsSupported);
 160
 161         LOG(_T("hr = %08x"), hr);
 162
 163         if(pdwNumGuidsSupported)
 164         {
 165                 LOG(_T("[out] *pdwNumGuidsSupported = %d"), *pdwNumGuidsSupported);
 166
 167                 if(pGuidsSupported)
 168                 {
 169                         for(int i = 0; i < *pdwNumGuidsSupported; i++)
 170                         {
 171                                 LOG(_T("[out] pGuidsSupported[%d] = %s"), i, CStringFromGUID(pGuidsSupported[i]));
 172                         }
 173                 }
 174         }
 175
 176         return hr;
 177 }
 178
 179 static HRESULT STDMETHODCALLTYPE GetUncompFormatsSupportedMine(
 180         IAMVideoAcceleratorC * This,
 181         /* [in] */ const GUID *pGuid,
 182         /* [out][in] */ LPDWORD pdwNumFormatsSupported,
 183         /* [out][in] */ LPDDPIXELFORMAT pFormatsSupported)
 184 {
 185         LOG(_T("\nGetUncompFormatsSupported"));
 186
 187         if(pGuid)
 188         {
 189                 LOG(_T("[in] *pGuid = %s"), CStringFromGUID(*pGuid));
 190         }
 191
 192         if(pdwNumFormatsSupported)
 193         {
 194                 LOG(_T("[in] *pdwNumFormatsSupported = %d"), *pdwNumFormatsSupported);
 195         }
 196
 197         HRESULT hr = GetUncompFormatsSupportedOrg(This, pGuid, pdwNumFormatsSupported, pFormatsSupported);
 198
 199         LOG(_T("hr = %08x"), hr);
 200
 201         if(pdwNumFormatsSupported)
 202         {
 203                 LOG(_T("[out] *pdwNumFormatsSupported = %d"), *pdwNumFormatsSupported);
 204
 205                 if(pFormatsSupported)
 206                 {
 207                         LOGPF(_T("[out] pFormatsSupported"), pFormatsSupported, *pdwNumFormatsSupported);
 208                 }
 209         }
 210
 211         return hr;
 212 }
 213
 214 static HRESULT STDMETHODCALLTYPE GetInternalMemInfoMine(
 215         IAMVideoAcceleratorC * This,
 216         /* [in] */ const GUID *pGuid,
 217         /* [in] */ const AMVAUncompDataInfo *pamvaUncompDataInfo,
 218         /* [out][in] */ LPAMVAInternalMemInfo pamvaInternalMemInfo)
 219 {
 220         LOG(_T("\nGetInternalMemInfo"));
 221
 222         HRESULT hr = GetInternalMemInfoOrg(This, pGuid, pamvaUncompDataInfo, pamvaInternalMemInfo);
 223
 224         LOG(_T("hr = %08x"), hr);
 225
 226         return hr;
 227 }
 228
 229 static HRESULT STDMETHODCALLTYPE GetCompBufferInfoMine(
 230         IAMVideoAcceleratorC * This,
 231         /* [in] */ const GUID *pGuid,
 232         /* [in] */ const AMVAUncompDataInfo *pamvaUncompDataInfo,
 233         /* [out][in] */ LPDWORD pdwNumTypesCompBuffers,
 234         /* [out] */ LPAMVACompBufferInfo pamvaCompBufferInfo)
 235 {
 236         LOG(_T("\nGetCompBufferInfo"));
 237
 238         if(pGuid)
 239         {
 240                 LOG(_T("[in] *pGuid = %s"), CStringFromGUID(*pGuid));
 241
 242                 if(pdwNumTypesCompBuffers)
 243                 {
 244                         LOG(_T("[in] *pdwNumTypesCompBuffers = %d"), *pdwNumTypesCompBuffers);
 245                 }
 246         }
 247
 248         HRESULT hr = GetCompBufferInfoOrg(This, pGuid, pamvaUncompDataInfo, pdwNumTypesCompBuffers, pamvaCompBufferInfo);
 249
 250         LOG(_T("hr = %08x"), hr);
 251
 252         if(pdwNumTypesCompBuffers)
 253         {
 254                 LOG(_T("[out] *pdwNumTypesCompBuffers = %d"), *pdwNumTypesCompBuffers);
 255
 256                 if(pamvaUncompDataInfo)
 257                 {
 258                         LOGUDI(_T("[out] pamvaUncompDataInfo"), pamvaUncompDataInfo, *pdwNumTypesCompBuffers);
 259                 }
 260         }
 261
 262         return hr;
 263 }
 264
 265 static HRESULT STDMETHODCALLTYPE GetInternalCompBufferInfoMine(
 266         IAMVideoAcceleratorC * This,
 267         /* [out][in] */ LPDWORD pdwNumTypesCompBuffers,
 268         /* [out] */ LPAMVACompBufferInfo pamvaCompBufferInfo)
 269 {
 270         LOG(_T("\nGetInternalCompBufferInfo"));
 271
 272         HRESULT hr = GetInternalCompBufferInfoOrg(This, pdwNumTypesCompBuffers, pamvaCompBufferInfo);
 273
 274         LOG(_T("hr = %08x"), hr);
 275
 276         return hr;
 277 }
 278
 279 static HRESULT STDMETHODCALLTYPE BeginFrameMine(
 280         IAMVideoAcceleratorC * This,
 281         /* [in] */ const AMVABeginFrameInfo *amvaBeginFrameInfo)
 282 {
 283         LOG(_T("\nBeginFrame"));
 284
 285         if(amvaBeginFrameInfo)
 286         {
 287                 LOG(_T("[in] amvaBeginFrameInfo->dwDestSurfaceIndex = %08x"), amvaBeginFrameInfo->dwDestSurfaceIndex);
 288                 LOG(_T("[in] amvaBeginFrameInfo->pInputData = %08x"), amvaBeginFrameInfo->pInputData);
 289                 LOG(_T("[in] amvaBeginFrameInfo->dwSizeInputData = %08x"), amvaBeginFrameInfo->dwSizeInputData);
 290                 LOG(_T("[in] amvaBeginFrameInfo->pOutputData = %08x"), amvaBeginFrameInfo->pOutputData);
 291                 LOG(_T("[in] amvaBeginFrameInfo->dwSizeOutputData = %08x"), amvaBeginFrameInfo->dwSizeOutputData);
 292         }
 293
 294         HRESULT hr = BeginFrameOrg(This, amvaBeginFrameInfo);
 295
 296         LOG(_T("hr = %08x"), hr);
 297
 298         if(amvaBeginFrameInfo && amvaBeginFrameInfo->pOutputData)
 299         {
 300                 LOG(_T("[out] amvaBeginFrameInfo->pOutputData = %02x %02x %02x %02x..."),
 301                         ((BYTE*)amvaBeginFrameInfo->pOutputData)[0],
 302                         ((BYTE*)amvaBeginFrameInfo->pOutputData)[1],
 303                         ((BYTE*)amvaBeginFrameInfo->pOutputData)[2],
 304                         ((BYTE*)amvaBeginFrameInfo->pOutputData)[3]);
 305         }
 306
 307         return hr;
 308 }
 309
 310 static HRESULT STDMETHODCALLTYPE EndFrameMine(
 311         IAMVideoAcceleratorC * This,
 312         /* [in] */ const AMVAEndFrameInfo *pEndFrameInfo)
 313 {
 314         LOG(_T("\nEndFrame"));
 315
 316         if(pEndFrameInfo)
 317         {
 318                 LOG(_T("[in] pEndFrameInfo->dwSizeMiscData = %08x"), pEndFrameInfo->dwSizeMiscData);
 319                 LOG(_T("[in] pEndFrameInfo->pMiscData = %08x"), pEndFrameInfo->pMiscData);
 320         }
 321
 322         HRESULT hr = EndFrameOrg(This, pEndFrameInfo);
 323
 324         LOG(_T("hr = %08x"), hr);
 325
 326         return hr;
 327 }
 328
 329 static HRESULT STDMETHODCALLTYPE GetBufferMine(
 330         IAMVideoAcceleratorC * This,
 331         /* [in] */ DWORD dwTypeIndex,
 332         /* [in] */ DWORD dwBufferIndex,
 333         /* [in] */ BOOL bReadOnly,
 334         /* [out] */ LPVOID *ppBuffer,
 335         /* [out] */ LONG *lpStride)
 336 {
 337         LOG(_T("\nGetBuffer"));
 338
 339         LOG(_T("[in] dwTypeIndex = %08x"), dwTypeIndex);
 340         LOG(_T("[in] dwBufferIndex = %08x"), dwBufferIndex);
 341         LOG(_T("[in] bReadOnly = %08x"), bReadOnly);
 342         LOG(_T("[in] ppBuffer = %08x"), ppBuffer);
 343         LOG(_T("[in] lpStride = %08x"), lpStride);
 344
 345         HRESULT hr = GetBufferOrg(This, dwTypeIndex, dwBufferIndex, bReadOnly, ppBuffer, lpStride);
 346
 347         LOG(_T("hr = %08x"), hr);
 348
 349         LOG(_T("[out] *ppBuffer = %02x %02x %02x %02x ..."), ((BYTE*)*ppBuffer)[0], ((BYTE*)*ppBuffer)[1], ((BYTE*)*ppBuffer)[2], ((BYTE*)*ppBuffer)[3]);
 350         LOG(_T("[out] *lpStride = %08x"), *lpStride);
 351
 352         return hr;
 353 }
 354
 355 static HRESULT STDMETHODCALLTYPE ReleaseBufferMine(
 356         IAMVideoAcceleratorC * This,
 357         /* [in] */ DWORD dwTypeIndex,
 358         /* [in] */ DWORD dwBufferIndex)
 359 {
 360         LOG(_T("\nReleaseBuffer"));
 361
 362         LOG(_T("[in] dwTypeIndex = %08x"), dwTypeIndex);
 363         LOG(_T("[in] dwBufferIndex = %08x"), dwBufferIndex);
 364
 365         HRESULT hr = ReleaseBufferOrg(This, dwTypeIndex, dwBufferIndex);
 366
 367         LOG(_T("hr = %08x"), hr);
 368
 369         return hr;
 370 }
 371
 372 static HRESULT STDMETHODCALLTYPE ExecuteMine(
 373         IAMVideoAcceleratorC * This,
 374         /* [in] */ DWORD dwFunction,
 375         /* [in] */ LPVOID lpPrivateInputData,
 376         /* [in] */ DWORD cbPrivateInputData,
 377         /* [in] */ LPVOID lpPrivateOutputData,
 378         /* [in] */ DWORD cbPrivateOutputData,
 379         /* [in] */ DWORD dwNumBuffers,
 380         /* [in] */ const AMVABUFFERINFO *pamvaBufferInfo)
 381 {
 382         LOG(_T("\nExecute"));
 383
 384         LOG(_T("[in] dwFunction = %08x"), dwFunction);
 385         if(lpPrivateInputData)
 386         {
 387                 LOG(_T("[in] lpPrivateInputData = %02x %02x %02x %02x ..."),
 388                         ((BYTE*)lpPrivateInputData)[0],
 389                         ((BYTE*)lpPrivateInputData)[1],
 390                         ((BYTE*)lpPrivateInputData)[2],
 391                         ((BYTE*)lpPrivateInputData)[3]);
 392         }
 393         LOG(_T("[in] cbPrivateInputData = %08x"), cbPrivateInputData);
 394         LOG(_T("[in] lpPrivateOutputData = %08"), lpPrivateOutputData);
 395         LOG(_T("[in] cbPrivateOutputData = %08x"), cbPrivateOutputData);
 396         LOG(_T("[in] dwNumBuffers = %08x"), dwNumBuffers);
 397         if(pamvaBufferInfo)
 398         {
 399                 LOG(_T("[in] pamvaBufferInfo->dwTypeIndex = %08x"), pamvaBufferInfo->dwTypeIndex);
 400                 LOG(_T("[in] pamvaBufferInfo->dwBufferIndex = %08x"), pamvaBufferInfo->dwBufferIndex);
 401                 LOG(_T("[in] pamvaBufferInfo->dwDataOffset = %08x"), pamvaBufferInfo->dwDataOffset);
 402                 LOG(_T("[in] pamvaBufferInfo->dwDataSize = %08x"), pamvaBufferInfo->dwDataSize);
 403         }
 404
 405         HRESULT hr = ExecuteOrg(This, dwFunction, lpPrivateInputData, cbPrivateInputData, lpPrivateOutputData, cbPrivateOutputData, dwNumBuffers, pamvaBufferInfo);
 406
 407         LOG(_T("hr = %08x"), hr);
 408
 409         if(lpPrivateOutputData)
 410         {
 411                 LOG(_T("[out] *lpPrivateOutputData = %08"), lpPrivateOutputData);
 412
 413                 if(cbPrivateOutputData)
 414                 {
 415                         LOG(_T("[out] cbPrivateOutputData = %02x %02x %02x %02x ..."),
 416                                 ((BYTE*)lpPrivateOutputData)[0],
 417                                 ((BYTE*)lpPrivateOutputData)[1],
 418                                 ((BYTE*)lpPrivateOutputData)[2],
 419                                 ((BYTE*)lpPrivateOutputData)[3]);
 420                 }
 421         }
 422
 423         return hr;
 424 }
 425
 426 static HRESULT STDMETHODCALLTYPE QueryRenderStatusMine(
 427         IAMVideoAcceleratorC * This,
 428         /* [in] */ DWORD dwTypeIndex,
 429         /* [in] */ DWORD dwBufferIndex,
 430         /* [in] */ DWORD dwFlags)
 431 {
 432         LOG(_T("\nQueryRenderStatus"));
 433
 434         HRESULT hr = QueryRenderStatusOrg(This, dwTypeIndex, dwBufferIndex, dwFlags);
 435
 436         LOG(_T("hr = %08x"), hr);
 437
 438         return hr;
 439 }
 440
 441 static HRESULT STDMETHODCALLTYPE DisplayFrameMine(
 442         IAMVideoAcceleratorC * This,
 443         /* [in] */ DWORD dwFlipToIndex,
 444         /* [in] */ IMediaSample *pMediaSample)
 445 {
 446         LOG(_T("\nDisplayFrame"));
 447
 448         HRESULT hr = DisplayFrameOrg(This, dwFlipToIndex, pMediaSample);
 449
 450         LOG(_T("hr = %08x"), hr);
 451
 452         return hr;
 453 }
 454
 455 void HookAMVideoAccelerator(IAMVideoAcceleratorC* pAMVideoAcceleratorC)
 456 {
 457         BOOL res;
 458         DWORD flOldProtect = 0;
 459         res = VirtualProtect(pAMVideoAcceleratorC->lpVtbl, sizeof(IAMVideoAcceleratorC), PAGE_WRITECOPY, &flOldProtect);
 460 /*
 461 */
 462         if(GetVideoAcceleratorGUIDsOrg == NULL) GetVideoAcceleratorGUIDsOrg = pAMVideoAcceleratorC->lpVtbl->GetVideoAcceleratorGUIDs;
 463         if(GetUncompFormatsSupportedOrg == NULL) GetUncompFormatsSupportedOrg = pAMVideoAcceleratorC->lpVtbl->GetUncompFormatsSupported;
 464         if(GetInternalMemInfoOrg == NULL) GetInternalMemInfoOrg = pAMVideoAcceleratorC->lpVtbl->GetInternalMemInfo;
 465         if(GetCompBufferInfoOrg == NULL) GetCompBufferInfoOrg = pAMVideoAcceleratorC->lpVtbl->GetCompBufferInfo;
 466         if(GetInternalCompBufferInfoOrg == NULL) GetInternalCompBufferInfoOrg = pAMVideoAcceleratorC->lpVtbl->GetInternalCompBufferInfo;
 467         if(BeginFrameOrg == NULL) BeginFrameOrg = pAMVideoAcceleratorC->lpVtbl->BeginFrame;
 468         if(EndFrameOrg == NULL) EndFrameOrg = pAMVideoAcceleratorC->lpVtbl->EndFrame;
 469         if(GetBufferOrg == NULL) GetBufferOrg = pAMVideoAcceleratorC->lpVtbl->GetBuffer;
 470         if(ReleaseBufferOrg == NULL) ReleaseBufferOrg = pAMVideoAcceleratorC->lpVtbl->ReleaseBuffer;
 471         if(ExecuteOrg == NULL) ExecuteOrg = pAMVideoAcceleratorC->lpVtbl->Execute;
 472         if(QueryRenderStatusOrg == NULL) QueryRenderStatusOrg = pAMVideoAcceleratorC->lpVtbl->QueryRenderStatus;
 473         if(DisplayFrameOrg == NULL) DisplayFrameOrg = pAMVideoAcceleratorC->lpVtbl->DisplayFrame;
 474 /*
 475 */
 476 /*
 477 */
 478         pAMVideoAcceleratorC->lpVtbl->GetVideoAcceleratorGUIDs = GetVideoAcceleratorGUIDsMine;
 479         pAMVideoAcceleratorC->lpVtbl->GetUncompFormatsSupported = GetUncompFormatsSupportedMine;
 480         pAMVideoAcceleratorC->lpVtbl->GetInternalMemInfo = GetInternalMemInfoMine;
 481         pAMVideoAcceleratorC->lpVtbl->GetCompBufferInfo = GetCompBufferInfoMine;
 482         pAMVideoAcceleratorC->lpVtbl->GetInternalCompBufferInfo = GetInternalCompBufferInfoMine;
 483         pAMVideoAcceleratorC->lpVtbl->BeginFrame = BeginFrameMine;
 484         pAMVideoAcceleratorC->lpVtbl->EndFrame = EndFrameMine;
 485         pAMVideoAcceleratorC->lpVtbl->GetBuffer = GetBufferMine;
 486         pAMVideoAcceleratorC->lpVtbl->ReleaseBuffer = ReleaseBufferMine;
 487         pAMVideoAcceleratorC->lpVtbl->Execute = ExecuteMine;
 488         pAMVideoAcceleratorC->lpVtbl->QueryRenderStatus = QueryRenderStatusMine;
 489         pAMVideoAcceleratorC->lpVtbl->DisplayFrame = DisplayFrameMine;
 490 /*
 491 */
 492         res = VirtualProtect(pAMVideoAcceleratorC->lpVtbl, sizeof(IAMVideoAcceleratorC), PAGE_EXECUTE, &flOldProtect);
 493 }