tffdshowbase.cpp.svn-base

来自「ffshow源码」· SVN-BASE 代码 · 共 898 行 · 第 1/2 页

STDMETHODIMP_(const char_t*) TffdshowBase::getExeflnm(void)
{
 return config.getExeflnm();
}
STDMETHODIMP TffdshowBase::inExplorer(void)
{
 return stricmp(getExeflnm(),_l("explorer.exe"))==0?S_OK:S_FALSE;
}

STDMETHODIMP TffdshowBase::getLibavcodec(Tlibavcodec* *libavcodecPtr)
{
 if (!libavcodecPtr) return E_POINTER;
 if (!libavcodec) libavcodec=new Tlibavcodec(&config);
 if (libavcodec->ok)
  {
   libavcodec->AddRef();
   *libavcodecPtr=libavcodec;
   return S_OK;
  }
 else
  {
   *libavcodecPtr=NULL;
   return E_FAIL;
  }
}

void TffdshowBase::onTrayIconChange(int id,int newval)
{
 if (globalSettings->trayIcon && inExplorer()!=S_OK)
  if (!trayHwnd) 
   {
    unsigned threadID;
    CAMEvent ev;
    hTrayThread=(HANDLE)_beginthreadex(NULL,128*1024,(unsigned(__stdcall *)(void*))trayIconStart,&std::make_tuple((IffdshowBase*)this,&ev,&trayHwnd),0,&threadID);
    ev.Wait();
   } 
}

STDMETHODIMP TffdshowBase::showTrayIcon(void)
{
 onTrayIconChange(0,0);
 return S_OK;
}
STDMETHODIMP TffdshowBase::hideTrayIcon(void)
{
 if (hTrayThread && trayHwnd) 
  {
   SendMessage(trayHwnd,WM_CLOSE,0,0);
   //MsgWaitForMultipleObjects(1,&hTrayThread,TRUE,INFINITE,QS_ALLEVENTS);
   WaitForSingleObject(hTrayThread,INFINITE);
   trayHwnd=NULL;
  } 
 return S_OK;
}

HRESULT TffdshowBase::onJoinFilterGraph(IFilterGraph *pGraph,LPCWSTR pName)
{
 HRESULT res;
 if (pGraph)
  {
   res=onGraphJoin(pGraph);
   if (res==S_OK)
    res=mfilter->TransformJoinFilterGraph(pGraph,pName);
  }
 else
  {
   res=mfilter->TransformJoinFilterGraph(pGraph,pName);
   if (res==S_OK)
    res=onGraphRemove();
  } 
 return res;
} 

HRESULT TffdshowBase::onGraphJoin(IFilterGraph *pGraph)
{
 DPRINTF(_l("Join filter graph"));
 if (!config.isDecoder[IDFF_MOVIE_MPLAYER])
  return VFW_E_CANNOT_CONNECT;

 if (globalSettings->multipleInstances==4)
  return E_FAIL;
 else if (globalSettings->multipleInstances==2)
  {
   CLSID clsid;
   mfilter->GetClassID(&clsid);
   if (searchFilter(pGraph,clsid,mfilter))
    return E_FAIL;
  }
 if (globalSettings->addToROT && !pdwROT)
  {
   comptr<IRunningObjectTable> pROT;
   if (SUCCEEDED(GetRunningObjectTable(0,&pROT))) 
    {
     WCHAR wsz[256];
     wsprintfW(wsz, L"FilterGraph %08p pid %08x (ffdshow)", (DWORD_PTR)pGraph,GetCurrentProcessId());
     comptr<IMoniker> pMoniker;
     if (SUCCEEDED(CreateItemMoniker(L"!",wsz,&pMoniker))) 
      pROT->Register(ROTFLAGS_REGISTRATIONKEEPSALIVE,(IUnknown*)pGraph,pMoniker,&pdwROT);
    }
  }
 return S_OK; 
}
HRESULT TffdshowBase::onGraphRemove(void)
{
 DPRINTF(_l("Removed from filter graph"));
 if (cfgDlgHwnd) SendMessage(cfgDlgHwnd,WM_CLOSE,0,0);
 if (pdwROT)
  {
   comptr<IRunningObjectTable> pROT;
   if (SUCCEEDED(GetRunningObjectTable(0,&pROT))) 
    pROT->Revoke(pdwROT);
   pdwROT=0;
  }
 hideTrayIcon(); 
 return S_OK;
}

STDMETHODIMP_(const char_t*) TffdshowBase::getSourceName(void)
{
 return minput?minput->getFileSourceName():_l("");
}
STDMETHODIMP_(int) TffdshowBase::getCurrentCodecId2(void)
{
 return minput?minput->getInCodecId2():CODEC_ID_NONE;
}

HRESULT TffdshowBase::checkInputConnect(IPin *pin)
{
 HRESULT res=S_OK;
 if (globalSettings->multipleInstances==3)
  {
   CLSID clsid;
   mfilter->GetClassID(&clsid);
   if (searchPrevNextFilter(PINDIR_INPUT,pin,clsid))
    res=VFW_E_INVALID_DIRECTION;
  } 
 else
  { 
   PIN_INFO pi;
   if (globalSettings->multipleInstances==1 && SUCCEEDED(pin->QueryPinInfo(&pi)))
    {
     CLSID inclsid,clsid;
     if (SUCCEEDED(pi.pFilter->GetClassID(&inclsid)) && SUCCEEDED(mfilter->GetClassID(&clsid)) && inclsid==clsid)
      res=VFW_E_INVALID_DIRECTION;
     pi.pFilter->Release();
    }
  }  
 return res; 
}

STDMETHODIMP TffdshowBase::getGraph(IFilterGraph* *graphPtr)
{
 if (!graphPtr) return E_POINTER;
 *graphPtr=graph;
 return S_OK;
}

//tell and seek
double TffdshowBase::tell(void)
{
 if (!graph) return E_UNEXPECTED;
 if (comptrQ<IMediaPosition> mpos=graph)
  {
   REFTIME pos;
   return (mpos->get_CurrentPosition(&pos)==S_OK)?pos:-1;
  }
 else 
  return S_FALSE;  
}
STDMETHODIMP TffdshowBase::tell(int *seconds)
{
 if (!graph) return E_UNEXPECTED;
 if (!seconds) return E_POINTER;
 *seconds=-1;
 return ((*seconds=(int)(tell()+0.5))!=-1)?S_OK:S_FALSE;
}
STDMETHODIMP TffdshowBase::seek(int seconds)
{
 if (!graph) return E_UNEXPECTED;
 if (hereSeek) return S_FALSE;
 hereSeek=true;
 if (comptrQ<IMediaPosition> mpos=graph)
  {
   HRESULT res;
   REFTIME duration;
   res=mpos->get_Duration(&duration);
   if (res==S_OK)
    res=mpos->put_CurrentPosition(limit(REFTIME(seconds),0.0,duration));
   hereSeek=false;
   return res;
  }
 else
  return S_FALSE;  
}
int TffdshowBase::getDuration(void)
{
 if (!graph) return E_UNEXPECTED;
 if (comptrQ<IMediaPosition> mpos=graph)
  {
   REFTIME duration;
   mpos->get_Duration(&duration);
   return (int)duration;
  }
 else
  return -1;  
}
STDMETHODIMP TffdshowBase::stop(void)
{
 if (!graph) return E_UNEXPECTED;
 if (comptrQ<IMediaControl> mc=graph)
  return mc->Stop();
 else 
  return S_FALSE;
}
STDMETHODIMP_(int) TffdshowBase::getCurTime2(void)
{
 if (!graph) return E_UNEXPECTED;
 if (comptrQ<IMediaPosition> mpos=graph)
  {
   REFTIME curtime;
   return FAILED(mpos->get_CurrentPosition(&curtime))?-1:int(curtime);
  }
 else
  return -1;  
}
STDMETHODIMP TffdshowBase::run(void)
{
 if (!graph) return E_UNEXPECTED;
 if (comptrQ<IMediaControl> mc=graph)
  return mc->Run();
 else
  return S_FALSE; 
}
STDMETHODIMP_(int) TffdshowBase::getState2(void)
{
 if (!mfilter) return E_UNEXPECTED;
 FILTER_STATE fs;
 return FAILED(mfilter->GetState(1000,&fs))?-1:fs;
}

STDMETHODIMP TffdshowBase::frameStep(int diff)
{
 if (!graph) return E_UNEXPECTED;
 if (comptrQ<IMediaSeeking> ms=graph)
  {
   HRESULT hr;
   GUID oldtf;
   if (FAILED(hr=ms->GetTimeFormat(&oldtf)))
    return hr;
   if (oldtf!=TIME_FORMAT_FRAME) 
    if (FAILED(hr=ms->SetTimeFormat(&TIME_FORMAT_FRAME)))
     return hr;
   LONGLONG curpos;
   hr=ms->GetCurrentPosition(&curpos);
   if (SUCCEEDED(hr))
    {
     curpos+=diff;
     hr=ms->SetPositions(&curpos,AM_SEEKING_AbsolutePositioning,NULL,AM_SEEKING_NoPositioning);
    }
   if (oldtf!=TIME_FORMAT_FRAME) 
    ms->SetTimeFormat(&oldtf);
   return hr;
  }
 else
  return E_NOINTERFACE;  
}

STDMETHODIMP TffdshowBase::getInCodecString(char_t *buf,size_t buflen)
{
 if (!buf) return E_POINTER;
 *buf='\0';
 return S_OK;
}
STDMETHODIMP TffdshowBase::getOutCodecString(char_t *buf,size_t buflen)
{
 if (!buf) return E_POINTER;
 *buf='\0';
 return S_OK;
}

STDMETHODIMP TffdshowBase::getMerit(DWORD *merit)
{
 if (!mfilter) return E_UNEXPECTED;
 CLSID clsid;mfilter->GetClassID(&clsid);
 return getFilterMerit(clsid,merit);
}
STDMETHODIMP TffdshowBase::setMerit(DWORD merit)
{
 if (!mfilter) return E_UNEXPECTED;
 CLSID clsid;mfilter->GetClassID(&clsid);
 return setFilterMerit(clsid,merit);
}
void TffdshowBase::onMeritChange(int id,int newval)
{
 setMerit(newval);
}

STDMETHODIMP TffdshowBase::lock(int lockId)
{
 if (!locks[lockId]) locks[lockId]=new CCritSec;
 locks[lockId]->Lock();
 return S_OK;
}
STDMETHODIMP TffdshowBase::unlock(int lockId)
{
 locks[lockId]->Unlock();
 return S_OK;
}

STDMETHODIMP TffdshowBase::exportRegSettings(int all,const char_t *regflnm,int unicode)
{
 return globalSettings->exportReg(!!all,regflnm,!!unicode)?S_OK:E_FAIL;
}

STDMETHODIMP TffdshowBase::getParamListItem(int paramId,int index,const char_t* *ptr)
{
 if (index<0) return S_FALSE;
 TparamListItems *items=options->getParamList(paramId);
 if (!items) return E_FAIL;
 if (index>=(int)items->size()) return S_FALSE; 
 *ptr=items->at(index).second;
 delete items;
 return S_OK;
}

STDMETHODIMP TffdshowBase::abortPlayback(HRESULT hr)
{
 mfilter->NotifyEvent(EC_ERRORABORT,hr,0);
 if (moutput) moutput->DeliverEndOfStream();
 return hr;
}

STDMETHODIMP TffdshowBase::resetEnum(void)
{
 TintStrColls colls;getColls(colls);
 enumInfos.clear();
 for (TintStrColls::iterator options=colls.begin();options!=colls.end();options++)
  (*options)->getInfoIDs(enumInfos);
 curEnumInfo=enumInfos.begin();
 return S_OK;
}
STDMETHODIMP TffdshowBase::nextEnum(TffdshowParamInfo *paramPtr)
{
 if (!paramPtr) return E_POINTER;
 if (curEnumInfo==enumInfos.end()) return S_FALSE;
 TintStrColls colls;getColls(colls);
 for (TintStrColls::iterator options=colls.begin();options!=colls.end();options++)
  if ((*options)->getInfo(*curEnumInfo,paramPtr))
   break;
 curEnumInfo++;
 return S_OK;
}

void TffdshowBase::initInfo(void)
{
 lock(IDFF_lockInfo);
 if (!info) info=createInfo();
 unlock(IDFF_lockInfo);
}
STDMETHODIMP TffdshowBase::getInfoItem(unsigned int index,int *id,const char_t* *name)
{
 if (!id || !name) return E_POINTER;
 initInfo();
 return info->getInfo(index,id,name)?S_OK:S_FALSE;
}
STDMETHODIMP_(const char_t*) TffdshowBase::getInfoItemName(int id)
{
 initInfo();
 return info->getName(id);
}
STDMETHODIMP TffdshowBase::getInfoItemValue(int id,const char_t* *valuePtr,int *wasChange,int *splitline)
{
 if (!valuePtr) return E_POINTER;
 initInfo();
 const char_t *value=info->getVal(id,wasChange,splitline);
 return value?(*valuePtr=value,S_OK):S_FALSE;
}
STDMETHODIMP_(const char_t*) TffdshowBase::getInfoItemShortcut(int id)
{
 initInfo();
 return info->getShortcut(id);
}
STDMETHODIMP_(int)TffdshowBase::getInfoShortcutItem(const char_t *s,int *toklen)
{
 if (!s) return E_POINTER;
 initInfo();
 return info->getInfoShortcutItem(s,toklen);
}

void TffdshowBase::setPropsTime(IMediaSample *sample,REFERENCE_TIME t1,REFERENCE_TIME t2,AM_SAMPLE2_PROPERTIES* const pProps,BOOL *m_bSampleSkipped)
{
 if (comptrQ<IMediaSample2> pOutSample2=sample) 
  {
   AM_SAMPLE2_PROPERTIES OutProps;
   EXECUTE_ASSERT(SUCCEEDED(pOutSample2->GetProperties(FIELD_OFFSET(AM_SAMPLE2_PROPERTIES,tStart),(PBYTE)&OutProps)));
   OutProps.dwTypeSpecificFlags=pProps->dwTypeSpecificFlags;
   OutProps.dwSampleFlags=(OutProps.dwSampleFlags&AM_SAMPLE_TYPECHANGED)|(pProps->dwSampleFlags&~AM_SAMPLE_TYPECHANGED);
   OutProps.tStart=t1;
   OutProps.tStop =t2;
   OutProps.cbData=FIELD_OFFSET(AM_SAMPLE2_PROPERTIES,dwStreamId);
   pOutSample2->SetProperties(FIELD_OFFSET(AM_SAMPLE2_PROPERTIES,dwStreamId),(PBYTE)&OutProps);
   if (pProps->dwSampleFlags&AM_SAMPLE_DATADISCONTINUITY)
    *m_bSampleSkipped=FALSE;
  }
 else 
  {
   if (pProps->dwSampleFlags&AM_SAMPLE_TIMEVALID)
    sample->SetTime(&t1,&t2);
   if (pProps->dwSampleFlags&AM_SAMPLE_SPLICEPOINT)
    sample->SetSyncPoint(TRUE);
   if (pProps->dwSampleFlags&AM_SAMPLE_DATADISCONTINUITY)
    {
     sample->SetDiscontinuity(TRUE);
     *m_bSampleSkipped=FALSE;
    }
   /* Copy the media times
   LONGLONG MediaStart, MediaEnd;
   if (pSample->GetMediaTime(&MediaStart,&MediaEnd)==NOERROR)
    pOutSample->SetMediaTime(&MediaStart,&MediaEnd);
   */ 
  }
}

HRESULT TffdshowBase::getDeliveryBuffer(IMediaSample **pSample,BYTE **pData)
{
 HRESULT hr;

 *pData=NULL;
 if (FAILED(hr=moutput->GetDeliveryBuffer(pSample,NULL,NULL,0)) ||
     FAILED(hr=(*pSample)->GetPointer(pData)))
  return hr;

 AM_MEDIA_TYPE *pmt=NULL;
 if (SUCCEEDED((*pSample)->GetMediaType(&pmt)) && pmt)
  {
   CMediaType mt=*pmt;
   moutput->SetMediaType(&mt);
   DeleteMediaType(pmt);
   pmt=NULL;
  }
 return S_OK;
}

STDMETHODIMP_(int) TffdshowBase::CPUcount(void)
{
 return m_CPUCount;
}