tffdshowdec.cpp.svn-base

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

 if (presets->empty()) return E_UNEXPECTED;
 Tpreset *preset=presets->newPreset(presetName);
 preset->autoLoadedFromFile=true;
 preset->loadReg();
 presets->push_back(preset);
 return S_OK;
}

STDMETHODIMP TffdshowDec::putStringParams(const char_t *params,char_t sep,int loaddef)
{
 if (!presetSettings) return E_UNEXPECTED;
 if (!params) return E_POINTER;
 TregOpStreamRead t(params,strlen(params),sep,!!loaddef);
 presetSettings->reg_op(t);
 notifyParamsChanged();
 return S_OK;
}

STDMETHODIMP TffdshowDec::resetFilter(unsigned int filterID)
{
 return resetFilterEx(filterID,0);
}
STDMETHODIMP TffdshowDec::resetFilterEx(unsigned int filterID,unsigned int filterPageId)
{
 if (!presetSettings) return E_UNEXPECTED;
 TfilterSettings *fs=presetSettings->getSettings(filterID);
 if (!fs) return E_INVALIDARG;
 return fs->reset(filterPageId)?S_OK:S_FALSE;
}
STDMETHODIMP TffdshowDec::filterHasReset(unsigned int filterID)
{
 return filterHasResetEx(filterID,0);
}
STDMETHODIMP TffdshowDec::filterHasResetEx(unsigned int filterID,unsigned int filterPageId)
{
 if (!presetSettings) return E_UNEXPECTED;
 TfilterSettings *fs=presetSettings->getSettings(filterID);
 if (!fs) return E_INVALIDARG;
 return fs->hasReset(filterPageId)?S_OK:S_FALSE;
}

STDMETHODIMP TffdshowDec::getFilterTip(unsigned int filterID,char_t *buf,size_t buflen)
{
 return getFilterTipEx(filterID,0,buf,buflen);
}
STDMETHODIMP TffdshowDec::getFilterTipEx(unsigned int filterID,unsigned int filterPageId,char_t *buf,size_t buflen)
{
 if (!presetSettings) return E_UNEXPECTED;
 if (!buf) return E_POINTER;
 TfilterSettings *fs=presetSettings->getSettings(filterID);
 if (!fs) return E_INVALIDARG;
 return fs->getTip(filterPageId,buf,buflen)?S_OK:S_FALSE;
}

STDMETHODIMP TffdshowDec::getPresetsPtr(Tpresets* *presetsPtr)
{
 if (!presetsPtr) return E_POINTER;
 *presetsPtr=presets;
 return S_OK;
}
STDMETHODIMP TffdshowDec::cyclePresets(int step)
{
 if (!presets || !presetSettings) return E_UNEXPECTED;
 Tpreset* preset=presets->getPreset(presetSettings->presetName,false);
 Tpresets::const_iterator pi=std::find(presets->begin(),presets->end(),preset);
 if (pi==presets->end()) return E_FAIL;
 for (int i=0;i!=step;i+=sign(step))
  {
   if (sign(step)==-1 && pi==presets->begin())
    pi=presets->end()-1;
   else if (sign(step)==1 && pi==presets->end()-1)
    pi=presets->begin();
   else
    pi+=sign(step);
  }
 setActivePreset((*pi)->presetName,false);
 return S_OK;
}

STDMETHODIMP TffdshowDec::newSample(IMediaSample* *samplePtr)
{
 return E_NOTIMPL;
}


STDMETHODIMP TffdshowDec::JoinFilterGraph(IFilterGraph *pGraph,LPCWSTR pName)
{ 
 return onJoinFilterGraph(pGraph,pName);
}

HRESULT TffdshowDec::BreakConnect(PIN_DIRECTION dir)
{
/*
 if (dir==PINDIR_OUTPUT && filters)
  filters->onDisconnect(dir);
*/
 return CTransformFilter::BreakConnect(dir);
}

HRESULT TffdshowDec::onGraphRemove(void)
{
 if (keys) delete keys;keys=NULL;
 if (mouse) delete mouse;mouse=NULL;
 if (remote) delete remote;remote=NULL;
 return TffdshowBase::onGraphRemove();
}

HRESULT TffdshowDec::StopStreaming(void)
{
 if (filters) filters->onStop();
 return CTransformFilter::StopStreaming();
}

STDMETHODIMP_(int) TffdshowDec::getMinOrder2(void)
{
 if (!presetSettings) return INT_MIN;
 return presetSettings->getMinOrder();
}
STDMETHODIMP_(int) TffdshowDec::getMaxOrder2(void)
{
 if (!presetSettings) return INT_MIN;
 return presetSettings->getMaxOrder();
}
STDMETHODIMP TffdshowDec::resetOrder(void)
{
 if (!presetSettings) return E_FAIL;
 if (presetSettings->resetOrder())
  sendOnChange(0,0);
 if (filters) filters->onQueueChange(0,0);
 return S_OK;
}
STDMETHODIMP TffdshowDec::setFilterOrder(unsigned int filterID,unsigned int newOrder)
{
 if (!presetSettings) return S_FALSE;
 return presetSettings->setFilterOrder(filterID,newOrder)?S_OK:S_FALSE;
}
 
STDMETHODIMP TffdshowDec::get_ExSeekCapabilities(long * pExCapabilities)
{
 *pExCapabilities=AM_EXSEEK_BUFFERING|AM_EXSEEK_NOSTANDARDREPAINT|AM_EXSEEK_CANSEEK|AM_EXSEEK_CANSCAN;//|AM_EXSEEK_SCANWITHOUTCLOCK;
 return S_OK;
}
STDMETHODIMP TffdshowDec::get_MarkerCount(long * pMarkerCount)
{
 *pMarkerCount=TffdshowBase::getDuration();
 return S_OK;
}
STDMETHODIMP TffdshowDec::get_CurrentMarker(long * pCurrentMarker)
{
 *pCurrentMarker=getCurTime2();
 return S_OK;
}
STDMETHODIMP TffdshowDec::GetMarkerTime(long MarkerNum, double * pMarkerTime)
{
 DPRINTF(_l("GetMarkerTime :%i"),MarkerNum);
 *pMarkerTime=MarkerNum;
 return S_OK;
}
STDMETHODIMP TffdshowDec::GetMarkerName(long MarkerNum, BSTR * pbstrMarkerName)
{
 return E_NOTIMPL;
}
STDMETHODIMP TffdshowDec::put_PlaybackSpeed(double Speed)
{
 if (comptrQ<IMediaSeeking> seek=graph)
  return seek->SetRate(Speed);
 else
  return E_NOINTERFACE; 
}
STDMETHODIMP TffdshowDec::get_PlaybackSpeed(double * pSpeed)
{
 if (comptrQ<IMediaSeeking> seek=graph)
  return seek->GetRate(pSpeed);
 else
  return E_NOINTERFACE; 
}

AM_MEDIA_TYPE* TffdshowDec::getInputMediaType(int lIndex)
{
 return CreateMediaType(&m_pInput->CurrentMediaType());
}

bool TffdshowDec::streamsSort(const Tstream *s1,const Tstream *s2)
{
 return s2->order>s1->order;
}

STDMETHODIMP TffdshowDec::Count(DWORD* pcStreams)
{
 if (!pcStreams) return E_POINTER;
 if (cfgDlgHwnd || !presetSettings)
  {
   *pcStreams=0;
   return S_OK;
  }
 for (Tstreams::iterator s=streams.begin();s!=streams.end();s++) delete *s;streams.clear();
 Ttranslate *tr;getTranslator(&tr);
 if (globalSettings->streamsMenu)
  {
   for (unsigned int i=0;i<presets->size();i++)
    streams.push_back(new TstreamPreset(this,-200+i,0,(*presets)[i]->presetName));
   const char_t *activepresetname=getActivePresetName2(); 
   if (activepresetname)
    {
     const TfilterIDFFs *filters;getFilterIDFFs(activepresetname,&filters);
     for (TfilterIDFFs::const_iterator f=filters->begin();f!=filters->end();f++)
      if (f->idff->is && (f->idff->show==0 || getParam2(f->idff->show)))
       streams.push_back(new TstreamFilter(this,getParam2(f->idff->order),1,f->idff,tr));
     std::sort(streams.begin(),streams.end(),streamsSort);
    }
   for (const TfilterIDFF *f=getNextFilterIDFF();f && f->name;f++)
    if (f->show==0 || getParam2(f->show))
     streams.push_back(new TstreamFilter(this,f->order?getParam2(f->order):1000,f->order?1:2,f,tr));
  }
 tr->release();
 addOwnStreams();
 *pcStreams=(DWORD)streams.size();
 return S_OK;
}
STDMETHODIMP TffdshowDec::Info(long lIndex, AM_MEDIA_TYPE** ppmt, DWORD* pdwFlags, LCID* plcid, DWORD* pdwGroup, WCHAR** ppszName, IUnknown** ppObject, IUnknown** ppUnk)
{
 if (lIndex<0 || lIndex>=(long)streams.size() || !presetSettings) return E_INVALIDARG;
 if (ppmt) *ppmt=getInputMediaType(lIndex);
 if (pdwFlags)
  *pdwFlags=streams[lIndex]->getFlags();
 if (plcid) *plcid=0;
 if (pdwGroup) *pdwGroup=streams[lIndex]->group;
 if (ppszName)
  {
   ffstring name=streams[lIndex]->getName();//stringreplace(ffstring(streams[lIndex]->getName()),"&","&&",rfReplaceAll);
   size_t wlen=(name.size()+1)*sizeof(WCHAR);
   *ppszName=(WCHAR*)CoTaskMemAlloc(wlen);memset(*ppszName,0,wlen);
   nCopyAnsiToWideChar(*ppszName,name.c_str());
  }
 if (ppObject) *ppObject=NULL;
 if (ppUnk) *ppUnk=NULL;
 return S_OK;
}
STDMETHODIMP TffdshowDec::Enable(long lIndex, DWORD dwFlags)
{
 if (firsttransform) return S_OK;
 if (/*!(dwFlags&AMSTREAMSELECTENABLE_ENABLE)*/dwFlags!=AMSTREAMSELECTENABLE_ENABLE) return E_NOTIMPL;
 if (lIndex<0 || lIndex>=(long)streams.size()) return E_INVALIDARG;
 if (streams[lIndex]->action())
  {
   saveGlobalSettings();
   saveKeysSettings();
   saveRemoteSettings();
   saveActivePreset(NULL);
  }
 return S_OK;
}

TffdshowDec::TstreamFilter::TstreamFilter(TffdshowDec *Iself,int Iorder,int Igroup,const TfilterIDFF *If,Ttranslate *Itr):Tstream(Iself,Iorder,Igroup),f(If)
{
 tr=Itr;
 tr->addref();
}
TffdshowDec::TstreamFilter::~TstreamFilter()
{
 tr->release();
}
DWORD TffdshowDec::TstreamFilter::getFlags(void)
{
 return ((f->is==IDFF_isKeys && !self->keys) || self->getParam2(f->is)==0)?0:AMSTREAMSELECTINFO_ENABLED;
}
const char_t* TffdshowDec::TstreamFilter::getName(void)
{
 const char_t *ret=tr->translate(NULL,f->dlgId,0,f->name);
 if (strcmp(ret,_l("Subtitles"))==0)
  return _l("Subtitles ");
 else
  return ret;
}
bool TffdshowDec::TstreamFilter::action(void)
{
 self->invParam(f->is);
 return true;
}

DWORD TffdshowDec::TstreamPreset::getFlags(void)
{
 return stricmp(preset,self->presetSettings->presetName)==0?AMSTREAMSELECTINFO_ENABLED|AMSTREAMSELECTINFO_EXCLUSIVE:0;
}
const char_t* TffdshowDec::TstreamPreset::getName(void)
{
 return preset;
}
bool TffdshowDec::TstreamPreset::action(void)
{
 self->setActivePreset(preset,0);
 return true;
}

STDMETHODIMP TffdshowDec::getShortDescription(char_t *buf,int buflen)
{
 if (!buf) return E_POINTER;
 const char_t *activepresetname=getActivePresetName2();
 if (!activepresetname)
  {
   buf[0]='\0';
   return E_UNEXPECTED;
  } 
 int len=tsnprintf(buf,buflen,_l("ffdshow %s: "),FFDSHOW_VER);
 buf+=len;buflen-=len;
 const TfilterIDFFs *filters;getFilterIDFFs(activepresetname,&filters);
 for (TfilterIDFFs::const_iterator f=filters->begin();f!=filters->end() && buflen>0;f++)
  if (f->idff->is && getParam2(f->idff->is))
   {
    len=tsnprintf(buf,buflen,_l("%s "),f->idff->name);
    buf+=len;buflen-=len;
   }
 for (const TfilterIDFF *f=getNextFilterIDFF();f && f->name && buflen>0;f++)
  if (f->is && getParam2(f->is))
   {
    len=tsnprintf(buf,buflen,_l("%s "),f->name);
    buf+=len;buflen-=len;
   }
 buf[-1]='\0';
 return true;
}

STDMETHODIMP TffdshowDec::createPresetPages(const char_t *presetname,TffdshowPageDec *pages)
{
 if (!presetname) return S_FALSE;
 Tpreset *preset=presets->getPreset(presetname,false);
 if (preset)
  {
   preset->createPages(pages);
   return S_OK;
  }
 else 
  return S_FALSE;
}

STDMETHODIMP TffdshowDec::getFilterIDFFs(const char_t *presetname,const TfilterIDFFs* *filters)
{
 if (!filters) return E_POINTER;
 Tpreset *preset=presets->getPreset(presetname,false);
 if (preset)
  {
   *filters=preset->getFilters();
   return S_OK;
  }
 else 
  return S_FALSE;
}

HRESULT TffdshowDec::NewSegment(REFERENCE_TIME tStart,REFERENCE_TIME tStop,double dRate)
{
 if ((tStop&0xfffffffffffffffLL)==0xfffffffffffffffLL)
  moviesecs=1; //tStop is most probably wrong, but don't risk getDuration
 else 
  moviesecs=int(tStop/REF_SECOND_MULT);
 if (filters) filters->onSeek();
 return CTransformFilter::NewSegment(tStart,tStop,dRate);
}

STDMETHODIMP TffdshowDec::GetPages(CAUUID *pPages)
{
 DPRINTF(_l("TffdshowDec::GetPages"));
 initDialog();
 onTrayIconChange(0,0);

 pPages->cElems=1;
 pPages->pElems=(GUID*)CoTaskMemAlloc(pPages->cElems*sizeof(GUID));
 if (pPages->pElems==NULL) return E_OUTOFMEMORY;
 pPages->pElems[0]=proppageid;
 return S_OK;
}

STDMETHODIMP_(unsigned int) TffdshowDec::getPresetAutoloadItemsCount2(void)
{
 return presetSettings?(unsigned int)presetSettings->getAutoPresetItemsCount():0;
}
STDMETHODIMP TffdshowDec::getPresetAutoloadItemInfo(unsigned int index,const char_t* *name,const char_t* *hint,int *allowWildcard,int *is,int *isVal,char_t *val,size_t vallen,int *isList,int *isHelp)
{
 if (!presetSettings) return E_UNEXPECTED;
 if (!name || !allowWildcard || !is || !val || !vallen) return E_POINTER;
 if (index>=presetSettings->getAutoPresetItemsCount()) return E_INVALIDARG;
 presetSettings->getAutoPresetItemInfo(index,name,hint,allowWildcard,is,isVal,val,vallen,isList,isHelp);
 return S_OK;
}
STDMETHODIMP TffdshowDec::setPresetAutoloadItem(unsigned int index,int is,const char_t *val)
{
 if (!presetSettings) return E_UNEXPECTED;
 if (!val) return E_POINTER;
 if (index>=presetSettings->getAutoPresetItemsCount()) return E_INVALIDARG;
 presetSettings->setAutoPresetItem(index,is,val);
 return S_OK;
}
STDMETHODIMP TffdshowDec::getPresetAutoloadItemHelp(unsigned int index,const char_t* *helpPtr)
{
 if (!presetSettings) return E_UNEXPECTED;
 if (!helpPtr) return E_POINTER;
 if (index>=presetSettings->getAutoPresetItemsCount()) return E_INVALIDARG;
 presetSettings->getAutoPresetItemHelp(index,helpPtr);
 return *helpPtr?S_OK:S_FALSE;
}

STDMETHODIMP_(const char_t*) TffdshowDec::getPresetAutoloadItemList(unsigned int paramIndex,unsigned int listIndex)
{
 return presetSettings && paramIndex<presetSettings->getAutoPresetItemsCount()?presetSettings->getAutoPresetItemList(this,paramIndex,listIndex):NULL;
}
STDMETHODIMP_(const char_t**) TffdshowDec::getSupportedFOURCCs(void)
{
 return globalSettings->getFOURCClist();
}
STDMETHODIMP_(const Tstrptrs*) TffdshowDec::getCodecsList(void)
{
 if (codecs.empty())
  globalSettings->getCodecsList(codecs);
 return &codecs;
}

STDMETHODIMP TffdshowDec::queryFilterInterface(const IID &iid,void **ptr)
{
 if (!ptr) return E_POINTER;
 if (!filters) return E_UNEXPECTED;
 lock(IDFF_lockPresetPtr);
 HRESULT res=filters->queryFilterInterface(iid,ptr);
 unlock(IDFF_lockPresetPtr);
 return res;
}
STDMETHODIMP TffdshowDec::setOnNewFiltersMsg(HWND wnd,unsigned int msg)
{
 onNewFiltersWnd=wnd;onNewFiltersMsg=msg;
 return S_OK;
}
STDMETHODIMP TffdshowDec::sendOnNewFiltersMsg(void)
{
 if (onNewFiltersMsg) 
  {
   PostMessage(onNewFiltersWnd,onNewFiltersMsg,0,0);
   return S_OK;
  }
 else 
  return S_FALSE;  
}

STDMETHODIMP_(int) TffdshowDec::getOSDpresetCount2(void)
{
 return (int)globalSettings->osd->getSize();
}
STDMETHODIMP_(const char_t*) TffdshowDec::getOSDpresetName2(unsigned int i)
{
 return globalSettings->osd->getPresetName(i);
}
STDMETHODIMP_(const char_t*) TffdshowDec::getOSDpresetFormat2(const char_t *presetName)
{
 return globalSettings->osd->getFormat(presetName);
}
STDMETHODIMP TffdshowDec::setOSDpresetFormat(const char_t *presetName,const char_t *format)
{
 return globalSettings->osd->setFormat(presetName,format)?S_OK:S_FALSE;
}
STDMETHODIMP TffdshowDec::setOSDpresetName(unsigned int i,const char_t *name)
{
 return globalSettings->osd->setPresetName(i,name);
}
STDMETHODIMP TffdshowDec::addOSDpreset(const char_t *presetName,const char_t *format)
{
 if (!presetName || presetName[0]=='\0' || !format) return E_INVALIDARG;
 globalSettings->osd->addPreset(presetName,format);
 return S_OK;
}
STDMETHODIMP TffdshowDec::deleteOSDpreset(const char_t *presetName)
{
 return globalSettings->osd->erase(presetName)?S_OK:S_FALSE;
}
STDMETHODIMP TffdshowDec::cycleOSDpresets(void)
{
 return globalSettings->osd->cycle()?S_OK:S_FALSE;
}
STDMETHODIMP_(const char_t*) TffdshowDec::getOSDstartupFormat(int *duration)
{
 return globalSettings->osd->getStartupFormat(duration);
}