devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

开源项目之Splayer 射手影音播放器_dsm muxer

作者：我家自动化 | 2024-02-26 06:10:09

赞

踩

dsm muxer


Splayer（射手影音播放器）是一款高画面、低消耗、智能化、精致美观的影音播放器。

具有如下八个独创：

独创ShaderEngineTM图像增强引擎，4倍速驱动，降低画面噪点，锐利画质呈现，低画质视频照样全屏放
独创LiveColorTM彩色增强算法，画面色彩更艳丽
独创SmartAmplifyTM智能音场平衡技术，声效更显震撼

独创FastMotionTM解码优化技术，大幅降低CPU和内存占用。多核 SSE2 SSE3 MMX GPU优化
独创PowerTravelTM旅行节电模式，降低能耗，增加笔记本的巡航时间
独创EyeCareTM护眼模式，久看不疲劳，健康最重要

独创Anti-SillyTM智能免配置，数百逻辑分支自动根据硬件配置选择最佳模式。
独创CloudMatchingTM智能显示字幕技术，外语片从此不再需要找寻匹配字幕

Splayer 是一款开源项目，项目总共有87个工程（含测试工程），如图：


效果如图：




这是我目前接触最大的项目，刚接触时不知道如何下手，于是把所有的库都大致的分析了一遍，由于缺少资料所以很多分析都带有主观，难免有瑕疵，

但我然仍贴出来，以鼓励我继续研究，我计划把Splayer集成为一个视频播放的控件，现在计划已经进行了38%，但由于工作原因，这项计划被搁置了，

但我相信我会慢慢把它完成，因为我是一个码农，o(∩_∩)o 哈哈!~~~

2012tvod项目如图：



效果如图：




 进入主题了，由于Splayer项目过多，所以把它分成二个部分（主程序、类库），现在从类库开始分析了。

  1. libpng   libpng是OSI认证开源软件，主要负责读写png文件。该库是用来创立和操作png格式的图像文件.png格式是设计来替代gif,他对于更小范围的tiff(标记图
  2. 象文件格式)。Splayer中类CPngIMage是对该库的应用，该类在libpng.h中。

  1. decss   DVD解密源码,专门针对DVD安全机制设计的破解其内容混合系统的,利用decss的功能从网上下载DVD格式的数字电影，还可以用DivX软件将下载的数字电影
  2. 压缩存储到硬盘或光盘上。该类库需要用到BaseClasses库。 该库有五个类，分别是CDeCSSInputPin、CVobDec、CDVDSession、CLBAFile、CVobFile。
dsutil   directshow工具类库,主要负责视频处理、捕获应用…等操作。该类库需要用到BaseClasses库和foundation库。该库还有类：IDSMPropertyBagImpl 编码器选项设置接口、CDSMResource、IDSMResourceBagImpl、CDSMChapter、IDSMChapterBagImpl、CDSMChapterBag、CFontInstaller 字体的初始化、CGolombBuffer、CH264Nalu、CHdmvClipInfo、CMediaTypeEx、CNullRenderer、CNullVideoRenderer、CNullUVideoRenderer、CNullAudioRenderer、CNullUAudioRenderer、CNullTextRenderer、CCpuID。其中DSUtil.h 包含很多视频操作函数。

foundation  该库是一个辅助库，内含：base64编解码、同步类CriticalSection/AutoCSLock、文件路径操作类FilePath、信息输出类LogController、加载资源类ResLoader、定义字符串Strings、多线程辅助模块ThreadHelperImpl、实例生成模块LazyInstanceImpl。
id3lib 该库是用于读、写和操纵ID3v1和ID3v2标签的对于媒体类型的文件，它能够调用id3lib库来获取诸如作者，唱片年代，风格等tag信息，如果是视频媒体文件，它还会抓图。


libssf 该库为一个操作 影视字幕以及特效的类库。
lyriclib 该库为歌词匹配类库。
subpic 该库为操作位图类库（例如 字幕图片显示）。
sqlitepp 该库是一个C++封装的 SQLite组件，开源、免费。目的是使用面向对象的方式来简化SQLite的使用，具有面向对象的访问方式。程序将通过它生成数据库，该数据库是settings.db 负责记录设置信息。
subtitles 该库是操作视频字幕的库。
svplib  该库是一个 字幕获取功能库，内含：CSVPEqualizer、CSVPRarLib 压缩包rar文件操作、CSVPSubfilterLib、CSVPToolBox 文件路径操作类。
yaml-cpp 是一个 开源的YAML 解析器。
CmdUI 是一个界面设置属性的对话框
ResizableLib 为一个界面库，可以根据父窗口的位置和大小动态调整控件窗口的大小。
sizecbar 为实现浮动工具条！
TreePropSheet 为树控件目录即文件目录
Updater 程序的升级程序
libmad 该库是一个MPEG音频解码库，是一个高-品质的??的的的MPEG音频解码器。目前，它支持MPEG-1和MPEG-2扩展到较低的采样频率，以及所谓的MPEG 2.5格式,是一个独立库。

filters 该库是滤波函数库等，该库主要有程序类CFilterApp、CInternalPropertyPageWnd属性窗体、CInternalPropertyPage属性页、CInternalPropertyPageTempl模块、CPinInfoWnd。
liba52  该库是一个解码ATSC A/52流的库，还包括一个MPEG-1和MPEG-2节目流复用器（音频和视频）。编码的环绕立体声缩混  大多数用户明显增加任意缩混扬声器配置，并实施动态范围压缩。
libdts  该库是一个DTS相干声学解码器库 负责解码DTS相干声学流，用于一个跨平台的视频播放和流VLC媒体播放器。
zlib 该库是一个压缩算法的库,提供数据压缩用的函式库。
libfaad 该库是软高级音频（AAC）解码器，含丁苯橡胶解码。其中in_mp4 - Winamp的MPEG-4 AAC文件输入插件，QCD的 - 典型的球员的AAC插件，QCDMp4 - 典型的播放器MP4插件，XMMS - XMMS的AAC插件，MPEG4IP - 为MPEG4IP播放器插件。
libdirac 该库是一个开源的视频编解码器。它采用了传统的混合视频编解码器架构，是与小波转换而不是通常的块转换。运动补偿使用重叠的块，以减少区块会扰乱变换编码阶段的文物。
baseclasses 该库是DirectX 自带的一个库，是微软推出的一套基于Windows系统的多媒体应用程式接口APIs函式。
libflac   该库是FLAC文件解码器的一个库，是无损音频编解码器库。
libavcodec  该库是非常先进的音频/视频编解码库，用于各种类型声音/图像编解码，无法使用VS2008编译。
libvorbisidec 该库是Ogg文件编解码器。
libmpeg2 该库是一个解码MPEG-2和MPEG-1视频的库。

SyncClock   该库是同步卡与服务器的时间设置库，该库主要有：CSyncClock、CSyncClockFilter。
BaseMuxer 该库为输入/输出流混合器基库，合成器可将特定的音视频流合成为特定的媒体容器格式，并交给文件写滤镜写入到磁盘中，从而最终实现媒体格式的转换。特定的合成器需要与特定的音视频编码器配合才能起作用，只不过有些合成器比较挑食，只能容纳一种类型的音视频编码，而有些合成器胃口很好，可容纳的多种音视频编码,如WMV和ASF的合成器只能容纳下WMA音频和WMV视频，而AVI的合成器则可以容纳从非压缩的RGB视频及PCM音频到高压缩率的DivX视频及MP3音频，至于MKV和DSM的合成器，几乎算是万能合成器了,该库主要有CBaseMuxerFilter、CBaseMuxerInputPin、CBaseMuxerOutputPin、CBaseMuxerRawOutputPin。
DSMMuxer 介绍同上,该库主要有CDSMMuxerFilter类
MatroskaMuxer 介绍同上,是负责将音频流和视频流合成为MKV格式，但要输出，还需要一个文件写出滤镜（File writer），它负责把“Matroska Muxer”合成的结果写入到磁盘当中，该类库主要有CMatroskaMuxerInputPin、CMatroskaMuxerOutputPin、CMatroskaMuxerFilter等类。
wavdest 主要用于将采集到的视频流写入到指定的文件，文件格式是.WAV。该库主要有CWavDestOutputPin、CWavDestFilter等类
streamdrivethru  该库是驱动流通过输入/输出引脚过滤器，该库主要有CStreamDriveThruInputPin、CStreamDriveThruOutputPin、CStreamDriveThruFilter等类。
AviSplitter  该库是AVI的滤镜分离器，默认用System的，因稳定性和兼容性最好；Gabest的可以读下载不完整的AVI文件；而Haali的支持多音轨的切换。该库涉及：BaseSplitter库、BaseClasses库，该库主要有：CAviFile、CAviPlotterWnd、CAviReportWnd、CAviSplitterOutputPin、CAviSplitterFilter、
CAviSourceFilter。
basesplitter 该库是分词基类，该库涉及dsutil、unrar、AudioSwitcher类库，该库主要有：CAsyncFileReader、CAsyncUrlReader、Packet、CPacketQueue、CBaseSplitterInputPin、CBaseSplitterOutputPin、CBaseSplitterFilter、CBaseSplitterFile、CBaseSplitterFileEx、CMultiFiles。
diracSplitter  该库是dirac滤镜分离器库，该库涉及：BaseSplitter库、BaseClasses库，该库主要有CDiracSplitterFilter、CDiracSourceFilter、CDiracVideoDecoder、CDiracSplitterFile。
DSMSplitter  该库是dsm滤镜分离器库，该库涉及：BaseSplitter库、BaseClasses库，该库主要有CDSMSplitterFilter、CDSMSourceFilter、CDSMSplitterFile等类。
EASplitter  该库是ea滤镜分离器库，该库涉及：BaseSplitter库、BaseClasses库、DSUtil库、ffmpeg库等，该库主要有CEAFile、CEASpliterFilter、CEASourceFilter。
flvsplitter  该库是flv滤镜分离器库，该库涉及：BaseSplitter库、BaseClasses库、DSUtil库、libVP62（flash vp6解码器）库，该库主要有CFLVSplitterFilter、CFLVSourceFilter、VP62。
MatroskaSplitter 该库是MKV滤镜分离器库（MKV视频的分离器），该库主要涉及：BaseSplitter库、BaseClasses库、DSUtil库。该库类较多。
mp4splitter  该库是MP4滤镜分离器库，该库主要涉及：BaseSplitter库、BaseClasses库、DSUtil库、Zlib库。该库主要有：CMP4SplitterFilter、CMP4SourceFilter、CMPEG4VideoSplitterFilter、CMPEG4VideoSourceFilter、CMP4SplitterFile……等等。
MpaSplitter  该库是Mpa滤镜分离器库，该库主要涉及：BaseSplitter库、BaseClasses库、DSUtil库。该库主要有：CMpaSplitterFilter、CMpaSplitterFile等类。
MpegSplitter  该库是MPEG滤镜分离器库,一个MPEG的分割工具，可将大尺寸MPEG文件分割成数个小尺寸的MPEG文件。该库主要涉及：BaseSplitter库、BaseClasses库、DSUtil库。该库主要有：CMpegSplitterFilter、CMpegSourceFilter、CMpegSplitterFile、CMpegSplitterSettingsWnd等类。
WMVSpliter 该库为WMV滤镜分离器库,WMA是一种视频编码格式,该库主要有StreamOnAsyncReader、ptr_shared_count（线程安全的共享数）、StreamInput、WMFOutputPin（输出引脚，提供的解码器的压缩数据）、IEncapsulatedAccess（分配缓冲区WMF时，我们需要返回一个IMediaSample对象周围的包装/INSSBuffer的接口）、EncapsulateSample、WMFDemuxFilter(分析器过滤器本身)、
NutSplitter  该库主要涉及：BaseSplitter库、BaseClasses库、DSUtil库。该库主要有：CNutFile、CNutSplitterFilter、CNutSourceFilter等类。
OggSplitter  该库是Ogg滤镜分离器库，Ogg是一种新的音频压缩格式，类似于MP3等的音乐格式。该库主要涉及：BaseSplitter库、BaseClasses库、DSUtil库。该库主要有：OggPage类、COggFile类、OggPacket类、COggSplitterOutputPin类、COggVorbisOutputPin类、COggDirectShowOutputPin类、COggS treamOutputPin类、COggSplitterFilter类、COggSourceFilter类…等等。
RealMediaSplitter 该库是real滤镜分离器库,是real播放器为除realplay外播放器播放real格式,比如RM,RMVB等等格式的播放插件.有了这个插件,其他播放器才能够播放REAL格式的视频,音频等文件.
RoQSplitter 该库是分离式联轴器的旋转编码器,该库主要有CRoQSplitterFilter、CRoQSourceFilter、CRoQVideoDecoder、CRoQAudioDecoder等类。
ssfsplitter 该库是特效字幕d的滤镜分离器，该库主要有CSSFSplitterFilter、CSSFSourceFilter等类。

asyncreader 该库是读取网络上的编码后的视频数据库，读取后交给解码filter。该库主要有：CAsyncStream、CAsyncIo、CAsyncOutputPin、CAsyncReader。

cddareader 该库是开源滤镜MPC，DTS技术编码的音频具有细节丰富、定位精确的特点，是传统CD和Dolby环绕声效的后继者。该库主要有：CCDDAStream、CCDDAReader类。

cdxareader  该库为系统滤镜，该库主要有CCDXAStream、CCDXAReader类。

udpreader   该库为系统滤镜，该库主要有CUDPStream、CUDPReader类。

vtsreader   该库为系统滤镜，该库主要有CVTSStream、CVTSReader类。
MpcAudioRenderer 该库为使用WASAPI音频输出MPC音频渲染器，该库主要有CMpcAudioRenderer类。
basesource  该库是解码文件的基础库，该库主要有：CBaseSource、CBaseStream等类。

dtsac3source该库是DTS/AC3输出滤镜的库，DTS(Digital Theater Systems)是一种高质量的多声道音频编码方式，目前主要用作DVD的伴音。DTS 5.1的最大码率(Bitrate)与LPCM(LPCM是数位非经压缩的声音规格，音质佳，所占容量空间较大)相同，可达1536Kbps，远高于目前另一种流行的多声道编码系统──Dolby Digital AC3的 448Kbps，虽然同样是有损压缩，但它可提供更为逼真，细节更为丰富的音响效果。用DVD中DTS音轨来制作音乐CD无疑是非常理想的。该库主要有：CDTSAC3Source、CDTSAC3Stream等类。

flicsource  该库是处理fli文件的库，主要有CFLICSource、CFLICStream等类。

flacsource  该库是音频压缩编解码库，其特点是无损压缩。不同于其他有损压缩编码如MP3 及 AAC，它不会破坏任何原有的音频资讯，所以可以还原音乐光盘音质。该库主要有：CFlacSource、CFlacStream类。该库主要牵涉

shoutcastsource  该库是采用了MPEG Layer 3(MP3)技术，实现了因特网上的音频流的实时广播或者点播。该库主要有：CShoutcastSource、CShoutcastStream等类。

d2vsource 该库为d2v输出滤镜的库,d2v即数字化视频，该库主要有CMPEG2Dec、CD2VSource、CMPEG2Dec等类。
subtitlesource 该库为字幕输出滤镜的库,该库主要有CSubtitleSource、CSubtitleStream等类。
audioswitcher  该库是一个自动切换扬声器的库，涉及主程序的eqPerset负责设置音频，该库主要有：AudioStreamResampler、CAudioSwitcherFilter、CStreamSwitcherPassThru、CStreamSwitcherAllocator、CStreamSwitcherInputPin、CStreamSwitcherOutputPin、CStreamSwitcherFilter。
Mpeg2DecFilter 该库是为测试程序是libmpeg2。它解码MPEG-1和MPEG-2视频流，还包括一个MPEG-1和MPEG-2解复用器节目流。该库牵涉:BaseVideoFilter.lib libmpeg2.lib dsutil.lib 等库，该库主要有：IMpeg2DecFilter接口、CMpeg2Info、CMpeg2Dec、CMpeg2DecFilter、CMpeg2DecInputPin、CMpeg2DecOutputPin、CSubpicInputPin、CMpe g2DecSettingsWnd等类。
avi2ac3filter 该库为AC3音效辅助插件库，目前DVDrip在制作音频部分时普遍采用两种方式：MP3格式压缩音轨和保留DVD中原有的AC3音频文件。一般来说，Windows操作系统已经自带了MP3的解码器——Fhg Radium MP3 codec，因此采用MP3格式做的DVDrip音频我们都可以听到。但对于以AC3音频文件制作的DVDrip，我们就只能看到图像而听不到声音了，该库主要有CAVI2AC3Filter类。

bufferfilter 该库为滤镜输出缓冲区库,该库主要有CBufferFilter、CBufferFilterOutputPin等类。

decssfilter 该库为CSS滤镜,对常规的CSS的一个扩展子集，可以使应用对象(文字,图片...)产生类似于PHOTOSHOP中的模糊,通透,边缘发光等效果。该库主要有CDeCSSFilter类。

Mpeg2DecFilter 该库为mpeg1、mpeg2解码过滤器，该库主要有CMpeg2Info、CMpeg2Dec、CMpeg2DecFilter、CMpeg2DecInputPin、CMpeg2DecOutputPin、CSubpicInputPin、CClosedCaptionOutputPin、CMpeg2DecSettingsWnd等类。
MpaDecFilter  该库为MPC H264/VC1硬解码器(主音频解码器)，该库主要有CMpaDecFilter、CMpaDecInputPin、CMpaDecSettingsWnd等类。
basevideofilter 该库为解码视频播放过滤器基库，该库主要有CBaseVideoFilter、CBaseVideoInputAllocator、CBaseVideoInputPin、CBaseVideoInputPin、CBaseVideoOutputPin等类。
MPCVideoDec 该库为主视频解码类库，该库主要有CMPCAudioDecFilter、CMPCVideoDecFilter、CMPCVideoDecSettingsWnd等类。
svpfilter 该库为字幕滤镜类库，该库主要有CSVPSubFilter类。


mplayerc为主程序，主程序自绘控件，以及应用视频音频编解码播放，此处就简单的看看涉及视频播放主要有哪些类！

  1. //渲染操作图像基类 定义如下
  2. class CBaseGraph
  3. 	: public CUnknown
  4. 	, public IGraphBuilder2  //IGraphBuilder接口允许应用程序调用时的过滤器图表管理器试图建立一个完整的过滤器图表
  5. 	, public IMediaControl  //IMediaControl接口提供控制的数据流通过过滤器图的方法。它包括运行，暂停和停止图形的方法
  6. 	, public IMediaEventEx  //其中包含了用于检索事件通知和用于重写筛选器图形的默认事件处理的方法
  7. 	, public IMediaSeeking  //IMediaSeeking接口包含寻求内流的位置，并设置播放速度的方法
  8. 	, public IVideoWindow  //IVideoWindow接口设置视频窗口的属性。应用程序可以使用它来 ​​设置窗口的所有者窗口的位置和尺寸，和其他属性。
  9. 	, public IBasicVideo  //IBasicVideo接口设置视频属性，如目标和源矩形。
  10. 	, public IBasicAudio   //IBasicAudio接口控制音频流的音量和平衡。
  11. 	, public IAMOpenProgress    //IAMOpenProgress接口报告的文件打开操作的进度，使应用程序能够取消操作。
  12. 	, public IGraphEngine	//渲染引擎接口
  1. //播放flash类
  2. class CShockwaveGraph : public CBaseGraph
  1. class CMacrovisionKicker
  2. 	: public CUnknown
  3. 	, public IKsPropertySet	//IKsPropertySet接口的最初目的是作为一种有效的方式来设置和检索WDM驱动程序的设备属性，使用KSProxy翻译用户模式COM方法调用进入内核模式属性的WDM流类驱动程序所使用的设置
interface __declspec(uuid("165BE9D6-0929-4363-9BA3-580D735AA0F6")) IGraphBuilder2 : public IFilterGraph2
  1. //IFilterGraph2接口扩展IFilterGraph的的IGraphBuilder接口，其中包含建立过滤器图表的方法。
  2. //筛选器图形管理器实现了这个接口。应用程序可以使用它建立图表时，利用它提供的其他方法的优势。
class __declspec(uuid("96F3E0BE-1BA4-4E79-973D-191FE425C86B")) CDeinterlacerFilter : public CTransformFilter
  1. //CTransformFilter类是为实施变换过滤器的基类。这个类是专为实施变换过滤器与一个输入引脚和一个输出引脚。
  2. //它使用的输入引脚和输出引脚独立的分配器。要创建一个过滤器，数据处理，使用CTransInPlaceFilter类。
  1. 	//DX7分配器演示
  2. 	class CDX7AllocatorPresenter
  3. 		: public ISubPicAllocatorPresenterImpl  //图像分配操作接口
  1. 	//DX9分配器演示
  2. 	class CDX9AllocatorPresenter
  3. 		: public ISubPicAllocatorPresenterImpl //图像分配操作接口
  1. 	//DXR分配器演示
  2. 	class CDXRAllocatorPresenter:
  3. 		public ISubPicAllocatorPresenterImpl  //图像分配操作接口
  1. //EVR方式输出
  2. class COuterEVR:
  3. 	public CUnknown,
  4. 	public IVMRffdshow9,
  5. 	public IVMRMixerBitmap9,  //使应用程序从位图或Direct3D表面上的视频流，混合静态图像，当使用视频混合渲染过滤器（VMR-9）。
  6. 	public IBaseFilter   //IBaseFilter接口是DirectShow过滤器的主界面
  1. //EVR分配器演示
  2. class CEVRAllocatorPresenter:
  3. 	public CDX9AllocatorPresenter,
  4. 	public IMFGetService,  //查询指定的服务接口的对象。
  5. 	public IMFTopologyServiceLookupClient,  //初始化视频混合器或演示。此接口由混频器和演示，使他们能够增强视频渲染器（EVR）查询接口指针。
  6. 	public IMFVideoDeviceID,  //返回视频渲染组件支持的设备标识符。实现此接口由混频器和增强视频渲染器（EVR）的主持人。
  7. 	public IMFVideoPresenter,  //增强视频渲染器（EVR）提供了一个默认的视频演示，应用程序可以实现自定义的主持人。
  8. 	public IDirect3DDeviceManager9,  //使两个线程共享相同的Direct3D 9设备，并提供访问的DirectX视频加速（DXVA）功能的设备。
  9. 	public IMFAsyncCallback,  //回调接口的异步方法完成时通知应用程序。
  10. 	public IQualProp,			//IQualProp接口提供视频渲染性能信息检索的方法。
  11. 	public IMFRateSupport,			//查询范围的支持，包括反向播放的播放率。	
  12. 	public IMFVideoDisplayControl,	//控制如何增强型视频渲染器（EVR）显示视频。
  13. 	public IEVRTrustedVideoPlugin		//1启用插件在增强视频渲染器（EVR）与保护媒体工作的组成部分。
  1. //映射过滤器
  2. class CFilterMapper2 : 
  3. 	protected CUnknown, 
  4. 	public IFilterMapper2	//注册和取消注册的过滤器，并在注册表中找到过滤器。
  1. //过滤器重叠 （找最近的过滤器）
  2. class FilterOverride
  1. //FG过滤器
  2. class CFGFilter
  1. //FG过滤器注册
  2. class CFGFilterRegistry :
  3. 	public CFGFilter
  1. //FG过滤器文件
  2. class CFGFilterFile :
  3. 	public CFGFilter
  1. //FG过滤器视频渲染
  2. class CFGFilterVideoRenderer : 
  3. 	public CFGFilter
  1. //FG过滤器管理
  2. class CFGManager
  3. 	: public CUnknown
  4. 	, public IGraphBuilder2
  5. 	, public IGraphBuilderDeadEnd
  6. 	, public CCritSec			//CCritSec类提供了一个线程锁。
  1. //添加过滤器
  2. class CFGManagerCustom : public CFGManager
  1. //视频播放时触发 寻找和链接过滤器
  2. class CFGManagerPlayer 
  3. 	: public CFGManagerCustom
  1. //DVD播放时触发 添加对应的过滤器以及渲染图像
  2. class CFGManagerDVD 
  3. 	: public CFGManagerPlayer
  1. //视频捕捉触发
  2. class CFGManagerCapture 
  3. 	: public CFGManagerPlayer
  1. //合成器
  2. class CFGManagerMuxer 
  3. 	: public CFGManagerCustom
  1. //FG聚合 可以根据riid查询对应的接口
  2. class CFGAggregator 
  3. 	: public CUnknown
  1. 	//同步锁
  2. 	class CGenlock
  1. //QT视图操作接口
  2. interface __declspec(uuid("A6AE36F7-A6F2-4157-AF54-6599857E4E20")) IQTVideoSurface : public IUnknown
  1. //视频解码设置类 读取显卡信息
  2. class MPCVideoDecSetting
  1. //VMR9方式输出
  2. class COuterVMR9:
  3. 	public CUnknown,
  4. 	public IVideoWindow,	//视频窗口接口
  5. 	public IBasicVideo2,  //视频渲染过滤器和视频混合渲染过滤器实现这个接口，但通过过滤器图表管理器的应用程序接口暴露。
  6. 	public IVMRWindowlessControl,	//IVMRWindowlessControl界面控制视频混合渲染过滤器（VMR-7）如何呈现在一个容器内窗口的视频流
  7. 	public IVMRffdshow9,
  8. 	public IVMRMixerBitmap9	//IVMRMixerBitmap9接口，使应用程序从位图或Direct3D表面上的视频流，混合静态图像，当使用视频混合渲染过滤器（VMR-9）
  1. //像素着色器编译器
  2. class CPixelShaderCompiler
  1. 	//QT7分配器演示
  2. 	class CQT7AllocatorPresenter
  3. 		: public CDX7AllocatorPresenter //
  4. 		, public IQTVideoSurface  //qt视图操作接口
  1. 	//QT9分配器演示
  2. 	class CQT9AllocatorPresenter:
  3. 		public CDX9AllocatorPresenter,
  4. 		public IQTVideoSurface //QT视图操作接口
  1. 	//实现QuickTime多媒体文件播放
  2. 	class CQuicktimeWindow : public CPlayerWindow
  1. //QuickTime多媒体文件渲染
  2. class CQuicktimeGraph :
  3. 	public CBaseGraph,  //基类渲染
  4. 	public IVideoFrameStep	//实现单帧前进后退
  1. 	//实现RealMedia多媒体文件播放
  2. 	class CRealMediaPlayer
  3. 		: public CUnknown
  4. 		, public IRMAErrorSink //错误处理接口
  5. 		, public IRMAClientAdviseSink //能够使 RealPlayer的上层感知内核中播放 状态的改变以及其他相关信息
  6. 		, public IRMAAuthenticationManager	//可以控制网络上多个数码复合机的认证数据，并能对每个用户的认证数据进行简单有效的设置。
  7. 		, public IRMASiteSupplier  //rma站点提供接口
  8. 		, public IRMAPassiveSiteWatcher	//通过站点观察接口
  9. 		, public IRMAAudioHook		//音频钩子接口
  1. //RealMedia媒体视频视图操作
  2. class CRealMediaVideoSurface
  3. 	: public CUnknown
  4. 	, public IRMAVideoSurface //视图操作接口
  1. 	//RM7分配器演示
  2. 	class CRM7AllocatorPresenter
  3. 		: public CDX7AllocatorPresenter
  4. 		, public IRMAVideoSurface  //视图操作接口
  1. 	//RM9分配器演示
  2. 	class CRM9AllocatorPresenter: 
  3. 		public CDX9AllocatorPresenter,
  4. 		public IRMAVideoSurface  //RMA视图操作接口
  1. 	//VMR7分配器演示
  2. 	class CVMR7AllocatorPresenter
  3. 		: public CDX7AllocatorPresenter
  4. 		, public IVMRSurfaceAllocator	//分配器演示使用这个接口进行通信的VMR
  5. 		, public IVMRImagePresenter	//IVMRImagePresenter9接口来实现的默认分配器演示视频混合呈现过滤器（VMR-9），VMR-9使用此接口通知分配器演示的，它应该呈现的视频帧中所提供的Direct3D表面。
  6. 		, public IVMRWindowlessControl	//显示窗口控制接口
  1. 	//VMR9分配器演示
  2. 	class CVMR9AllocatorPresenter
  3. 		: public CDX9AllocatorPresenter, 
  4. 		public IVMRSurfaceAllocator9,	//分配器演示使用这个接口进行通信的VMR
  5. 		public IVMRImagePresenter9,		//IVMRImagePresenter9接口来实现的默认分配器演示视频混合呈现过滤器（VMR-9），VMR-9使用此接口通知分配器演示的，它应该呈现的视频帧中所提供的Direct3D表面。
  6. 		public IVMRWindowlessControl9	//显示窗口控制接口
  1. class __declspec(uuid("96F3E0BE-1BA4-4E79-973D-191FE425C86B")) CDeinterlacerFilter 
  2. 	: public CTransformFilter // 用来浏览视频 时候旋转 
  1. class __declspec(uuid("E2BA9B7B-B65D-4804-ACB2-89C3E55511DB")) CTextPassThruFilter : 
  2. 	public CBaseFilter, 
  3. 	public CCritSec


视频播放大致跟这些类/接口有关！

主程序是如何播放的？先来看看主程序的几个成员函数：

  1.   // Operations   准备视频播放操作
  2.   bool OpenMediaPrivate(CAutoPtr<OpenMediaData> pOMD);
  3.   // 准备关闭当前视频操作
  4.   void CloseMediaPrivate();
  5. 	//创建渲染对象
  6.   void OpenCreateGraphObject(OpenMediaData* pOMD);
  7.   //路径操作
  8.   HRESULT OpenMMSUrlStream(CString szFn);
  9.   //打开目标文件
  10.   void OpenFile(OpenFileData* pOFD);
  11.   //打开DVD
  12.   void OpenDVD(OpenDVDData* pODD);
  13.   //打开视频捕捉
  14.   void OpenCapture(OpenDeviceData* pODD);
  15.   //通用渲染
  16.   void OpenCustomizeGraph();
  17.   //初始化视频操作
  18.   void OpenSetupVideo();
  19.   //初始化音频操作
  20.   void OpenSetupAudio();
这些函数进行了视频相关操作！~

当打开文件时触发

  1.  m_pGraphThread = (CGraphThread*)AfxBeginThread(RUNTIME_CLASS(CGraphThread));
  2. if(m_pGraphThread)
  3.     m_pGraphThread->SetMainFrame(this);
销毁时触发 

  1.   if(m_pGraphThread)
  2.   {
  3.     CAMEvent e;
  4.     m_pGraphThread->PostThreadMessage(CGraphThread::TM_EXIT, 0, (LPARAM)&e);
  5.     if(!e.Wait(5000))
  6.     {
  7.       TRACE(_T("ERROR: Must call TerminateThread() on CMainFrame::m_pGraphThread->m_hThread\n")); 
  8.       TerminateThread(m_pGraphThread->m_hThread, -1);
  9.     }
  10.   }

  1. 打开文件流程分析：
  2. void CMainFrame::OnFileOpenQuick()
  3. {
  4.    正在加载或列表未生成 则直接返回
  5.   if(m_iMediaLoadState == MLS_LOADING || !IsWindow(m_wndPlaylistBar)) return;
  6.  
  7.    近期文件列表
  8.   CRecentFileList& MRU = AfxGetAppSettings().MRU;
  9.  
  10.   CString szLastFile;  最后一次看的视频文件
  11.  
  12.   MRU.ReadList();    读取列表的文件路径
  13.  
  14.   if(MRU.GetSize() > 0){
  15.     szLastFile = MRU[0];    把读取的文件信息取出
  16.   }
  17.  
  18.   CString filter;
  19.   CAtlArray<CString> mask;
  20.   从设置里面读取过滤的设置
  21.   AfxGetAppSettings().Formats.GetFilter(filter, mask);
  22.  
  23.   COpenFileDlg fd(mask, true, NULL, szLastFile, 
  24.     OFN_EXPLORER|OFN_ENABLESIZING|OFN_HIDEREADONLY|OFN_ALLOWMULTISELECT|OFN_ENABLEINCLUDENOTIFY, 
  25.     filter, this);
  26.   if(fd.DoModal() != IDOK) return;    显示出打开文件对话框
  27.  
  28.   CAtlList<CString> fns;
  29.  
  30.   POSITION pos = fd.GetStartPosition();
  31.   while(pos) fns.AddTail(fd.GetNextPathName(pos)); 把选中的文件加入进来
  32.  
  33.   bool fMultipleFiles = false;
  34.  
  35.   判断是否多选 或选中的是目录
  36.   if(fns.GetCount() > 1 
  37.     || fns.GetCount() == 1 
  38.     && (fns.GetHead()[fns.GetHead().GetLength()-1] == '\\'
  39.     || fns.GetHead()[fns.GetHead().GetLength()-1] == '*'))
  40.   {
  41.     fMultipleFiles = true;
  42.   }
  43.  
  44.   猜测 关闭Media
  45.   SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);
  46.  
  47.   ShowWindow(SW_SHOW);
  48.   SetForegroundWindow();
  49.  
  50.   列表打开文件
  51.   m_wndPlaylistBar.Open(fns, fMultipleFiles);
  52.  
  53.   播放列表个数为一 且可见 并且不是自由的 则显示或隐藏
  54.   if(m_wndPlaylistBar.GetCount() == 1 && m_wndPlaylistBar.IsWindowVisible() && !m_wndPlaylistBar.IsFloating())
  55.   {
  56.     ShowControlBar(&m_wndPlaylistBar, FALSE, TRUE);
  57.   }
  58.  
  59.   OpenCurPlaylistItem();  打开当前列表选中项
  60. }
  61.  
  62. 进入 OpenCurPlaylistItem 函数分析  参数为树节点 默认为零
  63. void CMainFrame::OpenCurPlaylistItem(REFERENCE_TIME rtStart)
  64. {
  65.   如果列表中没有  则直接退出
  66.   if(m_wndPlaylistBar.GetCount() == 0)    return;
  67.  
  68.   CPlaylistItem pli;
  69.    得到当前选中项 如果没有则选中第一项
  70.   if(!m_wndPlaylistBar.GetCur(pli)) m_wndPlaylistBar.SetFirst();
  71.   if(!m_wndPlaylistBar.GetCur(pli)) return;
  72.  
  73.   AppSettings& s = AfxGetAppSettings();
  74.  
  75.   if(rtStart == 0){
  76.     CString fn;
  77.     fn = pli.m_fns.GetHead(); 获得文件路径
  78.  
  79.     // SVP_LogMsg5(L"GetFav Start1 %s", fn);
  80.     favtype ft ;
  81.     ft = FAV_FILE;
  82.  
  83.     if (!fn.IsEmpty() && s.autoResumePlay){
  84.       文件存在 且 自动恢复播放
  85.       std::string str = Strings::WStringToString(fn.GetBuffer());
  86.       CString szMatchmd5 = HashController::GetInstance()->GetMD5Hash(str.c_str(), str.length()).c_str();
  87.  
  88.       SVP_LogMsg5(L"GetFav Start %s", szMatchmd5);
  89.  
  90.       CAtlList<CString> sl;
  91.       s.GetFav(ft, sl, TRUE); 得到以前保存的数据
  92.  
  93.       CString PosStr ;
  94.       POSITION pos = sl.GetHeadPosition(); 获得
  95.       while(pos){   //判断以前是否播放过
  96.         PosStr = sl.GetNext(pos) ;
  97.         if( PosStr.Find(szMatchmd5 + _T(";")) == 0 ){
  98.           break;
  99.         }else{
  100.           PosStr.Empty();
  101.         }
  102.       }
  103.       if(!PosStr.IsEmpty()){  如果未播放 则记录
  104.  
  105.  
  106.         int iPos = PosStr.ReverseFind( _T(';') );
  107.         if(iPos >= 0){
  108.           CString s2 = PosStr.Right( PosStr.GetLength() - iPos - 1 );
  109.           _stscanf(s2, _T("%I64d"), &rtStart); // pos
  110.         }
  111.         SVP_LogMsg5(L"Got %f", double(rtStart) );
  112.       }
  113.       是否恢复退出时的状态
  114.       m_is_resume_from_last_exit_point = TRUE;
  115.       //SVP_LogMsg5(L"GetFav Done");
  116.     }
  117.   }else if(rtStart == -1){
  118.     rtStart = 0;
  119.   }
  120.   
  121.    打开媒体文件  根据OpenMediaData*初始化 OpenMediaData里面保存了路径和rtStart
  122.   CAutoPtr<OpenMediaData> p(m_wndPlaylistBar.GetCurOMD(rtStart));
  123.  
  124.   if(p) OpenMedia(p); 根据CAutoPtr<OpenMediaData> 进行打开播放
  125. }
  126.  
  127.  
  128.   进入OpenMedia进行 打开播放
  129. void CMainFrame::OpenMedia(CAutoPtr<OpenMediaData> pOMD)
  130. {
  131.   // shortcut 
  132.   if(OpenDeviceData* p = dynamic_cast<OpenDeviceData*>(pOMD.m_p))
  133.   {
  134.     如果是DeviceData数据 
  135.     if(m_iMediaLoadState == MLS_LOADED && pAMTuner
  136.       && m_VidDispName == p->DisplayName[0] && m_AudDispName == p->DisplayName[1])
  137.     {
  138.       m_wndCaptureBar.m_capdlg.SetVideoInput(p->vinput);
  139.       m_wndCaptureBar.m_capdlg.SetVideoChannel(p->vchannel);
  140.       m_wndCaptureBar.m_capdlg.SetAudioInput(p->ainput);
  141.       return;
  142.     }
  143.   }
  144.  
  145.   如果当前正在播放则关闭
  146.   if(m_iMediaLoadState != MLS_CLOSED)
  147.     CloseMedia();
  148.  
  149.   更改状态
  150.   m_iMediaLoadState = MLS_LOADING; // HACK: hides the logo
  151.   m_wndView.Invalidate();
  152.  
  153.   AppSettings& s = AfxGetAppSettings();
  154.  
  155.   bool fUseThread = true;
  156.  
  157.   if(OpenFileData* p = dynamic_cast<OpenFileData*>(pOMD.m_p))
  158.   {
  159.      如果是打开的文件
  160.     if(p->fns.GetCount() > 0)
  161.     {
  162.       解码类型
  163.       engine_t e = s.Formats.GetEngine(p->fns.GetHead());
  164.       如果是DirectShow  类型  只有.ram .rm .ra .qt .mov .ram 不需要
  165.       fUseThread = e == DirectShow /*|| e == RealMedia || e == QuickTime*/;
  166.     }
  167.   }
  168.   else if(OpenDeviceData* p = dynamic_cast<OpenDeviceData*>(pOMD.m_p))
  169.   {
  170.     fUseThread = false;
  171.   }
  172.  
  173.    如果渲染线程存在 且 需要使用线程 且 需要打开工作线程
  174.   if(m_pGraphThread && fUseThread&&AfxGetAppSettings().fEnableWorkerThreadForOpening)
  175.     m_pGraphThread->PostThreadMessage(CGraphThread::TM_OPEN, 0, (LPARAM)pOMD.Detach());
  176.   else
  177.     OpenMediaPrivate(pOMD);
  178. }
  179.  
  180. 进入 CGraphThread::TM_OPEN 事件  用一个新的线程打开播放文件
  181. void CGraphThread::OnOpen(WPARAM wParam, LPARAM lParam)
  182. {
  183.   if(m_pMainFrame)
  184.   {
  185.     CAutoPtr<OpenMediaData> pOMD((OpenMediaData*)lParam);
  186.     m_pMainFrame->OpenMediaPrivate(pOMD);
  187.   }
  188. }
  189.  
  190. 进入OpenMediaPrivate 分析
  191. bool CMainFrame::OpenMediaPrivate(CAutoPtr<OpenMediaData> pOMD)
  192. {
  193.   CString err, aborted(_T("Aborted"));
  194.   AppSettings& s = AfxGetAppSettings(); 获得设置信息
  195.  
  196.   {
  197.     打开关闭锁
  198.     CAutoLock mOpenCloseLock(&m_csOpenClose);
  199.     s.bIsIVM = false;
  200.     s.szCurrentExtension.Empty();
  201.  
  202.     如果状态不是关闭 且 不是正在加载  则出错
  203.     一定要是加载状态 或是关闭状态
  204.     if(m_iMediaLoadState != MLS_CLOSED && m_iMediaLoadState != MLS_LOADING)
  205.     {
  206.       ASSERT(0);
  207.       return(false);
  208.     }
  209.  
  210.     s.bExternalSubtitleTime = false;
  211.  
  212.     设置Slider
  213.     m_wndSeekBar.SetRange(0, 100);
  214.  
  215.     记录
  216.     s.szFGMLog.Empty();
  217.  
  218.     设置声道
  219.     s.SetNumberOfSpeakers(s.iDecSpeakers , -1);
  220.  
  221.     正在加载状态
  222.     m_iMediaLoadState = MLS_LOADING;
  223.  
  224.     2.5秒加载
  225.     SetTimer(TIMER_LOADING, 2500, NULL); 
  226.  
  227.     不显示关闭
  228.     // FIXME: Don't show "Closed" initially
  229.     PostMessage(WM_KICKIDLE);              调用主线程更新的东西
  230.  
  231.     m_fUpdateInfoBar = false;
  232.  
  233.     try
  234.     {
  235.       打开终止 异常
  236.       if(m_fOpeningAborted) throw aborted;
  237.  
  238.       if(OpenFileData* pOFD = dynamic_cast<OpenFileData*>(pOMD.m_p))
  239.       {
  240.         文件不存在异常
  241.         if(pOFD->fns.IsEmpty()) throw ResStr(IDS_MSG_THROW_FILE_NOT_FOUND);
  242.  
  243.         CString fn = pOFD->fns.GetHead();
  244.  
  245.         取出格式
  246.         s.szCurrentExtension = fn.Right(4).MakeLower();
  247.  
  248.         格式比较
  249.         .ivm格式
  250.         if(s.szCurrentExtension == _T(".ivm"))
  251.           s.bIsIVM = true;
  252.  
  253.         s.bDisableSoftCAVCForce = false;
  254.         
  255.         .mkv格式
  256.         if(!(s.useGPUAcel && s.bHasCUDAforCoreAVC) && !s.bDisableSoftCAVC 
  257.              && s.szCurrentExtension == _T(".mkv"))
  258.         {
  259.           FILE* fp;
  260.           if ( _wfopen_s( &fp, fn, _T("rb")) == 0)
  261.           {
  262.             char matchbuf[0x4000];
  263.             size_t iRead = fread(matchbuf, sizeof( char ), 0x4000 ,fp);
  264.             if( iRead > 200 && find_string_in_buf(matchbuf, iRead-100, "wpredp=2") > 0 )
  265.               s.bDisableSoftCAVCForce = true;
  266.  
  267.             fclose(fp);
  268.           }
  269.         }
  270.  
  271.         int i = fn.Find(_T(":\\"));
  272.         if(i > 0)
  273.         {
  274.           判断文件所在盘
  275.           CString drive = fn.Left(i+2);
  276.           UINT type = GetDriveType(drive);
  277.           CAtlList<CString> sl;
  278.  
  279.            可移动的 驱动  
  280.           if(type == DRIVE_REMOVABLE || type == DRIVE_CDROM && GetCDROMType(drive[0], sl) != CDROM_Audio)
  281.           {
  282.             int ret = IDRETRY;
  283.             while(ret == IDRETRY)
  284.             {
  285.               WIN32_FIND_DATA findFileData;
  286.               HANDLE h = FindFirstFile(fn, &findFileData);
  287.               if(h != INVALID_HANDLE_VALUE)
  288.               {
  289.                 FindClose(h);
  290.                 ret = IDOK;
  291.               }
  292.               else
  293.               {
  294.                 CString msg;
  295.                 msg.Format(ResStr(IDS_MSG_WARN_NOT_FOUND_AND_PLS_INSERT_DISK), fn);
  296.                 ret = AfxMessageBox(msg, MB_RETRYCANCEL);
  297.               }
  298.             }
  299.  
  300.             if(ret != IDOK) throw aborted;
  301.           }else{
  302.             否则是本地盘  判断文件是否存在
  303.             CSVPToolBox svpTool;
  304.             if(!svpTool.ifFileExist(fn, true)){
  305.               //SVP_LogMsg5(L"SVP 文件不存在" );
  306.               throw ResStr(IDS_MSG_THROW_FILE_NOT_EXIST);
  307.             }
  308.           }
  309.         }
  310.       }
  311.  
  312.       打开终止异常
  313.       if(m_fOpeningAborted) throw aborted;
  314.  
  315.       创建渲染对象  关键一
  316.       OpenCreateGraphObject(pOMD);   待分析
  317.  
  318.       打开终止异常
  319.       if(m_fOpeningAborted) throw aborted;
  320.  
  321.       m_pCAP2 = NULL;
  322.       m_pCAP = NULL;
  323.       m_pSVPSub = NULL;
  324.  
  325.       判断打开的文件的类型  待分析
  326.       if(OpenFileData* p = dynamic_cast<OpenFileData*>(pOMD.m_p)) OpenFile(p);
  327.       else if(OpenDVDData* p = dynamic_cast<OpenDVDData*>(pOMD.m_p)) OpenDVD(p);
  328.       else if(OpenDeviceData* p = dynamic_cast<OpenDeviceData*>(pOMD.m_p)) OpenCapture(p);
  329.       else throw _T("Can't open, invalid input parameters");
  330.  
  331.       查找相关接口
  332.       pGB->FindInterface(__uuidof(ISubPicAllocatorPresenter), (void**)&m_pCAP, FALSE);
  333.       pGB->FindInterface(__uuidof(ISubPicAllocatorPresenterRender), (void**)&m_pCAPR, TRUE);
  334.       pGB->FindInterface(__uuidof(ISubPicAllocatorPresenter2), (void**)&m_pCAP2, TRUE);
  335.       pGB->FindInterface(__uuidof(IVMRMixerControl9),(void**)&m_pMC,  TRUE);
  336.  
  337.        如果未找到 则用另外一种方法查找
  338.       if(!m_pCAP){
  339.         CComQIPtr<ISubPicAllocatorPresenter> pCAP =  FindFilter(__uuidof(CSVPSubFilter), pGB);
  340.         if(pCAP){
  341.           m_pCAP = pCAP;
  342.           CComQIPtr<ISVPSubFilter> pSVPSub= pCAP;
  343.           if(pSVPSub)
  344.             m_pSVPSub = pSVPSub;
  345.         }
  346.       }
  347.  
  348.        如果找到 则进行相关操作
  349.       if (m_pMC)
  350.       {
  351.         if (SetVMR9ColorControl(s.dBrightness, s.dContrast, s.dHue, s.dSaturation) == FALSE)
  352.           OsdMsg_SetShader();
  353.         else
  354.         {
  355.           CString  szMsg;
  356.           szMsg.Format(ResStr(IDS_OSD_MSG_BRIGHT_CONTRAST_CHANGED), s.dBrightness, s.dContrast);
  357.           SendStatusMessage(szMsg, 3000);
  358.         }
  359.         SetShaders(true);
  360.       }
  361.  
  362.       // === EVR !
  363.       pGB->FindInterface(__uuidof(IMFVideoDisplayControl), (void**)&m_pMFVDC,  TRUE);
  364.       if (m_pMFVDC)
  365.       {
  366.         RECT Rect;
  367.         ::GetClientRect (m_wndView.m_hWnd, &Rect);
  368.         m_pMFVDC->SetVideoWindow (m_wndView.m_hWnd);
  369.         m_pMFVDC->SetVideoPosition(NULL, &Rect);
  370.       }
  371.  
  372.       打开终止异常
  373.       if(m_fOpeningAborted) throw aborted;
  374.  
  375.       打开自定义大小的图像
  376.       OpenCustomizeGraph();   待分析
  377.  
  378.       打开终止异常
  379.       if(m_fOpeningAborted) throw aborted;
  380.  
  381.       打开初始化视频
  382.       OpenSetupVideo();    待分析
  383.  
  384.       打开终止异常
  385.       if(m_fOpeningAborted) throw aborted;
  386.  
  387.       打开初始化音频
  388.       OpenSetupAudio();    待分析
  389.  
  390.       打开终止异常
  391.       if(m_fOpeningAborted) throw aborted;
  392.  
  393.       打开终止异常
  394.       if(m_fOpeningAborted) throw aborted;
  395.  
  396.       改变声道
  397.       if(m_iAudioChannelMaping)
  398.         OnAudioChannalMapMenu(IDS_AUDIOCHANNALMAPNORMAL+m_iAudioChannelMaping);  待分析
  399.  
  400.       加载完毕
  401.       m_iMediaLoadState = MLS_LOADED;
  402.  
  403.       记录开始播放时间
  404.       time(&m_tPlayStartTime);
  405.  
  406.       发送暂停消息
  407.       PostMessage(WM_COMMAND, ID_PLAY_PAUSE);  待分析
  408.  
  409.       如果是打开  则发送播放消息
  410.       if(!(AfxGetAppSettings().nCLSwitches&CLSW_OPEN))
  411.         PostMessage(WM_COMMAND, ID_PLAY_PLAY);          待分析
  412.  
  413.       AfxGetAppSettings().nCLSwitches &= ~CLSW_OPEN;
  414.  
  415.       if(OpenFileData* p = dynamic_cast<OpenFileData*>(pOMD.m_p))
  416.       {
  417.         如果有记录 则跳到记录位置
  418.         if(p->rtStart > 0)
  419.           PostMessage(WM_RESUMEFROMSTATE, (WPARAM)PM_FILE, (LPARAM)(p->rtStart/10000)); // REFERENCE_TIME doesn't fit in LPARAM under a 32bit env.
  420.       }
  421.       else if(OpenDVDData* p = dynamic_cast<OpenDVDData*>(pOMD.m_p))
  422.       {
  423.         if(p->pDvdState)
  424.           PostMessage(WM_RESUMEFROMSTATE, (WPARAM)PM_DVD, (LPARAM)(CComPtr<IDvdState>(p->pDvdState).Detach())); // must be released by the called message handler
  425.       }
  426.       else if(OpenDeviceData* p = dynamic_cast<OpenDeviceData*>(pOMD.m_p))
  427.       {
  428.         m_wndCaptureBar.m_capdlg.SetVideoInput(p->vinput);
  429.         m_wndCaptureBar.m_capdlg.SetVideoChannel(p->vchannel);
  430.         m_wndCaptureBar.m_capdlg.SetAudioInput(p->ainput);
  431.       }
  432.  
  433.       进行加载字幕
  434.       if(m_pCAP && (!m_fAudioOnly || m_fRealMediaGraph))
  435.       {
  436.         POSITION pos = pOMD->subs.GetHeadPosition();
  437.         while(pos){ LoadSubtitle(pOMD->subs.GetNext(pos));}
  438.       }
  439.  
  440.       当前进程是不是主线程
  441.       if(::GetCurrentThreadId() == AfxGetApp()->m_nThreadID)
  442.       {
  443.         OnFilePostOpenmedia();
  444.       }
  445.       else
  446.       {
  447.         PostMessage(WM_COMMAND, ID_FILE_POST_OPENMEDIA);    待分析
  448.       }
  449.  
  450.       初始化标题
  451.       OpenSetupWindowTitle(pOMD->title);    待分析
  452.  
  453.       初始化打开时间
  454.       time_t tOpening = time(NULL);
  455.  
  456.       当状态不是加载完成或正在加载 则循环  还在加载前则循环
  457.       while(m_iMediaLoadState != MLS_LOADED 
  458.         && m_iMediaLoadState != MLS_CLOSING // FIXME
  459.         )
  460.       {
  461.         if( (time(NULL) - tOpening) > 10)
  462.           throw aborted;
  463.         Sleep(50);
  464.       }
  465.     }
  466.     catch(LPCTSTR msg)
  467.     {
  468.       err = msg;
  469.     }
  470.     catch(CString msg)
  471.     {
  472.       err = msg;
  473.     }
  474.   }
  475.  
  476.   if(!err.IsEmpty())
  477.   {
  478.     存在错误
  479.     SendStatusMessage(err, 3000);
  480.     CloseMediaPrivate();
  481.     m_closingmsg = err;
  482.  
  483.     OpenFileData* p = dynamic_cast<OpenFileData*>(pOMD.m_p);
  484.     if(p && err != aborted)
  485.     {
  486.       m_wndPlaylistBar.SetCurValid(false);
  487.       if(m_wndPlaylistBar.GetCount() > 1)
  488.       {
  489.         CPlaylistItem pli[2];
  490.         m_wndPlaylistBar.GetCur(pli[0]);
  491.         m_wndPlaylistBar.SetNext();
  492.         m_wndPlaylistBar.GetCur(pli[1]);
  493.         if(pli[0].m_id != pli[1].m_id)
  494.         {
  495.           //CAutoPtr<OpenMediaData> p(m_wndPlaylistBar.GetCurOMD());
  496.           //if(p) OpenMediaPrivate(p);
  497.         }
  498.       }
  499.     }
  500.   }
  501.   else
  502.   {
  503.     m_wndPlaylistBar.SetCurValid(true);  列表设置
  504.   }
  505.  
  506.   调用主线程更新的东西
  507.   PostMessage(WM_KICKIDLE); // calls main thread to update things  
  508.   return(err.IsEmpty());
  509. }
  510.  
  511. ————————————————————————————————————————————
  512.  2.5秒 循环载入
  513.   case TIMER_LOADING:
  514.     {
  515.       KillTimer(TIMER_LOADING);
  516.       if (IsSomethingLoading())
  517.       {
  518.         SetTimer( TIMER_LOADING , 1000, NULL);
  519.         CString msg;
  520.         if (m_fBuffering)
  521.         {
  522.           BeginEnumFilters(pGB, pEF, pBF)
  523.           {
  524.             if (CComQIPtr<IAMNetworkStatus, &IID_IAMNetworkStatus> pAMNS = pBF)
  525.             {
  526.               long BufferingProgress = 0;
  527.               if (SUCCEEDED(pAMNS->get_BufferingProgress(&BufferingProgress)) && BufferingProgress > 0 && BufferingProgress < 99)
  528.               {
  529.                 msg.Format(ResStr(IDS_CONTROLS_BUFFERING), BufferingProgress);
  530.                 SendStatusMessage(msg,1000);
  531.                 SVP_LogMsg5(msg);
  532.               }
  533.               break;
  534.             }
  535.           }
  536.           EndEnumFilters
  537.         }
  538.         else if (pAMOP)
  539.         {
  540.           __int64 t = 0, c = 0;
  541.           if (SUCCEEDED(pAMOP->QueryProgress(&t, &c)) && t > 0 && c < t)
  542.           {
  543.             msg.Format(ResStr(IDS_CONTROLS_BUFFERING), c*100/t);
  544.             SendStatusMessage(msg,1000);
  545.             SVP_LogMsg5(msg);
  546.           }
  547.         }
  548.         else
  549.           SendStatusMessage(ResStr(IDS_CONTROLS_OPENING), 1000);
  550.       }
  551.     }
  552.     break;
  553.  
  554.    进入CMainFrame::OpenCreateGraphObject  分析
  555. void CMainFrame::OpenCreateGraphObject(OpenMediaData* pOMD)
  556. {
  557.   解码接口不为空
  558.   ASSERT(pGB == NULL);
  559.   m_fCustomGraph = false;
  560.   m_fRealMediaGraph = m_fShockwaveGraph = m_fQuicktimeGraph = false;
  561.  
  562.   AppSettings& s = AfxGetAppSettings();
  563.  
  564.   if(OpenFileData* p = dynamic_cast<OpenFileData*>(pOMD))
  565.   {
  566.     获得解码类型
  567.     engine_t engine = s.Formats.GetEngine(p->fns.GetHead());
  568.  
  569.     std::wstring ct = ContentType::Get(p->fns.GetHead());
  570.  
  571.     if(ct == L"video/x-ms-asf")
  572.     {
  573.       // TODO: put something here to make the windows media source filter load later
  574.     }
  575.     else if (ct == L"audio/x-pn-realaudio"
  576.       || ct == L"audio/x-pn-realaudio-plugin"
  577.       || ct == L"audio/x-realaudio-secure"
  578.       || ct == L"video/vnd.rn-realvideo-secure"
  579.       || ct == L"application/vnd.rn-realmedia"
  580.       || ct.find(L"vnd.rn-") != ct.npos
  581.       || ct.find(L"realaudio") != ct.npos
  582.       || ct.find(L"realvideo") != ct.npos)
  583.     {
  584.       // TODO: go fuck this!!!
  585.       engine = RealMedia;
  586.     }
  587.     else if (ct == L"application/x-shockwave-flash")
  588.     {
  589.       engine = ShockWave;
  590.     }
  591.     else if (ct == L"video/quicktime"
  592.       || ct == L"application/x-quicktimeplayer")
  593.     {
  594.       engine = QuickTime;
  595.     }
  596.     if (engine == RealMedia)
  597.       engine = DirectShow;
  598.  
  599.     SVP_LogMsg5(L"got content type %s %d", ct.c_str(), engine );
  600.  
  601.     HRESULT hr;
  602.     CComPtr<IUnknown> pUnk;
  603.  
  604.     if(engine == RealMedia)
  605.     { 
  606.       if(!(pUnk = (IUnknown*)(INonDelegatingUnknown*)new CRealMediaGraph(m_wndView.m_hWnd, hr)))
  607.         throw _T("Out of memory");
  608.  
  609.       if(SUCCEEDED(hr) && !!(pGB = CComQIPtr<IGraphBuilder>(pUnk)))
  610.         m_fRealMediaGraph = true;
  611.     }
  612.     else if(engine == ShockWave)
  613.     {
  614.       if(!(pUnk = (IUnknown*)(INonDelegatingUnknown*)new CShockwaveGraph(m_wndView.m_hWnd, hr)))
  615.         throw _T("Out of memory");
  616.  
  617.       if(FAILED(hr) || !(pGB = CComQIPtr<IGraphBuilder>(pUnk)))
  618.         throw _T("Can't create shockwave control");
  619.  
  620.       m_fShockwaveGraph = true;
  621.     }
  622.     else if(engine == QuickTime)
  623.     {
  624.       if(!(pUnk = (IUnknown*)(INonDelegatingUnknown*)new CQuicktimeGraph(m_wndView.m_hWnd, hr)))
  625.         throw _T("Out of memory");
  626.  
  627.       if(SUCCEEDED(hr) && !!(pGB = CComQIPtr<IGraphBuilder>(pUnk)))
  628.         m_fQuicktimeGraph = true;
  629.     }
  630.  
  631.     m_fCustomGraph = m_fRealMediaGraph || m_fShockwaveGraph || m_fQuicktimeGraph;
  632.  
  633.     if(!m_fCustomGraph)
  634.     {
  635.       视频播放解码 生成接口
  636.       pGB = new CFGManagerPlayer(_T("CFGManagerPlayer"), NULL, s.SrcFilters, s.TraFilters, m_wndView.m_hWnd);
  637.     }
  638.   }
  639.   else if(OpenDVDData* p = dynamic_cast<OpenDVDData*>(pOMD))
  640.   {
  641.     pGB = new CFGManagerDVD(_T("CFGManagerDVD"), NULL, s.SrcFilters, s.TraFilters, m_wndView.m_hWnd);
  642.   }
  643.   else if(OpenDeviceData* p = dynamic_cast<OpenDeviceData*>(pOMD))
  644.   {
  645.     pGB = new CFGManagerCapture(_T("CFGManagerCapture"), NULL, s.SrcFilters, s.TraFilters, m_wndView.m_hWnd);
  646.   }
  647.  
  648.   if(!pGB)
  649.   {
  650.     throw _T("Failed to create the filter graph object");
  651.   }
  652.  
  653.   pGB->AddToROT();
  654.  
  655.   把视频解码接口赋值给其它
  656.   pMC = pGB; pME = pGB; pMS = pGB; // general
  657.   pVW = pGB; pBV = pGB; // video
  658.   pBA = pGB; // audio
  659.   pFS = pGB;
  660.  
  661.   if(!(pMC && pME && pMS)
  662.     || !(pVW && pBV)
  663.     || !(pBA))
  664.   {
  665.     throw ResStr(IDS_MSG_THROW_BROKEN_DIRECTX_SUPPORT);
  666.   }
  667.  
  668.   发送WM_GRAPHNOTIFY 消息
  669.   if(FAILED(pME->SetNotifyWindow((OAHWND)m_hWnd, WM_GRAPHNOTIFY, 0)))
  670.   {
  671.     throw _T("Could not set target window for graph notification");
  672.   }
  673.  
  674.   m_pProv = (IUnknown*)new CKeyProvider();   键盘提供者接口
  675.  
  676.   if(CComQIPtr<IObjectWithSite> pObjectWithSite = pGB)
  677.     pObjectWithSite->SetSite(m_pProv);     键盘站点  捕获键盘消息
  678.  
  679.  
  680.   m_pCB = new CDSMChapterBag(NULL, NULL); dstuil库中类
  681. }
  682.  
  683.   进入OpenFile分析
  684. void CMainFrame::OpenFile(OpenFileData* pOFD)
  685. {
  686.   if(pOFD->fns.IsEmpty())   文件为空  则抛出异常
  687.     throw _T("Invalid argument");
  688.  
  689.   AppSettings& s = AfxGetAppSettings();  获得设置信息
  690.  
  691.   bool fFirst = true;
  692.  
  693.   POSITION pos = pOFD->fns.GetHeadPosition();
  694.   while(pos)
  695.   {
  696.     CString fn = pOFD->fns.GetNext(pos);
  697.  
  698.     fn.Trim();
  699.     if(fn.IsEmpty() && !fFirst)
  700.       break;
  701.  
  702.     CString fnLower = fn;
  703.     fnLower.MakeLower();
  704.  
  705.     HRESULT hr = -1;
  706.     如果不是mms://路径或mmsh://路径
  707.     if(FAILED(hr) && ( fnLower.Find(_T("mms://")) == 0 || fnLower.Find(_T("mmsh://")) == 0 )){ // 
  708.       //render mms our own way
  709.       hr = OpenMMSUrlStream(fn);
  710.     }
  711.     if(FAILED(hr))  渲染文件  持续了很长时间
  712.       hr = pGB->RenderFile(CStringW(fn), NULL);  
  713.  
  714.     如果是网络文件  则大概网络流
  715.     if(FAILED(hr) && ( fnLower.Find(_T("http") == 0 || fnLower.Find(_T("https://")) == 0
  716.       || fnLower.Find(_T("udp://")) == 0 || fnLower.Find(_T("tcp://")) == 0)) ){ // 
  717.         //render mms our own way
  718.         hr = OpenMMSUrlStream(fn);
  719.     }
  720.  
  721.     /* not sure why this is not work for http youku etc  不知道这是为什么不适用于HTTP优酷等
  722.     HRESULT hr = -1;
  723.     if( ( fn.MakeLower().Find(_T("mms://")) == 0 || fn.MakeLower().Find(_T("mmsh://")) == 0 || (fn.MakeLower().Find(_T("http:")) == 0 && fn.MakeLower().Find(_T(":8902")) > 0 ))){ 
  724.     //render mms our own way 
  725.     hr = OpenMMSUrlStream(fn);
  726.     }
  728.     if(FAILED(hr))
  729.     hr = pGB->RenderFile(CStringW(fn), NULL);
  730.     */
  731.  
  732.     依然失败 则寻找错误  记录错误
  733.     if(FAILED(hr))
  734.     {
  735.       if(fFirst)
  736.       {
  737.         //if(s.fReportFailedPins)
  738.         {
  739.           CComQIPtr<IGraphBuilderDeadEnd> pGBDE = pGB;
  740.           if(pGBDE && pGBDE->GetCount()) CMediaTypesDlg(pGBDE, this).DoModal();
  741.         }
  742.  
  743.         CString err;
  744.  
  745.         switch(hr)
  746.         {
  747.         case E_ABORT: err = ResStr(IDS_MSG_THROW_OPRATION_CANCELED); break;
  748.         case E_FAIL: case E_POINTER: default: 
  749.           err.Format(ResStr(IDS_MSG_THROW_UNABLE_OPEN_FILE) , hr);
  750.           break;
  751.         case E_INVALIDARG: err = ResStr(IDS_MSG_THROW_ILLEGE_FILENAME); break;
  752.         case E_OUTOFMEMORY: err = ResStr(IDS_MSG_THROW_OUTOF_MEMORY); break;
  753.         case VFW_E_CANNOT_CONNECT: err = ResStr(IDS_MSG_THROW_UNABLE_DECODE); break;
  754.         case VFW_E_CANNOT_LOAD_SOURCE_FILTER: err = ResStr(IDS_MSG_THROW_UNSUPPORT_SOURCE); break;
  755.         case VFW_E_CANNOT_RENDER: err = ResStr(IDS_MSG_THROW_FAIL_CREATE_RENDER); break;
  756.         case VFW_E_INVALID_FILE_FORMAT: err = _T("Invalid file format"); break;
  757.         case VFW_E_NOT_FOUND: err = ResStr(IDS_MSG_THROW_FILE_NOT_FOUND); break;
  758.         case VFW_E_UNKNOWN_FILE_TYPE: err = ResStr(IDS_MSG_THROW_UNKNOWN_FILE_TYPE); break;
  759.         case VFW_E_UNSUPPORTED_STREAM: err = ResStr(IDS_MSG_THROW_UNSUPPORT_STREAM_TYPE); break;
  760.         }
  761.  
  762.         throw err;
  763.       }
  764.     }
  765.  
  766.     是否保存记录
  767.     if(s.fKeepHistory)
  768.     {
  769.       if(this->m_lastUrl == fn){   本次与上次是否相同
  770.         CRecentFileList* pMRU = &s.MRUUrl;
  771.         pMRU->ReadList();
  772.         pMRU->Add(fn);
  773.         pMRU->WriteList();
  774.         this->m_lastUrl.Empty();
  775.       }else{
  776.         不同则写入
  777.         CRecentFileList* pMRU = fFirst ? &s.MRU : &s.MRUDub;
  778.         pMRU->ReadList();
  779.         pMRU->Add(fn);
  780.         pMRU->WriteList();
  781.       }
  782.     }
  783.  
  784.     if(fFirst)  第一次运行？ 搜索字幕
  785.     {
  786.       AppSettings& s = AfxGetAppSettings();
  787.       pOFD->title = fn;
  788.       m_fnCurPlayingFile = fn;
  789.       //是否有字幕？ 沒有则下载字幕
  790.       CSVPToolBox svpTool;
  791.       //搜索目录下同名字幕
  792.       CAtlArray<CString> subSearchPaths;
  793.       subSearchPaths.Add(_T("."));
  794.       subSearchPaths.Add(s.GetSVPSubStorePath());
  795.       subSearchPaths.Add(svpTool.GetPlayerPath(L"SVPSub"));
  796.       subSearchPaths.Add(_T(".\\subtitles"));
  797.       subSearchPaths.Add(_T(".\\Subs"));
  798.       subSearchPaths.Add(_T("c:\\subtitles"));
  799.  
  800.       CAtlArray<SubFile> ret;
  801.  
  802.       POSITION pos = pOFD->subs.GetHeadPosition();
  803.       while(pos){
  804.         POSITION cur = pos;
  805.         CString szSubFn = pOFD->subs.GetNext(pos);
  806.         if(!svpTool.ifFileExist(szSubFn))
  807.           pOFD->subs.RemoveAt(cur);
  808.       }
  809.       CSVPRarLib svpRar;
  810.       if( svpRar.SplitPath(fn) ){
  811.         GetSubFileNames(svpRar.m_fnRAR, subSearchPaths, ret);
  812.         CAtlArray<SubFile> ret2;
  813.         GetSubFileNames(svpRar.m_fnInsideRar, subSearchPaths, ret2);
  814.         ret.Append(ret2);
  815.       }else{
  816.         GetSubFileNames(fn, subSearchPaths, ret);
  817.         //AfxMessageBox(fn);
  818.       }
  819.       for(int i = 0; i < ret.GetCount(); i++){
  820.         SubFile szBuf = ret.GetAt(i);
  821.         //AfxMessageBox(szBuf.fn);
  822.         if ( pOFD->subs.Find( szBuf.fn ) == NULL && svpTool.ifFileExist(szBuf.fn)){
  823.           pOFD->subs.AddTail(szBuf.fn);
  824.           //AfxMessageBox(szBuf.fn);
  825.         }
  826.       }
  827.       //AfxMessageBox(_T("1"));
  828.       if ( pOFD->subs.GetCount() <= 0){
  829.         // AfxMessageBox(_T("2"));
  830.  
  831.  
  832.  
  833.  
  834.         if(s.autoDownloadSVPSub){
  835.           CPath fPath(fn);
  836.           CString szExt;
  837.           szExt.Format(_T(" %s;"),fPath.GetExtension());
  838.           if(s.CheckSVPSubExts.Find(szExt) >= 0 ){
  839.             SVPSubDownloadByVPath(fn);
  840.           }else{
  841.             //SendStatusMessage(  _T("正在播放的文件类型看来不需要字幕，终止自动智能匹配"), 1000);
  842.           }
  843.         }
  844.       }
  845.     }
  846.     fFirst = false;
  847.  
  848.     if(m_fCustomGraph) break;
  849.   }   智能匹配字幕结束
  850.  
  851.   //if(s.fReportFailedPins)
  852.   {  如果绘图挂了 类型对话框弹出
  853.     CComQIPtr<IGraphBuilderDeadEnd> pGBDE = pGB;
  854.     if(pGBDE && pGBDE->GetCount()) CMediaTypesDlg(pGBDE, this).DoModal();
  855.   }   
  856.  
  857.   if(!(pAMOP = pGB))
  858.   {
  859.     BeginEnumFilters(pGB, pEF, pBF)
  860.       if(pAMOP = pBF) break;
  861.     EndEnumFilters
  862.   }
  863.  
  864.   if(FindFilter(__uuidof(CShoutcastSource), pGB))
  865.     m_fUpdateInfoBar = true;
  866.  
  867.   SetupChapters();  初始化章节
  868.  
  869.   枚举 寻找IKeyFrameInfo 接口
  870.   CComQIPtr<IKeyFrameInfo> pKFI;
  871.   BeginEnumFilters(pGB, pEF, pBF)
  872.     if(pKFI = pBF) break;
  873.   EndEnumFilters
  874.     UINT nKFs = 0, nKFsTmp = 0;
  875.   if(pKFI && S_OK == pKFI->GetKeyFrameCount(nKFs) && nKFs > 0)
  876.   {
  877.     m_kfs.SetCount(nKFsTmp = nKFs);
  878.     if(S_OK != pKFI->GetKeyFrames(&TIME_FORMAT_MEDIA_TIME, m_kfs.GetData(), nKFsTmp) || nKFsTmp != nKFs)
  879.       m_kfs.RemoveAll();
  880.   }
  881.  
  882.   m_iPlaybackMode = PM_FILE;
  883. }
  884.  
  885. 进入SetupChapters() 初始化章节
  886. void CMainFrame::SetupChapters()
  887. {
  888.   ASSERT(m_pCB); 解码不为空
  889.  
  890.   m_pCB->ChapRemoveAll();
  891.  
  892.   查找过滤接口  并添加到pBFs
  893.   CInterfaceList<IBaseFilter> pBFs;
  894.   BeginEnumFilters(pGB, pEF, pBF) 
  895.     pBFs.AddTail(pBF);
  896.   EndEnumFilters
  897.   
  898.     POSITION pos;
  899.  
  900.   循环遍历过滤接口 进行追加操作 具体什么 待分析
  901.   pos = pBFs.GetHeadPosition();
  902.   while(pos && !m_pCB->ChapGetCount())
  903.   {
  904.     IBaseFilter* pBF = pBFs.GetNext(pos);
  905.  
  906.     CComQIPtr<IDSMChapterBag> pCB = pBF;
  907.     if(!pCB) continue;
  908.  
  909.     for(DWORD i = 0, cnt = pCB->ChapGetCount(); i < cnt; i++)
  910.     {
  911.       REFERENCE_TIME rt;
  912.       CComBSTR name;
  913.       if(SUCCEEDED(pCB->ChapGet(i, &rt, &name)))
  914.         m_pCB->ChapAppend(rt, name);
  915.     }
  916.   }
  917.  
  918.   循环遍历过滤接口 进行追加操作 具体什么 待分析
  919.   pos = pBFs.GetHeadPosition();
  920.   while(pos && !m_pCB->ChapGetCount())
  921.   {
  922.     IBaseFilter* pBF = pBFs.GetNext(pos);
  923.  
  924.     CComQIPtr<IChapterInfo> pCI = pBF;
  925.     if(!pCI) continue;
  926.  
  927.     CHAR iso6391[3];
  928.     ::GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_SISO639LANGNAME, iso6391, 3);
  929.     CStringA iso6392 = ISO6391To6392(iso6391);
  930.     if(iso6392.GetLength() < 3) iso6392 = "eng";
  931.  
  932.     UINT cnt = pCI->GetChapterCount(CHAPTER_ROOT_ID);
  933.     for(UINT i = 1; i <= cnt; i++)
  934.     {
  935.       UINT cid = pCI->GetChapterId(CHAPTER_ROOT_ID, i);
  936.  
  937.       ChapterElement ce;
  938.       if(pCI->GetChapterInfo(cid, &ce))
  939.       {
  940.         char pl[3] = {iso6392[0], iso6392[1], iso6392[2]};
  941.         char cc[] = "  ";
  942.         CComBSTR name;
  943.         name.Attach(pCI->GetChapterStringInfo(cid, pl, cc));
  944.         m_pCB->ChapAppend(ce.rtStart, name);
  945.       }
  946.     }
  947.   }
  948.  
  949.   循环遍历过滤接口 进行追加操作 具体什么 待分析
  950.   pos = pBFs.GetHeadPosition();
  951.   while(pos && !m_pCB->ChapGetCount())
  952.   {
  953.     IBaseFilter* pBF = pBFs.GetNext(pos);
  954.  
  955.     CComQIPtr<IAMExtendedSeeking, &IID_IAMExtendedSeeking> pES = pBF;
  956.     if(!pES) continue;
  957.  
  958.     long MarkerCount = 0;
  959.     if(SUCCEEDED(pES->get_MarkerCount(&MarkerCount)))
  960.     {
  961.       for(long i = 1; i <= MarkerCount; i++)
  962.       {
  963.         double MarkerTime = 0;
  964.         if(SUCCEEDED(pES->GetMarkerTime(i, &MarkerTime)))
  965.         {
  966.           CStringW name;
  967.           name.Format(L"Chapter %d", i);
  968.  
  969.           CComBSTR bstr;
  970.           if(S_OK == pES->GetMarkerName(i, &bstr))
  971.             name = bstr;
  972.  
  973.           m_pCB->ChapAppend(REFERENCE_TIME(MarkerTime*10000000), name);
  974.         }
  975.       }
  976.     }
  977.   }
  978.  
  979.   循环遍历过滤接口 进行追加操作 具体什么 待分析
  980.   pos = pBFs.GetHeadPosition();
  981.   while(pos && !m_pCB->ChapGetCount())
  982.   {
  983.     IBaseFilter* pBF = pBFs.GetNext(pos);
  984.  
  985.     if(GetCLSID(pBF) != CLSID_OggSplitter)
  986.       continue;
  987.  
  988.     BeginEnumPins(pBF, pEP, pPin)
  989.     {
  990.       if(m_pCB->ChapGetCount()) break;
  991.  
  992.       if(CComQIPtr<IPropertyBag> pPB = pPin)
  993.       {
  994.         for(int i = 1; ; i++)
  995.         {
  996.           CStringW str;
  997.           CComVariant var;
  998.  
  999.           var.Clear();
  1000.           str.Format(L"CHAPTER%02d", i);
  1001.           if(S_OK != pPB->Read(str, &var, NULL)) 
  1002.             break;
  1003.           int h, m, s, ms;
  1004.           WCHAR wc;
  1005.           if(7 != swscanf(CStringW(var), L"%d%c%d%c%d%c%d", &h, &wc, &m, &wc, &s, &wc, &ms)) 
  1006.             break;
  1007.           CStringW name;
  1008.           name.Format(L"Chapter %d", i);
  1009.           var.Clear();
  1010.           str += L"NAME";
  1011.           if(S_OK == pPB->Read(str, &var, NULL))
  1012.             name = var;
  1013.           m_pCB->ChapAppend(10000i64*(((h*60 + m)*60 + s)*1000 + ms), name);
  1014.         }
  1015.       }
  1016.     }
  1017.     EndEnumPins
  1018.   }
  1019.   m_pCB->ChapSort();
  1020. }
  1021.  
  1022.    进入OpenCustomizeGraph  自定义图像大小
  1023. void CMainFrame::OpenCustomizeGraph()
  1024. {
  1025.   总共有enum {PM_NONE, PM_FILE, PM_DVD, PM_CAPTURE}种模式
  1026.  
  1027.   PM_CAPTURE 模式 不支持自定义图像大小
  1028.   if(m_iPlaybackMode == PM_CAPTURE)    return;
  1029.  
  1030.   CleanGraph();   清楚画像
  1031.  
  1032.   if(m_iPlaybackMode == PM_FILE)  文件模式
  1033.   {
  1034.     if(m_pCAP) {
  1035.       if(AfxGetAppSettings().fAutoloadSubtitles) {
  1036.         AddTextPassThruFilter();    进行了很多连接  需要分析
  1037.       }
  1038.     }
  1039.   }
  1040.   
  1041.   同步视频
  1042.   AppSettings& s = AfxGetAppSettings();
  1043.   if (s.m_RenderSettings.bSynchronizeVideo)
  1044.   {
  1045.     HRESULT hr;
  1046.     m_pRefClock = DNew CSyncClockFilter(NULL, &hr);
  1047.     CStringW name;
  1048.     name.Format(L"SyncClock Filter");
  1049.     pGB->AddFilter(m_pRefClock, name);
  1050.  
  1051.     CComPtr<IReferenceClock> refClock;
  1052.     m_pRefClock->QueryInterface(IID_IReferenceClock, reinterpret_cast<void**>(&refClock));
  1053.     CComPtr<IMediaFilter> mediaFilter;
  1054.     pGB->QueryInterface(IID_IMediaFilter, reinterpret_cast<void**>(&mediaFilter));
  1055.     mediaFilter->SetSyncSource(refClock);
  1056.     mediaFilter = NULL;
  1057.     refClock = NULL;
  1058.  
  1059.     m_pRefClock->QueryInterface(IID_ISyncClock, reinterpret_cast<void**>(&m_pSyncClock));
  1060.   }
  1061.  
  1062.   BeginEnumFilters(pGB, pEF, pBF)
  1063.   {
  1064.     查找CLSID_OggSplitter 控件
  1065.     if(GetCLSID(pBF) == CLSID_OggSplitter)
  1066.     {
  1067.        查找IAMStreamSelect接口
  1068.       if(CComQIPtr<IAMStreamSelect> pSS = pBF)
  1069.       {
  1070.         LCID idAudio = AfxGetAppSettings().idAudioLang;
  1071.         if(!idAudio) idAudio = GetUserDefaultLCID();
  1072.         LCID idSub = AfxGetAppSettings().idSubtitlesLang;
  1073.         if(!idSub) idSub = GetUserDefaultLCID();
  1074.  
  1075.         DWORD cnt = 0;
  1076.         pSS->Count(&cnt);
  1077.         for(DWORD i = 0; i < cnt; i++)
  1078.         {
  1079.           AM_MEDIA_TYPE* pmt = NULL;
  1080.           DWORD dwFlags = 0;
  1081.           LCID lcid = 0;
  1082.           DWORD dwGroup = 0;
  1083.           WCHAR* pszName = NULL;
  1084.           if(SUCCEEDED(pSS->Info((long)i, &pmt, &dwFlags, &lcid, &dwGroup, &pszName, NULL, NULL)))
  1085.           {
  1086.             CStringW name(pszName), sound(L"Sound"), subtitle(L"Subtitle");
  1087.  
  1088.             if(idAudio != -1 && (idAudio&0x3ff) == (lcid&0x3ff) // sublang seems to be zeroed out in ogm...
  1089.               && name.GetLength() > sound.GetLength()
  1090.               && !name.Left(sound.GetLength()).CompareNoCase(sound))
  1091.             {
  1092.               if(SUCCEEDED(pSS->Enable(i, AMSTREAMSELECTENABLE_ENABLE)))
  1093.                 idAudio = -1;
  1094.             }
  1095.  
  1096.             if(idSub != -1 && (idSub&0x3ff) == (lcid&0x3ff) // sublang seems to be zeroed out in ogm...
  1097.               && name.GetLength() > subtitle.GetLength()
  1098.               && !name.Left(subtitle.GetLength()).CompareNoCase(subtitle)
  1099.               && name.Mid(subtitle.GetLength()).Trim().CompareNoCase(L"off"))
  1100.             {
  1101.               if(SUCCEEDED(pSS->Enable(i, AMSTREAMSELECTENABLE_ENABLE)))
  1102.                 idSub = -1;
  1103.             }
  1104.  
  1105.             if(pmt) DeleteMediaType(pmt);
  1106.             if(pszName) CoTaskMemFree(pszName);
  1107.           }
  1108.         }
  1109.       }
  1110.     }
  1111.   }
  1112.   EndEnumFilters
  1113.  
  1114.     CleanGraph();
  1115. }
  1116.  
  1117.  进入OpenSetupVideo() 初始化视频
  1118. void CMainFrame::OpenSetupVideo()
  1119. {
  1120.   只自动？
  1121.   m_fAudioOnly = true;
  1122.  
  1123.   if (m_pMFVDC) // EVR 
  1124.   {
  1125.     EVR  不支持
  1126.     m_fAudioOnly = false;
  1127.   }
  1128.   else if(m_pCAPR)
  1129.   {
  1130.      获得视频大小
  1131.     CSize vs = m_pCAPR->GetVideoSize();
  1132.     m_fAudioOnly = (vs.cx <= 0 || vs.cy <= 0);
  1133.   }
  1134.   else
  1135.   {
  1136.     否则其它
  1137.     {
  1138.       long w = 0, h = 0;
  1139.  
  1140.       if(CComQIPtr<IBasicVideo> pBV = pGB)
  1141.       {
  1142.         pBV->GetVideoSize(&w, &h);
  1143.       }
  1144.  
  1145.       if(w > 0 && h > 0)
  1146.       {
  1147.         m_fAudioOnly = false;
  1148.       }
  1149.     }
  1150.  
  1151.     if(m_fAudioOnly)
  1152.     {
  1153.       BeginEnumFilters(pGB, pEF, pBF)
  1154.       {
  1155.         long w = 0, h = 0;
  1156.  
  1157.  
  1158.         if(CComQIPtr<IVideoWindow> pVW = pBF)
  1159.         {
  1160.           long lVisible;
  1161.           if(FAILED(pVW->get_Visible(&lVisible)))
  1162.             continue;
  1163.  
  1164.           pVW->get_Width(&w);
  1165.           pVW->get_Height(&h);
  1166.         }
  1167.  
  1168.         if(w > 0 && h > 0)
  1169.         {
  1170.           m_fAudioOnly = false;
  1171.           break;
  1172.         }
  1173.       }
  1174.       EndEnumFilters
  1175.     }
  1176.   }
  1177.  
  1178.   if(m_fShockwaveGraph)  flash控件
  1179.   {
  1180.     m_fAudioOnly = false;
  1181.   }
  1182.  
  1183.   if(m_pCAP)
  1184.   {
  1185.     SetShaders();
  1186.   }
  1187.   // else
  1188.   {
  1189.     // TESTME
  1190.  
  1191.     pVW->put_Owner((OAHWND)m_wndView.m_hWnd);
  1192.     pVW->put_WindowStyle(WS_CHILD|WS_CLIPSIBLINGS|WS_CLIPCHILDREN);
  1193.     pVW->put_MessageDrain((OAHWND)m_hWnd);
  1194.  
  1195.     for(CWnd* pWnd = m_wndView.GetWindow(GW_CHILD); pWnd; pWnd = pWnd->GetNextWindow())
  1196.       pWnd->EnableWindow(FALSE); // little trick to let WM_SETCURSOR thru
  1197.   }
  1198. }
  1199.  
  1200.  进入SetShaders( BOOL silent )  设置着色
  1201. void CMainFrame::SetShaders( BOOL silent )
  1202. {
  1203.   if(!m_pCAPR) return;   不存在则直接返回
  1204.  
  1205.   AppSettings& s = AfxGetAppSettings();
  1206.  
  1207.   CAtlStringMap<const AppSettings::Shader*> s2s;
  1208.  
  1209.   POSITION pos = s.m_shaders.GetHeadPosition();
  1210.   while(pos)
  1211.   {
  1212.     const AppSettings::Shader* pShader = &s.m_shaders.GetNext(pos); 关键取值
  1213.     s2s[pShader->label] = pShader;
  1214.   }
  1215.   if(!silent){
  1216.     m_pCAPR->SetPixelShader(NULL, NULL);
  1217.     if (m_pCAP2)
  1218.       m_pCAP2->SetPixelShader2(NULL, NULL, true);
  1219.   }
  1220.  
  1221.   CAtlList<CString> labels;
  1222.  
  1223.   pos = m_shaderlabels.GetHeadPosition();
  1224.   while(pos)
  1225.   {
  1226.     const AppSettings::Shader* pShader = NULL;
  1227.     if(s2s.Lookup(m_shaderlabels.GetNext(pos), pShader))
  1228.     {
  1229.       CStringA target = pShader->target;
  1230.       CStringA srcdata = pShader->srcdata;
  1231.  
  1232.       HRESULT hr = m_pCAPR->SetPixelShader(srcdata, target );
  1233.  
  1234.       if(FAILED(hr))
  1235.       {
  1236.         //m_pCAP->SetPixelShader(NULL, NULL);
  1237.         if (m_pCAP2)
  1238.           hr = m_pCAP2->SetPixelShader2(srcdata, target, true);
  1239.         if(FAILED(hr)){
  1240.           // if (m_pCAP2)
  1241.           // m_pCAP2->SetPixelShader2(NULL, NULL, true,  !silent);
  1242.           if(!silent)
  1243.           {
  1244.             CString label = pShader->label;
  1245.             OsdMsg_SetShader(&label);
  1246.           }
  1247.         }
  1248.         return;
  1249.       }
  1250.       labels.AddTail(pShader->label);
  1251.     }
  1252.   }
  1253.  
  1254.   if(m_iMediaLoadState == MLS_LOADED)
  1255.   {
  1256.     CString str = Implode(labels, '|');
  1257.     str.Replace(_T("|"), _T(", "));
  1258.     if(!silent) SendStatusMessage(_T("Shader: ") + str, 3000);
  1259.   }
  1260.   if(!silent){
  1261.     if (SetVMR9ColorControl(s.dBrightness , s.dContrast, 0, 0, true) == FALSE)
  1262.       OsdMsg_SetShader();
  1263.   }
  1264. }
  1265.  
  1266.   进入OpenSetupAudio()  初始化音频
  1267. void CMainFrame::OpenSetupAudio()
  1268. {
  1269.   赋值
  1270.   pBA->put_Volume(m_wndToolBar.Volume);
  1271.  
  1272.   // FIXME
  1273.   // 又是从设置中取得数据
  1274.   int balance = AfxGetAppSettings().nBalance;
  1275.   int sign = balance>0?-1:1;
  1276.   balance = max(100-abs(balance), 1);
  1277.   balance = (int)((log10(1.0*balance)-2)*5000*sign);
  1278.   balance = max(min(balance, 10000), -10000);
  1279.   pBA->put_Balance(balance);
  1280. }
  1281.  
  1282.   进入CMainFrame::OpenSetupWindowTitle 初始化标题
  1283. void CMainFrame::OpenSetupWindowTitle(CString fn)
  1284. {
  1285.   CString title(MAKEINTRESOURCE(IDR_MAINFRAME));
  1286.  
  1287.   AppSettings& s = AfxGetAppSettings();
  1288.  
  1289.   int i = s.iTitleBarTextStyle;
  1290.  
  1291.   if(!fn.IsEmpty() && (i == 0 || i == 1))
  1292.   {
  1293.     if(i == 1)
  1294.     {
  1295.       if(m_iPlaybackMode == PM_FILE)
  1296.       {
  1297.         fn.Replace('\\', '/');
  1298.         CString fn2 = fn.Mid(fn.ReverseFind('/')+1);
  1299.         if(!fn2.IsEmpty()) fn = fn2;
  1300.  
  1301.         if(s.fTitleBarTextTitle)
  1302.         {
  1303.           BeginEnumFilters(pGB, pEF, pBF)
  1304.           {
  1305.             if(CComQIPtr<IAMMediaContent, &IID_IAMMediaContent> pAMMC = pBF)
  1306.             {
  1307.               CComBSTR bstr;
  1308.               if(SUCCEEDED(pAMMC->get_Title(&bstr)) && bstr.Length())
  1309.               {
  1310.                 fn = CString(bstr.m_str);
  1311.                 break;
  1312.               }
  1313.             }
  1314.           }
  1315.           EndEnumFilters
  1316.         }
  1317.       }
  1318.       else if(m_iPlaybackMode == PM_DVD)
  1319.       {
  1320.         fn = _T("DVD");
  1321.       }
  1322.       else if(m_iPlaybackMode == PM_CAPTURE)
  1323.       {
  1324.         fn = _T("Live");
  1325.       }
  1326.     }
  1327.     title = fn + _T(" - ") + title;
  1328.   }
  1329.   //CString szBuild;
  1330.   //szBuild.Format(_T(" (Build %s)"),SVP_REV_STR);
  1331.   //title += szBuild;
  1332.   //SetWindowText(title);
  1333.   m_szTitle = title;
  1334.   RedrawNonClientArea();
  1335. }
  1336.  
  1337. 在OpenMediaPrivate（）中
  1338. PostMessage(WM_COMMAND, ID_PLAY_PAUSE);
  1339. if(!(AfxGetAppSettings().nCLSwitches&CLSW_OPEN))
  1340.         PostMessage(WM_COMMAND, ID_PLAY_PLAY);
  1341.  
  1342.  紧紧只是更新UI？
  1343. ON_UPDATE_COMMAND_UI(ID_PLAY_PLAY, OnUpdatePlayPauseStop)
  1344.  
  1345.    进入OnUpdatePlayPauseStop 分析
  1346. void CMainFrame::OnUpdatePlayPauseStop(CCmdUI* pCmdUI)
  1347. {
  1348.   OAFilterState fs = m_fFrameSteppingActive ? State_Paused : GetMediaState();
  1349.  
  1350.   UI消息
  1351.   pCmdUI->SetCheck(fs == State_Running && pCmdUI->m_nID == ID_PLAY_PLAY
  1352.     || fs == State_Paused && pCmdUI->m_nID == ID_PLAY_PAUSE
  1353.     || fs == State_Stopped && pCmdUI->m_nID == ID_PLAY_STOP
  1354.     || (fs == State_Paused || fs == State_Running) && pCmdUI->m_nID == ID_PLAY_PLAYPAUSE);
  1355.  
  1356.   bool fEnable = false;
  1357.  
  1358.   if(fs >= 0)
  1359.   {
  1360.     if(m_iPlaybackMode == PM_FILE || m_iPlaybackMode == PM_CAPTURE)
  1361.     {
  1362.       fEnable = true;
  1363.  
  1364.       不能进入暂停状态，从停止使用rm
  1365.       if(fs == State_Stopped && pCmdUI->m_nID == ID_PLAY_PAUSE && m_fRealMediaGraph) fEnable = false; // can't go into paused state from stopped with rm
  1366.       else if(m_fCapturing) fEnable = false;
  1367.       else if(m_fLiveWM && pCmdUI->m_nID == ID_PLAY_PAUSE) fEnable = false;
  1368.     }
  1369.     else if(m_iPlaybackMode == PM_DVD)
  1370.     {
  1371.       fEnable = m_iDVDDomain != DVD_DOMAIN_VideoManagerMenu 
  1372.         && m_iDVDDomain != DVD_DOMAIN_VideoTitleSetMenu;
  1373.  
  1374.       if(fs == State_Stopped && pCmdUI->m_nID == ID_PLAY_PAUSE) fEnable = false;
  1375.     }
  1376.   }
  1377.   if(pCmdUI->m_nID == ID_PLAY_PLAY || pCmdUI->m_nID == ID_PLAY_PLAYPAUSE) fEnable = true;
  1378.   pCmdUI->Enable(fEnable);
  1379. }
  1380.  
  1381. ON_COMMAND(ID_PLAY_PAUSE, OnPlayPause)
  1382. void CMainFrame::OnPlayPause()
  1383. //支持ffdshow的排队。
  1384. //为了避免暂停黑掉，我们以锁定g_ffdshowReceive同步与ReceiveMine的。
  1385. void CMainFrame::OnPlayPause()
  1386. {
  1387.   // Support ffdshow queueing.
  1388.   // To avoid black out on pause, we have to lock g_ffdshowReceive to synchronize with ReceiveMine.
  1389.   time(&m_tPlayPauseTime);
  1390.   if(queueu_ffdshow_support)
  1391.   {
  1392.     CAutoLock lck(&g_ffdshowReceive);
  1393.     return OnPlayPauseI();
  1394.   }
  1395.   OnPlayPauseI();
  1396. }
  1397.  
  1398.   进入OnPlayPauseI()分析
  1399. void CMainFrame::OnPlayPauseI()
  1400. {
  1401.   if(m_iMediaLoadState == MLS_LOADED)   已经加载
  1402.   {
  1403.     if(m_iPlaybackMode == PM_FILE)
  1404.     {
  1405.       pMC->Pause();   停止
  1406.     }
  1407.     else if(m_iPlaybackMode == PM_DVD)
  1408.     {
  1409.       pMC->Pause();
  1410.     }
  1411.     else if(m_iPlaybackMode == PM_CAPTURE)
  1412.     {
  1413.       pMC->Pause();
  1414.     } 
  1415.  
  1416.     SetTimer(TIMER_STREAMPOSPOLLER, 40, NULL);
  1417.     SetTimer(TIMER_STREAMPOSPOLLER2, 500, NULL);
  1418.     SetTimer(TIMER_STATS, 1000, NULL);
  1419.  
  1420.     KillTimer(TIMER_IDLE_TASK);
  1421.     SetTimer(TIMER_IDLE_TASK, 30000, NULL);
  1422.  
  1423.     SetAlwaysOnTop(AfxGetAppSettings().iOnTop);  设置置顶
  1424.   }
  1425.   MoveVideoWindow();
  1426. }
  1427.  
  1428.     移动视频窗体
  1429. void CMainFrame::MoveVideoWindow(bool fShowStats)
  1430. {
  1431.    视频已经加载  不是自动  窗体可见
  1432.   if(m_iMediaLoadState == MLS_LOADED && !m_fAudioOnly && IsWindowVisible())
  1433.   {
  1434.     AppSettings &s = AfxGetAppSettings();
  1435.     CRect wr;
  1436.  
  1437.     if(!m_fFullScreen && (s.bUserAeroUI() || (!s.bUserAeroUI() && ( s.nCS & CS_TOOLBAR ))) )
  1438.     {
  1439.       m_wndView.GetClientRect(wr);
  1440.     }
  1441.     else
  1442.     {
  1443.       GetWindowRect(&wr);
  1444.       // HACK
  1445.       CRect r;
  1446.       m_wndView.GetWindowRect(&r);
  1447.       wr -= r.TopLeft();
  1448.     }
  1449.     CRect vr = CRect(0,0,0,0);
  1450.  
  1451.     OAFilterState fs = GetMediaState();
  1452.     if(fs == State_Paused || fs == State_Running || fs == State_Stopped && (m_fShockwaveGraph || m_fQuicktimeGraph))
  1453.     {
  1454.       CSize arxy = GetVideoSize();
  1455.  
  1456.       int iDefaultVideoSize = AfxGetAppSettings().iDefaultVideoSize;
  1457.  
  1458.       CSize ws = 
  1459.         iDefaultVideoSize == DVS_HALF ? CSize(arxy.cx/2, arxy.cy/2) :
  1460.         iDefaultVideoSize == DVS_NORMAL ? arxy :
  1461.         iDefaultVideoSize == DVS_DOUBLE ? CSize(arxy.cx*2, arxy.cy*2) :
  1462.         wr.Size();
  1463.  
  1464.       int w = ws.cx;
  1465.       int h = ws.cy;
  1466.  
  1467.       if(!m_fShockwaveGraph) //&& !m_fQuicktimeGraph)
  1468.       {
  1469.         if(iDefaultVideoSize == DVS_FROMINSIDE || iDefaultVideoSize == DVS_FROMOUTSIDE)
  1470.         {
  1471.           h = ws.cy;
  1472.           w = MulDiv(h, arxy.cx, arxy.cy);
  1473.  
  1474.           if(iDefaultVideoSize == DVS_FROMINSIDE && w > ws.cx
  1475.             || iDefaultVideoSize == DVS_FROMOUTSIDE && w < ws.cx)
  1476.           {
  1477.             w = ws.cx;
  1478.             h = MulDiv(w, arxy.cy, arxy.cx);
  1479.           }
  1480.         }
  1481.       }
  1482.  
  1483.       CSize size(
  1484.         (int)(m_ZoomX*w), 
  1485.         (int)(m_ZoomY*h));
  1486.  
  1487.       CPoint pos(
  1488.         (int)(m_PosX*(wr.Width()*3 - m_ZoomX*w) - wr.Width()), 
  1489.         (int)(m_PosY*(wr.Height()*3 - m_ZoomY*h) - wr.Height()));
  1490.  
  1491.       /* CPoint pos(
  1492.       (int)(m_PosX*(wr.Width() - size.cx)), 
  1493.       (int)(m_PosY*(wr.Height() - size.cy)));
  1496.       */
  1497.       vr = CRect(pos, size);
  1498.     }
  1499.  
  1500.     wr |= CRect(0,0,0,0);
  1501.     vr |= CRect(0,0,0,0);
  1502.  
  1503.     //CString szLog;
  1504.     //szLog.Format(_T("WVSize3 %d %d %d %d %d %d %d "), wr.Width(), wr.Height(), vr.Width(), vr.Height(), m_AngleX , m_AngleY , m_AngleZ);
  1505.     //SVP_LogMsg(szLog);
  1506.     if(m_pCAPR)
  1507.     {
  1508.       m_pCAPR->SetPosition(wr, vr);
  1509.       m_pCAPR->SetVideoAngle(Vector(DegToRad(m_AngleX), DegToRad(m_AngleY), DegToRad(m_AngleZ)));
  1510.     }
  1511.     else
  1512.     {
  1513.       HRESULT hr;
  1514.       hr = pBV->SetDefaultSourcePosition();
  1515.       hr = pBV->SetDestinationPosition(vr.left, vr.top, vr.Width(), vr.Height());
  1516.       hr = pVW->SetWindowPosition(wr.left, wr.top, wr.Width(), wr.Height());
  1517.  
  1518.       if (m_pMFVDC) m_pMFVDC->SetVideoPosition (NULL, wr);
  1519.     }
  1520.     //SVP_LogMsg5(_T("MoveVideoWindow %d ") , wr.Height());
  1521.     m_wndView.SetVideoRect(wr);
  1522.  
  1523.     if(fShowStats && vr.Height() > 0)
  1524.     {
  1525.       CString info(L"正在使用智能拖拽功能。可在画面右上角进行拖拽");
  1526.       // info.Format(_T("Pos %.2f %.2f, Zoom %.2f %.2f, AR %.2f"), m_PosX, m_PosY, m_ZoomX, m_ZoomY, (float)vr.Width()/vr.Height());
  1527.       SendStatusMessage(info, 3000);
  1528.     }
  1529.   }
  1530.   else
  1531.   {
  1532.     m_wndView.SetVideoRect();
  1533.   }
  1534.  
  1535.   CRect r;
  1536.   m_wndView.GetClientRect(r);
  1537.   if(m_iMediaLoadState == MLS_LOADED){
  1538.     float fViewRatio = (float)r.Width() / r.Height();
  1539.     CSize vsize = GetVideoSize();
  1540.     float fVideoRatio = (float)vsize.cx / vsize.cy;
  1541.     m_fScreenHigherThanVideo = (fViewRatio < fVideoRatio );
  1542.   }
  1543. }
  1544.  
  1545.   仅仅只是更新UI
  1546. void CMainFrame::OnUpdatePlayPauseStop(CCmdUI* pCmdUI)
  1547. {
  1548.   OAFilterState fs = m_fFrameSteppingActive ? State_Paused : GetMediaState();
  1549.  
  1550.   pCmdUI->SetCheck(fs == State_Running && pCmdUI->m_nID == ID_PLAY_PLAY
  1551.     || fs == State_Paused && pCmdUI->m_nID == ID_PLAY_PAUSE
  1552.     || fs == State_Stopped && pCmdUI->m_nID == ID_PLAY_STOP
  1553.     || (fs == State_Paused || fs == State_Running) && pCmdUI->m_nID == ID_PLAY_PLAYPAUSE);
  1554.  
  1555.   bool fEnable = false;
  1556.  
  1557.   if(fs >= 0)
  1558.   {
  1559.     if(m_iPlaybackMode == PM_FILE || m_iPlaybackMode == PM_CAPTURE)
  1560.     {
  1561.       fEnable = true;
  1562.  
  1563.       if(fs == State_Stopped && pCmdUI->m_nID == ID_PLAY_PAUSE && m_fRealMediaGraph) fEnable = false; // can't go into paused state from stopped with rm
  1564.       else if(m_fCapturing) fEnable = false;
  1565.       else if(m_fLiveWM && pCmdUI->m_nID == ID_PLAY_PAUSE) fEnable = false;
  1566.     }
  1567.     else if(m_iPlaybackMode == PM_DVD)
  1568.     {
  1569.       fEnable = m_iDVDDomain != DVD_DOMAIN_VideoManagerMenu 
  1570.         && m_iDVDDomain != DVD_DOMAIN_VideoTitleSetMenu;
  1571.  
  1572.       if(fs == State_Stopped && pCmdUI->m_nID == ID_PLAY_PAUSE) fEnable = false;
  1573.     }
  1574.   }
  1575.   if(pCmdUI->m_nID == ID_PLAY_PLAY || pCmdUI->m_nID == ID_PLAY_PLAYPAUSE) fEnable = true;
  1576.   pCmdUI->Enable(fEnable);
  1577. }
  1578.  
  1579. // play 播放事件
  1580. void CMainFrame::OnPlayPlay()
  1581. {
  1582.   if(m_iMediaLoadState == MLS_LOADED) 必须载入
  1583.   {
  1584.     if(GetMediaState() == State_Stopped) {  m_iSpeedLevel = 0; time(&m_tPlayStartTime);} 记录
  1585.     try
  1586.     {
  1587.       if(m_iPlaybackMode == PM_FILE)  文件格式
  1588.       {
  1589.         time_t ttNow;
  1590.         time(&ttNow);
  1591.         if( m_tPlayPauseTime > m_tPlayStartTime){
  1592.           m_tPlayStartTime += (ttNow - m_tPlayPauseTime);
  1593.         }
  1594.         if(m_fEndOfStream){   如果文件流没有 则停止
  1595.           SendMessage(WM_COMMAND, ID_PLAY_STOP);
  1596.           Sleep(1500);
  1597.         }
  1598.         pMC->Run();   运行
  1599.       }
  1600.       else if(m_iPlaybackMode == PM_DVD) DVD格式
  1601.       {
  1602.         double dRate = 1.0;
  1603.         //if(m_iSpeedLevel != -4 && m_iSpeedLevel != 0)
  1604.         // dRate = pow(2.0, m_iSpeedLevel >= -3 ? m_iSpeedLevel : (-m_iSpeedLevel - 8));
  1605.         dRate = 1.0 + m_iSpeedLevel * 0.1;
  1606.         pDVDC->PlayForwards(dRate, DVD_CMD_FLAG_Block, NULL);
  1607.         pDVDC->Pause(FALSE);
  1608.         pMC->Run();
  1609.       }
  1610.       else if(m_iPlaybackMode == PM_CAPTURE)  CAPTURE 格式
  1611.       { 
  1612.         pMC->Stop(); // audio preview won't be in sync if we run it from paused state
  1613.         pMC->Run();
  1614.       }
  1615.     }
  1616.     catch (...)
  1617.     {
  1618.       SendMessage(WM_COMMAND, ID_FILE_CLOSEMEDIA);  异常 就关闭视频
  1619.       return;
  1620.     }
  1621.     SetTimer(TIMER_STREAMPOSPOLLER, 40, NULL);  位置信息
  1622.     SetTimer(TIMER_STREAMPOSPOLLER2, 500, NULL);  位置2信息
  1623.     SetTimer(TIMER_STATS, 1000, NULL);   状态信息
  1624.  
  1625.     if(m_fFrameSteppingActive) // FIXME   第一次  设置声音
  1626.     {
  1627.       m_fFrameSteppingActive = false;
  1628.       pBA->put_Volume(m_VolumeBeforeFrameStepping);
  1629.     }
  1630.  
  1631.     SetAlwaysOnTop(AfxGetAppSettings().iOnTop);   置顶
  1632.     m_wndColorControlBar.CheckAbility();   控件状态位置等信息
  1633.     MoveVideoWindow();   移动视频
  1634.   }else if(m_iMediaLoadState == MLS_CLOSED){  如果是关闭状态 则重新播放
  1635.     if(m_WndSizeInited >= 2){
  1636.       if(m_wndPlaylistBar.GetCount()){
  1637.         OpenCurPlaylistItem();
  1638.         //}else
  1639.         // SendMessage(WM_COMMAND, ID_FILE_OPENMEDIA);
  1640.       }
  1641.     }
  1642.   }
  1643.   //KillTimer(TIMER_SNAP);
  1644.   //SetTimer(TIMER_SNAP, 10000, NULL);
  1645. }
  1646.  
  1647.   进入OnFilePostOpenmedia() 分析
  1648. void CMainFrame::OnFilePostOpenmedia()
  1649. {
  1650.   OpenSetupClipInfo();  初始化剪切板信息
  1651.   //A-B Control
  1652.   m_aRefTime = 0;
  1653.   m_bRefTime = 0;
  1654.   ABControlOn = FALSE;
  1655.  
  1656.   OpenSetupCaptureBar();  初始化控件
  1657.  
  1658.   AppSettings& s = AfxGetAppSettings();
  1659.   m_wndColorControlBar.CheckAbility();  检查能力
  1660.  
  1661.   if(m_wndToolBar.IsVisible())
  1662.     ShowControls(AfxGetAppSettings().nCS | CS_SEEKBAR, false);  显示控件
  1663.  
  1664.   __int64 rtDur = 0;
  1665.   pMS->GetDuration(&rtDur);   从视频接口获得当前位置
  1666.   m_wndPlaylistBar.SetCurTime(rtDur);  设置控件位置
  1667.  
  1668.   if(m_iPlaybackMode == PM_CAPTURE)
  1669.   {
  1670.     ShowControlBar(&m_wndPlaylistBar, FALSE, TRUE);
  1671.     ShowControlBar(&m_wndCaptureBar, TRUE, TRUE);
  1672.   }
  1673.   
  1674. / /重要：不能调用任何窗口封邮件之前
  1675.   / /这一点上，它会僵局时OpenMediaPrivate
  1676.   / /仍在运行，并创建渲染窗口
  1677.   / /相同的工作者线程
  1678.   std::wstring szFileHash = HashController::GetInstance()->GetSPHash(m_fnCurPlayingFile);
  1679.  
  1680.   CString FPath = szFileHash.c_str();
  1681.  
  1682.    加载第二字幕
  1683.   if(m_pCAP && (!m_fAudioOnly || m_fRealMediaGraph))
  1684.   {
  1685.     if(m_pSubStreams.GetCount() == 0){
  1686.       if ( !m_wndPlaylistBar.m_pl.szPlayListSub.IsEmpty() ){
  1687.         int delayms = 0 - m_wndPlaylistBar.GetTotalTimeBeforeCur();
  1688.         LoadSubtitle(m_wndPlaylistBar.m_pl.szPlayListSub, delayms , true); 
  1689.       }
  1690.     }
  1691.  
  1692.     if(s.fEnableSubtitles && m_pSubStreams.GetCount() > 0){
  1693.       BOOL HavSubs1 = FALSE;
  1694.  
  1695.       Sql 操作  搜索历史记录
  1696.       if(AfxGetMyApp()->sqlite_local_record ){
  1697.         CString szSQL;
  1698.         szSQL.Format(L"SELECT subid FROM histories WHERE fpath = \"%s\" ", FPath);
  1699.         int subid = AfxGetMyApp()->sqlite_local_record->get_single_int_from_sql(szSQL.GetBuffer(), -1);
  1700.         if(subid >= 0){
  1701.           //SVP_LogMsg5(L"subid %d %d", subid, m_pSubStreams.GetCount());
  1702.           int i = subid;
  1703.  
  1704.       字幕流？
  1705.           POSITION pos = m_pSubStreams.GetHeadPosition();
  1706.           while(pos && i >= 0)
  1707.           {
  1708.             循环查找
  1709.             CComPtr<ISubStream> pSubStream = m_pSubStreams.GetNext(pos);
  1710.  
  1711.             if(i < pSubStream->GetStreamCount()) 
  1712.             {
  1713.               SendStatusMessage(ResStr(IDS_OSD_MSG_RESTORE_TO_LAST_REMEMBER_SUBTITLE_TRACK),3000);
  1714.               CAutoLock cAutoLock(&m_csSubLock);
  1715.               pSubStream->SetStream(i);
  1716.               SetSubtitle(pSubStream);
  1717.               HavSubs1 = true;
  1718.               break;
  1719.             }
  1720.             i -= pSubStream->GetStreamCount();
  1721.           }
  1722.         }
  1723.       }
  1724.  
  1725.       字幕流？
  1726.       if(!HavSubs1 && !s.sSubStreamName1.IsEmpty()){
  1727.         POSITION pos = m_pSubStreams.GetHeadPosition();
  1728.         while(pos){
  1729.           CComPtr<ISubStream> pSubStream = m_pSubStreams.GetNext(pos);
  1730.           if(!pSubStream) continue;
  1731.           for(int i = 0, j = pSubStream->GetStreamCount(); i < j; i++)
  1732.           {
  1733.             WCHAR* pName = NULL;
  1734.             if(SUCCEEDED(pSubStream->GetStreamInfo(i, &pName, NULL)))
  1735.             {
  1736.               CString name(pName);
  1737.               //SVP_LogMsg5(L"sub2 %s", name);
  1738.               if( name == s.sSubStreamName1){
  1739.                 SetSubtitle( pSubStream);
  1740.                 HavSubs1 = true;
  1741.               }
  1742.               CoTaskMemFree(pName);
  1743.               if(HavSubs1)
  1744.                 break;
  1745.             }
  1746.           }
  1747.           if(HavSubs1)
  1748.             break;
  1749.         }
  1750.       }
  1751.  
  1752.       设置字幕流
  1753.       if(!HavSubs1){
  1754.         POSITION pos = m_pSubStreams.GetHeadPosition();
  1755.         while(pos){
  1756.           CComPtr<ISubStream> pSubStream = m_pSubStreams.GetNext(pos);
  1757.           if(!pSubStream) continue;
  1758.           for(int i = 0, j = pSubStream->GetStreamCount(); i < j; i++)
  1759.           {
  1760.             WCHAR* pName = NULL;
  1761.             if(SUCCEEDED(pSubStream->GetStreamInfo(i, &pName, NULL)))
  1762.             {
  1763.               CString name(pName);
  1764.               //SVP_LogMsg5(L"sub2 %s", name);
  1765.               if( name.Find(L"plain text") > 0){ //Apple Text Media Handler (plain text)
  1766.                 SetSubtitle( pSubStream);
  1767.                 HavSubs1 = true;
  1768.               }
  1769.               CoTaskMemFree(pName);
  1770.               if(HavSubs1)
  1771.                 break;
  1772.             }
  1773.           }
  1774.           if(HavSubs1)
  1775.             break;
  1776.         }
  1777.       }
  1778.  
  1779.       字幕流
  1780.       if(!HavSubs1)
  1781.         SetSubtitle(m_pSubStreams.GetHead());
  1782.  
  1783.       if(s.fAutoloadSubtitles2 && m_pSubStreams2.GetCount() > 1 ){
  1784.         BOOL HavSubs = false;
  1785.         if(AfxGetMyApp()->sqlite_local_record ){
  1786.           CString szSQL;
  1787.           szSQL.Format(L"SELECT subid2 FROM histories WHERE fpath = \"%s\" ", FPath);
  1788.           int subid = AfxGetMyApp()->sqlite_local_record->get_single_int_from_sql(szSQL.GetBuffer(), -1);
  1789.           if(subid >= 0){
  1790.             //SVP_LogMsg5(L"subid %d %d", subid, m_pSubStreams.GetCount());
  1791.             int i = subid;
  1792.             POSITION pos = m_pSubStreams2.GetHeadPosition();
  1793.             while(pos && i >= 0)
  1794.             {
  1795.               CComPtr<ISubStream> pSubStream = m_pSubStreams2.GetNext(pos);
  1796.               if(i < pSubStream->GetStreamCount()) 
  1797.               {
  1798.                 CAutoLock cAutoLock(&m_csSubLock);
  1799.                 pSubStream->SetStream(i);
  1800.                 SetSubtitle2(pSubStream);
  1801.                 //SendStatusMessage(ResStr(IDS_OSD_MSG_RESTORE_TO_LAST_REMEMBER_SUBTITLE2_TRACK),3000);
  1802.                 HavSubs = true;
  1803.                 break;
  1804.               }
  1805.               i -= pSubStream->GetStreamCount();
  1806.             }
  1807.           }
  1808.         }
  1809.  
  1810.         字幕流
  1811.         if(!HavSubs && !s.sSubStreamName2.IsEmpty()){
  1812.           POSITION pos = m_pSubStreams2.GetHeadPosition();
  1813.           while(pos){
  1814.             CComPtr<ISubStream> pSubStream = m_pSubStreams2.GetNext(pos);
  1815.  
  1816.             if(!pSubStream) continue;
  1817.  
  1818.             for(int i = 0, j = pSubStream->GetStreamCount(); i < j; i++)
  1819.             {
  1820.               WCHAR* pName = NULL;
  1821.               if(SUCCEEDED(pSubStream->GetStreamInfo(i, &pName, NULL)))
  1822.               {
  1823.                 CString name(pName);
  1824.                 //SVP_LogMsg5(L"sub2 %s", name);
  1825.                 if((!s.sSubStreamName2.IsEmpty() && name == s.sSubStreamName2)  ){
  1826.                   SetSubtitle2( pSubStream);
  1827.                   HavSubs = true;
  1828.                 }
  1829.                 CoTaskMemFree(pName);
  1830.                 if(HavSubs)
  1831.                   break;
  1832.               }
  1833.             }
  1834.             if(HavSubs)
  1835.               break;
  1836.           }
  1837.         }
  1838.  
  1839.         字幕流
  1840.         if(!HavSubs){
  1841.           POSITION pos = m_pSubStreams2.GetHeadPosition();
  1842.           while(pos){
  1843.             CComPtr<ISubStream> pSubStream = m_pSubStreams2.GetNext(pos);
  1844.  
  1845.             if(!pSubStream) continue;
  1846.  
  1847.             for(int i = 0, j = pSubStream->GetStreamCount(); i < j; i++)
  1848.             {
  1849.               WCHAR* pName = NULL;
  1850.               if(SUCCEEDED(pSubStream->GetStreamInfo(i, &pName, NULL)))
  1851.               {
  1852.                 CString name(pName);
  1853.                 //SVP_LogMsg5(L"sub2 %s", name);
  1854.                 if( ( name.Find(_T("en")) >= 0 ||  name.Find(_T("eng")) >= 0 ||  name.Find(_T("英文")) >= 0) ){
  1855.                   SetSubtitle2( pSubStream);
  1856.                   HavSubs = true;
  1857.                 }
  1858.                 CoTaskMemFree(pName);
  1859.                 if(HavSubs)
  1860.                   break;
  1861.               }
  1862.             }
  1863.             if(HavSubs)
  1864.               break;
  1865.           }
  1866.         }
  1867.         if(!HavSubs){
  1868.           POSITION pos = m_pSubStreams2.GetHeadPosition();
  1869.           m_pSubStreams2.GetNext(pos);
  1870.           if(pos)
  1871.             SetSubtitle2( m_pSubStreams2.GetNext(pos));
  1872.         }
  1873.       }
  1874.     }
  1875.     //make sure the subtitle displayed
  1876.     UpdateSubtitle(true);  设置字幕流
  1877.     UpdateSubtitle2(true);  设置字幕流
  1878.   }
  1879.  
  1880.   根据Sql查找历史   发送状态
  1881.   if(AfxGetMyApp()->sqlite_local_record ){
  1882.     CString szSQL;
  1883.     szSQL.Format(L"SELECT audioid FROM histories WHERE fpath = \"%s\" ", FPath);
  1884.     //SVP_LogMsg5(szSQL);
  1885.     int audid = AfxGetMyApp()->sqlite_local_record->get_single_int_from_sql(szSQL.GetBuffer(), -1);
  1886.     if(audid > 0){
  1887.       SVP_LogMsg5(L"audid %d subs %d", audid, m_pSubStreams.GetCount());
  1888.       CComQIPtr<IAMStreamSelect> pSS = FindFilter(__uuidof(CAudioSwitcherFilter), pGB);
  1889.       if(!pSS) pSS = FindFilter(L"{D3CD7858-971A-4838-ACEC-40CA5D529DC8}", pGB);
  1890.       if( pSS)
  1891.       {
  1892.         pSS->Enable(audid, AMSTREAMSELECTENABLE_ENABLE);
  1893.         SendStatusMessage(ResStr(IDS_OSD_MSG_RESTORE_TO_LAST_REMEMBER_AUDIO_TRACK),3000);
  1894.       }
  1895.     }
  1896.   }
  1897.  
  1898.   根据SQL 设置字幕
  1899.   if (AfxGetMyApp()->sqlite_local_record)
  1900.   {
  1901.     CString szSQL;
  1902.     if (s.fEnableSubtitles ){
  1903.       szSQL.Format(L"SELECT subid FROM histories_stream WHERE fpath = \"%s\" ", FPath);
  1904.       int subid = AfxGetMyApp()->sqlite_local_record->get_single_int_from_sql(szSQL.GetBuffer(), -1);
  1905.       if(subid > 0){
  1906.         OnPlayLanguage(subid);
  1907.       }
  1908.     }
  1909.     szSQL.Format(L"SELECT audioid FROM histories_stream WHERE fpath = \"%s\" ", FPath);
  1910.     int audid = AfxGetMyApp()->sqlite_local_record->get_single_int_from_sql(szSQL.GetBuffer(), -1);
  1911.     if(audid > 0){
  1912.       OnPlayLanguage(audid);
  1913.     }
  1914.   }
  1915.  
  1916.   if(!m_pCAP && m_fAudioOnly){ / /这是我们第一次检测，这是仅音频文件
  1917.  
  1918.     m_wndView.m_strAudioInfo.Empty();
  1919.     //This is silly
  1920.     if(!m_fLastIsAudioOnly)
  1921.       ShowControlBar(&m_wndPlaylistBar, FALSE, TRUE);
  1922.  
  1923.     KillTimer(TIMER_TRANSPARENTTOOLBARSTAT);
  1924.     SetTimer(TIMER_TRANSPARENTTOOLBARSTAT, 20,NULL);
  1925.     rePosOSD();  重新计算位置
  1926.   }
  1927.  
  1928.   {
  1929.     WINDOWPLACEMENT wp;
  1930.     wp.length = sizeof(wp);
  1931.     GetWindowPlacement(&wp);  记录窗体位置
  1932.  
  1933.     // restore magnification   只有音频的情况下
  1934.     if(IsWindowVisible() && AfxGetAppSettings().fRememberZoomLevel
  1935.       && !(m_fFullScreen || wp.showCmd == SW_SHOWMAXIMIZED || wp.showCmd == SW_SHOWMINIMIZED))
  1936.     {
  1937.       if(m_fAudioOnly && m_fLastIsAudioOnly){
  1938.       }else{
  1939.         ZoomVideoWindow();  全屏播放
  1940.         // m_fFullScreen意思现在是指当前播放模式是全屏还是非全屏，如果是全屏就会在Toogle中变为非全屏，反之亦然
  1941.         if (!m_fFullScreen)
  1942.         {
  1943.           PlayerPreference* pref = PlayerPreference::GetInstance();
  1944.           bool bToBeFullScreen = pref->GetIntVar(INTVAR_TOGGLEFULLSCRENWHENPLAYBACKSTARTED);
  1945.           if (bToBeFullScreen)   是否全屏
  1946.           {
  1947.             ToggleFullscreen(true, true);
  1948.             SetCursor(NULL);
  1949.           }
  1950.         }
  1951.       }
  1952.       m_fLastIsAudioOnly = m_fAudioOnly;
  1953.     }
  1954.   }
  1955.  
  1956.   if(!m_fAudioOnly && (s.nCLSwitches&CLSW_FULLSCREEN))  全屏时
  1957.   {
  1958.     SendMessage(WM_COMMAND, ID_VIEW_FULLSCREEN);
  1959.     s.nCLSwitches &= ~CLSW_FULLSCREEN;
  1960.   }
  1961.   m_bDxvaInUse = false;
  1962.   m_bMustUseExternalTimer = false;
  1963.   m_haveSubVoted = false;
  1964.   m_DXVAMode = _T("");
  1965.   视频解码接口
  1966.   CComQIPtr<IMPCVideoDecFilter> pMDF  = FindFilter(__uuidof(CMPCVideoDecFilter), pGB);
  1967.   if(pMDF){
  1968.     GUID* DxvaGui = NULL;
  1969.     DxvaGui = pMDF->GetDXVADecoderGuid();
  1970.     if (DxvaGui != NULL)
  1971.     {
  1972.       m_DXVAMode = GetDXVAMode (DxvaGui);
  1973.       m_bDxvaInUse = (m_DXVAMode != _T("Not using DXVA"));
  1974.     }
  1975.   }else if(FindFilter(L"{09571A4B-F1FE-4C60-9760-DE6D310C7C31}", pGB)) {
  1976.     if(s.bHasCUDAforCoreAVC){
  1977.       m_bDxvaInUse = true;
  1978.       m_DXVAMode = _T("CoreAVC");
  1979.     }
  1980.   }
  1981.   /*
  1982.   CComQIPtr<IWMReaderAdvanced2> pWMR  = FindFilter(__uuidof(IWMReaderAdvanced2), pGB);
  1983.   if(pWMR){
  1984.   pWMR->SetPlayMode(WMT_PLAY_MODE_STREAMING);
  1985.   AfxMessageBox(L"1");
  1986.   }*/
  1987.   if(FindFilter(L"{FA10746C-9B63-4B6C-BC49-FC300EA5F256}", pGB)){
  1988.     m_bEVRInUse = true;
  1989.   }
  1990.   if( FindFilter(L"{6F513D27-97C3-453C-87FE-B24AE50B1601}", pGB)){//m_bEVRInUse
  1991.     SVP_LogMsg5(L"Has Divx H264 Dec and EVR so use External Timer");
  1992.     m_bMustUseExternalTimer = true;
  1993.   }
  1994.  
  1995.   RedrawNonClientArea();  重新绘画客户区
  1996.  
  1997.   if(m_iPlaybackMode == PM_FILE){  回放模式
  1998.     if(!s.bDontNeedSVPSubFilter && !m_pCAP && s.iSVPRenderType && !m_fAudioOnly ){
  1999.       s.iSVPRenderType = 0;
  2000.       SendStatusMessage( ResStr(IDS_OSD_MSG_DEVICE_NOT_SUPPORT_VIDEO_QMODE), 2000);
  2001.     }
  2002.  
  2003.     if(m_fAudioOnly && m_fnCurPlayingFile.Find(L"://") < 0){
  2004.        只有音频时  查找歌词
  2005.       //find lyric file
  2006.       m_LyricFilePaths.RemoveAll();    
  2007.       CAtlArray<CString> lrcSearchPaths;
  2008.       lrcSearchPaths.Add(_T("."));
  2009.       lrcSearchPaths.Add(s.GetSVPSubStorePath());
  2010.  
  2011.       CAtlArray<LrcFile> ret;
  2012.       int bGotLrc = 0 ; 
  2013.       m_Lyric.GetLrcFileNames( m_fnCurPlayingFile , lrcSearchPaths, ret);
  2014.       if( ret.GetCount() ){
  2015.         LrcFile oLrcFile = ret.GetAt(0);
  2016.         if( m_Lyric.LoadLyricFile( oLrcFile.fn) >= 0)  装载歌词
  2017.         {
  2018.           //maybe we should do something here?
  2019.           if(m_Lyric.m_has_lyric)
  2020.             bGotLrc = 1;
  2021.         }
  2022.       }
  2023.       if( !bGotLrc && s.autoDownloadSVPSub  ) {   没有歌词 但自动下载
  2024.         //debug
  2025.         //m_Lyric.LoadLyricFile(L"D:\\-=SVN=-\\test.lrc");
  2026.  
  2027.         m_Lyric.Empty();
  2028.         //download it by thead
  2029.         m_Lyric.title = GetClipInfo(IDS_INFOBAR_TITLE).c_str();
  2030.         m_Lyric.artist = GetClipInfo(IDS_INFOBAR_AUTHOR).c_str();
  2031.         m_Lyric.album = GetClipInfo(IDS_INFOBAR_DESCRIPTION).c_str();
  2032.         m_Lyric.m_sz_current_music_file = m_fnCurPlayingFile;
  2033.         //m_Lyric.m_stop_downloading = 1;
  2034.         //TerminateThread(m_lyricDownloadThread , 0);
  2035.         启动线程下载
  2036.         m_lyricDownloadThread = AfxBeginThread(lyric_fetch_Proc, &m_Lyric, THREAD_PRIORITY_LOWEST, 0, CREATE_SUSPENDED);
  2037.         m_lyricDownloadThread->m_pMainWnd = AfxGetMainWnd();
  2038.         m_lyricDownloadThread->ResumeThread();
  2039.       }
  2040.     }
  2041.   }
  2042.   // send sphash to remote  发送sphash到远程
  2043.   m_wndToolBar.HideMovieShareBtn(TRUE);
  2044.   UserShareController::GetInstance()->HideCommentPlane();
  2045.   UserShareController::GetInstance()->CloseShooterMedia();
  2046.   if(IsSomethingLoaded() && !m_fAudioOnly && (UINT)((INT64)rtDur/10000000) > 90)
  2047.   {
  2048.     m_movieShared = false;
  2049.     m_wndToolBar.HideMovieShareBtn(FALSE);
  2050.     SetTimer(TIMER_MOVIESHARE, 300000, NULL);   
  2051.   }
  2052.   KillTimer(TIMER_IDLE_TASK);
  2053. }
  2054.  
  2055.   进入CMainFrame::OpenSetupCaptureBar 分析
  2056. void CMainFrame::OpenSetupCaptureBar()  初始化头导航
  2057. {
  2058.   初始化控件
  2059.   if(m_iPlaybackMode == PM_CAPTURE)
  2060.   {
  2061.     if(pVidCap && pAMVSCCap) 
  2062.     {
  2063.       CComQIPtr<IAMVfwCaptureDialogs> pVfwCD = pVidCap;
  2064.  
  2065.       if(!pAMXBar && pVfwCD)
  2066.       {
  2067.         m_wndCaptureBar.m_capdlg.SetupVideoControls(m_VidDispName, pAMVSCCap, pVfwCD);
  2068.       }
  2069.       else
  2070.       {
  2071.         m_wndCaptureBar.m_capdlg.SetupVideoControls(m_VidDispName, pAMVSCCap, pAMXBar, pAMTuner);
  2072.       }
  2073.     }
  2074.  
  2075.     if(pAudCap && pAMASC)
  2076.     {
  2077.       CInterfaceArray<IAMAudioInputMixer> pAMAIM;
  2078.       BeginEnumPins(pAudCap, pEP, pPin)
  2079.       {
  2080.         if(CComQIPtr<IAMAudioInputMixer> pAIM = pPin) 
  2081.           pAMAIM.Add(pAIM);
  2082.       }
  2083.       EndEnumPins
  2084.         m_wndCaptureBar.m_capdlg.SetupAudioControls(m_AudDispName, pAMASC, pAMAIM);
  2085.     }
  2086.   }
  2087.  
  2088.   BuildGraphVideoAudio(
  2089.     m_wndCaptureBar.m_capdlg.m_fVidPreview, false, 
  2090.     m_wndCaptureBar.m_capdlg.m_fAudPreview, false);
  2091. }
  2092.  
  2093.   进入CMainFrame::BuildGraphVideoAudio 分析
  2094. bool CMainFrame::BuildGraphVideoAudio(int fVPreview, bool fVCapture, int fAPreview, bool fACapture)
  2095. {
  2096.   if(!pCGB) return(false);  不存在直接返回  关键是pCGB另一个
  2097.  
  2098.   SaveMediaState;
  2099.  
  2100.   HRESULT hr;
  2101.  
  2102.   pGB->NukeDownstream(pVidCap);
  2103.   pGB->NukeDownstream(pAudCap);
  2104.  
  2105.   CleanGraph();
  2106.  
  2107.   if(pAMVSCCap) hr = pAMVSCCap->SetFormat(&m_wndCaptureBar.m_capdlg.m_mtv);
  2108.   if(pAMVSCPrev) hr = pAMVSCPrev->SetFormat(&m_wndCaptureBar.m_capdlg.m_mtv);
  2109.   if(pAMASC) hr = pAMASC->SetFormat(&m_wndCaptureBar.m_capdlg.m_mta);
  2110.  
  2111.   CComPtr<IBaseFilter> pVidBuffer = m_wndCaptureBar.m_capdlg.m_pVidBuffer;
  2112.   CComPtr<IBaseFilter> pAudBuffer = m_wndCaptureBar.m_capdlg.m_pAudBuffer;
  2113.   CComPtr<IBaseFilter> pVidEnc = m_wndCaptureBar.m_capdlg.m_pVidEnc;
  2114.   CComPtr<IBaseFilter> pAudEnc = m_wndCaptureBar.m_capdlg.m_pAudEnc;
  2115.   CComPtr<IBaseFilter> pMux = m_wndCaptureBar.m_capdlg.m_pMux;
  2116.   CComPtr<IBaseFilter> pDst = m_wndCaptureBar.m_capdlg.m_pDst;
  2117.   CComPtr<IBaseFilter> pAudMux = m_wndCaptureBar.m_capdlg.m_pAudMux;
  2118.   CComPtr<IBaseFilter> pAudDst = m_wndCaptureBar.m_capdlg.m_pAudDst;
  2119.  
  2120.   bool fFileOutput = (pMux && pDst) || (pAudMux && pAudDst);
  2121.   bool fCapture = (fVCapture || fACapture);
  2122.  
  2123.   if(pAudCap)
  2124.   {
  2125.     AM_MEDIA_TYPE* pmt = &m_wndCaptureBar.m_capdlg.m_mta;
  2126.     int ms = (fACapture && fFileOutput && m_wndCaptureBar.m_capdlg.m_fAudOutput) ? AUDIOBUFFERLEN : 60;
  2127.     if(pMux != pAudMux && fACapture) SetLatency(pAudCap, -1);
  2128.     else if(pmt->pbFormat) SetLatency(pAudCap, ((WAVEFORMATEX*)pmt->pbFormat)->nAvgBytesPerSec * ms / 1000);
  2129.   }
  2130.  
  2131.   CComPtr<IPin> pVidCapPin, pVidPrevPin, pAudCapPin, pAudPrevPin;
  2132.   BuildToCapturePreviewPin(pVidCap, &pVidCapPin, &pVidPrevPin, pAudCap, &pAudCapPin, &pAudPrevPin);
  2133.  
  2134.   // if(pVidCap)
  2135.   {
  2136.     bool fVidPrev = pVidPrevPin && fVPreview;
  2137.     bool fVidCap = pVidCapPin && fVCapture && fFileOutput && m_wndCaptureBar.m_capdlg.m_fVidOutput;
  2138.  
  2139.     if(fVPreview == 2 && !fVidCap && pVidCapPin)
  2140.     {
  2141.       pVidPrevPin = pVidCapPin;
  2142.       pVidCapPin = NULL;
  2143.     }
  2144.  
  2145.     if(fVidPrev)
  2146.     {
  2147.       m_pCAP = NULL;
  2148.       m_pCAP2 = NULL;
  2149.       m_pCAPR = NULL;
  2150.       pGB->Render(pVidPrevPin);
  2151.       pGB->FindInterface(__uuidof(ISubPicAllocatorPresenter), (void**)&m_pCAP, FALSE);
  2152.       pGB->FindInterface(__uuidof(ISubPicAllocatorPresenterRender), (void**)&m_pCAPR, TRUE);
  2153.       pGB->FindInterface(__uuidof(ISubPicAllocatorPresenter2), (void**)&m_pCAP2, TRUE);
  2154.     }
  2155.  
  2156.     if(fVidCap)
  2157.     {
  2158.       IBaseFilter* pBF[3] = {pVidBuffer, pVidEnc, pMux};
  2159.       HRESULT hr = BuildCapture(pVidCapPin, pBF, MEDIATYPE_Video, &m_wndCaptureBar.m_capdlg.m_mtcv);
  2160.     }
  2161.  
  2162.     pAMDF = NULL;
  2163.     pCGB->FindInterface(&PIN_CATEGORY_CAPTURE, &MEDIATYPE_Video, pVidCap, IID_IAMDroppedFrames, (void**)&pAMDF);
  2164.   }
  2165.  
  2166.   // if(pAudCap)
  2167.   {
  2168.     bool fAudPrev = pAudPrevPin && fAPreview;
  2169.     bool fAudCap = pAudCapPin && fACapture && fFileOutput && m_wndCaptureBar.m_capdlg.m_fAudOutput;
  2170.  
  2171.     if(fAPreview == 2 && !fAudCap && pAudCapPin)
  2172.     {
  2173.       pAudPrevPin = pAudCapPin;
  2174.       pAudCapPin = NULL;
  2175.     }
  2176.  
  2177.     if(fAudPrev)
  2178.     {
  2179.       pGB->Render(pAudPrevPin);
  2180.     }
  2181.  
  2182.     if(fAudCap)
  2183.     {
  2184.       IBaseFilter* pBF[3] = {pAudBuffer, pAudEnc, pAudMux ? pAudMux : pMux};
  2185.       HRESULT hr = BuildCapture(pAudCapPin, pBF, MEDIATYPE_Audio, &m_wndCaptureBar.m_capdlg.m_mtca);
  2186.     }
  2187.   }
  2188.  
  2189.   if((pVidCap || pAudCap) && fCapture && fFileOutput)
  2190.   {
  2191.     if(pMux != pDst)
  2192.     {
  2193.       hr = pGB->AddFilter(pDst, L"File Writer V/A");
  2194.       hr = pGB->ConnectFilter(GetFirstPin(pMux, PINDIR_OUTPUT), pDst);
  2195.     }
  2196.  
  2197.     if(CComQIPtr<IConfigAviMux> pCAM = pMux)
  2198.     {
  2199.       int nIn, nOut, nInC, nOutC;
  2200.       CountPins(pMux, nIn, nOut, nInC, nOutC);
  2201.       pCAM->SetMasterStream(nInC-1);
  2202.       // pCAM->SetMasterStream(-1);
  2203.       pCAM->SetOutputCompatibilityIndex(FALSE);
  2204.     }
  2205.  
  2206.     if(CComQIPtr<IConfigInterleaving> pCI = pMux)
  2207.     {
  2208.       // if(FAILED(pCI->put_Mode(INTERLEAVE_CAPTURE)))
  2209.       if(FAILED(pCI->put_Mode(INTERLEAVE_NONE_BUFFERED)))
  2210.         pCI->put_Mode(INTERLEAVE_NONE);
  2211.  
  2212.       REFERENCE_TIME rtInterleave = 10000i64*AUDIOBUFFERLEN, rtPreroll = 0;//10000i64*500
  2213.       pCI->put_Interleaving(&rtInterleave, &rtPreroll);
  2214.     }
  2215.  
  2216.     if(pMux != pAudMux && pAudMux != pAudDst)
  2217.     {
  2218.       hr = pGB->AddFilter(pAudDst, L"File Writer A");
  2219.       hr = pGB->ConnectFilter(GetFirstPin(pAudMux, PINDIR_OUTPUT), pAudDst);
  2220.     }
  2221.   }
  2222.  
  2223.   REFERENCE_TIME stop = MAX_TIME;
  2224.   hr = pCGB->ControlStream(&PIN_CATEGORY_CAPTURE, NULL, NULL, NULL, &stop, 0, 0); // stop in the infinite
  2225.  
  2226.   CleanGraph();
  2227.  
  2228.   OpenSetupVideo();
  2229.   OpenSetupAudio();
  2230.  
  2231.   RestoreMediaState;
  2232.  
  2233.   return(true);
  2234. }
  2235.  
  2236. OnFilePostOpenmedia() 中  SetTimer(TIMER_MOVIESHARE, 300000, NULL);  
  2237.   case TIMER_MOVIESHARE:
  2238.     {
  2239.       KillTimer(TIMER_MOVIESHARE);
  2240.       if (IsSomethingLoaded() && !m_fAudioOnly && !m_movieShared)  已经加载  不是音频 文件不共享
  2241.       {
  2242.         m_movieShared = true;
  2243.         std::wstring uuid, moviehash;
  2244.         SPlayerGUID::GenerateGUID(uuid);
  2245.         UserShareController* usc = UserShareController::GetInstance();
  2246.         usc->CreateCommentPlane();
  2247.         moviehash = HashController::GetInstance()->GetSPHash(m_fnCurPlayingFile);
  2248.         usc->ShareMovie(uuid, moviehash, m_fnCurPlayingFile.GetString());
  2249.       }
  2250.     }
  2251.     break;
  2252.  
  2253.    进入CMainFrame::ZoomVideoWindow 分析
  2254. void CMainFrame::ZoomVideoWindow(double scale)
  2255. {
  2256.   if(m_iMediaLoadState != MLS_LOADED)    return;  没有装载 直接退出 ？
  2257.  
  2258.   AppSettings& s = AfxGetAppSettings();
  2259.  
  2260.   if(s.bUserAeroUI()){   用户区域UI
  2261.     m_lTransparentToolbarStat = 0;
  2262.     m_wndFloatToolBar->ShowWindow(SW_HIDE);
  2263.   }
  2264.  
  2265.   BOOL bThisIsAutoZoom = false;  自动大小
  2266.  
  2267.   if(scale <= 0)
  2268.   {
  2269.     bThisIsAutoZoom = true;
  2270.     scale = 
  2271.       s.iZoomLevel == 0 ? 0.5 : 
  2272.       s.iZoomLevel == 1 ? 1.0 : 
  2273.       s.iZoomLevel == 2 ? 2.0 : 
  2274.       s.iZoomLevel == 3 ? GetZoomAutoFitScale() : 
  2275.       1.0;
  2276.     m_last_size_of_current_kind_of_video.cx = -1;
  2277.     m_last_size_of_current_kind_of_video.cy = -1;
  2278.   }
  2279.  
  2280.   if(m_fFullScreen)  如果全屏 则全屏
  2281.   {
  2282.     OnViewFullscreen();
  2283.   }
  2284.  
  2285.   MINMAXINFO mmi;
  2286.   OnGetMinMaxInfo(&mmi);
  2287.  
  2288.   CRect r;
  2289.   int w = 0, h = 0;
  2290.  
  2291.   if(!m_fAudioOnly)  不是音频
  2292.   {
  2293.     CSize arxy = m_original_size_of_current_video = GetVideoSize();
  2294.     long lWidth = int(arxy.cx * scale + 0.5);
  2295.     long lHeight = int(arxy.cy * scale + 0.5);
  2296.     CString string_remember_windows_size_for_this_video_size_parm;
  2297.     string_remember_windows_size_for_this_video_size_parm.Format(L"ORGSIZE%dx%d", m_original_size_of_current_video.cx, m_original_size_of_current_video.cy );
  2298.     AppSettings& s = AfxGetAppSettings();
  2299.     long lPerfWidth = m_last_size_of_current_kind_of_video.cx = AfxGetMyApp()->GetProfileInt(ResStr(IDS_R_SETTINGS)+L"REMENBERWNDSIZE", string_remember_windows_size_for_this_video_size_parm+L"W", -1);
  2300.     long lPerfHeight = m_last_size_of_current_kind_of_video.cy = AfxGetMyApp()->GetProfileInt(ResStr(IDS_R_SETTINGS)+L"REMENBERWNDSIZE", string_remember_windows_size_for_this_video_size_parm+L"H", -1);
  2301.  
  2302.     DWORD style = GetStyle();
  2303.  
  2304.     CRect r3 ,r4;
  2305.     GetWindowRect(r3);
  2306.     m_wndView.GetWindowRect(r4);
  2307.     //GetClientRect(&r1);
  2308.     //m_wndView.GetClientRect(&r2);
  2309.     int wDelta = 0;
  2310.     int hDelta = 0;
  2311.  
  2312.     wDelta = r3.Width() - r4.Width();
  2313.     hDelta = r3.Height() - r4.Height();
  2314.  
  2315.     if(style&WS_CAPTION)
  2316.     {
  2317.       //h += GetSystemMetrics(SM_CYCAPTION);
  2318.       //w += 2; h += 2; // for the 1 pixel wide sunken frame
  2319.       //w += 2; h += 3; // for the inner black border
  2320.     }
  2321.  
  2322.     GetWindowRect(r);
  2323.  
  2324.     if (lHeight + hDelta < 280 || lWidth + wDelta < 480) {
  2325.       int w1 = 480 - wDelta;
  2326.       int h1 = 280 - hDelta;
  2327.       SVP_ASSERT(w1 > 0);
  2328.       SVP_ASSERT(h1 > 0);
  2329.  
  2330.       // Re-evaluate current 'w' and 'h' to keep aspect ratio
  2331.       int h2 = arxy.cy * w1 / arxy.cx, w2 = arxy.cx * h1 / arxy.cy;
  2332.       // Choose by the fitting rectangle.
  2333.       if (h2 + hDelta >= 280) {
  2334.         w = 480;
  2335.         h = h2 + hDelta;
  2336.       } else {
  2337.         w = w2 + wDelta;
  2338.         h = 280;
  2339.       }
  2340.  
  2341.  
  2342.     } else {
  2343.       h = lHeight + hDelta;
  2344.       w = lWidth + wDelta;
  2345.     }
  2346.  
  2347.  
  2348.     if(bThisIsAutoZoom && 0){
  2349.       double mratio = (double)lHeight/lWidth;
  2350.       //SVP_LogMsg5(L"%d %d %f %d %d %f",h , w, w * mratio + (h - lHeight), lHeight, lWidth, mratio);
  2351.       h = max(h , w * mratio + (h - lHeight));
  2352.     }
  2353.  
  2354.  
  2355.     if(bThisIsAutoZoom && lPerfWidth > 240 && lPerfHeight > 120)
  2356.     {
  2357.       //Only do this if its auto zoom
  2358.       w = lPerfWidth;
  2359.       h = lPerfHeight;
  2360.     }
  2361.   }
  2362.   else
  2363.   {
  2364.     GetWindowRect(r);
  2365.  
  2366.  
  2367.     //w = r.Width(); //;mmi.ptMinTrackSize.x;
  2368.     //h = r.Height();//;mmi.ptMinTrackSize.y;
  2369.     w = 320;
  2370.     if(s.bUserAeroUI()){
  2371.       w /= 0.9;
  2372.     }
  2373.     h = 110;
  2374.  
  2375.  
  2376.     AppSettings& s = AfxGetAppSettings();
  2377.     long lPerfWidth = m_last_size_of_current_kind_of_video.cx = AfxGetMyApp()->GetProfileInt(ResStr(IDS_R_SETTINGS)+L"REMENBERWNDSIZE", L"ORGSIZE0x0W", -1);
  2378.     long lPerfHeight = m_last_size_of_current_kind_of_video.cy = AfxGetMyApp()->GetProfileInt(ResStr(IDS_R_SETTINGS)+L"REMENBERWNDSIZE", L"ORGSIZE0x0H", -1);
  2379.  
  2380.  
  2381.     w = max(w, lPerfWidth);
  2382.     h = max(h, lPerfHeight);
  2383.  
  2384.  
  2385.   }
  2386.  
  2387.  
  2388.   // center window
  2389.   //if(!s.fRememberWindowPos)
  2390.   {
  2391.     CPoint cp = r.CenterPoint();
  2392.     r.left = cp.x - w/2;
  2393.     r.top = cp.y - h/2;
  2394.   }
  2395.  
  2396.  
  2397.   r.right = r.left + w;
  2398.   r.bottom = r.top + h;
  2399.  
  2400.  
  2401.   MONITORINFO mi;
  2402.   mi.cbSize = sizeof(MONITORINFO);
  2403.  
  2404.  
  2405.   获得窗体信息
  2406.   GetMonitorInfo(MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST), &mi);
  2407.   if(r.right > mi.rcWork.right) r.OffsetRect(mi.rcWork.right-r.right, 0);
  2408.   if(r.left < mi.rcWork.left) r.OffsetRect(mi.rcWork.left-r.left, 0);
  2409.   if(r.bottom > mi.rcWork.bottom) r.OffsetRect(0, mi.rcWork.bottom-r.bottom);
  2410.   if(r.top < mi.rcWork.top) r.OffsetRect(0, mi.rcWork.top-r.top);
  2411.   CRect rcWork(mi.rcWork);
  2412.   if(r.Width() >  rcWork.Width() ){
  2413.     r.left = rcWork.left;
  2414.     r.right = rcWork.right;
  2415.   }
  2416.   if(r.Height() >  rcWork.Height() ){
  2417.     r.top = rcWork.top;
  2418.     r.bottom = rcWork.bottom;
  2419.   }
  2420.   if(m_fFullScreen || !s.HasFixedWindowSize())
  2421.   {
  2422.     MoveWindow(r);
  2423.   }
  2424.  
  2425.  
  2426.   //AfxMessageBox(_T("1"));
  2427.   //Sleep(200);
  2428.   // ShowWindow(SW_SHOWNORMAL);
  2429.  
  2430.  
  2431.   MoveVideoWindow();
  2432. }
  2433.  
  2434.  
  2435.  
  2436.  
  2437.    进入CMainFrame::ToggleFullscreen 分析
  2438. void CMainFrame::ToggleFullscreen(bool fToNearest, bool fSwitchScreenResWhenHasTo)
  2439. {
  2440.   CRect r;
  2441.   m_lastTimeToggleFullsreen = AfxGetMyApp()->GetPerfCounter();
  2442.   // const CWnd* pWndInsertAfter;
  2443.   DWORD dwRemove = 0, dwAdd = 0;
  2444.   DWORD dwRemoveEx = 0, dwAddEx = 0;
  2445.   HMENU hMenu;
  2446.  
  2447.  
  2448.   if(!m_fFullScreen)  
  2449.   {  不是全屏
  2450.  
  2451.  
  2452.     if(m_wndPlaylistBar.IsVisible()){
  2453.       m_fPlaylistBeforeToggleFullScreen = true;
  2454.       ShowControlBar(&m_wndPlaylistBar, FALSE, TRUE);
  2455.     }
  2456.  
  2457.  
  2458.     GetWindowRect(&m_lastWindowRect);
  2459.  
  2460.  
  2461.     dispmode& dm = AfxGetAppSettings().dmFullscreenRes;
  2462.     m_dmBeforeFullscreen.fValid = false;
  2463.     if(dm.fValid && fSwitchScreenResWhenHasTo)
  2464.     {
  2465.       GetCurDispMode(m_dmBeforeFullscreen);
  2466.       SetDispMode(dm);
  2467.     }
  2468.  
  2469.  
  2470.     MONITORINFO mi;
  2471.     mi.cbSize = sizeof(MONITORINFO);
  2472.     GetMonitorInfo(MonitorFromWindow(m_hWnd, MONITOR_DEFAULTTONEAREST), &mi);
  2473.  
  2474.  
  2475.     dwRemove = WS_CAPTION|WS_THICKFRAME;
  2476.     if(fToNearest) r = mi.rcMonitor;
  2477.     else GetDesktopWindow()->GetWindowRect(&r);
  2478.     hMenu = NULL;
  2479.  
  2480.  
  2481.  
  2482.  
  2483.   }
  2484.   else
  2485.   {
  2486.     全屏
  2487.     if( AfxGetAppSettings().htpcmode){
  2488.       return;
  2489.     }
  2490.     if( m_fPlaylistBeforeToggleFullScreen )  
  2491.       ShowControlBar(&m_wndPlaylistBar, TRUE, TRUE);
  2492.  
  2493.  
  2494.     if(m_dmBeforeFullscreen.fValid)
  2495.       SetDispMode(m_dmBeforeFullscreen);
  2496.  
  2497.  
  2498.     dwAdd = (AfxGetAppSettings().fHideCaptionMenu ? 0 : WS_CAPTION) | WS_THICKFRAME;
  2499.     r = m_lastWindowRect;
  2500.     hMenu = NULL;//AfxGetAppSettings().fHideCaptionMenu ? NULL : m_hMenuDefault;
  2501.   }
  2502.  
  2503.  
  2504.  
  2505.  
  2506.  
  2507.  
  2508.   //bool fAudioOnly = m_fAudioOnly;
  2509.   //m_fAudioOnly = true;
  2510.  
  2511.  
  2512.   m_fFullScreen = !m_fFullScreen;
  2513.  
  2514.  
  2515.   SetAlwaysOnTop(AfxGetAppSettings().iOnTop);
  2516.  
  2517.  
  2518.   修改属性  进行全屏
  2519.   ModifyStyle(dwRemove, dwAdd, SWP_NOZORDER);
  2520.   ModifyStyleEx(dwRemoveEx, dwAddEx, SWP_NOZORDER);
  2521.   ::SetMenu(m_hWnd, hMenu);
  2522.   SetWindowPos(NULL, r.left, r.top, r.Width(), r.Height(), SWP_NOZORDER|SWP_NOSENDCHANGING /*SWP_FRAMECHANGED*/);
  2523.   RedrawNonClientArea();
  2524.  
  2525.  
  2526.   KillTimer(TIMER_FULLSCREENCONTROLBARHIDER);
  2527.   KillTimer(TIMER_FULLSCREENMOUSEHIDER);
  2528.   if(m_fFullScreen)
  2529.   {
  2530.     // SVP_LogMsg5(L"Fullscreen");
  2531.     m_fHideCursor = true;
  2532.     SetTimer(TIMER_FULLSCREENMOUSEHIDER, 800, NULL);
  2533.     ShowControls(CS_NONE, false);
  2534.   }
  2535.   else
  2536.   {
  2537.     m_lastMouseMove.x = m_lastMouseMove.y = -1;
  2538.     m_fHideCursor = false;
  2539.     ShowControls(AfxGetAppSettings().nCS);
  2540.   }
  2541.  
  2542.  
  2543.   m_wndView.SetWindowPos(NULL, 0, 0, 0, 0, SWP_FRAMECHANGED|SWP_NOSIZE|SWP_NOMOVE|SWP_NOZORDER);
  2544.   //m_fAudioOnly = fAudioOnly;
  2545.  
  2546.  
  2547.   rePosOSD();
  2548.  
  2549.  
  2550.   MoveVideoWindow();
  2551.  
  2552.  
  2553.   // insert after the HWND_TOP if the player is not full screen
  2554.   if (m_fFullScreen)  全屏的话  就置顶
  2555.     ::SetWindowPos(m_hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOREDRAW|SWP_NOSIZE|SWP_NOMOVE);
  2556.   else
  2557.     ::SetWindowPos(m_hWnd, HWND_TOP, 0, 0, 0, 0, SWP_NOREDRAW|SWP_NOSIZE|SWP_NOMOVE);
  2558. }
  2559.  
  2560.  
  2561.  
  2562.  
  2563. TIMER_STREAMPOSPOLLER:  定时事件
  2564.   case TIMER_STREAMPOSPOLLER:
  2565.     if (m_iMediaLoadState == MLS_LOADED)
  2566.       _HandleTimer_StreamPosPoller();
  2567.     break;
  2568.  
  2569.  
  2570. void CMainFrame::_HandleTimer_StreamPosPoller()   处理位置信息  比如播放进度
  2571. {
  2572.   REFERENCE_TIME rtNow = 0, rtDur = 0;
  2573.  
  2574.  
  2575.   if (m_iPlaybackMode == PM_FILE)
  2576.   {
  2577.     pMS->GetCurrentPosition(&rtNow);
  2578.     pMS->GetDuration(&rtDur);
  2579.  
  2580.  
  2581.     if (m_rtDurationOverride >= 0)
  2582.       rtDur = m_rtDurationOverride;
  2583.  
  2584.  
  2585.     m_wndSeekBar.Enable(rtDur > 0);
  2586.     m_wndSeekBar.SetRange(0, rtDur);
  2587.     m_wndSeekBar.SetPos(rtNow);
  2588.   }
  2589.   else if (m_iPlaybackMode == PM_CAPTURE)
  2590.   {
  2591.     if (m_fCapturing && m_wndCaptureBar.m_capdlg.m_pMux)
  2592.     {
  2593.       CComQIPtr<IMediaSeeking> pMuxMS = m_wndCaptureBar.m_capdlg.m_pMux;
  2594.       if (!pMuxMS || FAILED(pMuxMS->GetCurrentPosition(&rtNow)))
  2595.         rtNow = 0;
  2596.     }
  2597.  
  2598.  
  2599.     if (m_rtDurationOverride >= 0)
  2600.       rtDur = m_rtDurationOverride;
  2601.  
  2602.  
  2603.     m_wndSeekBar.Enable(false);
  2604.     m_wndSeekBar.SetRange(0, rtDur);
  2605.     m_wndSeekBar.SetPos(rtNow);
  2606.     /*
  2607.     if (m_fCapturing)
  2608.     {
  2609.     if (rtNow > 10000i64*1000*60*60*3)
  2610.     m_wndCaptureBar.m_capdlg.OnRecord();
  2611.     }
  2612.     */
  2613.   }
  2614.  
  2615.  
  2616.   if (m_pCAP && (m_iPlaybackMode != PM_FILE || m_bMustUseExternalTimer))
  2617.   {
  2618.     g_bExternalSubtitleTime = true;
  2619.     AfxGetAppSettings().bExternalSubtitleTime = true;
  2620.     if (pDVDI)
  2621.     {
  2622.       DVD_PLAYBACK_LOCATION2 Location;
  2623.       if (pDVDI->GetCurrentLocation(&Location) == S_OK)
  2624.       {
  2625.         double fps = Location.TimeCodeFlags == DVD_TC_FLAG_25fps ? 25.0
  2626.           : Location.TimeCodeFlags == DVD_TC_FLAG_30fps ? 30.0
  2627.           : Location.TimeCodeFlags == DVD_TC_FLAG_DropFrame ? 29.97
  2628.           : 25.0;
  2629.  
  2630.  
  2631.         LONGLONG rtTimeCode = HMSF2RT(Location.TimeCode, fps);
  2632.         m_pCAP->SetTime(rtTimeCode);
  2633.       }
  2634.       else
  2635.         m_pCAP->SetTime(/*rtNow*/m_wndSeekBar.GetPos());
  2636.     }
  2637.     else
  2638.       m_pCAP->SetTime(/*rtNow*/m_wndSeekBar.GetPos());
  2639.   }
  2640.   else
  2641.   {
  2642.     g_bExternalSubtitleTime = false;
  2643.     AfxGetAppSettings().bExternalSubtitleTime = false;
  2644.   }
  2645. }
  2646.  
  2647.  
  2648.  
  2649.  
  2650. TIMER_STREAMPOSPOLLER2: 定时设置
  2651.   case TIMER_STREAMPOSPOLLER2:
  2652.     if (m_iMediaLoadState == MLS_LOADED)   设置位置  和  时间
  2653.     {
  2654.       __int64 start, stop, pos;
  2655.       m_wndSeekBar.GetRange(start, stop);
  2656.       pos = m_wndSeekBar.GetPosReal();
  2657.  
  2658.  
  2659.       if (ABControlOn && m_bRefTime > m_aRefTime && GetMediaState() == State_Running)
  2660.       {
  2661.         if (pos > m_bRefTime)
  2662.           //goto aRefTimer
  2663.           SeekTo(m_aRefTime, 0);
  2664.       }
  2665.       GUID tf;
  2666.       pMS->GetTimeFormat(&tf);
  2667.  
  2668.  
  2669.       if (m_iPlaybackMode == PM_CAPTURE && !m_fCapturing)
  2670.       {
  2671.         CString str = _T("Live");
  2672.         long lChannel = 0, lVivSub = 0, lAudSub = 0;
  2673.         if (pAMTuner 
  2674.           && m_wndCaptureBar.m_capdlg.IsTunerActive()
  2675.           && SUCCEEDED(pAMTuner->get_Channel(&lChannel, &lVivSub, &lAudSub)))
  2676.         {
  2677.           CString ch;
  2678.           ch.Format(_T(" (ch%d)"), lChannel);
  2679.           str += ch;
  2680.         }
  2681.         //m_wndStatusBar.SetStatusTimer(str);
  2682.         m_wndToolBar.SetStatusTimer(str);
  2683.       }
  2684.       else
  2685.       {
  2686.         double pRate;
  2687.         if (E_NOTIMPL == pMS->GetRate(&pRate))
  2688.           pRate = 0;
  2689.         m_wndToolBar.SetStatusTimer(pos, stop, 0, &tf, pRate);
  2690.         //m_wndToolBar.SetStatusTimer(str);
  2691.       }
  2692.  
  2693.  
  2694.       if (m_pCAPR && GetMediaState() == State_Paused)
  2695.         m_pCAPR->Paint(true);
  2696.     }
  2697.     break;
  2698.  
  2699.  
  2700.  
  2701.  
  2702.  
  2703.  
  2704.  
  2705.  
  2706.   case TIMER_STATS:   定时 事件
  2707.     _HandleTimer_Stats();   处理事件状态
  2708.     break;
  2709. void CMainFrame::_HandleTimer_Stats()
  2710. {
  2711.   m_l_been_playing_sec++;
  2712.   if (AfxGetMyApp()->IsWin7() && pTBL)
  2713.   {
  2714.     try
  2715.     {
  2716.       BOOL bHasValue = 0;
  2717.       BOOL bSetPaused = 0;
  2718.       if (IsSomethingLoaded())   确认已经加载
  2719.       {
  2720.         //TBPF_PAUSED
  2721.         //TBPF_NORMAL
  2722.         //TBPF_INDETERMINATE
  2723.         switch (GetMediaState())
  2724.         {
  2725.         case State_Paused:
  2726.           //not using TBPF_PAUSED since it hide progress
  2727.           pTBL->SetProgressState(m_hWnd,TBPF_NORMAL);
  2728.           bSetPaused = true;
  2729.           bHasValue = true;
  2730.           break;
  2731.         case State_Running:
  2732.           pTBL->SetProgressState(m_hWnd,TBPF_NORMAL);
  2733.           bHasValue = true;
  2734.           break;
  2735.         case State_Stopped:
  2736.           pTBL->SetProgressState(m_hWnd,TBPF_NOPROGRESS);
  2737.           break;
  2738.         }
  2739.       }
  2740.       else
  2741.         pTBL->SetProgressState(m_hWnd,TBPF_NOPROGRESS);
  2742.  
  2743.  
  2744.       if (bHasValue)
  2745.       {
  2746.         __int64 iSeekStart, iSeekStop;
  2747.         m_wndSeekBar.GetRange(iSeekStart, iSeekStop);
  2748.         __int64 iSeekPos = m_wndSeekBar.GetPosReal();
  2749.         pTBL->SetProgressValue(m_hWnd, iSeekPos ,(iSeekStop - iSeekStart));
  2750.       }
  2751.       if (bSetPaused)
  2752.         pTBL->SetProgressState(m_hWnd,TBPF_PAUSED);
  2753.     }
  2754.     catch (...)
  2755.     {
  2756.       pTBL->Release();
  2757.       pTBL = NULL;
  2758.     }
  2759.   }
  2760.  
  2761.  
  2762.   if (IsSomethingLoaded() && m_fAudioOnly && (!m_Lyric.m_has_lyric || m_wndView.m_strAudioInfo.IsEmpty()))
  2763.   {    已经加载  是音频  没有歌词
  2764.     m_wndView.m_AudioInfoCounter++;
  2765.     BOOL bHaveInfo = false;
  2766.  
  2767.  
  2768.     for (int i = 0; i < 4; i++)
  2769.     {
  2770.       if ((m_wndView.m_AudioInfoCounter%4) == 0 || m_wndView.m_strAudioInfo.IsEmpty())
  2771.       {
  2772.         CString szInfo , szMusicTitle, szMusicAuthor;
  2773.         szMusicTitle = GetClipInfo(IDS_INFOBAR_TITLE).c_str();
  2774.         szMusicAuthor = GetClipInfo(IDS_INFOBAR_AUTHOR).c_str();
  2775.  
  2776.  
  2777.         switch (m_wndView.m_AudioInfoCounter/4 %4)
  2778.         {
  2779.         case 0:
  2780.           szInfo = szMusicTitle;
  2781.           break;
  2782.         case 1:
  2783.           szInfo = szMusicAuthor;
  2784.           break;
  2785.         case 2:
  2786.           szInfo = GetClipInfo(IDS_INFOBAR_DESCRIPTION).c_str();
  2787.           break;
  2788.         case 3:
  2789.           szInfo = GetClipInfo(IDS_INFOBAR_COPYRIGHT).c_str();
  2790.           break;
  2791.         }
  2792.         if (szInfo.IsEmpty())
  2793.         {
  2794.           m_wndView.m_AudioInfoCounter+=4;
  2795.           continue;
  2796.         }
  2797.         else
  2798.         {
  2799.           m_wndView.m_strAudioInfo = szInfo;
  2800.           CString szTitleItShouleBe = szMusicTitle + _T(" - ") + szMusicAuthor;
  2801.           if (szTitleItShouleBe != m_szTitle)
  2802.           {
  2803.             m_szTitle = szTitleItShouleBe;
  2804.             RedrawNonClientArea();
  2805.           }
  2806.           m_wndView.Invalidate();
  2807.           bHaveInfo = true;
  2808.         }
  2809.       }
  2810.       break;
  2811.     }
  2812.   }
  2813.  
  2814.  
  2815.   if (m_iPlaybackMode == PM_FILE)
  2816.   {
  2817.     REFERENCE_TIME rtNow = 0, rtDur = 0;
  2818.     pMS->GetCurrentPosition(&rtNow);
  2819.     pMS->GetDuration(&rtDur);
  2820.  
  2821.  
  2822.  
  2823.  
  2824.     if (m_fAudioOnly && m_Lyric.m_has_lyric)// && m_wndLycShowBox
  2825.     {
  2826.       int iLastingTime;
  2827.       CString szLyricLine = m_Lyric.GetCurrentLyricLineByTime(rtNow, &iLastingTime);
  2828.       if (!szLyricLine.IsEmpty())
  2829.       {
  2830.         wchar_t music_note[] = {0x266A, 0x0020, 0};
  2831.         szLyricLine.Insert(0, music_note);
  2832.         if (m_wndView.m_strAudioInfo != szLyricLine)
  2833.         {
  2834.           m_wndView.m_strAudioInfo = szLyricLine;
  2835.           if (iLastingTime > 0)
  2836.             m_wndView.SetLyricLasting(iLastingTime);
  2837.           else
  2838.             m_wndView.SetLyricLasting(15);
  2839.           m_wndView.Invalidate();
  2840.         }
  2841.       }
  2842.     }
  2843.  
  2844.  
  2845.     UINT iTotalLenSec = (UINT)( (INT64) rtDur / 20000000 );
  2846.     //如果视频长度大于1分钟， 而且是文件模式，而且正在播放中
  2847.     if (!m_fAudioOnly && iTotalLenSec >  180 && m_iPlaybackMode == PM_FILE && GetMediaState() == State_Running)
  2848.     {
  2849.       time_t time_now = time(NULL);
  2850.       UINT totalplayedtime =  time_now - m_tPlayStartTime;
  2851.       //SVP_LogMsg5(L"time_now > ( m_tLastLogTick  %f %f" , (double)time_now , (double)m_tLastLogTick);
  2852.       if (time_now > ( m_tLastLogTick + 180 ))
  2853.       { //如果和上次检查已经超n秒
  2854.         CString fnVideoFile , fnSubtitleFile; 
  2855.         int subDelayMS = 0;
  2856.         fnVideoFile = m_fnCurPlayingFile;
  2857.         fnSubtitleFile = getCurPlayingSubfile(&subDelayMS);
  2858.  
  2859.  
  2860.         if (!fnSubtitleFile.IsEmpty())
  2861.         { //如果有字幕
  2862.           CString szLog;
  2863.           //szLog.Format(_T(" %s ( with sub %s delay %d ) %d sec of %d sec ( 1/2 length video = %d ) ") , fnVideoFile, fnSubtitleFile,subDelayMS, totalplayedtime , iTotalLenSec, (UINT)(iTotalLenSec/2)  );
  2864.           //SVP_LogMsg(szLog);
  2865.           //if time > 50%
  2866.           if (totalplayedtime > (UINT)(iTotalLenSec/2))
  2867.           {
  2868.             if (!m_haveSubVoted && m_pCAP && rtNow > (rtDur - 3000000000i64))
  2869.             {
  2870.               //如果还没提示过vote
  2871.               //如果时间接近最末5分钟
  2872.               AppSettings& s = AfxGetAppSettings();
  2873.               if (s.bIsChineseUIUser())
  2874.               {
  2875.                 //如果是中文
  2876.                 if ( m_wndPlaylistBar.GetCount() <= 1)
  2877.                 {
  2878.                   //如果是1CD
  2879.                   int nSubPics;
  2880.                   REFERENCE_TIME rtSubNow,  rtSubStart, rtSubStop;
  2881.                   m_pCAP->GetSubStats(nSubPics,rtSubNow,  rtSubStart, rtSubStop);
  2882.                   if (rtSubNow > rtSubStop)
  2883.                   {
  2884.                     //如果没有更多字幕
  2885.                     SVP_LogMsg5(L"Sub Voted Event");
  2886.                     //vote之
  2887.                     m_haveSubVoted = true;
  2888.                   }
  2889.                 }
  2890.               }
  2891.             }
  2892.             //是否已经上传过呢
  2893.             if (m_fnsAlreadyUploadedSubfile.Find(fnVideoFile+fnSubtitleFile) < 0)
  2894.             {
  2895.               //upload subtitle
  2896.               Logging(L"Uploading sub %s of %s width delay %d ms since user played %d sec of %d sec ( more than 1/2 length video ) " , fnSubtitleFile, fnVideoFile ,subDelayMS, totalplayedtime , iTotalLenSec  );
  2897.               SVP_UploadSubFileByVideoAndSubFilePath(fnVideoFile , fnSubtitleFile, subDelayMS);
  2898.               m_fnsAlreadyUploadedSubfile.Append( fnVideoFile+fnSubtitleFile+_T(";") );
  2899.             }
  2900.             int subDelayMS2 = 0;
  2901.             CString fnSubtitleFile2 = getCurPlayingSubfile(&subDelayMS2);
  2902.             if (!fnSubtitleFile2.IsEmpty())
  2903.             {
  2904.               if (m_fnsAlreadyUploadedSubfile.Find( fnVideoFile+fnSubtitleFile2 ) < 0)
  2905.               {
  2906.                 //upload subtitle
  2907.                 Logging((L"Uploading sub2 %s of %s width delay %d ms since user played %d sec of %d sec ( more than 1/2 length video ) ") , fnSubtitleFile2, fnVideoFile ,subDelayMS2, totalplayedtime , iTotalLenSec);
  2908.                 SVP_UploadSubFileByVideoAndSubFilePath(fnVideoFile , fnSubtitleFile2, subDelayMS2);
  2909.                 m_fnsAlreadyUploadedSubfile.Append( fnVideoFile+fnSubtitleFile2+_T(";") );
  2910.               }
  2911.             }
  2912.           }
  2913.         }
  2914.         m_tLastLogTick = time_now;
  2915.         //SVP_LogMsg5(L"m_tLastLogTick = time_now;   %f %f" , (double)time_now , (double)m_tLastLogTick);
  2916.       }
  2917.     }
  2918.   }
  2919.  
  2920.  
  2921.   CString msg;
  2922.   if (m_fBuffering)
  2923.   {
  2924.     BeginEnumFilters(pGB, pEF, pBF)
  2925.     {
  2926.       if (CComQIPtr<IAMNetworkStatus, &IID_IAMNetworkStatus> pAMNS = pBF)
  2927.       {
  2928.         long BufferingProgress = 0;
  2929.         if (SUCCEEDED(pAMNS->get_BufferingProgress(&BufferingProgress)) && BufferingProgress > 0 && BufferingProgress < 99)
  2930.         {
  2931.           msg.Format(ResStr(IDS_CONTROLS_BUFFERING), BufferingProgress);
  2932.           SendStatusMessage(msg,1000);
  2933.           SVP_LogMsg5(msg);
  2934.         }
  2935.         break;
  2936.       }
  2937.     }
  2938.     EndEnumFilters
  2939.   }
  2940.   else if (pAMOP)
  2941.   {
  2942.     __int64 t = 0, c = 0;
  2943.     if(SUCCEEDED(pAMOP->QueryProgress(&t, &c)) && t > 0 && c < t)
  2944.     {
  2945.       msg.Format(ResStr(IDS_CONTROLS_BUFFERING), c*100/t);
  2946.       SendStatusMessage(msg,1000);
  2947.       SVP_LogMsg5(msg);
  2948.     }
  2949.   }
  2950.   m_wndToolBar.m_buffering  = msg;
  2951.  
  2952.  
  2953.   if (m_iPlaybackMode == PM_FILE)
  2954.     SetupChapters();
  2955.   
  2956.  
  2957.  
  2958.   if (GetMediaState() == State_Running)
  2959.   {
  2960.     if (m_fAudioOnly)
  2961.     {
  2962.       UINT fSaverActive = 0;
  2963.       if (SystemParametersInfo(SPI_GETPOWEROFFACTIVE, 0, (PVOID)&fSaverActive, 0))
  2964.       {
  2965.         SystemParametersInfo(SPI_SETPOWEROFFACTIVE, 0, 0, SPIF_SENDWININICHANGE); // this might not be needed at all...
  2966.         SystemParametersInfo(SPI_SETPOWEROFFACTIVE, fSaverActive, 0, SPIF_SENDWININICHANGE);
  2967.       }
  2968.       SetThreadExecutionState(ES_SYSTEM_REQUIRED); 
  2969.     }
  2970.     else
  2971.     {
  2972.       UINT fSaverActive = 0;
  2973.       if (SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, (PVOID)&fSaverActive, 0))
  2974.       {
  2975.         SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 0, 0, SPIF_SENDWININICHANGE); // this might not be needed at all...
  2976.         SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, fSaverActive, 0, SPIF_SENDWININICHANGE);
  2977.       }
  2978.       fSaverActive = 0;
  2979.       if (SystemParametersInfo(SPI_GETPOWEROFFACTIVE, 0, (PVOID)&fSaverActive, 0))
  2980.       {
  2981.         SystemParametersInfo(SPI_SETPOWEROFFACTIVE, 0, 0, SPIF_SENDWININICHANGE); // this might not be needed at all...
  2982.         SystemParametersInfo(SPI_SETPOWEROFFACTIVE, fSaverActive, 0, SPIF_SENDWININICHANGE);
  2983.       }
  2984.       SetThreadExecutionState(ES_DISPLAY_REQUIRED|ES_SYSTEM_REQUIRED); //this is the right way, only this work under vista . no ES_CONTINUOUS  so it can goes to sleep when not playing
  2985.     }
  2986.  
  2987.  
  2988.  
  2989.  
  2990.     if (GetExStyle() & WS_EX_LAYERED)
  2991.     {
  2992.       BYTE dAlpha = 0 ;
  2993.       DWORD dwFlag = 0;
  2994.       if (AfxGetMyApp()->m_pGetLayeredWindowAttributes)
  2995.       {
  2996.         AfxGetMyApp()->m_pGetLayeredWindowAttributes(m_hWnd, NULL, &dAlpha , &dwFlag);
  2997.         if (dAlpha == 255)
  2998.           ModifyStyleEx(WS_EX_LAYERED , 0);
  2999.       }
  3000.     }
  3001.   }
  3002.  
  3003. namespace DSObjects  操作DirectShow类库
  3004.  
  3005.  
  3006. 空间中有
  3007. 操作DirectShow  D3D7
  3008. CDX7AllocatorPresenter继承ISubPicAllocatorPresenterImpl
  3009.  
  3010.  
  3011. 操作DirectShow  D3D9
  3012. CDX9AllocatorPresenter继承ISubPicAllocatorPresenterImpl
  3013.  
  3014.  
  3015. CDXRAllocatorPresenter继承ISubPicAllocatorPresenterImpl
  3016.  
  3017.  
  3018. VMR7分配器
  3019. CVMR7AllocatorPresenter继承CDX7AllocatorPresenter，继承IVMRSurfaceAllocator，继承IVMRImagePresenter，继承IVMRWindowlessControl
  3020.  
  3021.  
  3022. VMR9分配器
  3023. CVMR9AllocatorPresenter继承CDX9AllocatorPresenter,继承IVMRSurfaceAllocator9,继承IVMRImagePresenter9, 继承IVMRWindowlessControl9
  3024.  
  3025.  
  3026. CGenlock   管理视频和显示的同步。
  3027.  
  3028.  
  3029. VR分配器
  3030. CmadVRAllocatorPresenter继承ISubPicAllocatorPresenterImpl
  3031.  
  3032.  
  3033. QT7分配器
  3034. CQT7AllocatorPresenter继承CDX7AllocatorPresenter，继承IQTVideoSurface
  3035.  
  3036.  
  3037. QT9分配器
  3038. CQT9AllocatorPresenter继承CDX9AllocatorPresenter，继承IQTVideoSurface
  3039.  
  3040.  
  3041. Quicktime格式绘图
  3042. CQuicktimeGraph继承CBaseGraph,继承IVideoFrameStep
  3043.  
  3044.  
  3045. Quicktime载体
  3046. CQuicktimeWindow继承CPlayerWindow
  3047.  
  3048.  
  3049. Real格式绘图
  3050. CRealMediaGraph继承CBaseGraph
  3051.  
  3052.  
  3053. Real格式播放
  3054. CRealMediaPlayer继承CUnknown,继承IRMAErrorSink,继承IRMAClientAdviseSink,继承IRMAAuthenticationManager,继承IRMASiteSupplier,继承IRMAPassiveSiteWatcher,继承IRMAAudioHook
  3055.  
  3056.  
  3057. Real格式播放载体
  3058. CRealMediaPlayerWindowed继承CRealMediaPlayer
  3059.  
  3060.  
  3061. Real格式播放载体
  3062. CRealMediaPlayerWindowless继承CRealMediaPlayer
  3063.  
  3064.  
  3065. Real格式视频面
  3066. CRealMediaVideoSurface继承CUnknown，继承IRMAVideoSurface
  3067.  
  3068.  
  3069. Real格式载体站点
  3070. CRealMediaWindowlessSite继承CUnknown,继承IRMASite,继承IRMASite2,继承IRMASiteWindowless,继承IRMAVideoSurface
  3071.  
  3072.  
  3073. RM7分配器
  3074. CRM7AllocatorPresenter继承CDX7AllocatorPresenter，继承IRMAVideoSurface
  3075.  
  3076.  
  3077. RM9分配器
  3078. CRM9AllocatorPresenter继承CDX9AllocatorPresenter,继承IRMAVideoSurface
  3079.  
  3080.  
  3081. Flash绘图
  3082. CShockwaveGraph继承CBaseGraph
  3083.  
  3084.  
  3085.  
  3086.  
  3087.  
  3088.  
  3089. 主程序有的类库：
  3090.  
  3091.  
  3092. 链接广告的类  实现了动画效果
  3093. AdController继承ThreadHelperImpl<AdController>
  3094.  
  3095.  
  3096. ButtonManage  按钮管理类 
  3097.  
  3098.  
  3099. CAboutDlg继承CDialog  关于对话框
  3100.  
  3101.  
  3102. 自定义了一个映射模版类
  3103. template <class T = CString, class S = CString>
  3104. class CAtlStringMap : public CAtlMap<S, T, CStringElementTraits<S> > {};
  3105.  
  3106.  
  3107. 一个音频格式集合类
  3108. class CAudFormatArray : public CFormatArray<AUDIO_STREAM_CONFIG_CAPS>
  3109.  
  3110.  
  3111. 一个作者登陆框
  3112. class CAuthDlg : public CDialog
  3113.  
  3114.  
  3115. 视频绘画类
  3116. class CBaseGraph继承CUnknown, 继承IGraphBuilder2, public IMediaControl, 继承IMediaEventEx, 继承IMediaSeeking, 继承IVideoWindow, 继承IBasicVideo, 继承IBasicAudio, 继承IAMOpenProgress, public IGraphEngine
  3117.  
  3118.  
  3119.  
  3120.  
  3121. class CBtnAlign  按钮位置区域对齐类
  3122.  
  3123.  
  3124. 自绘了Edit类 阙套了Button
  3125. class CBtnEditCtrl继承CWindowImpl<CBtnEditCtrl, CEdit>
  3126.  
  3127.  
  3128. CChildView继承CWnd  窗体类 实现了视频载体
  3129.  
  3130.  
  3131. COM组件属性页站点
  3132. CComPropertyPageSite继承CUnknown，继承IPropertyPageSite
  3133.  
  3134.  
  3135. CConvertChapDlg继承CResizableDialog 转换章节对话框
  3136.  
  3137.  
  3138. CConvertDlg继承CResizableDialog  转换对话框
  3139.  
  3140.  
  3141. CConvertPropsDlg继承CResizableDialog 转换属性页对话框
  3142.  
  3143.  
  3144. CConvertResDlg继承CResizableDialog 转换资源对话框
  3145.  
  3146.  
  3147. 分行过滤器
  3148. CDeinterlacerFilter继承CTransformFilter
  3149.  
  3150.  
  3151. CDisplaySettingDetector 显示设置探测器
  3152.  
  3153.  
  3154. CDlgChkUpdater继承CDialog  确认更新对话框
  3155.  
  3156.  
  3157. CDropTarget  移动文件类
  3158.  
  3159.  
  3160. EVR分配器
  3161. CEVRAllocatorPresenter继承CDX9AllocatorPresenter,继承IMFGetService,继承IMFTopologyServiceLookupClient,继承IMFVideoDeviceID,继承IMFVideoPresenter,继承IDirect3DDeviceManager9,继承IMFAsyncCallback,继承IQualProp,继承IMFRateSupport,继承IMFVideoDisplayControl,继承IEVRTrustedVideoPlugin
  3162.  
  3163.  
  3164. 渐变视频解码
  3165. CFakeDirectXVideoDecoder继承CUnknown,继承IDirectXVideoDecoder
  3166.  
  3167.  
  3168. CFavoriteAddDlg继承CCmdUIDialog  收藏对话框
  3169.  
  3170.  
  3171. CFavoriteOrganizeDlg继承CResizableDialog 收藏组织对话框
  3172.  
  3173.  
  3174. CFFindByDir  目录查找类
  3175.  
  3176.  
  3177. CFFindMoreFiles 查找更多文件类
  3178.  
  3179.  
  3180. CFGAggregator继承CUnknown  FG集合类
  3181.  
  3182.  
  3183. CFGFilter   FG过滤类
  3184.  
  3185.  
  3186. CFGFilterFile继承CFGFilter FG过滤文件
  3187.  
  3188.  
  3189. CFGFilterInternal继承CFGFilter  FG内部过滤
  3190.  
  3191.  
  3192. CFGFilterList  FG过滤列表
  3193.  
  3194.  
  3195. CFGFilterRegistry继承CFGFilter FG过滤继承类
  3196.  
  3197.  
  3198. CFGFilterVideoRenderer继承CFGFilter  FG过滤视频渲染类
  3199.  
  3200.  
  3201. FG管理类
  3202. CFGManager继承CUnknown, 继承IGraphBuilder2, 继承IGraphBuilderDeadEnd, 继承CCritSec
  3203.  
  3204.  
  3205. CFGManagerCapture继承CFGManagerPlayer FG捕捉管理类
  3206.  
  3207.  
  3208. CFGManagerCustom继承CFGManager   FG自定义管理类
  3209.  
  3210.  
  3211. CFGManagerDVD继承CFGManagerPlayer  FG_DVD管理类
  3212.  
  3213.  
  3214. CFGManagerMuxer继承CFGManagerCustom  FG 混合器管理类
  3215.  
  3216.  
  3217. CFGManagerPlayer继承CFGManagerCustom  FG视频管理
  3218.  
  3219.  
  3220. CFileDropTarget继承COleDropTarget   文件移动类
  3221.  
  3222.  
  3223. CFilterMapper2继承CUnknown继承IFilterMapper2   过滤映射类
  3224.  
  3225.  
  3226. CFilterTreeCtrl继承CTreeCtrl   过滤器树列表
  3227.  
  3228.  
  3229. CFloatEdit继承CEdit  浮动的编辑框
  3230.  
  3231.  
  3232. 格式模块
  3233. template<class T>
  3234. class CFormat : public CAutoPtrArray<CFormatElem<T> >
  3235.  
  3236.  
  3237. 格式数组模块
  3238. template<class T>
  3239. class CFormatArray : public CAutoPtrArray<CFormat<T> >
  3240.  
  3241.  
  3242. 格式节点
  3243. template<class T>
  3244. class CFormatElem
  3245.  
  3246.  
  3247. CGoToDlg继承CDialog  转到对话框
  3248.  
  3249.  
  3250. CGraphCore / /我们需要打开/播放暂停/寻求/关闭/ VOL控制/子控制/音频和视频切换的类
  3251.  
  3252.  
  3253. CGraphThread继承CWinThread  播放线程类
  3254.  
  3255.  
  3256. CHexEdit继承CEdit  16进制编辑框
  3257.  
  3258.  
  3259. ChkDefPlayerControlBar继承 CSVPDialog  默认播放控制航
  3260.  
  3261.  
  3262. CIfo  文件信息类
  3263.  
  3264.  
  3265. CInfoReport继承CDialog  信息报告对话框
  3266.  
  3267.  
  3268. CInPlaceComboBox继承CComboBox  阙套下拉框
  3269.  
  3270.  
  3271. CInPlaceEdit继承CEdit  阙套编辑框
  3272.  
  3273.  
  3274. CInPlaceListBox继承CListBox  阙套列表框
  3275.  
  3276.  
  3277. CIntEdit继承CEdit   整形编辑框
  3278.  
  3279.  
  3280. CKeyProvider继承CUnknown，继承IServiceProvider  键盘提供者
  3281.  
  3282.  
  3283. CLineNumberEdit继承CEdit   线数编辑框
  3284.  
  3285.  
  3286. CLineNumberStatic继承CStatic  线数静态框
  3287.  
  3288.  
  3289.  
  3290.  
  3291. CMacrovisionKicker继承CUnknown，继承IKsPropertySet
  3292.  
  3293.  
  3294. 主程序
  3295. CMainFrame继承CFrameWnd，继承CDropTarget,继承CGraphCore
  3296.  
  3297.  
  3298.  
  3299.  
  3300. CMediaFormatCategory   媒体格式分类
  3301.  
  3302.  
  3303. CMediaTypesDlg继承CResizableDialog  媒体类型对话框
  3304.  
  3305.  
  3306. CMemoryDC继承CDC   内存离屏DC
  3307.  
  3308.  
  3309. CMPlayerCApp继承CWinApp 启动类
  3310.  
  3311.  
  3312. CNEWOSDWnd继承CWnd  Osd窗体
  3313.  
  3314.  
  3315. ContentTypeTemp  内容类型
  3316.  
  3317.  
  3318. COpenCapDeviceDlg继承CResizableDialog  打开捕捉设备对话框
  3319.  
  3320.  
  3321. COpenDlg继承CResizableDialog  打开对话框
  3322.  
  3323.  
  3324. COpenFileDlg继承CFileDialog  打开文件对话框
  3325.  
  3326.  
  3327. COpenURLDlg继承CResizableDialog  打开URL 对话框
  3328.  
  3329.  
  3330. 输出EVR
  3331. COuterEVR继承CUnknown,继承IVMRffdshow9,继承IVMRMixerBitmap9,继承IBaseFilter
  3332.  
  3333.  
  3334. 输出VMR9
  3335. COuterVMR9继承CUnknown,继承IVideoWindow,
  3336. 继承IBasicVideo2,继承IVMRWindowlessControl,继承IVMRffdshow9,继承IVMRMixerBitmap9
  3337.  
  3338.  
  3339. CPixelShaderCompiler  像素着色器编译器
  3340.  
  3341.  
  3342. CPlayerCaptureBar继承baseCPlayerCaptureBar  视频捕捉条
  3343.  
  3344.  
  3345. CPlayerCaptureDialog继承CResizableDialog //CDialog 视频捕捉对话框
  3346.  
  3347.  
  3348. CPlayerChannelNormalizer继承CSVPDialog  视频通道正规化对话框
  3349.  
  3350.  
  3351. CPlayerColorControlBar继承CSVPDialog  视频颜色控制条
  3352.  
  3353.  
  3354. CPlayerEQControlBar继承CSVPDialog   视频EQ控制条
  3355.  
  3356.  
  3357. CPlayerFloatToolBar继承CFrameWnd  视频浮动控制条
  3358.  
  3359.  
  3360. CPlayerListCtrl继承CListCtrl  播放器列表
  3361.  
  3362.  
  3363. CPlayerPlaylistBar继承CSizingControlBarG  播放器列表条
  3364.  
  3365.  
  3366. CPlayerSeekBar继承CDialogBar   视频跳转条
  3367.  
  3368.  
  3369. CPlayerShaderEditorBar继承baseCPlayerShaderEditorBar 视频着色编辑条
  3370.  
  3371.  
  3372. CPlayerToolBar继承CToolBar  视频工具条
  3373.  
  3374.  
  3375. CPlayerToolTopBar继承CWnd  视频上面的工具条
  3376.  
  3377.  
  3378. CPlayerWindow继承 CWnd  视频窗体
  3379.  
  3380.  
  3381. CPlaylist继承CList<CPlaylistItem>  播放列表
  3382.  
  3383.  
  3384. CPlaylistItem  播放列表节点
  3385.  
  3386.  
  3387. CPngImage继承CImage  处理png图片
  3388.  
  3389.  
  3390. CPnSPresetsDlg继承CCmdUIDialog  预设对话框
  3391.  
  3392.  
  3393. CPPageBase继承CCmdUIPropertyPage   基本属性页
  3394.  
  3395.  
  3396. CPPageFileInfoClip继承CPropertyPage 文件信息属性页
  3397.  
  3398.  
  3399. CPPageFileInfoDetails继承CPropertyPage  详细文件信息页
  3400.  
  3401.  
  3402. CPPageFileInfoRes继承CPPageBase  文件信息资源属性页
  3403.  
  3404.  
  3405. CPPageFileInfoSheet继承CPropertySheet  文件信息页
  3406.  
  3407.  
  3408. CPPageFileMediaInfo继承CPropertyPage  媒体文件信息
  3409.  
  3410.  
  3411. CPPageFormats  页格式
  3412.  
  3413.  
  3414. CResetDVD继承CDVDSession  重设DVD
  3415.  
  3416.  
  3417. CSaveDlg继承CCmdUIDialog  保存对话框
  3418.  
  3419.  
  3420. CSaveTextFileDialog继承CFileDialog  保存文本文件对话框
  3421.  
  3422.  
  3423. CSaveThumbnailsDialog继承CFileDialog  保存缩略图对话框
  3424.  
  3425.  
  3426. CSeekBarTip继承CWnd   赚到提示信息
  3427.  
  3428.  
  3429. CShaderAutoCompleteDlg继承CResizableDialog  着色自动完成对话框
  3430.  
  3431.  
  3432. CShaderCombineDlg继承CResizableDialog 着色连接对话框
  3433.  
  3434.  
  3435. CShaderEdit继承CLineNumberEdit  着色编辑框
  3436.  
  3437.  
  3438. CShaderEditorDlg继承CResizableDialog  着色编辑对话框
  3439.  
  3440.  
  3441. CShaderLabelComboBox继承CComboBox 着色下拉框
  3442.  
  3443.  
  3444. CShockwaveFlash继承CWnd   flash控件
  3445.  
  3446.  
  3447. CSUIBtnList继承CList<CSUIButton*>  按钮列表
  3448.  
  3449.  
  3450. CSUIButton  自绘按钮类
  3451.  
  3452.  
  3453. CSVPButton继承CButton   自绘按钮
  3454.  
  3455.  
  3456. CSVPDialog继承CWnd    自绘对话框
  3457.  
  3458.  
  3459. CSVPSliderCtrl继承CSliderCtrl  自绘Slider
  3460.  
  3461.  
  3462. CSVPStatic继承CStatic   自绘Static
  3463.  
  3464.  
  3465. CSVPSubUploadDl继承CResizableDialog  字幕上传对话框
  3466.  
  3467.  
  3468. CSVPSubVoteControlBar继承CSVPDialog 
  3469.  
  3470.  
  3471. CTextFile继承CStdioFile  操作文件类
  3472.  
  3473.  
  3474. CTextPassThruFilter继承CBaseFilter,继承CCritSec  文本直通过滤器
  3475.  
  3476.  
  3477. CTextPassThruInputPin继承CSubtitleInputPin  文本直通输入流
  3478.  
  3479.  
  3480. CTextPassThruOutputPin继承CBaseOutputPin  文本直通输出流
  3481.  
  3482.  
  3483. CTransparentControlBar继承CSVPDialog   透明控制条
  3484.  
  3485.  
  3486. CustomDrawBtn继承CButton  自定义按钮
  3487.  
  3488.  
  3489. CVidFormatArray继承CFormatArray<VIDEO_STREAM_CONFIG_CAPS>  视频格式集合
  3490.  
  3491.  
  3492. CVolumeCtrl继承CSliderCtrl  声音控件
  3493.  
  3494.  
  3495. CWebTextFile继承CTextFile  网站文本
  3496.  
  3497.  
  3498. FileAssoc   文件关联
  3499.  
  3500.  
  3501. FilterOverride  过滤器重叠
  3502.  
  3503.  
  3504. FrameCfgFileManage  窗体设置文件管理
  3505.  
  3506.  
  3507. GUIConfigManage GUI配置管理
  3508.  
  3509.  
  3510. 哈希值管理
  3511. HashController继承LazyInstanceImpl<HashController>
  3512.  
  3513.  
  3514. HotkeyCmd继承ACCEL   快捷键
  3515.  
  3516.  
  3517. HotkeyController继承LazyInstanceImpl<HotkeyController>  快捷键控制
  3518.  
  3519.  
  3520. HotkeySchemeParser  快捷键计划分析器
  3521.  
  3522.  
  3523. LayeredWindowUtils  窗体单元
  3524.  
  3525.  
  3526. 实例模版
  3527. template<class T>
  3528. class LazyInstanceImpl
  3529.  
  3530.  
  3531. template<class T>
  3532. class MainFrameSPlayerCmd
  3533.  
  3534.  
  3535. MakeMultiplyBmp
  3536.  
  3537.  
  3538. 媒体中心管理
  3539. MediaCenterController继承LazyInstanceImpl<MediaCenterController>
  3540.  
  3541.  
  3542. 媒体中心视图
  3543. MediaCenterView继承ATL::CWindowImpl<MediaCenterView>,继承MediaScrollbar,继承MediaListView
  3544.  
  3545.  
  3546. MediaCheckDB继承ThreadHelperImpl<MediaCheckDB>  媒体确认数据库
  3547.  
  3548.  
  3549. MediaDB  媒体数据库
  3550.  
  3551.  
  3552. MediaListView 媒体列表视图
  3553.  
  3554.  
  3555. MediaModel继承SourceModel<MediaData, MediaFindCondition>  媒体模式
  3556.  
  3557.  
  3558. MediaScrollbar  媒体滚动条
  3559.  
  3560.  
  3561. MediaSpiderAbstract继承ThreadHelperImpl<T> 媒体摘要
  3562.  
  3563.  
  3564. MediaSpiderFolderTree继承MediaSpiderAbstract<MediaSpiderFolderTree>  媒体摘要树
  3565.  
  3566.  
  3567. MediaSQLite  媒体SQL
  3568.  
  3569.  
  3570. MediaTreeModel 媒体树模式
  3571.  
  3572.  
  3573. MovieComment继承CDHtmlDialog  电影评论
  3574.  
  3575.  
  3576. NetworkControlerImpl 网络任务控制接口
  3577.  
  3578.  
  3579. OpenDeviceData继承OpenMediaData  设备打开方式
  3580.  
  3581.  
  3582. OpenDVDData继承OpenMediaData  DVD打开方式
  3583.  
  3584.  
  3585. OpenFileData继承OpenMediaData   文件打开方式
  3586.  
  3587.  
  3588. OpenMediaData  打开方式基类
  3589.  
  3590.  
  3591. 建议选项属性页
  3592. OptionAdvancedPage继承WTL::CPropertyPageImpl<OptionAdvancedPage>,继承WTL::CWinDataExchange<OptionAdvancedPage>
  3593.  
  3594.  
  3595. 关联文件属性页
  3596. OptionAssociationPage继承WTL::CPropertyPageImpl<OptionAssociationPage>,继承WTL::CWinDataExchange<OptionAssociationPage>
  3597.  
  3598.  
  3599. 基本选项属性页
  3600. OptionBasicPage继承WTL::CPropertyPageImpl<OptionBasicPage>,继承WTL::CWinDataExchange<OptionBasicPage>
  3601.  
  3602.  
  3603. OptionDlg继承WTL::CPropertySheetImpl<OptionDlg>  选项对话框
  3604.  
  3605.  
  3606. 第二字幕选项属性页
  3607. OptionSubtitlePage继承WTL::CPropertyPageImpl<OptionSubtitlePage>,继承WTL::COwnerDraw<OptionSubtitlePage>,继承WTL::CWinDataExchange<OptionSubtitlePage>
  3608.  
  3609.  
  3610. OSDController继承LazyInstanceImpl<OSDController> OSD控制
  3611.  
  3612.  
  3613. OSDView继承ATL::CWindowImpl<OSDView>,继承LayeredWindowUtils<OSDView> OSD视图
  3614.  
  3615.  
  3616. PlayerPreference继承LazyInstanceImpl<PlayerPreference>  播放器引用
  3617.  
  3618.  
  3619. PlaylistController继承LazyInstanceImpl<PlaylistController>  播放列表控制
  3620.  
  3621.  
  3622. PlaylistParser  播放列表分析
  3623.  
  3624.  
  3625. 播放列表视图
  3626. PlaylistView继承ATL::CWindowImpl<PlaylistView>,继承WTL::COwnerDraw<PlaylistView>,继承 WTL::CCustomDraw<PlaylistView>
  3627.  
  3628.  
  3629. PlaylistViewMfcProxy继承CSizingControlBarG   播放列表代理
  3630.  
  3631.  
  3632. SkinDownload继承CDHtmlDialog,继承ThreadHelperImpl<SkinDownload> 皮肤下载
  3633.  
  3634.  
  3635. SkinFolderManager  皮肤管理类
  3636.  
  3637.  
  3638. SnapUploadController继承ThreadHelperImpl<SnapUploadController> 对齐上传控制器
  3639.  
  3640.  
  3641. 源模式模块
  3642. template<class TDATA, class TCONDITION>
  3643. class SourceModel
  3644.  
  3645.  
  3646. SPlayerGUID 播放ID
  3647.  
  3648.  
  3649. SQLliteapp 操作数据库
  3650.  
  3651.  
  3652. ssftest  测试ssf
  3653.  
  3654.  
  3655. SubtitleStyle  内部风格指数提供了实际的映射  字幕渲染设置接受外部字幕滤镜。它还提供Windows基于GDI画画的能力
  3656. 模拟渲染对话框显示的目的。
  3657.  
  3658.  
  3659. 字幕透明控制
  3660. SubTransController继承ThreadHelperImpl<SubTransController>,继承NetworkControlerImpl
  3661.  
  3662.  
  3663. SubTransFormat  字幕透明格式
  3664.  
  3665.  
  3666. SUIVoteStar
  3667.  
  3668.  
  3669. SVPLycShowBox  //歌词显示面板 mouseover时显示半透明玻璃背景、关闭按钮和变色按钮，out后仅显示文字
  3670. //默认在屏幕底部区域显示，可以通过拖拽改变位置  关闭后改为在主窗口界面内显示
  3671.  
  3672.  
  3673. ThemePkg  主题背景
  3674.  
  3675.  
  3676. ThemePkgController 主题背景控制
  3677.  
  3678.  
  3679. TimeBmpManage 事件画面控制
  3680.  
  3681.  
  3682.  上传控制
  3683. UbdUploadController继承ThreadHelperImpl<UbdUploadController>,继承LazyInstanceImpl<UbdUploadController>
  3684.  
  3685.  
  3686. UnCompressZip  解压控制
  3687.  
  3688.  
  3689.  更新控制
  3690. UpdateController继承NetworkControlerImpl,继承ThreadHelperImpl<UpdateController>,继承LazyInstanceImpl<UpdateController>
  3691.  
  3692.  
  3693. 用户着色控制
  3694. UserShareController继承NetworkControlerImpl,继承ThreadHelperImpl<UserShareController>,继承LazyInstanceImpl<UserShareController>
  3695.  
  3696.  
  3697. 用户行为控制
  3698. UsrBehaviorController继承LazyInstanceImpl<UsrBehaviorController>
  3699.  
  3700.  
  3701. 用户行为数据
  3702. UsrBehaviorData
  3703.  
  3704.  
  3705. 今天主要针对  SPlayer 播放器项目的  CMPlayerc 分析
  3706.  
  3707. mplayerc  
  3708.  
  3709.    -->Model\appSQLite.h   主要负责操作sql  
  3710.       类成员成员中有两个成员
  3711.       SQLliteapp* sqlite_setting; 
  3712.       SQLliteapp* sqlite_local_record; 
  3713.  
  3714.       对sqlite_setting  分析
  3715.  
  3716.       在StoreSettingsToIni 产生一个对象  
  3717.       sqlite_setting = PlayerPreference::GetInstance()->GetSqliteSettingPtr();
  3718.  
  3719.  
  3720.       保存数据前 存在 则开始输出 BEGIN
  3721.       if(pApp->sqlite_setting){
  3722. pApp->sqlite_setting->begin_transaction();
  3723. }
  3724.       保存数据后 存在 则开始输出 END
  3725.       if(pApp->sqlite_setting){
  3726. pApp->sqlite_setting->end_transaction();
  3727. }
  3728.  
  3729.       读取整形数据
  3730.       if(sqlite_setting){
  3731. return sqlite_setting->GetProfileInt( lpszSection,  lpszEntry,  nDefault);
  3732. }else{
  3733. return __super::GetProfileInt( lpszSection,  lpszEntry,  nDefault);
  3734. }
  3735. }
  3736.  
  3737.        写入整形数据
  3738. if(sqlite_setting){
  3739. return sqlite_setting->WriteProfileInt( lpszSection,  lpszEntry,  nValue);
  3740. }else{
  3741. SVP_LogMsg6("dwqdwq");
  3742. return __super::WriteProfileInt( lpszSection,  lpszEntry,  nValue);
  3743. }
  3744.  
  3745.         读取字符集数据
  3746. if(sqlite_setting){
  3747. return sqlite_setting->GetProfileString( lpszSection,  lpszEntry,
  3748. lpszDefault );
  3749. }else{
  3750. return __super::GetProfileString( lpszSection,  lpszEntry,
  3751. lpszDefault );
  3752. }
  3753.  
  3754.  
  3755.         写入字符集数据
  3756. if(sqlite_setting){
  3757. return sqlite_setting->WriteProfileString( lpszSection,  lpszEntry,
  3758. lpszValue);
  3759. }else{
  3760. return __super::WriteProfileString( lpszSection,  lpszEntry,
  3761. lpszValue);
  3762. }
  3763.  
  3764.         读取二进制数据
  3765. if(sqlite_setting){
  3766. return sqlite_setting->GetProfileBinary( lpszSection,  lpszEntry,
  3767. ppData,  pBytes);
  3768. }else{
  3769. return __super::GetProfileBinary( lpszSection,  lpszEntry,
  3770. ppData,  pBytes);
  3771. }
  3772.  
  3773.  
  3774.         写入二进制数据
  3775. if(sqlite_setting){
  3776. return sqlite_setting->WriteProfileBinary( lpszSection,  lpszEntry,
  3777. pData,  nBytes);
  3778. }else{
  3779. return __super::WriteProfileBinary( lpszSection,  lpszEntry,
  3780. pData,  nBytes);
  3781. }
  3782.  
  3783.         对sqlite_setting 分析完
  3784.         对sqlite_local_record 分析
  3785.         在InitInstanceThreaded(INT64 CLS64) 函数中 产生对象
  3786.  
  3787.  
  3788.         sqlite_local_record = new SQLliteapp(tmPath.m_strPath.GetBuffer())
  3789.       
  3790.       判断是否打开数据库
  3791.       if(!sqlite_local_record->db_open)
  3792.       {
  3793.         delete sqlite_local_record;
  3794.         sqlite_local_record = NULL;
  3795.       }
  3796.  
  3797.       执行数据库  主要是创建表
  3798.       if(sqlite_local_record)
  3799.       {
  3800.         sqlite_local_record->exec_sql(L"CREATE TABLE  IF NOT EXISTS histories_stream (\"fpath\" TEXT, \"subid\" INTEGER, \"subid2\" INTEGER, \"audioid\" INTEGER, \"videoid\" INTEGER )");
  3801.         sqlite_local_record->exec_sql(L"CREATE UNIQUE INDEX  IF NOT EXISTS \"hispks\" on histories_stream (fpath ASC)");
  3802.  
  3803.  
  3804.         sqlite_local_record->exec_sql(L"CREATE TABLE  IF NOT EXISTS histories (\"fpath\" TEXT, \"subid\" INTEGER, \"subid2\" INTEGER, \"audioid\" INTEGER, \"stoptime\" INTEGER, \"modtime\" INTEGER )");
  3805.         sqlite_local_record->exec_sql(L"CREATE UNIQUE INDEX  IF NOT EXISTS \"hispk\" on histories (fpath ASC)");
  3806.         sqlite_local_record->exec_sql(L"CREATE INDEX  IF NOT EXISTS \"modtime\" on histories (modtime ASC)");
  3807.  
  3808.  
  3809.         sqlite_local_record->exec_sql(L"CREATE TABLE  IF NOT EXISTS settingstring (\"hkey\" TEXT, \"sect\" TEXT, \"vstring\" TEXT )");
  3810.         sqlite_local_record->exec_sql(L"PRAGMA synchronous=OFF");
  3811.         //sqlite_local_record->end_transaction();
  3812.       }
  3813.  
  3814.       在退出程序的时候  ExitInstance()
  3815.   if(sqlite_local_record){
  3816.    CString szSQL;
  3817.    szSQL.Format(L"DELETE FROM histories WHERE modtime < '%d' ", time(NULL)-3600*24*30);
  3818.    
  3819. // SVP_LogMsg5(szSQL);
  3820.    
  3821. sqlite_local_record->exec_sql(szSQL.GetBuffer());
  3822.    
  3823. sqlite_local_record->exec_sql(L"PRAGMA synchronous=ON");
  3824.   }
  3825.   if (sqlite_local_record)    delete sqlite_local_record;
  3826. $(ConfigurationName)


以上是针对主程序播放视频的分析。


ChuckTest工程 是针对rar包里的测试项目，测试代码如下：

  1. int _tmain(int argc, _TCHAR* argv[])
  2. {
  3.   HANDLE rar_handle = NULL;
  4.   //std::wstring fn_rar = L"E:\\-=eMule=-\\1140746814_39741.rar";
  5.   //std::wstring fn_rar = L"E:\\-=eMule=-\\Bride.Flight.2008.Bluray.720p.AC3.x264-CHD_新娘航班\\B2_新娘航班.part1.rar";
  6.   //std::wstring fn_rar = L"D:\\xxxx.part1.rar";
  7.   std::wstring fn_rar = L"E:\\-=eMule=-\\Overheard.2009.REPACK.CN.DVDRip.Xvid-XTM\\sample\\xtm-overheard.repack-sample_stored.rar";
  8.   //std::wstring fn_rar = L"E:\\-=eMule=-\\Overheard.2009.REPACK.CN.DVDRip.Xvid-XTM\\sample\\xtm-overheard.repack-sample_s.part1.rar";
  9.   
  10.   std::wstring tmp_dir = L"C:\\Temp\\";
  11.   
  12.   struct RAROpenArchiveDataEx ArchiveDataEx;
  13.   memset(&ArchiveDataEx, 0, sizeof(ArchiveDataEx));
  14.   
  15.   ArchiveDataEx.ArcNameW = (wchar_t*)fn_rar.c_str();
  16.   //ArchiveDataEx.ArcName = "E:\\-=eMule=-\\1140746814_39741.rar";
  17.  
  18.   ArchiveDataEx.OpenMode = RAR_OM_EXTRACT;
  19.   ArchiveDataEx.CmtBuf = 0;
  20.   rar_handle = RAROpenArchiveEx(&ArchiveDataEx);
  21.  
  22.   const long buffsize = 1000;
  23.   char testbuff[buffsize];
  24.  
  25.   if (rar_handle)
  26.   {
  27.     wprintf(L"RAROpenArchiveEx open successed\n");
  28.     struct RARHeaderDataEx HeaderDataEx;
  29.     HeaderDataEx.CmtBuf = NULL;
  30.     while (RARReadHeaderEx(rar_handle, &HeaderDataEx) == 0)
  31.     {
  32.       // 正常解压该文件
  33.       unsigned long long filesize = ((unsigned long long)HeaderDataEx.UnpSizeHigh << 32) + HeaderDataEx.UnpSize;
  34.       int err = 0;
  35.       std::wstring unp_tmpfile = tmp_dir + HeaderDataEx.FileNameW;
  36.       err = RARProcessFileW(rar_handle, RAR_EXTRACT, (wchar_t*)tmp_dir.c_str(), HeaderDataEx.FileNameW);
  37.       wprintf(L"RARProcessFileW to %s return %d size %lld %x %x\n", unp_tmpfile.c_str(), err, filesize, HeaderDataEx.UnpVer, HeaderDataEx.Method);
  38.     }
  39.     RARCloseArchive(rar_handle);
  40.   }
  41.  
  42.   rar_handle = RAROpenArchiveEx(&ArchiveDataEx);
  43.   if (rar_handle)
  44.   {
  45.     wprintf(L"RAROpenArchiveEx open successed\n");
  46.     struct RARHeaderDataEx HeaderDataEx;
  47.     HeaderDataEx.CmtBuf = NULL;
  48.     while (RARReadHeaderEx(rar_handle, &HeaderDataEx) == 0)
  49.     {
  50.       unsigned long long filesize = ((unsigned long long)HeaderDataEx.UnpSizeHigh << 32) + HeaderDataEx.UnpSize;
  51.       int err = 0;
  52.       std::wstring unp_tmpfile = tmp_dir + HeaderDataEx.FileNameW;
  53.       err = RARExtractChunkInit(rar_handle, HeaderDataEx.FileName);
  54.       if (err != 0)
  55.       {
  56.         wprintf(L"RARExtractChunkInit return error %d\n", err);
  57.         continue;
  58.       }
  59.  
  60.       FILE* unp_filehandle = NULL;
  61.       err = _wfopen_s(&unp_filehandle, unp_tmpfile.c_str(), L"rb");
  62.       if (err)
  63.       {
  64.         wprintf(L"open extracted file fail %d %d\n", err, unp_filehandle);
  65.         continue;
  66.       }
  67.  
  68.       
  69.       // 顺序测试
  70.       int iExtractRet = 0;
  71.       unsigned long long fpos = 0;
  72.       do
  73.       {
  74.         iExtractRet = RARExtractChunk(rar_handle, (char*)testbuff, buffsize);
  75.         // Compare 
  76.         if (compare_filebinary(unp_filehandle, fpos, testbuff, iExtractRet, 0))
  77.         {
  78.           wprintf(L"Sequence compare difference found at %lld for %d\n", fpos, buffsize);
  79.           break;
  80.         }
  81.         //else
  82.         //  wprintf(L"Sequence compare is same %lld %d\n", fpos, iExtractRet);
  83.  
  84.         fpos += iExtractRet;
  85.       } while(iExtractRet > 0);
  86.  
  87.       // 随机测试
  88.       for (int i = 0; i < 100; i++)
  89.       {
  90.         unsigned long long ll_pos = rand() * filesize/RAND_MAX;
  91.         RARExtractChunkSeek(rar_handle, ll_pos, SEEK_SET);
  92.         RARExtractChunk(rar_handle, (char*)testbuff, buffsize);
  93.         // Compare 
  94.         if (compare_filebinary(unp_filehandle, ll_pos, testbuff, iExtractRet, 0))
  95.         {
  96.           wprintf(L"Random compare difference found at %lld\n", ll_pos);
  97.           break;
  98.         }
  99.         //else
  100.         //  wprintf(L"Random compare is same %lld\n", ll_pos);
  101.       }
  102.       wprintf(L"RARExtractChunk test for %s finished\n", unp_tmpfile.c_str());
  103.     }
  104.     RARCloseArchive(rar_handle);
  105.   }
  106.   wprintf(L"Test finished\n");
  107.   scanf_s("%d");
  108. 	return 0;
  109. }
  1. //字符切换
  2. std::string WStringToString(const std::wstring& s)
  3. {
  4.   char* ch;
  5.   UINT bytes = WideCharToMultiByte(CP_ACP, 0, s.c_str(), -1, NULL, 0,
  6.     NULL, NULL); 
  7.   ch = new char[bytes];
  8.   if(ch)
  9.     bytes = WideCharToMultiByte(CP_ACP, 0, s.c_str(), -1, ch, bytes,
  10.     NULL, NULL);
  11.   std::string str = ch;
  12.   delete[] ch;
  13.   return str;
  14. }
  15.  
  16. //比较文件
  17. int compare_filebinary(FILE* filehandle, unsigned long long filepos, char* buff, unsigned long buffsize, int debug)
  18. {
  19.   char *fbuf = (char *)malloc(buffsize);
  20.   _fseeki64(filehandle, filepos, SEEK_SET);
  21.   fread_s(fbuf, buffsize, sizeof(char), buffsize, filehandle);
  22.   int ret = memcmp(buff, fbuf, buffsize);
  23.   
  24.   if (debug)
  25.   {
  26.     for (int i = 0;i < 100;i++)
  27.       wprintf(L"%02x", (DWORD)buff[i] & 0xff);
  28.     wprintf(L"\n");
  29.     for (int i = 0;i < 100;i++)
  30.       wprintf(L"%02x", (DWORD)fbuf[i] & 0xff);
  31.     wprintf(L"\n");
  32.   }
  33.  
  34.   free(fbuf);
  35.   return ret;
  36. }


HotkeySchemeParser_UnitTest 是针对热键计划分析器单元测试，测试代码如下： 

  1. //热键计划分析器单元测试
  2. int _tmain(int argc, _TCHAR* argv[])
  3. {
  4.   HotkeySchemeParser parser;
  5.   printf("HotkeySchemeParser unit test\n");
  6.   printf("----------------------------------------------------------\n");
  7.   printf("Populating default scheme (HotkeySchemeParser::PopulateDefaultScheme) ...\n");
  8.   parser.PopulateDefaultScheme();
  9.   printf("Attempting to write scheme file (HotkeySchemeParser::WriteToFile) ... ");
  10.   if (!parser.WriteToFile(L"SPlayerHotKey.txt"))
  11.   {
  12.     printf("[FAILED]\n");
  13.     return 0;
  14.   }
  15.   printf("[OK]\n");
  16.   printf("Attempting to read scheme file (HotkeySchemeParser::ReadFromFile) ... ");
  17.   if (!parser.ReadFromFile(L"SPlayerHotKey.txt"))
  18.   {
  19.     printf("[FAILED]\n");
  20.     return 0;
  21.   }
  22.   printf("[OK]\n");
  23.  
  24.   //目标键
  25.   HotkeySchemeParser target;
  26.   target.PopulateDefaultScheme();
  27.   printf("Comparing results (scheme name)... ");
  28.   if (target.GetSchemeName() != parser.GetSchemeName())
  29.   {
  30.     printf("[ERROR]\n");
  31.     return 0;
  32.   }
  33.   printf("[OK]\n");
  34.   printf("Comparing results (list)... ");
  35.   std::vector<HotkeyCmd> parser_list = parser.GetScheme();
  36.   std::vector<HotkeyCmd> target_list = target.GetScheme();
  37.   if (parser_list.size() != target_list.size())
  38.   {
  39.     printf("[SIZE MISMATCH]\n");
  40.     return 0;
  41.   }
  42.   for (std::vector<HotkeyCmd>::iterator it1 = parser_list.begin(),
  43.     it2 = target_list.begin();
  44.     it1 != parser_list.end(),
  45.     it2 != target_list.end();
  46.     it1++, it2++)
  47.   {
  48.     if (it1->cmd != it2->cmd ||
  49.       it1->key != it2->key ||
  50.       it1->fVirt != it2->fVirt ||
  51.       it1->appcmd != it2->appcmd ||
  52.       it1->mouse != it2->mouse)
  53.     {
  54.       printf("[ERROR @ %d]\n", std::distance(parser_list.begin(), it1));
  55.       return 0;
  56.     }
  57.   }
  58.   printf("[OK]\n");
  59.  
  60. 	return 0;
  61. }
sqliteppTest 是针对第三方库sqlitepp操作数据库的测试，测试代码如下： 

  1. /* step0 init - *******************
  2. *first check del file Testsqlite.db*/
  3.  
  4. const wchar_t *filename=L"./Testsqlite.db";
  5. const wchar_t *sqlc1=L"CREATE TABLE IF NOT EXISTS \"settingint\" (\"hkey\" TEXT,\"sect\" TEXT,\"sval\" INTEGER)";
  6. const wchar_t *sqlc2=L"CREATE TABLE IF NOT EXISTS \"settingstring\" (\"hkey\" TEXT,   \"sect\" TEXT, \"vstring\" TEXT)";
  7. const wchar_t *sqlc3 = L"CREATE TABLE IF NOT EXISTS \"settingbin2\" (\"skey\" TEXT,   \"sect\" TEXT, \"vdata\" BLOB)";
  8. const wchar_t *sqlc4 = L"CREATE UNIQUE INDEX IF NOT EXISTS \"pkey\" on settingint (hkey ASC, sect ASC)";
  9. const wchar_t *sqlc5 = L"CREATE UNIQUE INDEX IF NOT EXISTS \"pkeystring\" on settingstring (hkey ASC, sect ASC)";
  10. const wchar_t *sqlc6 = L"CREATE UNIQUE INDEX IF NOT EXISTS \"pkeybin\" on settingbin2 (skey ASC, sect ASC)";
  11.  
  12. //定义
  13. TCHAR path[MAX_PATH] = {0};
  14. ::GetModuleFileName(NULL,path,MAX_PATH);
  15. CStringW strSQL(path);
  16. strSQL.Replace(_T("TestSqlite.exe"),_T("Testsqlite.db"));
  17.  
  18. int i=0;
  19. std::wstring sql,sql2,sql3,sql4,sql5;
  20. SQLliteapp p(strSQL.GetBuffer());  //构造会创建数据库文件
  21.  
  22. /* step1 : Create Table 执行sql语句 创建表 字段 数值*/
  23. p.exec_sql(sqlc1);
  24. p.exec_sql(sqlc2);
  25. p.exec_sql(sqlc3);
  26. p.exec_sql(sqlc4);
  27. p.exec_sql(sqlc5);
  28. p.exec_sql(sqlc6);
  29.  
  30. std::wstring str1=L"hello";
  31. std::wstring str2=L"world";
  32.  
  33. /* step2 int-test  *******************
  34.  *
  35.  *   write int - WriteProfileInt
  36.  get int - GetProfileInt compare    写入 读取整形数值 比较
  37.   ************************************/
  38. {
  39. int geti1=1;
  40. int geti2=100;
  41.  
  42. geti1=p.WriteProfileInt(str2.c_str(),str1.c_str(),-10,false);
  43. int test01=p.GetProfileInt(str2.c_str(),str1.c_str(),10,false);
  44. if(geti1)
  45. printf("pass -- 1 \n");
  46. else
  47. printf("fail -- 1 \n");
  48. p.WriteProfileInt(str1.c_str(),str2.c_str(),geti2,false);
  49. geti1=p.GetProfileInt(str1.c_str(),str2.c_str(),-1,false);
  50. if(geti2==geti1)
  51. printf("pass -- 2 \n");
  52. else
  53. printf("fail -- 2 \n");
  54. }
  55.  
  56. /* step3 string-test  ***************
  57.  *
  58.  *   write str - WriteProfileString
  59. get str - GetProfileString
  60. compare    写入 读取 字符集比较
  61.  ************************************/
  62. {
  63. std::wstring str3s1, str3s2;
  64. str3s1 = L"ss";
  65. str3s2 = L"hello你好\n";
  66. str3s1 = p.GetProfileString(str2.c_str(), str1.c_str(),L"xx",false);
  67.  
  68. if(str3s1 == L"xx")
  69. printf("pass--3\n");   // ok
  70. else
  71. printf("fail--3\n");
  72.  
  73. p.WriteProfileString(str1.c_str(), str2.c_str(), str3s2.c_str());
  74. str3s1 = p.GetProfileString(str1.c_str(), str2.c_str(), L"xx",false);
  75.  
  76. if(str3s1.compare(str3s2) == 0)
  77. printf("pass--4\n");   // ok
  78. else
  79. printf("fail--4\n");
  80. }
  81.  
  82. /* step4 binrary-test  **************
  83.  *
  84.  *   write bin
  85.  get bin - donot forget new/delete   写入 读取 二进制文件
  86.  **************************************/
  87. {
  88. char *pp = 0; //donot forget new/delete
  89. char buf[100];
  90. char str3[] = "hello4";
  91. char str4[] = "world4";
  92.  
  93. for(i=0;i<80;i++)
  94. {
  95. buf[i] = i * 3 % 5 + 2;
  96. }
  97.  
  98. int bPass=0;    //成功的话 bPass 返回个数
  99. p.GetProfileBinary(str2.c_str(), str1.c_str(),(LPBYTE*)&pp,(UINT*)&bPass,false);
  100.  
  101. if( bPass == 0 )
  102. printf("pass--5 bin\n");
  103. else
  104. printf("fail--5 bin\n");
  105.  
  106. if(i>0 && pp)
  107. {
  108. delete[] pp;
  109. pp = NULL;
  110. }
  111.  
  112. p.WriteProfileBinary(str1.c_str(), str2.c_str(), (LPBYTE)buf, 80); //w 80 BYTE
  113. p.GetProfileBinary(str1.c_str(), str2.c_str(), (LPBYTE*)&pp, (UINT*)&bPass, false); //成功的话 bPass 返回个数
  114.  
  115. if(memcmp(pp,buf,30) == 0)
  116. printf("pass--6 bin\n");
  117. else
  118. printf("fail--6 bin\n");
  119.  
  120. if(bPass>0 && pp)
  121. {
  122. delete[] pp;
  123. pp = NULL;
  124. }
  125. }

 分析到此就结束了！~这是我针对这SPlayer项目的简单分析！

 学习的目标是成熟！~~~




声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/144586
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号