dsallocator.cc

   1 /*
   2     Copyright 2004-2005 Chris Tallon, Marten Richter
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP.  If not, see <https://www.gnu.org/licenses/>.
  18 */
  19
  20 #define INITGUID
  21
  22 #include "osd.h"
  23 #include "windowsosd.h"
  24 #include "dsallocator.h"
  25 #include "log.h"
  26
  27 #include <math.h>
  28
  29 #include <mfidl.h>
  30 #include <Mfapi.h>
  31 #include <mferror.h>
  32
  33 typedef HRESULT (__stdcall *FCT_MFCreateVideoSampleFromSurface)(IUnknown* pUnkSurface, IMFSample** ppSample);
  34
  35 extern FCT_MFCreateVideoSampleFromSurface ptrMFCreateVideoSampleFromSurface;
  36
  37
  38 DsAllocator::DsAllocator() {
  39     surfallocnotify=NULL;
  40     refcount=1;
  41     inevrmode=false;
  42     mftransform=NULL;
  43     mediasink=NULL;
  44     mfclock=NULL;
  45     mfmediatype=NULL;
  46     endofstream=false;
  47     start_get_evr_samples=false;
  48     ResetSyncOffsets();
  49
  50
  51
  52 }
  53
  54 DsAllocator::~DsAllocator() {
  55         dynamic_cast<WindowsOsd*>(Osd::getInstance())->SetEVRStatus(WindowsOsd::EVR_pres_off);
  56         dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(NULL, vwidth, vheight);
  57     CleanupSurfaces();
  58
  59 }
  60
  61 void DsAllocator::CleanupSurfaces() {
  62     dsaLock.lock();
  63     while(fullevrsamples.size()>0)
  64     {
  65         IMFSample *sample=fullevrsamples.front();
  66         fullevrsamples.pop();
  67         sample->Release();
  68     }
  69     while(emptyevrsamples.size()>0)
  70     {
  71         IMFSample *sample=emptyevrsamples.front();
  72         emptyevrsamples.pop();
  73         sample->Release();
  74     }
  75
  76     for (int i=0;i<surfaces.size();i++) {
  77         if (surfaces[i]!=NULL) surfaces[i]->Release();
  78         surfaces[i]=NULL;
  79     }
  80     start_get_evr_samples=false;
  81     dsaLock.unlock();
  82 }
  83
  84 HRESULT STDMETHODCALLTYPE DsAllocator::InitializeDevice(DWORD_PTR userid,VMR9AllocationInfo* allocinf,DWORD*numbuf){
  85     if (!surfallocnotify) return S_FALSE;
  86
  87     CleanupSurfaces();
  88     dsaLock.lock();
  89     surfaces.resize(*numbuf);
  90     HRESULT hres= surfallocnotify->AllocateSurfaceHelper(allocinf,numbuf,&surfaces.at(0));
  91     vheight=allocinf->dwHeight;
  92     vwidth=allocinf->dwWidth;
  93     start_get_evr_samples=false;
  94     dsaLock.unlock();
  95     /*  char buffer[1024];
  96     sprintf(buffer,"%d * %d",allocinf->dwWidth,allocinf->dwHeight);
  97     MessageBox(0,"hi",buffer,0);*/
  98     return hres;
  99 }
 100
 101 void DsAllocator::LostDevice(IDirect3DDevice9 *d3ddev, IDirect3D9* d3d) {
 102     if (!surfallocnotify) return ;
 103     CleanupSurfaces();
 104     dsaLock.lock();
 105     //  d3ddev=((OsdWin*)Osd::getInstance())->getD3dDev();
 106     HMONITOR hmon=d3d->GetAdapterMonitor(D3DADAPTER_DEFAULT);
 107     surfallocnotify->ChangeD3DDevice(d3ddev,hmon);
 108     dsaLock.unlock();
 109
 110 }
 111
 112 HRESULT STDMETHODCALLTYPE DsAllocator::TerminateDevice(DWORD_PTR userid){
 113     CleanupSurfaces();
 114
 115     return S_OK; //Do nothing
 116 }
 117 HRESULT STDMETHODCALLTYPE DsAllocator::GetSurface(DWORD_PTR userid,DWORD surfindex,DWORD surfflags, IDirect3DSurface9** surf)
 118 {
 119     if (surfindex>=surfaces.size()) return E_FAIL;
 120     if (surf==NULL) return E_POINTER;
 121
 122     dsaLock.lock();
 123     surfaces[surfindex]->AddRef();
 124     *surf=surfaces[surfindex];
 125     dsaLock.unlock();
 126     return S_OK;
 127 }
 128 HRESULT STDMETHODCALLTYPE DsAllocator::AdviseNotify(IVMRSurfaceAllocatorNotify9* allnoty){
 129     dsaLock.lock();
 130     surfallocnotify=allnoty;
 131     IDirect3DDevice9 *d3ddev;
 132     //OK lets set the direct3d object from the osd
 133     d3ddev=dynamic_cast<WindowsOsd*>(Osd::getInstance())->getD3dDev();
 134     HMONITOR hmon=dynamic_cast<WindowsOsd*>(Osd::getInstance())->getD3d()->GetAdapterMonitor(D3DADAPTER_DEFAULT);
 135     HRESULT hres=surfallocnotify->SetD3DDevice(d3ddev,hmon);
 136     dsaLock.unlock();
 137     return hres;
 138 }
 139
 140
 141 HRESULT STDMETHODCALLTYPE DsAllocator::StartPresenting(DWORD_PTR userid){
 142     //MessageBox(0,"drive me","drive me",0);
 143     dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(this,vwidth,vheight);
 144     start_get_evr_samples=false;
 145     return S_OK;
 146 }
 147
 148 HRESULT STDMETHODCALLTYPE DsAllocator::StopPresenting(DWORD_PTR userid){
 149     dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(NULL,0,0);
 150     start_get_evr_samples=false;
 151     return S_OK;
 152 }
 153
 154 HRESULT STDMETHODCALLTYPE DsAllocator::PresentImage(DWORD_PTR userid,VMR9PresentationInfo* presinf){
 155     dynamic_cast<WindowsOsd*>(Osd::getInstance())->RenderDS(presinf->lpSurf); //render and return
 156     return S_OK;
 157
 158 }
 159
 160 HRESULT STDMETHODCALLTYPE DsAllocator::QueryInterface(REFIID refiid,void ** obj){
 161     if (obj==NULL) return E_POINTER;
 162
 163     if (refiid==IID_IVMRSurfaceAllocator9) {
 164         *obj=static_cast<IVMRSurfaceAllocator9*>(this);
 165         AddRef();
 166         return S_OK;
 167     } else if (refiid==IID_IVMRImagePresenter9) {
 168         *obj=static_cast<IVMRImagePresenter9*>(this);
 169         AddRef();
 170         return S_OK;
 171     } else if (refiid==IID_IMFVideoDeviceID) {
 172         *obj=static_cast<IMFVideoDeviceID*> (this);
 173         AddRef();
 174         return S_OK;
 175     } else if (refiid==IID_IMFTopologyServiceLookupClient ) {
 176         *obj=static_cast<IMFTopologyServiceLookupClient*> (this);
 177         AddRef();
 178         return S_OK;
 179     } else if (refiid==IID_IQualProp ) {
 180         *obj=static_cast<IQualProp*> (this);
 181         AddRef();
 182         return S_OK;
 183     }  else if (refiid==IID_IMFGetService) {
 184         *obj=static_cast<IMFGetService*> (this);
 185         AddRef();
 186         return S_OK;
 187     } else if (refiid==IID_IDirect3DDeviceManager9) {
 188         IDirect3DDeviceManager9 *d3dman=dynamic_cast<WindowsOsd*>(Osd::getInstance())->getD3dMan();
 189         if (d3dman){
 190             return d3dman->QueryInterface(refiid,obj);
 191         }
 192         else
 193         {
 194             return E_NOINTERFACE;
 195         }
 196     }
 197     return E_NOINTERFACE;
 198 }
 199
 200
 201
 202 ULONG STDMETHODCALLTYPE  DsAllocator::AddRef(){
 203     return InterlockedIncrement(&refcount);
 204 }
 205
 206 ULONG STDMETHODCALLTYPE DsAllocator::Release(){
 207     ULONG ref=0;
 208     ref=InterlockedDecrement(&refcount);
 209     if (ref==NULL) {
 210         delete this; //Commit suicide
 211     }
 212     return ref;
 213 }
 214
 215 HRESULT STDMETHODCALLTYPE  DsAllocator::GetDeviceID(IID *pDid)
 216 {
 217     if (pDid==NULL)
 218         return E_POINTER;
 219
 220     *pDid=__uuidof(IDirect3DDevice9);
 221     return S_OK;
 222 }
 223
 224 HRESULT STDMETHODCALLTYPE DsAllocator::InitServicePointers(IMFTopologyServiceLookup *plooky)
 225 {
 226     if (!plooky) return E_POINTER;
 227     dsaLock.lock();
 228     inevrmode=true;
 229     /* get all interfaces we need*/
 230
 231     DWORD dwobjcts=1;
 232     plooky->LookupService(MF_SERVICE_LOOKUP_GLOBAL,0,MR_VIDEO_MIXER_SERVICE,
 233         __uuidof(IMFTransform),(void**)&mftransform, &dwobjcts);
 234     plooky->LookupService(MF_SERVICE_LOOKUP_GLOBAL,0,MR_VIDEO_RENDER_SERVICE,
 235         __uuidof(IMediaEventSink),(void**)&mediasink, &dwobjcts);
 236     plooky->LookupService(MF_SERVICE_LOOKUP_GLOBAL, 0, MR_VIDEO_RENDER_SERVICE,
 237         __uuidof(IMFClock),(void**)&mfclock,&dwobjcts);
 238
 239
 240     dsaLock.unlock();
 241     return S_OK;
 242 }
 243
 244 HRESULT STDMETHODCALLTYPE DsAllocator::ReleaseServicePointers()
 245 {
 246     dsaLock.lock();
 247     inevrmode=false;
 248     /* TODO Set RenderState , sample type etc.*/
 249
 250         dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(NULL, 0, 0);
 251
 252     if (mftransform) mftransform->Release();
 253     mftransform=NULL;
 254
 255     if (mediasink) mediasink->Release();
 256     mediasink=NULL;
 257
 258     if (mfclock) mfclock->Release();
 259     mfclock=NULL;
 260     if (mfmediatype) mfmediatype->Release();
 261     mfmediatype=NULL;
 262
 263     dsaLock.unlock();
 264     return S_OK;
 265 }
 266
 267 HRESULT STDMETHODCALLTYPE DsAllocator::GetService(const GUID &guid,const IID &iid,LPVOID *obj)
 268 {
 269     if (guid==MR_VIDEO_ACCELERATION_SERVICE)
 270     {
 271         IDirect3DDeviceManager9 *d3dman=dynamic_cast<WindowsOsd*>(Osd::getInstance())->getD3dMan();
 272         if (d3dman)
 273         {
 274             return d3dman->QueryInterface (__uuidof(IDirect3DDeviceManager9), (void**) obj);
 275         }
 276         else
 277         {
 278             return E_NOINTERFACE;
 279         }
 280
 281     }
 282     else if (guid==MR_VIDEO_RENDER_SERVICE)
 283     {
 284         return QueryInterface(iid,obj);
 285     }
 286     else
 287     {
 288         return E_NOINTERFACE;
 289     }
 290 }
 291
 292
 293 void DsAllocator::GetEVRSamples()
 294 {
 295     dsaLock.lock();
 296     MFCLOCK_STATE clockstate;
 297     if (mfclock) mfclock->GetState(0,&clockstate);
 298     //MessageBox(0,"get samples","samples",0);
 299
 300     if (mfclock && clockstate==MFCLOCK_STATE_STOPPED && fullevrsamples.size()>0)
 301     {
 302         dsaLock.unlock();
 303         return;
 304     }
 305
 306     while (emptyevrsamples.size()>0)
 307     {
 308
 309         MFT_OUTPUT_DATA_BUFFER outdatabuffer;
 310         ZeroMemory(&outdatabuffer,sizeof(outdatabuffer));
 311         outdatabuffer.pSample=emptyevrsamples.front();
 312         DWORD status=0;
 313         LONGLONG starttime,endtime;
 314         MFTIME dummy;
 315         starttime=0;
 316         endtime=0;
 317
 318         if (mfclock)
 319         {
 320             mfclock->GetCorrelatedTime(0,&starttime,&dummy);
 321             if (lastdelframe) CalcJitter( (starttime-lastdelframe)/10000);
 322             lastdelframe=starttime;
 323         }
 324
 325         HRESULT hres=mftransform->ProcessOutput(0,1,&outdatabuffer,&status);
 326
 327
 328         if (hres==MF_E_TRANSFORM_NEED_MORE_INPUT)
 329         {
 330             if (endofstream)
 331             {
 332
 333                 endofstream=false;
 334                 mediasink->Notify(EC_COMPLETE,(LONG_PTR) S_OK,0);
 335
 336             }
 337             break;
 338         }
 339         else if (hres==MF_E_TRANSFORM_STREAM_CHANGE)
 340         {
 341             if (mfmediatype) mfmediatype->Release();
 342             mfmediatype=NULL;
 343             break;
 344         }
 345         else if (hres==MF_E_TRANSFORM_TYPE_NOT_SET)
 346         {
 347             if (mfmediatype) mfmediatype->Release();
 348             mfmediatype=NULL;
 349             RenegotiateEVRMediaType();
 350             break;
 351         }
 352         else if (hres==S_OK)
 353         {
 354             LONGLONG prestime=0;
 355             hres=outdatabuffer.pSample->GetSampleTime(&prestime);
 356             //Log::getInstance()->log("DsAllocator", Log::DEBUG , "Got EVR Sample %lld",prestime);
 357             IMFSample *temp=emptyevrsamples.front();
 358             emptyevrsamples.pop();
 359
 360
 361
 362             fullevrsamples.push(temp);
 363             //Log::getInstance()->log("DsAllocator", Log::DEBUG , "got evr sample %d, %d",
 364             //  emptyevrsamples.size(),fullevrsamples.size());
 365             if (mfclock){
 366                 mfclock->GetCorrelatedTime(0,&endtime,&dummy);
 367                 LONGLONG delay=endtime-starttime;
 368                 mediasink->Notify( EC_PROCESSING_LATENCY,(LONG_PTR)&delay,0);
 369
 370                 //Check if presentation is soon
 371                 MFTIME   systime=0;
 372                 LONGLONG currenttime=0;
 373                 hres=outdatabuffer.pSample->GetSampleTime(&prestime);
 374                 if (hres==S_OK)
 375                 {
 376                     if (mfclock) mfclock->GetCorrelatedTime(0,&currenttime,&systime);
 377                 }
 378                 LONGLONG delta=prestime-currenttime;
 379                 if (delta<0) {
 380                     break; //break if presentation is soon
 381                 }
 382
 383
 384             }
 385         } else break;
 386
 387     }
 388     dsaLock.unlock();
 389 }
 390
 391 HRESULT STDMETHODCALLTYPE DsAllocator::ProcessMessage(MFVP_MESSAGE_TYPE mess,ULONG_PTR mess_para)
 392 {
 393     switch (mess) {
 394         case MFVP_MESSAGE_FLUSH:{
 395             //Log::getInstance()->log("DsAllocator", Log::DEBUG , "EVR Message MFVP_MESSAGE_FLUSH received");
 396             FlushEVRSamples();
 397             start_get_evr_samples=false;
 398                                 }break;
 399         case MFVP_MESSAGE_INVALIDATEMEDIATYPE: {
 400             Log::getInstance()->log("DsAllocator", Log::DEBUG , "EVR Message MFVP_MESSAGE_INVALIDATEMEDIATYPE received");
 401             if (mfmediatype) mfmediatype->Release();
 402             mfmediatype=NULL;
 403             start_get_evr_samples=false;
 404             RenegotiateEVRMediaType();}break;
 405         case MFVP_MESSAGE_PROCESSINPUTNOTIFY: {
 406             Log::getInstance()->log("DsAllocator", Log::DEBUG , "EVR Message MFVP_MESSAGE_PROCESSINPUTNOTIFY received");
 407             if (!start_get_evr_samples) GetEVRSamples();
 408             start_get_evr_samples=true;
 409                                       } break;
 410         case MFVP_MESSAGE_BEGINSTREAMING:{
 411             Log::getInstance()->log("DsAllocator", Log::DEBUG , "EVR Message MFVP_MESSAGE_BEGINSTREAMING received");
 412             ResetSyncOffsets();
 413             dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(this,vwidth,vheight);
 414             //((OsdWin*)Osd::getInstance())->SetEVRStatus(OsdWin::EVR_pres_started);//No need to do this causes misbehaviout
 415             endofstream=false;
 416                                          }break;
 417         case MFVP_MESSAGE_ENDSTREAMING: {
 418             Log::getInstance()->log("DsAllocator", Log::DEBUG , "EVR Message MFVP_MESSAGE_ENDSTREAMING received");
 419                         dynamic_cast<WindowsOsd*>(Osd::getInstance())->SetEVRStatus(WindowsOsd::EVR_pres_off);
 420                         dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(NULL, vwidth, vheight);
 421             start_get_evr_samples=false;
 422             //FlushEVRSamples();
 423             //if (mfmediatype) mfmediatype->Release();
 424             //mfmediatype=NULL;
 425                                         } break;
 426         case MFVP_MESSAGE_ENDOFSTREAM: {
 427             Log::getInstance()->log("DsAllocator", Log::DEBUG , "EVR Message MFVP_MESSAGE_ENDOFSTREAM received");
 428             //MessageBox(0,"endofstream","endofstream",0);
 429             endofstream=true;
 430             start_get_evr_samples=false;
 431                                        } break;
 432         case MFVP_MESSAGE_STEP: {
 433             Log::getInstance()->log("DsAllocator", Log::DEBUG , "EVR Message MFVP_MESSAGE_STEP received");
 434                         dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(this, vwidth, vheight);
 435                         dynamic_cast<WindowsOsd*>(Osd::getInstance())->SetEVRStatus(WindowsOsd::EVR_pres_pause);
 436             //MessageBox(0,"steppy","steppy",0);
 437             FlushEVRSamples(/*LOWORD(mess_para)*/); //Message sending, has to be done after compeletion
 438                                 }; break;
 439         case MFVP_MESSAGE_CANCELSTEP: {
 440             Log::getInstance()->log("DsAllocator", Log::DEBUG , "EVR Message MFVP_MESSAGE_CANCELSTEP received");
 441             //???
 442                                       }; break;
 443         default:
 444             MessageBox(0,"unhandled","unhandled",0);
 445     };
 446     return S_OK;
 447 }
 448
 449 HRESULT STDMETHODCALLTYPE DsAllocator::OnClockStart(MFTIME systime,LONGLONG startoffset)
 450 {
 451     //((OsdWin*)Osd::getInstance())->SetEVRTimes(systime,startoffset);
 452     timeBeginPeriod(1);
 453
 454     if (PRESENTATION_CURRENT_POSITION!=startoffset) FlushEVRSamples();
 455         dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(this, vwidth, vheight);
 456      Log::getInstance()->log("DsAllocator", Log::DEBUG , "OnClockStart");
 457          dynamic_cast<WindowsOsd*>(Osd::getInstance())->SetEVRStatus(WindowsOsd::EVR_pres_started);
 458     //GetEVRSamples();
 459
 460     return S_OK;
 461 }
 462
 463 HRESULT STDMETHODCALLTYPE DsAllocator::OnClockStop(MFTIME systime)
 464 {
 465     timeEndPeriod(1);
 466
 467         dynamic_cast<WindowsOsd*>(Osd::getInstance())->SetEVRStatus(WindowsOsd::EVR_pres_off);
 468
 469     Log::getInstance()->log("DsAllocator", Log::DEBUG , "OnClockStop");
 470         dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(NULL, vwidth, vheight);
 471     FlushEVRSamples();
 472     return S_OK;
 473 }
 474
 475 HRESULT STDMETHODCALLTYPE DsAllocator::OnClockPause(MFTIME systime)
 476 {
 477     timeEndPeriod(1);
 478         dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(this, vwidth, vheight);
 479
 480      Log::getInstance()->log("DsAllocator", Log::DEBUG , "OnClockPause");
 481          dynamic_cast<WindowsOsd*>(Osd::getInstance())->SetEVRStatus(WindowsOsd::EVR_pres_pause);
 482     return S_OK;
 483 }
 484
 485 HRESULT STDMETHODCALLTYPE DsAllocator::OnClockRestart(MFTIME systime)
 486 {
 487         dynamic_cast<WindowsOsd*>(Osd::getInstance())->setExternalDriving(this, vwidth, vheight);
 488
 489     Log::getInstance()->log("DsAllocator", Log::DEBUG , "OnClockRestart");
 490         dynamic_cast<WindowsOsd*>(Osd::getInstance())->SetEVRStatus(WindowsOsd::EVR_pres_started);
 491
 492     return S_OK;
 493 }
 494
 495 HRESULT STDMETHODCALLTYPE DsAllocator::OnClockSetRate(MFTIME systime,float rate)
 496 {
 497     timeBeginPeriod(1);
 498     return S_OK;
 499 }
 500
 501 HRESULT STDMETHODCALLTYPE DsAllocator::GetCurrentMediaType(IMFVideoMediaType **mtype)
 502 {// MessageBox(0,"mediatype","mediatype",0);
 503 if (mtype==NULL) return E_POINTER;
 504 dsaLock.lock();
 505 if (mfmediatype==NULL)
 506 {
 507     dsaLock.unlock();
 508     *mtype=NULL;
 509     return MF_E_NOT_INITIALIZED;
 510 }
 511 HRESULT hres=mfmediatype->QueryInterface(IID_IMFVideoMediaType,(void**)mtype);
 512 dsaLock.unlock();
 513 return hres;
 514 }
 515
 516 void DsAllocator::RenegotiateEVRMediaType()
 517 {
 518     if (!mftransform) {
 519         Log::getInstance()->log("DsAllocator", Log::DEBUG , "Cannot renegotiate without transform!");
 520         return ;
 521     }
 522     bool gotcha=false;
 523     DWORD index=0;
 524
 525
 526     while (!gotcha) {
 527         IMFMediaType *mixtype=NULL;
 528         HRESULT hres;
 529         if (hres=mftransform->GetOutputAvailableType(0,index++,&mixtype)!=S_OK)
 530         {
 531             Log::getInstance()->log("DsAllocator", Log::DEBUG , "No more types availiable from EVR %d !",hres);
 532             break;
 533         }
 534
 535         //Type check
 536         BOOL compressed;
 537         mixtype->IsCompressedFormat(&compressed);
 538         if (compressed)
 539         {
 540             mixtype->Release();
 541             continue;
 542         }
 543         UINT32 helper;
 544         mixtype->GetUINT32(MF_MT_INTERLACE_MODE,&helper);
 545         if (helper!=MFVideoInterlace_Progressive) {
 546             Log::getInstance()->log("DsAllocator", Log::DEBUG , "Skip media type interlaced!");
 547             mixtype->Release();
 548             continue;
 549         }
 550         GUID temp;
 551         mixtype->GetMajorType(&temp);
 552         if (temp!=MEDIATYPE_Video) {
 553             Log::getInstance()->log("DsAllocator", Log::DEBUG , "Skip media type no video!");
 554             mixtype->Release();
 555             continue;
 556         }
 557         if(mftransform->SetOutputType(0,mixtype,MFT_SET_TYPE_TEST_ONLY)!=S_OK)
 558         {
 559             Log::getInstance()->log("DsAllocator", Log::DEBUG , "Skip media type test failed!");
 560             mixtype->Release();
 561             continue;
 562         }
 563         //Type is ok!
 564
 565         gotcha=true;
 566
 567         dsaLock.lock();
 568         if (mfmediatype) mfmediatype->Release();
 569         mfmediatype=NULL;
 570
 571         mfmediatype=mixtype;
 572         AllocateEVRSurfaces();
 573         dsaLock.unlock();
 574
 575         hres=mftransform->SetOutputType(0,mixtype,0);
 576
 577
 578
 579         if (hres!=S_OK)
 580         {
 581             dsaLock.lock();
 582             if (mfmediatype) mfmediatype->Release();
 583             mfmediatype=NULL;
 584             gotcha=false;
 585
 586             dsaLock.unlock();
 587         }
 588
 589
 590         Log::getInstance()->log("DsAllocator", Log::DEBUG , "Output type set! %d",hres);
 591     }
 592     if (!gotcha) Log::getInstance()->log("DsAllocator", Log::DEBUG , "No suitable output type!");
 593
 594
 595
 596 }
 597
 598 void DsAllocator::AllocateEVRSurfaces()
 599 {
 600
 601     LARGE_INTEGER temp64;
 602     mfmediatype->GetUINT64(MF_MT_FRAME_SIZE, (UINT64*)&temp64);
 603     vwidth=temp64.HighPart;
 604     vheight=temp64.LowPart;
 605     GUID subtype;
 606     subtype.Data1=D3DFMT_X8R8G8B8;
 607     mfmediatype->GetGUID(MF_MT_SUBTYPE,&subtype);
 608     D3DFORMAT format=(D3DFORMAT)subtype.Data1;
 609     Log::getInstance()->log("DsAllocator", Log::DEBUG , "Surfaceformat is %d, width %d, height %d",format,vwidth,vheight);
 610     format=D3DFMT_X8R8G8B8;
 611
 612     CleanupSurfaces();
 613     dsaLock.lock();
 614         WindowsOsd* osdwin = dynamic_cast<WindowsOsd*>(Osd::getInstance());
 615     LPDIRECT3DDEVICE9 d3ddev=osdwin->getD3dDev();
 616     osdwin->BeginPainting();
 617     surfaces.resize(10);
 618     for (int i=0;i<10;i++)
 619     {
 620         HRESULT hres;
 621         LPDIRECT3DSURFACE9 surfy;
 622
 623         hres=d3ddev->CreateRenderTarget(vwidth,vheight,format,
 624             D3DMULTISAMPLE_NONE,0,FALSE,&surfy,NULL);
 625         if (hres==S_OK)
 626         {
 627             surfaces[i]=surfy;
 628         }
 629         else
 630         {
 631             surfaces[i]=NULL;
 632         }
 633     }
 634     osdwin->EndPainting();
 635
 636
 637
 638     for (int i=0;i<surfaces.size();i++) {
 639         if (surfaces[i]!=NULL)
 640         {
 641             IMFSample *sample=NULL;
 642             ptrMFCreateVideoSampleFromSurface(surfaces[i],&sample);
 643             if (sample) emptyevrsamples.push(sample);
 644         }
 645     }
 646     dsaLock.unlock();
 647
 648 }
 649
 650 void DsAllocator::FlushEVRSamples()
 651 {
 652     dsaLock.lock();
 653     while(fullevrsamples.size()>0)
 654     {
 655         IMFSample *sample=fullevrsamples.front();
 656         fullevrsamples.pop();
 657         emptyevrsamples.push(sample);
 658     }
 659     dsaLock.unlock();
 660 }
 661 #define FAC 1
 662
 663 void DsAllocator::GetNextSurface(LPDIRECT3DSURFACE9* surf,DWORD *waittime)
 664 {
 665
 666     *surf=NULL;
 667     *waittime=10;
 668     dsaLock.lock();
 669     if (fullevrsamples.size()==0) {
 670         *waittime=1;
 671         if (start_get_evr_samples) GetEVRSamples();
 672     }
 673     //Log::getInstance()->log("DsAllocator", Log::DEBUG , "Enter Get Next Surface");
 674
 675     while (fullevrsamples.size()>0)
 676     {
 677         //MessageBox(0,"Got a sample","got a sample",0);
 678         IMFSample *sample=fullevrsamples.front();
 679         LONGLONG prestime=0;
 680         MFTIME   systime=0;
 681         LONGLONG currenttime=0;
 682
 683         HRESULT hres=sample->GetSampleTime(&prestime);
 684         if (hres==S_OK)
 685         {
 686             if (mfclock) mfclock->GetCorrelatedTime(0,&currenttime,&systime);
 687         }
 688         LONGLONG delta=prestime-currenttime;
 689
 690
 691
 692         if (delta<-10000*20 && false) { //SkipIT
 693             LONGLONG latency=-delta;
 694             //mediasink->Notify(EC_SAMPLE_LATENCY,(LONG_PTR) &latency,0);
 695             LARGE_INTEGER helper;
 696             helper.QuadPart=-delta;
 697             Log::getInstance()->log("DsAllocator", Log::DEBUG , "skip 1 frame %d %d prestime %lld",helper.LowPart,helper.HighPart,prestime);
 698             CalcSyncOffsets(delta/10000LL);
 699             //  emptyevrsamples.size(),fullevrsamples.size());
 700             fullevrsamples.pop();
 701             emptyevrsamples.push(sample);
 702             framesdropped++;
 703             continue;
 704         }
 705
 706         if (delta<10000*20 || !mfclock )
 707         {
 708             *waittime=0;
 709             IMFMediaBuffer* buffy=NULL;
 710             //MessageBox(0,"its showtime","showtimw",0);
 711             CalcSyncOffsets(delta/10000LL);
 712             framesdrawn++;
 713             hres=sample->GetBufferByIndex(0,&buffy);
 714             //LARGE_INTEGER helper;
 715             //helper.QuadPart=-delta;
 716             //Log::getInstance()->log("DsAllocator", Log::DEBUG , "Paint 1 frame %d %d, frames  %d prestime %lld",
 717              //   helper.LowPart,helper.HighPart,fullevrsamples.size(),prestime);
 718             if (hres!=S_OK) { //SkipIT
 719                 fullevrsamples.pop();
 720                 emptyevrsamples.push(sample);
 721                 continue;
 722             }
 723             IMFGetService* service;
 724             hres=buffy->QueryInterface(IID_IMFGetService,(void**)&service);
 725             buffy->Release();
 726             if (hres!=S_OK) { //SkipIT
 727                 fullevrsamples.pop();
 728                 emptyevrsamples.push(sample);
 729                 continue;
 730             }
 731             LPDIRECT3DSURFACE9 tempsurf;
 732             hres=service->GetService(MR_BUFFER_SERVICE,IID_IDirect3DSurface9 ,(void**) &tempsurf);
 733             service->Release();
 734             if (hres!=S_OK) { //SkipIT
 735                 fullevrsamples.pop();
 736                 emptyevrsamples.push(sample);
 737                 continue;
 738             }
 739             *surf=tempsurf;
 740             break;
 741         } else {
 742             *waittime=delta/10000-10;
 743             *surf=NULL;
 744             break;
 745         }
 746     }
 747
 748     dsaLock.unlock();
 749
 750 }
 751
 752 void DsAllocator::DiscardSurfaceandgetWait(DWORD *waittime)
 753 {
 754     //Log::getInstance()->log("DsAllocator", Log::DEBUG , "Discard surface and get Wait");
 755     if (start_get_evr_samples) GetEVRSamples();
 756     //Log::getInstance()->log("DsAllocator", Log::DEBUG , "Discard surface and get Wait2");
 757     dsaLock.lock();
 758     if (fullevrsamples.size()==0) {
 759         *waittime=0;
 760         dsaLock.unlock();
 761         return;
 762     }
 763     IMFSample *sample=fullevrsamples.front();
 764     fullevrsamples.pop();
 765     emptyevrsamples.push(sample);
 766     *waittime=0;
 767
 768     while (fullevrsamples.size()>0)
 769     {
 770
 771         IMFSample *sample=fullevrsamples.front();
 772         LONGLONG prestime=0;
 773         MFTIME   systime=0;
 774         LONGLONG currenttime=0;
 775
 776         HRESULT hres=sample->GetSampleTime(&prestime);
 777         if (hres==S_OK)
 778         {
 779             if (mfclock) mfclock->GetCorrelatedTime(0,&currenttime,&systime);
 780         }
 781         LONGLONG delta=prestime-currenttime;
 782
 783
 784         if (delta<-10000*20 ) { //SkipIT
 785              LONGLONG latency=-delta;
 786            // mediasink->Notify(EC_SAMPLE_LATENCY,(LONG_PTR) &latency,0);
 787             //LARGE_INTEGER helper;
 788             //helper.QuadPart=-delta;
 789             //Log::getInstance()->log("DsAllocator", Log::DEBUG , "skip 1 frame %d %d time %lld",helper.LowPart,helper.HighPart,prestime);
 790             CalcSyncOffsets(delta/10000LL);
 791             //  emptyevrsamples.size(),fullevrsamples.size());
 792             fullevrsamples.pop();
 793             emptyevrsamples.push(sample);
 794             framesdropped++;
 795             continue;
 796         }
 797
 798         *waittime=min(delta/10000/2-10,1);
 799
 800         break;
 801     }
 802     dsaLock.unlock();
 803
 804 }
 805 void DsAllocator::ResetSyncOffsets()
 806 {
 807     for (int i=0;i<n_stats;i++)
 808     {
 809         sync_offset[i]=0;
 810         jitter_offset[i]=0;
 811     }
 812     framesdrawn=0;
 813     lastdelframe=0;
 814     framesdropped=0;
 815     avg_sync_offset=0;
 816     dev_sync_offset=0;
 817     jitter=0;
 818     sync_pos=0;
 819     jitter_pos=0;
 820     avgfps=0;
 821 }
 822
 823 void DsAllocator::CalcSyncOffsets(int sync)
 824 {
 825     sync_offset[sync_pos]=sync;
 826     sync_pos=(sync_pos +1)%n_stats;
 827
 828     double mean_value=0;
 829     for (int i=0;i<n_stats;i++)
 830     {
 831         mean_value+=sync_offset[i];
 832     }
 833     mean_value/=(double) n_stats;
 834     double std_dev=0;
 835     for (int i=0;i<n_stats;i++)
 836     {
 837         double temp_dev=(mean_value-(double)sync_offset[i]);
 838         std_dev+=temp_dev*temp_dev;
 839     }
 840     std_dev/=(double)n_stats;
 841     avg_sync_offset=mean_value;
 842     dev_sync_offset=sqrt(std_dev);
 843 }
 844
 845 void DsAllocator::CalcJitter(int jitter)
 846 {
 847     jitter_offset[jitter_pos]=jitter;
 848     jitter_pos=(jitter_pos +1)%n_stats;
 849
 850
 851     double mean_value=0;
 852     for (int i=0;i<n_stats;i++)
 853     {
 854         mean_value+=jitter_offset[i];
 855     }
 856     mean_value/=(double) n_stats;
 857     avgfps=1000./mean_value*100.;
 858     double std_dev=0;
 859     for (int i=0;i<n_stats;i++)
 860     {
 861         double temp_dev=(mean_value-(double)jitter_offset[i]);
 862         std_dev+=temp_dev*temp_dev;
 863     }
 864     std_dev/=(double)n_stats;
 865     jitter=sqrt(std_dev);
 866 }
 867
 868
 869 HRESULT STDMETHODCALLTYPE DsAllocator::get_FramesDrawn(int *val)
 870 {
 871     *val=framesdrawn;
 872     return S_OK;
 873 }
 874
 875 HRESULT STDMETHODCALLTYPE DsAllocator::get_AvgFrameRate(int *val)
 876 {
 877     *val=avgfps;
 878     return S_OK;
 879 }
 880
 881 HRESULT STDMETHODCALLTYPE DsAllocator::get_Jitter(int *val)
 882 {
 883     *val=jitter;
 884     return S_OK;
 885 }
 886
 887 HRESULT STDMETHODCALLTYPE DsAllocator::get_AvgSyncOffset(int *val)
 888 {
 889     *val=avg_sync_offset;
 890     return S_OK;
 891 }
 892
 893 HRESULT STDMETHODCALLTYPE DsAllocator::get_DevSyncOffset(int *val)
 894 {
 895     *val=dev_sync_offset;
 896     return S_OK;
 897 }
 898 HRESULT STDMETHODCALLTYPE DsAllocator::get_FramesDroppedInRenderer(int *val)
 899 {
 900     *val=framesdropped;
 901     return S_OK;
 902 }