1. <!-- data-setup{}可以控制播放器的一些功能；autoplay:true/false，是否自动播放；preload：auto\none\meta，自动加载\不加载\加载元数据 -->  
2.     <video id="videoPlayer" class="video-js vjs-default-skin vjs-big-play-centered"   
3.     controls preload="auto" poster="img/eguidlogo.png" width="640" height="360"   
4.     data-setup=‘{ "html5" : { "nativeTextTracks" : false } }‘>  
5.         <source src=‘rtmp://192.168.30.21/live/‘ type=‘rtmp/flv‘  />  
6.     </video>  

1. //播放器实例  
2. var player = videojs(‘videoPlayer‘);  

1. /*  
2. * 根据videoJS官方文档编写的播放器常用操作    
3. */  
4.   
5.     //获取当前类型  
6.     function getCurrentType(idnex) {  
7.         return idnex.currentType();  
8.     }  
9.     //获取当前播放地址  
10.     function getCurrentAddr(index) {  
11.         return index.currentSrc();  
12.     }  
13.     //获取当前播放时间  
14.     function getCurrentTime(index) {  
15.         return index.currentTime();  
16.     }  
17.     //获取当前网络状态  
18.     function networkState(index) {  
19.         return index.networkState();  
20.     }  
21.     //修改播放地址  
22.     function setsrc(index, url, type) {  
23.         index.src({  
24.             type : type,  
25.             src : url  
26.         });  
27.     }  
28.     //重载播放器  
29.     function reset(index) {  
30.         index.reset();  
31.         index.load();  
32.     }  
33.     //播放  
34.     function play(index) {  
35.         index.play();  
36.     }  
37.     //暂停  
38.     function pause(index) {  
39.         index.pause();  
40.     }  

1. //播放器实例  
2. var player = videojs(‘videoPlayer‘);  
3.   
4. //播放器初始化操作面板清晰度菜单  
5.     function playerInitVideo() {  
6.         $videoPanelMenu = $(".vjs-fullscreen-control");  
7.         $videoPanelMenu.before(‘<div class="vjs-subtitles-button vjs-menu-button vjs-menu-button-popup vjs-control vjs-button" tabindex="0" role="menuitem" aria-live="polite" aria-expanded="false" aria-haspopup="true">‘  
8.                         + ‘<div class="vjs-menu" role="presentation">‘  
9.                         + ‘<ul class="vjs-menu-content" role="menu">‘  
10.                         + ‘<li class="vjs-menu-item" tabindex="-1" role="menuitemcheckbox"  onclick="changeUrl(this)">高清</li>‘  
11.                         + ‘<li class="vjs-menu-item vjs-selected" tabindex="-1" role="menuitemcheckbox"  onclick="changeUrl(this)">标清 </li>‘  
12.                         + ‘</ul></div><span class="vjs-control-text">清晰度</span></div>‘);  
13.         }  
14.     //加载页面进行播放器初始化  
15.     player.ready(function() {  
16.         playerInitVideo();  
17.         //player.play();  
18.         //setsrc(player,"rtmp://192.168.30.21/live/test3","rtmp/flv");  
19.     });  
20.       
21.     //通过id获取DOM  
22.     function get(index) {  
23.         return document.getElementById(index);  
24.     }  
25.     //修改播放地址并播放  
26.     function writeAddressAndPlay(index,url,type) {  
27.         //播放器操作  
28.         setsrc(index, url, type?type:"rtmp/flv");  
29.         play(index);  
30.     }  
31.     //高清标清切换就是应用名加减HD  
32.     function changeUrl(video) {  
33.         var index = $(video).text();  
34.         //获取当前播放的url  
35.         var CurrentUrl = getCurrentAddr(player);  
36.         $(".vjs-menu-item").removeClass("vjs-selected");  
37.             $(video).addClass("vjs-selected");  
38.         if (index == "高清") {  
39.             if (CurrentUrl.indexOf("HD") == -1) {  
40.                 CurrentUrl = CurrentUrl + "HD";  
41.             } else {  
42.                 return;  
43.             }  
44.         } else {  
45.             if (CurrentUrl.indexOf("HD") != -1) {  
46.                 CurrentUrl = CurrentUrl.replace("HD", "");  
47.             } else {  
48.                 return;  
49.             }  
50.         }  
51.         //修改地址并播放  
52.         writeAddressAndPlay(player, CurrentUrl);  
53.     }  
54.       

1.     <script type="text/javascript">  
2.     //如果你不需要某项设置，可以直接删除，注意var flashvars的最后一个值后面不能有逗号  
3.     function loadedHandler(){  
4.         if(CKobject.getObjectById(‘ckplayer_a1‘).getType()){//说明使用html5播放器  
5.             alert(‘播放器已加载，调用的是HTML5播放模块‘);  
6.         }  
7.         else{  
8.             alert(‘播放器已加载，调用的是Flash播放模块‘);  
9.         }  
10.     }  
11.     var _nn=0;  
12.     function ckplayer_status(str){  
13.         _nn+=1;  
14.         if(_nn>100){  
15.             _nn=0;  
16.             document.getElementById(‘statusvalue‘).value=‘‘;  
17.         }  
18.         document.getElementById(‘statusvalue‘).value=str+‘\n‘+document.getElementById(‘statusvalue‘).value;  
19.     }  
20.       
21.         var flashvars={  
22.         f:‘http://192.168.30.21/test1HD.video.flv‘,//视频地址  
23.         a:‘‘,//调用时的参数，只有当s>0的时候有效  
24.         s:‘0‘,//调用方式，0=普通方法（f=视频地址），1=网址形式,2=xml形式，3=swf形式(s>0时f=网址，配合a来完成对地址的组装)  
25.         c:‘1‘,//是否读取文本配置,0不是，1是  
26.         x:‘‘,//调用配置文件路径，只有在c=1时使用。默认为空调用的是ckplayer.xml  
27.         i:‘‘,//初始图片地址  
28.         d:‘‘,//暂停时播放的广告，swf/图片,多个用竖线隔开，图片要加链接地址，没有的时候留空就行  
29.         u:‘‘,//暂停时如果是图片的话，加个链接地址  
30.         l:‘‘,//前置广告，swf/图片/视频，多个用竖线隔开，图片和视频要加链接地址  
31.         r:‘‘,//前置广告的链接地址，多个用竖线隔开，没有的留空  
32.         t:‘0|0‘,//视频开始前播放swf/图片时的时间，多个用竖线隔开  
33.         y:‘‘,//这里是使用网址形式调用广告地址时使用，前提是要设置l的值为空  
34.         z:‘‘,//缓冲广告，只能放一个，swf格式  
35.         e:‘2‘,//视频结束后的动作，0是调用js函数，1是循环播放，2是暂停播放并且不调用广告，3是调用视频推荐列表的插件，4是清除视频流并调用js功能和1差不多，5是暂停播放并且调用暂停广告  
36.         v:‘80‘,//默认音量，0-100之间  
37.         p:‘1‘,//视频默认0是暂停，1是播放，2是不加载视频  
38.         h:‘0‘,//播放http视频流时采用何种拖动方法，=0不使用任意拖动，=1是使用按关键帧，=2是按时间点，=3是自动判断按什么(如果视频格式是.mp4就按关键帧，.flv就按关键时间)，=4也是自动判断(只要包含字符mp4就按mp4来，只要包含字符flv就按flv来)  
39.         q:‘‘,//视频流拖动时参考函数，默认是start  
40.         m:‘‘,//让该参数为一个链接地址时，单击播放器将跳转到该地址  
41.         o:‘‘,//当p=2时，可以设置视频的时间，单位，秒  
42.         w:‘‘,//当p=2时，可以设置视频的总字节数  
43.         g:‘‘,//视频直接g秒开始播放  
44.         j:‘‘,//跳过片尾功能，j>0则从播放多少时间后跳到结束，<0则总总时间-该值的绝对值时跳到结束  
45.         k:‘‘,//提示点时间，如 30|60鼠标经过进度栏30秒，60秒会提示n指定的相应的文字  
46.         n:‘‘,//提示点文字，跟k配合使用，如 提示点1|提示点2  
47.         wh:‘‘,//宽高比，可以自己定义视频的宽高或宽高比如：wh:‘4:3‘,或wh:‘1080:720‘  
48.         lv:‘0‘,//是否是直播流，=1则锁定进度栏  
49.         loaded:‘loadedHandler‘,//当播放器加载完成后发送该js函数loaded  
50.         //调用播放器的所有参数列表结束  
51.         //以下为自定义的播放器参数用来在插件里引用的  
52.         my_url:encodeURIComponent(window.location.href)//本页面地址  
53.         //调用自定义播放器参数结束  
54.         };  
55.     var params={bgcolor:‘#FFF‘,allowFullScreen:true,allowScriptAccess:‘always‘};//这里定义播放器的其它参数如背景色（跟flashvars中的b不同），是否支持全屏，是否支持交互  
56.     var video=[‘http://192.168.30.21/test1HD.video.mp4‘];  
57.     CKobject.embed(‘ckplayer/ckplayer/ckplayer.swf‘,‘player1‘,‘ckplayer_1‘,‘720px‘,‘360px‘,false,flashvars,video,params);  
58. </script>  

1. /*  
2. -------------------------------------------------------------------------  
3.   说明:  
4.   正式使用时可以把该文件的注释全部去掉，节省加载时间  
5.   ckplayer6.7,有问题请访问http://www.ckplayer.com  
6.   请注意，该文件为UTF-8编码，不需要改变编码即可使用于各种编码形式的网站内      
7. -------------------------------------------------------------------------  
8. 第一部分，加载插件  
9. 以下为加载的插件部份  
10. 插件的设置参数说明：  
11.     1、插件名称  
12.     2、水平对齐方式（0左，1中，2右）  
13.     3、垂直对齐方式（0上，1中，2下）  
14.     4、水平方向位置偏移量  
15.     5、垂直方向位置偏移量  
16.     6、插件的等级，0=普通图片插件且跟随控制栏隐藏而隐藏，显示而显示，1=普通图片插件且永久显示，2=swf插件，默认显示，3=swf插件，默认隐藏，swf插件都可以交互  
17.     7、插件是否绑定在控制栏上，0不绑定，1绑定，当值是1的时候该插件将会随着控制栏一起隐藏或缓动  
18.     8、插件为swf并且可交互时，默认调用的类所在的包名称，详细说明可以到帮助手册里查看，默认无  
19.     插件名称不能相同，对此的详细说明请到网站查看  
20. */  
21. function ckcpt() {  
22.     var cpt = ‘‘;  
23.     cpt += ‘right.swf,2,1,0,0,2,0|‘; //右边开关灯，调整，分享按钮的插件  
24.     cpt += ‘share.swf,1,1,-180,-100,3,0|‘; //分享插件  
25.     cpt += ‘adjustment.swf,1,1,-180,-100,3,0|‘; //调整大小和颜色的插件  
26.     return cpt;  
27. }  
28. /*  
29. 插件的定义结束  
30. 以下是对播放器功能进行配置  
31. */  
32. function ckstyle() { //定义总的风格  
33.     var ck = {  
34.         cpath: ‘‘,  
35.         /*  
36.         播放器风格压缩包文件的路径，默认的是style.swf  
37.         如果调用不出来可以试着设置成绝对路径试试  
38.         如果不知道路径并且使用的是默认配置，可以直接留空，播放器会  
39.         */  
40.         language: ‘‘,  
41.         /*播放器所使用的语言配置文件，需要和播放器在同目录下，默认是language.xml*/  
42.         flashvars: ‘‘,  
43.         /*  
44.         这里是用来做为对flashvars值的补充，除了c和x二个参数以外的设置都可以在这里进行配置  
45.                                   1 1 1 1   1 1 1 1 1 1 2 2 2  2 2 2 2 2    2 2 3 3 3 3 3 3 3 3 3   3 4  4 4 4  
46.                 1 2 3 4 5 6 7 8 9 0 1 2 3   4 5 6 7 8 9 0 1 2  3 4 5 6 7    8 9 0 1 2 3 4 5 6 7 8   9 0  1 2 3*/  
47.         setup: ‘1,1,1,1,1,2,0,1,2,0,0,1,200,0,2,1,0,1,1,1,2,10,3,0,1,2,3000,0,0,0,0,1,1,1,1,1,1,250,0,90,0,0,0‘,  
48.         /*  
49.         这是配置文件里比较重要的一个参数，共有N个功能控制参数，并且以后会继续的增加，各控制参数以英文逗号(,)隔开。下面列出各参数的说明：  
50.             1、鼠标经过按钮是否使用手型，0普通鼠标，1手型鼠标，2是只有按钮手型，3是控制栏手型  
51.             2、是否支持单击暂停，0不支持，1是支持  
52.             3、是否支持双击全屏，0不支持，1是支持  
53.             4、在播放前置广告时是否同时加载视频，0不加载，1加载  
54.             5、广告显示的参考对象，0是参考视频区域，1是参考播放器区域  
55.             6、广告大小的调整方式,只针对swf和图片有效,视频是自动缩放的  
56.                 =0是自动调整大小，意思是说大的话就变小，小的话就变大  
57.                 =1是大的化变小，小的话不变  
58.                 =2是什么也不变，就这么大  
59.                 =3是跟参考对像(第5个控制)参数设置的一样宽高  
60.             7、前置广告播放顺序，0是顺序播放，1是随机播放，>1则随机取所有广告中的(N-1)个进行播放  
61.             8、对于视频广告是否采用修正，0是不使用，1是使用，如果是1，则用户在网速慢的情况下会按设定的倒计时进行播放广告，计时结束则放正片（比较人性化），设置成0的话，则强制播放完广告才能播放正片  
62.             9、是否开启滚动文字广告，0是不开启，1是开启且不使用关闭按钮，2是开启并且使用关闭按钮，开启后将在加载视频的时候加载滚动文字广告  
63.             10、视频的调整方式  
64.                 =0是自动调整大小，意思是说大的话就变小，小的话就变大，同时保持长宽比例不变  
65.                 =1是大的化变小，小的话不变  
66.                 =2是什么也不变，就这么大  
67.                 =3是跟参考对像(pm_video的设置)参数设置的一样宽高  
68.             11、是否在多视频时分段加载，0不是，1是  
69.             12、缩放视频时是否进行平滑处理，0不是，1是  
70.             13、视频缓冲时间,单位：毫秒,建议不超过300  
71.             14、初始图片调整方式(  
72.                 =0是自动调整大小，意思是说大的话就变小，小的话就变大，同时保持长宽比例不变  
73.                 =1是大的化变小，小的话不变  
74.                 =2是什么也不变，就这么大  
75.                 =3是跟pm_video参数设置的一样宽高  
76.             15、暂停广告调整方式(  
77.                 =0是自动调整大小，意思是说大的话就变小，小的话就变大，同时保持长宽比例不变  
78.                 =1是大的化变小，小的话不变  
79.                 =2是什么也不变，就这么大  
80.                 =3是跟pm_video参数设置的一样宽  
81.             16、暂停广告是否使用关闭广告设置，0不使用，1使用  
82.             17、缓冲时是否播放广告，0是不显示，1是显示并同时隐藏掉缓冲图标和进度，2是显示并不隐藏缓冲图标  
83.             18、是否支持键盘空格键控制播放和暂停0不支持，1支持  
84.             19、是否支持键盘左右方向键控制快进快退0不支持，1支持  
85.             20、是否支持键盘上下方向键控制音量0不支持，1支持  
86.             21、播放器返回js交互函数的等级，0-2,等级越高，返回的参数越多  
87.                 0是返回少量常用交互  
88.                 1返回播放器在播放的时候的参数，不返回广告之类的参数  
89.                 2返回全部参数  
90.                 3返回全部参数，并且在参数前加上"播放器ID->"，用于多播放器的监听  
91.             22、快进和快退的秒数  
92.             23、界面上图片元素加载失败重新加载次数  
93.             24、开启加载皮肤压缩文件包的加载进度提示  
94.             25、使用隐藏控制栏时显示简单进度条的功能,0是不使用，1是使用，2是只在普通状态下使用  
95.             26、控制栏隐藏设置(0不隐藏，1全屏时隐藏，2都隐藏  
96.             27、控制栏隐藏延时时间，即在鼠标离开控制栏后多少毫秒后隐藏控制栏  
97.             28、左右滚动时是否采用无缝，默认0采用，1是不采用  
98.             29、0是正常状态，1是控制栏默认隐藏，播放状态下鼠标经过播放器显示控制栏，2是一直隐藏控制栏  
99.             30、在播放rtmp视频时暂停后点击播放是否采用重新链接的方式,这里一共分0-2三个等级  
100.             31、当采用网址形式(flashvars里s=1/2时)读取视频地址时是采用默认0=get方法，1=post方式  
101.             32、是否启用播放按钮和暂停按钮  
102.             33、是否启用中间暂停按钮  
103.             34、是否启用静音按钮  
104.             35、是否启用全屏按钮  
105.             36、是否启用进度调节栏,0不启用，1是启用，2是只能前进（向右拖动），3是只能后退，4是只能前进但能回到第一次拖动时的位置，5是看过的地方可以随意拖动，  
106.             37、是否启用调节音量  
107.             38、计算时间的间隔，毫秒  
108.             39、前置logo至少显示的时间，单位：毫秒  
109.             40、前置视频广告的默认音量  
110.             41、当s=3/4时加载插件是否从压缩包里加载，0不是，1是  
111.             42、加载风格是否采用加密方式传送，该功能普通用户不能使用  
112.             43、在s=1/2时，调用地址里的地址是否是相对地址（相对于调用文件），0不是，1是  
113.         */  
114.         pm_bg: ‘0x000000,100,230,180‘,  
115.         /*播放器整体的背景配置，请注意，这里只是一个初始化的设置，如果需要真正的改动播放器的背景和最小宽高，需要在风格文件里找到相同的参数进行更改。  
116.         1、整体背景颜色  
117.         2、背景透明度  
118.         3、播放器最小宽度  
119.         4、播放器最小高度  
120.         这里只是初始化时的设置，最终加载完播放器后显示的效果需要在style.swf/style.xml里设置该参数  
121.         */  
122.         mylogo: ‘logo.swf‘,  
123.         /*  
124.         视频加载前显示的logo文件，不使用设置成null，即mylogo=‘null‘;  
125.         */  
126.         pm_mylogo: ‘1,1,-100,-55‘,  
127.         /*  
128.         视频加载前显示的logo文件(mylogo参数的)的位置  
129.         本软件所有的四个参数控制位置的方式全部都是统一的意思，如下  
130.         1、水平对齐方式，0是左，1是中，2是右  
131.         2、垂直对齐方式，0是上，1是中，2是下  
132.         3、水平偏移量，举例说明，如果第1个参数设置成0左对齐，第3个偏移量设置成10，就是离左边10个像素，第一个参数设置成2，偏移量如果设置的是正值就会移到播放器外面，只有设置成负值才行，设置成-1，按钮就会跑到播放器外面  
133.         4、垂直偏移量   
134.         */  
135.         logo: ‘cklogo.png‘,  
136.         /*  
137.         默认右上角一直显示的logo，不使用设置成null，即logo=‘null‘;  
138.         */  
139.         pm_logo: ‘2,0,-100,20‘,  
140.         /*  
141.         播放器右上角的logo的位置  
142.             1、水平对齐方式，0是左，1是中，2是右  
143.             2、垂直对齐方式，0是上，1是中，2是下  
144.             3、水平偏移量  
145.             4、垂直偏移量   
146.         以下是播放器自带的二个插件  
147.         */  
148.         control_rel: ‘related.swf,ckplayer/related.xml,0‘,  
149.         /*  
150.         视频结束显示精彩视频的插件  
151.             1、视频播放结束后显示相关精彩视频的插件文件（注意，视频结束动作设置成3时(即var flashvars={e:3})有效），  
152.             2、xml文件是调用精彩视频的示例文件，可以自定义文件类型（比如asp,php,jsp,.net只要输出的是xml格式就行）,实际使用中一定要注意第二个参数的路径要正确  
153.             3、第三个参数是设置配置文件的编码，0是默认的utf-8,1是gbk2312   
154.         */  
155.         control_pv: ‘Preview.swf,105,2000‘,  
156.         /*  
157.         视频预览插件  
158.             1、插件文件名称(该插件和上面的精彩视频的插件都是放在风格压缩包里的)  
159.             2、离进度栏的高(指的是插件的顶部离进度栏的位置)  
160.             3、延迟时间(该处设置鼠标经过进度栏停顿多少毫秒后才显示插件)  
161.             建议一定要设置延时时间，不然当鼠标在进度栏上划过的时候就会读取视频地址进行预览，很占资源   
162.         */  
163.         pm_repc: ‘‘,  
164.         /*  
165.         视频地址替换符，该功能主要是用来做简单加密的功能，使用方法很简单，请注意，只针对f值是视频地址的时候有效，其它地方不能使用。具体的请查看http://www.ckplayer.com/manual.php?id=4#title_25  
166.         */  
167.         pm_spac: ‘|‘,  
168.         /*  
169.         视频地址间隔符，这里主要是播放多段视频时使用普通调用方式或网址调用方式时使用的。默认使用|，如果视频地址里本身存在|的话需要另外设置一个间隔符，注意，即使只有一个视频也需要设置。另外在使用rtmp协议播放视频的时候，如果视频存在多级目录的话，这里要改成其它的符号，因为rtmp协议的视频地址多级的话也需要用到|隔开流地址和实例地址   
170.         */  
171.         pm_fpac: ‘file->f‘,  
172.         /*  
173.         该参数的功能是把自定义的flashvars里的变量替换成ckplayer里对应的变量，默认的参数的意思是把flashvars里的file值替换成f值，因为ckplayer里只认f值，多个替换之间用竖线隔开  
174.         */  
175.         pm_advtime: ‘2,0,-110,10,0,300,0‘,  
176.         /*  
177.         前置广告倒计时文本位置，播放前置 广告时有个倒计时的显示文本框，这里是设置该文本框的位置和宽高，对齐方式的。一共7个参数，分别表示：  
178.             1、水平对齐方式，0是左对齐，1是中间对齐，2是右对齐  
179.             2、垂直对齐方式，0是上对齐，1是中间对齐，2是低部对齐  
180.             3、水平位置偏移量  
181.             4、垂直位置偏移量  
182.             5、文字对齐方式，0是左对齐，1是中间对齐，2是右对齐，3是默认对齐  
183.             6、文本框宽席  
184.             7、文本框高度   
185.         */  
186.         pm_advstatus: ‘1,2,2,-200,-40‘,  
187.         /*  
188.         前置广告静音按钮，静音按钮只在是视频广告时显示，当然也可以控制不显示   
189.             1、是否显示0不显示，1显示  
190.             2、水平对齐方式  
191.             3、垂直对齐方式  
192.             4、水平偏移量  
193.             5、垂直偏移量  
194.         */  
195.         pm_advjp: ‘1,1,2,2,-100,-40‘,  
196.         /*  
197.         前置广告跳过广告按钮的位置  
198.             1、是否显示0不显示，1是显示  
199.             2、跳过按钮触发对象(值0/1,0是直接跳转,1是触发js:function ckadjump(){})  
200.             3、水平对齐方式  
201.             4、垂直对齐方式  
202.             5、水平偏移量  
203.             6、垂直偏移量  
204.         */  
205.         pm_padvc: ‘2,0,-10,-10‘,  
206.         /*  
207.         暂停广告的关闭按钮的位置  
208.             1、水平对齐方式  
209.             2、垂直对齐方式  
210.             3、水平偏移量  
211.             4、垂直偏移量  
212.         */  
213.         pm_advms: ‘2,2,-46,-56‘,  
214.         /*  
215.         滚动广告关闭按钮位置  
216.             1、水平对齐方式  
217.             2、垂直对齐方式  
218.             3、水平偏移量  
219.             4、垂直偏移量  
220.         */  
221.         pm_zip: ‘1,1,-20,-8,1,0,0‘,  
222.         /*  
223.         加载皮肤压缩包时提示文字的位置  
224.             1、水平对齐方式，0是左对齐，1是中间对齐，2是右对齐  
225.             2、垂直对齐方式，0是上对齐，1是中间对齐，2是低部对齐  
226.             3、水平位置偏移量  
227.             4、垂直位置偏移量  
228.             5、文字对齐方式，0是左对齐，1是中间对齐，2是右对齐，3是默认对齐  
229.             6、文本框宽席  
230.             7、文本框高度  
231.         */  
232.         //pm_advmarquee: ‘1,2,50,-60,50,18,0,0x000000,50,0,20,1,15,2000‘,  
233.         pm_advmarquee: ‘1,2,50,-60,50,20,0,0x000000,50,0,20,1,30,2000‘,  
234.         /*  
235.         滚动广告的控制，要使用的话需要在setup里的第9个参数设置成1  
236.         这里分二种情况,前六个参数是定位控制，第7个参数是设置定位方式(0：相对定位，1：绝对定位)  
237.         第一种情况：第7个参数是0的时候，相对定位，就是播放器长宽变化的时候，控制栏也跟着变  
238.             1、默认1:中间对齐  
239.             2、上中下对齐（0是上，1是中，2是下）  
240.             3、离左边的距离  
241.             4、Y轴偏移量  
242.             5、离右边的距离  
243.             6、高度  
244.             7、定位方式  
245.         第二种情况：第7个参数是1的时候，绝对定位，就是播放器长宽变化的时候，控制栏不跟着变，这种方式一般使用在控制栏大小不变的时候  
246.             1、左中右对齐方式（0是左，1是中间，2是右）  
247.             2、上中下对齐（0是上，1是中，2是下）  
248.             3、x偏移量  
249.             4、y偏移量  
250.             5、宽度  
251.             6、高度  
252.             7、定位方式  
253.         以上是前7个参数的作用  
254.             8、是文字广告的背景色  
255.             9、置背景色的透明度  
256.             10、控制滚动方向，0是水平滚动（包括左右），1是上下滚动（包括向上和向下）  
257.             11、移动的单位时长，即移动单位像素所需要的时长，毫秒  
258.             12、移动的单位像素,正数同左/上，负数向右/下  
259.             13、是行高，这个在设置向上或向下滚动的时候有用处  
260.             14、控制向上或向下滚动时每次停止的时间  
261.         */  
262.         pm_glowfilter:‘1,0x01485d, 100, 6, 3, 10, 1, 0, 0‘,  
263.         /*滚动文字广告是否采用发光滤镜  
264.             1、是否使用发光滤镜，0是不采用，1是使用  
265.             2、(default = 0xFF0000) — 光晕颜色，采用十六进制格式 0xRRGGBB。 默认值为 0xFF0000    
266.             3、(default = 100) — 颜色的 Alpha 透明度值。 有效值为 0 到 100。 例如，25 设置透明度为 25%  
267.             4、(default = 6.0) — 水平模糊量。 有效值为 0 到 255（浮点）。 2 的乘方值（如 2、4、8、16 和 32）经过优化，呈现速度比其它值更快    
268.             5、(default = 6.0) — 垂直模糊量。 有效值为 0 到 255（浮点）。 2 的乘方值（如 2、4、8、16 和 32）经过优化，呈现速度比其它值更快    
269.             6、(default = 2) — 印记或跨页的强度。 该值越高，压印的颜色越深，而且发光与背景之间的对比度也越强。 有效值为 0 到 255    
270.             7、(default = 1) — 应用滤镜的次数  
271.             8、(default = 0) — 指定发光是否为内侧发光。 值 1 指定发光是内侧发光。 值 0 指定发光是外侧发光（对象外缘周围的发光）    
272.             9、(default = 0) — 指定对象是否具有挖空效果。 值为 1 将使对象的填充变为透明，并显示文档的背景颜色   
273.         */  
274.         advmarquee: escape(‘{a href="http://www.ckplayer.com"}{font color="#FFFFFF" size="12"}这里可以放文字广告，播放器默认使用这里设置的广告内容，如果不想在这里使用可以清空这里的内容，如果想在页面中实时定义滚动文字广告内容，可以清空这里的内容，然后在页面中设置广告函数。{/font}{/a}‘),  
275.         /*  
276.         该处是滚动文字广告的内容，如果不想在这里设置，就把这里清空并且在页面中使用js的函数定义function ckmarqueeadv(){return ‘广告内容‘}  
277.         */  
278.         mainfuntion:‘‘,  
279.         /*  
280.         当flashvars里s=3/4时，调用的函数包名称，默认为空，调用时间轴上的函数setAppObj  
281.         */  
282.         flashplayer:‘‘,  
283.         /*  
284.         当flashvars里的s=3/4时，也可以把swf文件放在这里  
285.         */  
286.         calljs:‘ckplayer_status,ckadjump,playerstop,ckmarqueeadv‘,  
287.         /*  
288.             跳过广告和播放结束时调用的js函数  
289.         */  
290.         myweb: escape(‘‘),  
291.         /*  
292.         ------------------------------------------------------------------------------------------------------------------  
293.         以下内容部份是和插件相关的配置，请注意，自定义插件以及其配置的命名方式要注意，不要和系统的相重复，不然就会替换掉系统的相关设置，删除相关插件的话也可以同时删除相关的配置  
294.         ------------------------------------------------------------------------------------------------------------------  
295.         以下内容定义自定义插件的相关配置，这里也可以自定义任何自己的插件需要配置的内容，当然，如果你某个插件不使用的话，也可以删除相关的配置  
296.         ------------------------------------------------------------------------------------------------------------------  
297.         */  
298.         cpt_lights: ‘1‘,  
299.         /*  
300.         该处定义是否使用开关灯，和right.swf插件配合作用,使用开灯效果时调用页面的js函数function closelights(){};  
301.         */  
302.         cpt_share: ‘ckplayer/share.xml‘,  
303.         /*  
304.         分享插件调用的配置文件地址  
305.         调用插件开始  
306.         */  
307.         cpt_list: ckcpt()  
308.         /*  
309.         ckcpt()是本文件最上方的定义插件的函数  
310.         */  
311.     }  
312.     return ck;  
313. }  
314. /*  
315. html5部分开始  
316. 以下代码是支持html5的，如果你不需要，可以删除。  
317. html5代码块的代码可以随意更改以适合你的应用，欢迎到论坛交流更改心得  
318. */  
319. (function() {  
320.     var CKobject = {  
321.         _K_: function(d){return document.getElementById(d);},  
322.         _T_: false,  
323.         _M_: false,  
324.         _G_: false,  
325.         _Y_: false,  
326.         _I_: null,  
327.         _J_: 0,  
328.         _O_: {},  
329.         uaMatch:function(u,rMsie,rFirefox,rOpera,rChrome,rSafari,rSafari2,mozilla,mobile){  
330.             var match = rMsie.exec(u);  
331.             if (match != null) {  
332.                 return {  
333.                     b: ‘IE‘,  
334.                     v: match[2] || ‘0‘  
335.                 }  
336.             }  
337.             match = rFirefox.exec(u);  
338.             if (match != null) {  
339.                 return {  
340.                     b: match[1] || ‘‘,  
341.                     v: match[2] || ‘0‘  
342.                 }  
343.             }  
344.             match = rOpera.exec(u);  
345.             if (match != null) {  
346.                 return {  
347.                     b: match[1] || ‘‘,  
348.                     v: match[2] || ‘0‘  
349.                 }  
350.             }  
351.             match = rChrome.exec(u);  
352.             if (match != null) {  
353.                 return {  
354.                     b: match[1] || ‘‘,  
355.                     v: match[2] || ‘0‘  
356.                 }  
357.             }  
358.             match = rSafari.exec(u);  
359.             if (match != null) {  
360.                 return {  
361.                     b: match[2] || ‘‘,  
362.                     v: match[1] || ‘0‘  
363.                 }  
364.             }  
365.             match = rSafari2.exec(u);  
366.             if (match != null) {  
367.                 return {  
368.                     b: match[1] || ‘‘,  
369.                     v: match[2] || ‘0‘  
370.                 }  
371.             }  
372.             match = mozilla.exec(u);  
373.             if (match != null) {  
374.                 return {  
375.                     b: match[1] || ‘‘,  
376.                     v: match[2] || ‘0‘  
377.                 }  
378.             }  
379.             match = mobile.exec(u);  
380.             if (match != null) {  
381.                 return {  
382.                     b: match[1] || ‘‘,  
383.                     v: match[2] || ‘0‘  
384.                 }  
385.             }  
386.             else {  
387.                 return {  
388.                     b: ‘unknown‘,  
389.                     v: ‘0‘  
390.                 }  
391.             }  
392.         },  
393.         browser: function() {  
394.             var u = navigator.userAgent,  
395.             rMsie = /(msie\s|trident.*rv:)([\w.]+)/,  
396.             rFirefox = /(firefox)\/([\w.]+)/,  
397.             rOpera = /(opera).+version\/([\w.]+)/,  
398.             rChrome = /(chrome)\/([\w.]+)/,  
399.             rSafari = /version\/([\w.]+).*(safari)/,  
400.             rSafari2 = /(safari)\/([\w.]+)/,  
401.             mozilla = /(mozilla)\/([\w.]+)/,  
402.             mobile = /(mobile)\/([\w.]+)/;  
403.             var c = u.toLowerCase();  
404.             var d = this.uaMatch(c,rMsie,rFirefox,rOpera,rChrome,rSafari,rSafari2,mozilla,mobile);  
405.             if (d.b) {  
406.                 b = d.b;  
407.                 v = d.v;  
408.             }  
409.             return {B: b, V: v};  
410.         },  
411.         Platform: function() {  
412.             var w = ‘‘;  
413.             var u = navigator.userAgent,  
414.             app = navigator.appVersion;  
415.             var b = {  
416.                 iPhone: u.indexOf(‘iPhone‘) > -1 || u.indexOf(‘Mac‘) > -1,  
417.                 iPad: u.indexOf(‘iPad‘) > -1,  
418.                 ios: !!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/),  
419.                 android: u.indexOf(‘Android‘) > -1 || u.indexOf(‘Linux‘) > -1,  
420.                 webKit: u.indexOf(‘AppleWebKit‘) > -1,  
421.                 trident: u.indexOf(‘Trident‘) > -1,  
422.                 gecko: u.indexOf(‘Gecko‘) > -1 && u.indexOf(‘KHTML‘) == -1,  
423.                 presto: u.indexOf(‘Presto‘) > -1,  
424.                 mobile: !!u.match(/AppleWebKit.*Mobile.*/) || !!u.match(/AppleWebKit/),  
425.                 webApp: u.indexOf(‘Safari‘) == -1  
426.             };  
427.             for (var k in b) {  
428.                 if (b[k]) {  
429.                     w = k;  
430.                     break;  
431.                 }  
432.             }  
433.             return w;  
434.         },  
435.         isHTML5:function(){  
436.             return !!document.createElement(‘video‘).canPlayType;  
437.         },  
438.         getType:function(){  
439.             return this._T_;  
440.         },  
441.         getVideo: function() {  
442.             var v = ‘‘;  
443.             var s = this._E_[‘v‘];  
444.             if (s && s.length>1) {  
445.                 for (var i = 0; i < s.length; i++) {  
446.                     var a = s[i].split(‘->‘);  
447.                     if (a.length >= 1 && a[0] != ‘‘) {  
448.                         v += ‘<source src="‘ + a[0] + ‘"‘;  
449.                     }  
450.                     if (a.length >= 2 && a[1] != ‘‘) {  
451.                         v += ‘ type="‘ + a[1] + ‘"‘;  
452.                     }  
453.                     v += ‘>‘;  
454.                 }  
455.             }  
456.             return v;  
457.         },  
458.         getVars: function(k) {  
459.             var o=this._A_;  
460.             if (typeof(o) == ‘undefined‘) {   
461.                 return null;  
462.             }  
463.             if (k in o) {  
464.                 return o[k];  
465.             } else {  
466.                 return null;  
467.             }  
468.         },  
469.         getParams: function() {  
470.             var p = ‘‘;  
471.             if (this._A_) {  
472.                 if (parseInt(this.getVars(‘p‘)) == 1) {  
473.                     p += ‘ autoplay="autoplay"‘;  
474.                 }  
475.                 if (parseInt(this.getVars(‘e‘)) == 1) {  
476.                     p += ‘ loop="loop"‘;  
477.                 }  
478.                 if (parseInt(this.getVars(‘p‘)) == 2) {  
479.                     p += ‘ preload="metadata"‘;  
480.                 }  
481.                 if (this.getVars(‘i‘)) {  
482.                     p += ‘ poster="‘ + this.getVars(‘i‘) + ‘"‘;  
483.                 }  
484.             }  
485.             return p;  
486.         },  
487.         getpath: function(z) {  
488.             var f=‘CDEFGHIJKLMNOPQRSTUVWXYZcdefghijklmnopqrstuvwxyz‘;  
489.             var w=z.substr(0,1);  
490.             if(f.indexOf(w)>-1 && (z.substr(0,4)==w+‘://‘ || z.substr(0,4)==w+‘:\\‘)){  
491.                 return z;  
492.             }  
493.             var d = unescape(window.location.href).replace(‘file:///‘, ‘‘);  
494.             var k = parseInt(document.location.port);  
495.             var u = document.location.protocol + ‘//‘ + document.location.hostname;  
496.             var l = ‘‘,  
497.             e = ‘‘,  
498.             t = ‘‘;  
499.             var s = 0;  
500.             var r = unescape(z).split(‘//‘);  
501.             if (r.length > 0) {  
502.                 l = r[0] + ‘//‘  
503.             }  
504.             var h = ‘http|https|ftp|rtsp|mms|ftp|rtmp|file‘;  
505.             var a = h.split(‘|‘);  
506.             if (k != 80 && k) {  
507.                 u += ‘:‘ + k;  
508.             }  
509.             for (i = 0; i < a.length; i++) {  
510.                 if ((a[i] + ‘://‘) == l) {  
511.                     s = 1;  
512.                     break;  
513.                 }  
514.             }  
515.             if (s == 0) {  
516.                 if (z.substr(0, 1) == ‘/‘) {  
517.                     t = u + z;  
518.                 } else {  
519.                     e = d.substring(0, d.lastIndexOf(‘/‘) + 1).replace(‘\\‘, ‘/‘);  
520.                     var w = z.replace(‘../‘, ‘./‘);  
521.                     var u = w.split(‘./‘);  
522.                     var n = u.length;  
523.                     var r = w.replace(‘./‘, ‘‘);  
524.                     var q = e.split(‘/‘);  
525.                     var j = q.length - n;  
526.                     for (i = 0; i < j; i++) {  
527.                         t += q[i] + ‘/‘;  
528.                     }  
529.                     t += r;  
530.                 }  
531.             } else {  
532.                 t = z;  
533.             }  
534.             return t;  
535.         },  
536.         getXhr: function() {  
537.             var x;  
538.             try {  
539.                 x = new ActiveXObject(‘Msxml2.XMLHTTP‘);  
540.             } catch(e) {  
541.                 try {  
542.                     x = new ActiveXObject(‘Microsoft.XMLHTTP‘);  
543.                 } catch(e) {  
544.                     x = false;  
545.                 }  
546.             }  
547.             if (!x && typeof XMLHttpRequest != ‘undefined‘) {  
548.                 x = new XMLHttpRequest();  
549.             }  
550.             return x;  
551.         },  
552.         getX: function(){  
553.             var f=‘ckstyle()‘;  
554.             if (this.getVars(‘x‘) && parseInt(this.getVars(‘c‘))!=1 ) {  
555.                 f=this.getVars(‘x‘)+‘()‘;  
556.             }  
557.             try {  
558.                 if (typeof(eval(f)) == ‘object‘) {  
559.                     this._X_ = eval(f);  
560.                 }  
561.             } catch(e) {  
562.                 try {  
563.                     if (typeof(eval(ckstyle)) == ‘object‘) {  
564.                         this._X_ = ckstyle();  
565.                     }  
566.                 } catch(e) {  
567.                     this._X_ = ckstyle();  
568.                 }  
569.             }  
570.         },  
571.         getSn: function(s, n) {  
572.             if(n>=0){  
573.                 return this._X_[s].split(‘,‘)[n];  
574.             }  
575.             else{  
576.                 return this._X_[s];  
577.             }  
578.         },  
579.         getUrl: function(L, B) {  
580.             var b = [‘get‘, ‘utf-8‘];  
581.             if (L && L.length == 2) {  
582.                 var a = L[0];  
583.                 var c = L[1].split(‘/‘);  
584.                 if (c.length >= 2) {  
585.                     b[0] = c[1];  
586.                 }  
587.                 if (c.length >= 3) {  
588.                     b[1] = c[2];  
589.                 }  
590.                 this.ajax(b[0], b[1], a,  
591.                 function(s) {  
592.                     var C = CKobject;  
593.                     if (s && s != ‘error‘) {  
594.                         var d = ‘‘,  
595.                         e = s;  
596.                         if (s.indexOf(‘}‘) > -1) {  
597.                             var f = s.split(‘}‘);  
598.                             for (var i = 0; i < f.length - 1; i++) {  
599.                                 d += f[i] + ‘}‘;  
600.                                 var h = f[i].replace(‘{‘, ‘‘).split(‘->‘);  
601.                                 if (h.length == 2) {  
602.                                     C._A_[h[0]] = h[1];  
603.                                 }  
604.                             }  
605.                             e = f[f.length - 1];  
606.                         }  
607.                         C._E_[‘v‘] = e.split(‘,‘);  
608.                         if (B) {  
609.                             C.showHtml5();  
610.                         } else {  
611.                             C.changeParams(d);  
612.                             C.newAdr();  
613.                         }  
614.                     }  
615.                 });  
616.             }  
617.         },  
618.         getflashvars: function(s) {  
619.             var v = ‘‘,  
620.             i = 0;  
621.             if (s) {  
622.                 for (var k in s) {  
623.                     if (i > 0) {  
624.                         v += ‘&‘;  
625.                     }  
626.                     if (k == ‘f‘ && s[k] && ! this.getSn(‘pm_repc‘,-1)) {  
627.                         s[k] = this.getpath(s[k]);  
628.                         if (s[k].indexOf(‘&‘) > -1) {  
629.                             s[k] = encodeURIComponent(s[k]);  
630.                         }  
631.                     }  
632.                     if (k == ‘y‘ && s[k]) {  
633.                         s[k] = this.getpath(s[k]);  
634.                     }  
635.                     v += k + ‘=‘ + s[k];  
636.                     i++;  
637.                 }  
638.             }  
639.             return v;  
640.         },  
641.         getparam: function(s) {  
642.             var w = ‘‘,  
643.             v = ‘‘,  
644.             o = {  
645.                 allowScriptAccess: ‘always‘,  
646.                 allowFullScreen: true,  
647.                 quality: ‘high‘,  
648.                 bgcolor: ‘#000‘  
649.             };  
650.             if (s) {  
651.                 for (var k in s) {  
652.                     o[k] = s[k];  
653.                 }  
654.             }  
655.             for (var e in o) {  
656.                 w += e + ‘="‘ + o[e] + ‘" ‘;  
657.                 v += ‘<param name="‘ + e + ‘" value="‘ + o[e] + ‘" />‘;  
658.             }  
659.             w = w.replace(‘movie=‘, ‘src=‘);  
660.             return {  
661.                 w: w,  
662.                 v: v  
663.             };  
664.         },  
665.         getObjectById: function(s) {  
666.             if (this._T_) {  
667.                 return this;  
668.             }  
669.             var x = null,  
670.             y = this._K_(s),  
671.             r = ‘embed‘;  
672.             if (y && y.nodeName == ‘OBJECT‘) {  
673.                 if (typeof y.SetVariable != ‘undefined‘) {  
674.                    x= y;  
675.                 } else {  
676.                     var z = y.getElementsByTagName(r)[0];  
677.                     if (z) {  
678.                         x= z;  
679.                     }  
680.                 }  
681.             }  
682.             return x;  
683.         },  
684.         ajax: function(b, u, s, f) {  
685.             var x = this.getXhr();  
686.             var a = [],  
687.             m = ‘‘;  
688.             if (b == ‘get‘) {  
689.                 if (s.indexOf(‘?‘) > -1) {  
690.                     m = s + ‘&t=‘ + new Date().getTime();  
691.                 } else {  
692.                     m = s + ‘?t=‘ + new Date().getTime();  
693.                 }  
694.                 x.open(‘get‘, m);  
695.             } else {  
696.                 a = s.split(‘?‘);  
697.                 s = a[0],  
698.                 m = a[1];  
699.                 x.open(‘post‘, s, true);  
700.             }  
701.             x.setRequestHeader(‘Content-Type‘, ‘application/x-www-form-urlencoded‘);  
702.             x.setRequestHeader(‘charset‘, u);  
703.             if (b == ‘post‘) {  
704.                 x.send(m);  
705.             } else {  
706.                 x.send(null);  
707.             }  
708.             x.onreadystatechange = function() {  
709.                 if (x.readyState == 4) {  
710.                     var g = x.responseText;  
711.                     if (g != ‘‘) {  
712.                         f(g);  
713.                     } else {  
714.                         f(null);  
715.                     }  
716.                 }  
717.             }  
718.         },  
719.         addListener: function(e, f) {  
720.             var o=CKobject._V_;  
721.             if (o.addEventListener) {  
722.                 try{  
723.                     o.addEventListener(e, f, false);  
724.                 }  
725.                 catch (e) {  
726.                      this.getNot();  
727.                 }  
728.             }  
729.             else if (o.attachEvent) {  
730.                 try{  
731.                     o.attachEvent(‘on‘ + e, f);  
732.                 }  
733.                 catch(e){  
734.                      this.getNot();  
735.                 }  
736.             }  
737.             else {  
738.                 o[‘on‘ + e] = f;  
739.             }  
740.         },  
741.         removeListener: function( e, f) {  
742.             var o=CKobject._V_;  
743.             if (o.removeEventListener) {  
744.                 try{  
745.                     o.removeEventListener(e, f, false);  
746.                 }  
747.                 catch(e){  
748.                      this.getNot();  
749.                 }  
750.             }  
751.             else if (o.detachEvent) {  
752.                 try{  
753.                     o.detachEvent(‘on‘ + e, f);  
754.                 }  
755.                 catch(e){  
756.                      this.getNot();  
757.                 }  
758.             }  
759.             else {  
760.                 o[‘on‘ + e] = null;  
761.             }  
762.         },  
763.         Flash: function() {  
764.             var f = false,v = 0;  
765.             if (document.all  || this.browser()[‘B‘].toLowerCase().indexOf(‘ie‘)>-1) {  
766.                 try {  
767.                     var s = new ActiveXObject(‘ShockwaveFlash.ShockwaveFlash‘);  
768.                     f = true;  
769.                     var z = s.GetVariable(‘$version‘);  
770.                     v = parseInt(z.split(‘ ‘)[1].split(‘,‘)[0]);  
771.                 } catch(e) {}  
772.             } else {  
773.                 if (navigator.plugins && navigator.plugins.length > 0) {  
774.                     var s = navigator.plugins[‘Shockwave Flash‘];  
775.                     if (s) {  
776.                         f = true;  
777.                         var w = s.description.split(‘ ‘);  
778.                         for (var i = 0; i < w.length; ++i) {  
779.                             if (isNaN(parseInt(w[i]))) continue;  
780.                             v = parseInt(w[i]);  
781.                         }  
782.                     }  
783.                 }  
784.             }  
785.             return {  
786.                 f: f,  
787.                 v: v  
788.             };  
789.         },  
790.         embed:function(f,d,i,w,h,b,v,e,p,j){  
791.             var s=[‘all‘];  
792.             if(b){  
793.                 if(this.isHTML5()){  
794.                     this.embedHTML5(d,i,w,h,e,v,s,j);  
795.                 }  
796.                 else{  
797.                     this.embedSWF(f,d,i,w,h,v,p);  
798.                 }  
799.             }  
800.             else{  
801.                 if(this.Flash()[‘f‘] && parseInt(this.Flash()[‘v‘])>10){  
802.                     this.embedSWF(f,d,i,w,h,v,p);  
803.                 }  
804.                 else if(this.isHTML5()){  
805.                     this.embedHTML5(d,i,w,h,e,v,s,j);  
806.                 }  
807.                 else{  
808.                     this.embedSWF(f,d,i,w,h,v,p);  
809.                 }  
810.             }  
811.         },  
812.         embedSWF: function(C, D, N, W, H, V, P) {  
813.             if (!N) {  
814.                 N = ‘ckplayer_a1‘  
815.             }  
816.             if (!P) {  
817.                 P = {  
818.                     bgcolor: ‘#FFF‘,  
819.                     allowFullScreen: true,  
820.                     allowScriptAccess: ‘always‘,  
821.                     wmode:‘transparent‘  
822.                 };  
823.             }  
824.             this._A_=V;  
825.             this.getX();  
826.             var u = ‘undefined‘,  
827.             g = false,  
828.             j = document,  
829.             r = ‘http://www.macromedia.com/go/getflashplayer‘,  
830.             t = ‘<a href="‘ + r + ‘" target="_blank">请点击此处下载安装最新的flash插件</a>‘,  
831.             error = {  
832.                 w: ‘您的网页不符合w3c标准，无法显示播放器‘,  
833.                 f: ‘您没有安装flash插件，无法播放视频，‘ + t,  
834.                 v: ‘您的flash插件版本过低，无法播放视频，‘ + t  
835.             },  
836.             w3c = typeof j.getElementById != u && typeof j.getElementsByTagName != u && typeof j.createElement != u,  
837.             i = ‘id="‘ + N + ‘" name="‘ + N + ‘" ‘,  
838.             s = ‘‘,  
839.             l = ‘‘;  
840.             P[‘movie‘] = C;  
841.             P[‘flashvars‘] = this.getflashvars(V);  
842.             if(W==-1){  
843.                 d=true;  
844.                 this._K_(D).style.width=‘100%‘;  
845.                 W=‘100%‘;  
846.             }  
847.             s += ‘<object pluginspage="http://www.macromedia.com/go/getflashplayer" ‘;  
848.             s += ‘classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" ‘;  
849.             s += ‘codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=11,3,0,0" ‘;  
850.             s += ‘width="‘ + W + ‘" ‘;  
851.             s += ‘height="‘ + H + ‘" ‘;  
852.             s += i;  
853.             s += ‘align="middle">‘;  
854.             s += this.getparam(P)[‘v‘];  
855.             s += ‘<embed ‘;  
856.             s += this.getparam(P)[‘w‘];  
857.             s += ‘ width="‘ + W + ‘" height="‘ + H + ‘" name="‘ + N + ‘" id="‘ + N + ‘" align="middle" ‘ + i;  
858.             s += ‘type="application/x-shockwave-flash" pluginspage="‘ + r + ‘" />‘;  
859.             s += ‘</object>‘;  
860.             if (!w3c) {  
861.                 l = error[‘w‘];  
862.                 g = true;  
863.             } else {  
864.                 if (!this.Flash()[‘f‘]) {  
865.                     l = error[‘f‘];  
866.                     g = true;  
867.                 } else {  
868.                     if (this.Flash()[‘v‘] < 11) {  
869.                         l = error[‘v‘];  
870.                         g = true;  
871.                     } else {  
872.                         l = s;  
873.                         this._T_=false;  
874.                     }  
875.                 }  
876.             }  
877.             if (l) {  
878.                 this._K_(D).innerHTML = l;  
879.             }  
880.             if (g){  
881.                 this._K_(D).style.color = ‘#0066cc‘;  
882.                 this._K_(D).style.lineHeight = this._K_(D).style.height;  
883.                 this._K_(D).style.textAlign= ‘center‘;  
884.             }  
885.         },  
886.         embedHTML5: function(C, P, W, H, V, A, S, J) {  
887.             this._E_ = {  
888.                 c: C,  
889.                 p: P,  
890.                 w: W,  
891.                 h: H,  
892.                 v: V,  
893.                 s: S,  
894.                 j: J==undefined || J?true:false  
895.             };  
896.             this._A_ = A;  
897.             this.getX();  
898.             b = this.browser()[‘B‘],  
899.             v = this.browser()[‘V‘],  
900.             x = v.split(‘.‘),  
901.             t = x[0],  
902.             m = b + v,  
903.             n = b + t,  
904.             w = ‘‘,  
905.             s = false,  
906.             f = this.Flash()[‘f‘],  
907.             a = false;  
908.             if (!S) {  
909.                 S = [‘iPad‘, ‘iPhone‘, ‘ios‘];  
910.             }  
911.             for (var i = 0; i < S.length; i++) {  
912.                 w = S[i];  
913.                 if (w.toLowerCase() == ‘all‘) {  
914.                     s = true;  
915.                     break;  
916.                 }  
917.                 if (w.toLowerCase() == ‘all+false‘ && !f) {  
918.                     s = true;  
919.                     break;  
920.                 }  
921.                 if (w.indexOf(‘+‘) > -1) {  
922.                     w = w.split(‘+‘)[0];  
923.                     a = true;  
924.                 } else {  
925.                     a = false;  
926.                 }  
927.                 if (this.Platform() == w || m == w || n == w || b == w) {  
928.                     if (a) {  
929.                         if (!f) {  
930.                             s = true;  
931.                             break;  
932.                         }  
933.                     }else {  
934.                         s = true;  
935.                         break;  
936.                     }  
937.                 }  
938.             }  
939.             if (s) {  
940.                 if (V) {  
941.                     var l = V[0].split(‘->‘);  
942.                     if (l && l.length == 2 && l[1].indexOf(‘ajax‘) > -1) {  
943.                         this.getUrl(l, true);  
944.                         return;  
945.                     }  
946.                 }  
947.                 this.showHtml5();  
948.             }  
949.         },  
950.         status: function() {  
951.             this._H_ = parseInt(this.getSn(‘setup‘, 20));  
952.             var f=‘ckplayer_status‘;  
953.             if (this.getSn(‘calljs‘, 0)!=‘‘) {  
954.                 f=this.getSn(‘calljs‘, 0);  
955.             }  
956.             try {  
957.                 if (typeof(eval(f)) == ‘function‘) {  
958.                     this._L_=eval(f);  
959.                     this._M_=true;  
960.                     return true;  
961.                 }  
962.             } catch(e) {  
963.                 try {  
964.                     if (typeof(eval(ckplayer_status)) == ‘function‘) {  
965.                         this._L_=ckplayer_status;  
966.                         this._M_=true;  
967.                         return true;  
968.                     }  
969.                 } catch(e) {  
970.                     return false;  
971.                 }  
972.             }  
973.             return false;  
974.         },  
975.         showHtml5: function() {  
976.             var C = CKobject;  
977.             var p = C._E_[‘p‘],  
978.             a = C._E_[‘v‘],  
979.             c = C._E_[‘c‘],  
980.             j = ‘‘,  
981.             b = false;  
982.             var s = this._E_[‘v‘];  
983.             var w=C._E_[‘w‘],h=C._E_[‘h‘];  
984.             var d=false;  
985.             var r=‘‘;  
986.             if(s.length==1){  
987.                 r=‘ src="‘+s[0].split(‘->‘)[0]+‘"‘;  
988.             }  
989.             if(w==-1){  
990.                 d=true;  
991.                 C._K_(c).style.width=‘100%‘;  
992.                 w=‘100%‘;  
993.             }  
994.             if(w.toString().indexOf(‘%‘)>-1){  
995.                 w=‘100%‘;  
996.             }  
997.             if(h.toString().indexOf(‘%‘)>-1){  
998.                 h=‘100%‘;  
999.             }  
1000.             if(C._E_[‘j‘]){  
1001.                 j=‘controls="controls"‘;  
1002.             }  
1003.             var v = ‘<video ‘+j+r+‘ id="‘ + p + ‘" width="‘ + w + ‘" height="‘ + h + ‘"‘ + C.getParams() + ‘>‘ + C.getVideo() + ‘</video>‘;  
1004.             C._K_(c).innerHTML = v;  
1005.             C._K_(c).style.backgroundColor = ‘#000‘;  
1006.             C._V_ = C._K_(p);  
1007.             if(!d){  
1008.                 C._K_(c).style.width=C._E_[‘w‘].toString().indexOf(‘%‘)>-1?(C._K_(c).offsetWidth*parseInt(C._E_[‘w‘])*0.01)+‘px‘:C._V_.width+‘px‘;  
1009.                 C._K_(c).style.height=C._E_[‘h‘].toString().indexOf(‘%‘)>-1?(C._K_(c).offsetHeight*parseInt(C._E_[‘h‘])*0.01)+‘px‘:C._V_.height+‘px‘;  
1010.             }  
1011.             C._P_ = false;  
1012.             C._T_ = true;  
1013.             if (C.getVars(‘loaded‘)!=‘‘) {  
1014.                 var f=C.getVars(‘loaded‘)+‘()‘;  
1015.                 try {  
1016.                     if (typeof(eval(f)) == ‘function‘) {  
1017.                         eval(f);  
1018.                     }  
1019.                 } catch(e) {  
1020.                     try {  
1021.                         if (typeof(eval(loadedHandler)) == ‘function‘) {  
1022.                             loadedHandler();  
1023.                         }  
1024.                     } catch(e) {  
1025.                     }  
1026.                 }  
1027.             }  
1028.             C.status();  
1029.             C.addListener(‘play‘, C.playHandler);  
1030.             C.addListener(‘pause‘, C.playHandler);  
1031.             C.addListener(‘error‘, C.errorHandler);  
1032.             C.addListener(‘emptied‘, C.errorHandler);  
1033.             C.addListener(‘loadedmetadata‘, C.loadedMetadataHandler);  
1034.             C.addListener(‘ended‘, C.endedHandler);  
1035.             C.addListener(‘volumechange‘, C.volumeChangeHandler);  
1036.             if((C.getVars(‘m‘)!=‘‘ && C.getVars(‘m‘)!=null) || parseInt( C.getSn(‘setup‘, 0))>0){  
1037.                 C._K_(c).style.cursor=‘pointer‘;  
1038.             }  
1039.             if((C.getVars(‘m‘)!=‘‘ && C.getVars(‘m‘)!=null) || parseInt( C.getSn(‘setup‘, 1))==1){  
1040.                 C.addListener(‘click‘, C.html5Click);  
1041.             }  
1042.         },  
1043.         videoPlay: function() {  
1044.             if (this._T_) {  
1045.                 this._V_.play();  
1046.             }  
1047.         },  
1048.         videoPause: function() {  
1049.             if (this._T_) {  
1050.                 this._V_.pause();  
1051.             }  
1052.         },  
1053.         playOrPause: function() {  
1054.             if (this._T_) {  
1055.                 if (this._V_.paused) {  
1056.                     this._V_.play();  
1057.                 } else {  
1058.                     this._V_.pause();  
1059.                 }  
1060.             }  
1061.         },  
1062.         fastNext: function() {  
1063.             if (this._T_) {  
1064.                 this._V_[‘currentTime‘] = this._V_[‘currentTime‘] + 10;  
1065.             }  
1066.         },  
1067.         fastBack: function() {  
1068.             if (this._T_) {  
1069.                 this._V_[‘currentTime‘] = this._V_[‘currentTime‘] - 10;  
1070.             }  
1071.         },  
1072.         changeVolume: function(n) {  
1073.             if (this._T_) {  
1074.                 this._V_[‘volume‘] = n * 0.01;  
1075.             }  
1076.         },  
1077.         videoSeek: function(t) {  
1078.             if (this._T_) {  
1079.                 this._V_[‘currentTime‘] = t;  
1080.             }  
1081.         },  
1082.         newAddress: function(u) {  
1083.             var s = [];  
1084.             if (u) {  
1085.                 s = this.isHtml5New(u);  
1086.             } else {  
1087.                 return;  
1088.             }  
1089.             if (s && this._T_) {  
1090.                 this.changeParams(u);  
1091.                 var l = s[0].split(‘->‘);  
1092.                 if (l && l.length == 2 && l[1].indexOf(‘ajax‘) > -1) {  
1093.                     this.getUrl(l, false);  
1094.                     return;  
1095.                 }  
1096.                 this._E_[‘v‘] = s;  
1097.                 this.newAdr();  
1098.             }  
1099.         },  
1100.         quitFullScreen:function() {  
1101.             if(document.cancelFullScreen) {  
1102.                 document.cancelFullScreen();  
1103.             }   
1104.             else if(document.mozCancelFullScreen) {  
1105.                 document.mozCancelFullScreen();  
1106.             } else if(document.webkitCancelFullScreen) {  
1107.                 document.webkitCancelFullScreen();  
1108.             }  
1109.   
1110.         },  
1111.         changeStatus:function(n){  
1112.             this._H_=n;  
1113.         },  
1114.         newAdr: function() {  
1115.             var s = this._E_[‘v‘];  
1116.             this._V_.pause();  
1117.             if(s.length==1){  
1118.                 this._V_.src=s[0].split(‘->‘)[0];  
1119.             }  
1120.             else{  
1121.                 this._V_[‘innerHTML‘] = this.getVideo();  
1122.             }  
1123.             this._V_.load();  
1124.         },  
1125.         isHtml5New: function(s) {  
1126.             if (s.indexOf(‘html5‘) == -1) {  
1127.                 return false;  
1128.             }  
1129.             var a = s.replace(/{/g, ‘‘);  
1130.             var b = a.split(‘}‘);  
1131.             var c = ‘‘;  
1132.             for (var i = 0; i < b.length; i++) {  
1133.                 if (b[i].indexOf(‘html5‘) > -1) {  
1134.                     c = b[i].replace(‘html5->‘, ‘‘).split(‘,‘);  
1135.                     break;  
1136.                 }  
1137.             }  
1138.             return c;  
1139.         },  
1140.         changeParams: function(f) {  
1141.             if (f) {  
1142.                 var a = f.replace(/{/g, ‘‘);  
1143.                 var b = a.split(‘}‘);  
1144.                 var c = ‘‘;  
1145.                 for (var i = 0; i < b.length; i++) {  
1146.                     var d = b[i].split(‘->‘);  
1147.                     if(d.length == 2){  
1148.                         switch(d[0]){  
1149.                             case ‘p‘:  
1150.                                 if(parseInt(d[1]) == 1){  
1151.                                     this._V_.autoplay = true;  
1152.                                 }  
1153.                                 else if(parseInt(d[1]) == 2){  
1154.                                     this._V_.preload = ‘metadata‘;  
1155.                                 }  
1156.                                 else{  
1157.                                     this._V_.autoplay = false;  
1158.                                     if(this._I_!=null){  
1159.                                         clearInterval(this._I_);  
1160.                                         this._I_=null;  
1161.                                     }  
1162.                                 }  
1163.                                 break;  
1164.                             case ‘e‘:  
1165.                                 if(parseInt(d[1]) == 1){  
1166.                                     this._V_.loop = true;  
1167.                                 }  
1168.                                 else{  
1169.                                     this._V_.loop = false;  
1170.                                 }  
1171.                                 break;  
1172.                             case ‘i‘:  
1173.                                 this._V_.poster = d[1];  
1174.                                 break;  
1175.                             default:  
1176.                                 break;  
1177.                         }  
1178.                     }  
1179.                 }  
1180.             }  
1181.         },  
1182.         frontAdPause: function(s) {  
1183.             this.getNot();  
1184.         },  
1185.         frontAdUnload: function() {  
1186.             this.getNot();  
1187.         },  
1188.         changeFace: function(s) {  
1189.             this.getNot();  
1190.         },  
1191.         plugin: function(a, b, c, d, e, f, g) {  
1192.             this.getNot();  
1193.         },  
1194.         videoClear: function() {  
1195.             this.getNot();  
1196.         },  
1197.         videoBrightness: function(s) {  
1198.             this.getNot();  
1199.         },  
1200.         videoContrast: function(s) {  
1201.             this.getNot();  
1202.         },  
1203.         videoSaturation: function(s) {  
1204.             this.getNot();  
1205.         },  
1206.         videoSetHue: function(s) {  
1207.             this.getNot();  
1208.         },  
1209.         videoWAndH: function(a, b) {  
1210.             this.getNot();  
1211.         },  
1212.         videoWHXY: function(a, b, c, d) {  
1213.             this.getNot();  
1214.         },  
1215.         changeFlashvars: function(a) {  
1216.             this.getNot();  
1217.         },  
1218.         changeMyObject: function(a, b) {  
1219.             this.getNot();  
1220.         },  
1221.         getMyObject: function(a, b) {  
1222.             this.getNot();  
1223.         },  
1224.         changeeFace: function() {  
1225.             this.getNot();  
1226.         },  
1227.         changeStyle: function(a, b) {  
1228.             this.getNot();  
1229.         },  
1230.         promptLoad: function() {  
1231.             this.getNot();  
1232.         },  
1233.         promptUnload: function() {  
1234.             this.getNot();  
1235.         },  
1236.         marqueeLoad: function(a,b) {  
1237.             this.getNot();  
1238.         },  
1239.         marqueeClose: function(s) {  
1240.             this.getNot();  
1241.         },  
1242.         getNot: function() {  
1243.             var s=‘The ckplayer\‘s API for HTML5 does not exist‘;  
1244.             return s;  
1245.         },  
1246.         volumeChangeHandler: function() {  
1247.             var C = CKobject;  
1248.             if (C._V_.muted) {  
1249.                 C.returnStatus(‘volumechange:0‘, 1);  
1250.                 C._O_[‘volume‘] = 0;  
1251.                 C._O_[‘mute‘] = true;  
1252.             } else {  
1253.                 C._O_[‘mute‘] = false;  
1254.                 C._O_[‘volume‘] = C._V_[‘volume‘] * 100;  
1255.                 C.returnStatus(‘volumechange:‘+C._V_[‘volume‘] * 100, 1);  
1256.             }  
1257.         },  
1258.         endedHandler: function() {  
1259.             var C = CKobject;  
1260.             var e=parseInt(C.getVars(‘e‘));  
1261.             C.returnStatus(‘ended‘, 1);  
1262.             if(C._I_){  
1263.                 clearInterval(C._I_);  
1264.                 C._I_=null;  
1265.             }  
1266.             if ( e!= 0 && e !=4 && e !=6) {  
1267.                 return;  
1268.             }  
1269.             if(e==6){  
1270.                 this.quitFullScreen();  
1271.             }  
1272.             var f=‘playerstop()‘;  
1273.             if (C.getSn(‘calljs‘, 2)!=‘‘) {  
1274.                 f=C.getSn(‘calljs‘, 2)+‘()‘;  
1275.             }  
1276.             try {  
1277.                 if (typeof(eval(f)) == ‘function‘) {  
1278.                     eval(f);  
1279.                     return;  
1280.                 }  
1281.             } catch(e) {  
1282.                 try {  
1283.                     if (typeof(eval(playerstop)) == ‘function‘) {  
1284.                         playerstop();  
1285.                         return;  
1286.                     }  
1287.                 } catch(e) {  
1288.                     return;  
1289.                 }  
1290.             }  
1291.         },  
1292.         loadedMetadataHandler: function() {  
1293.             var C = CKobject;  
1294.             C.returnStatus(‘loadedmetadata‘, 1);  
1295.             C._O_[‘totaltime‘] = C._V_[‘duration‘];  
1296.             C._O_[‘width‘] = C._V_[‘width‘];  
1297.             C._O_[‘height‘] = C._V_[‘height‘];  
1298.             C._O_[‘awidth‘] = C._V_[‘videoWidth‘];  
1299.             C._O_[‘aheight‘] = C._V_[‘videoHeight‘];  
1300.             if (C._V_.defaultMuted) {  
1301.                 C.returnStatus(‘volumechange:0‘, 1);  
1302.                 C._O_[‘mute‘] = true;  
1303.                 C._O_[‘volume‘] = 0;  
1304.             } else {  
1305.                 C._O_[‘mute‘] = false;  
1306.                 C._O_[‘volume‘] = C._V_[‘volume‘] * 100;  
1307.                 C.returnStatus(‘volumechange:‘+C._V_[‘volume‘] * 100, 1);  
1308.             }  
1309.             if (parseInt(C.getVars(‘p‘)) == 1) {  
1310.                 C.playHandler();  
1311.             }  
1312.         },  
1313.         errorHandler: function() {  
1314.             CKobject.returnStatus(‘error‘, 1);  
1315.         },  
1316.         playHandler: function() {  
1317.             var C = CKobject;  
1318.             if (C._V_.paused) {  
1319.                 C.returnStatus(‘pause‘, 1);  
1320.                 C.addO(‘play‘, false);  
1321.                 if(C._I_!=null){  
1322.                     clearInterval(C._I_);  
1323.                     C._I_=null;  
1324.                 }  
1325.             } else {  
1326.                 C.returnStatus(‘play‘, 1);  
1327.                 C.addO(‘play‘, true);  
1328.                 if (!C._P_) {  
1329.                     C.returnStatus(‘play‘, 1);  
1330.                     C._P_ = true;  
1331.                 }  
1332.                 C._I_ = setInterval(C.playTime, parseInt( C.getSn(‘setup‘, 37)));  
1333.                 if(!C._G_){  
1334.                     C._G_=true;  
1335.                     for(var k in C._A_){  
1336.                         if(k==‘g‘ && C._A_[k]){  
1337.                             var g=parseInt(C._A_[k]);  
1338.                             C.videoSeek(g);  
1339.                         }     
1340.                     }  
1341.                 }  
1342.                 if(!C._Y_){  
1343.                     C._Y_=true;  
1344.                     for(var k in C._A_){  
1345.                         if(k==‘j‘ && C._A_[k]){  
1346.                             var j=parseInt(C._A_[k]);  
1347.                             if(j>0){  
1348.                                 C._J_=j;  
1349.                             }  
1350.                             else{  
1351.                                 C._J_=parseInt(C._O_[‘totaltime‘])+j;  
1352.                             }  
1353.                         }     
1354.                     }  
1355.                 }  
1356.             }  
1357.         },  
1358.         html5Click: function(){  
1359.             var C = CKobject;  
1360.             if(C.getVars(‘m‘)!=‘‘ && C.getVars(‘m‘)!=null){  
1361.                 window.open(C.getVars(‘m‘));  
1362.             }  
1363.         },  
1364.         returnStatus: function(s, j) {  
1365.             var h = s;  
1366.             if (this._H_ == 3) {  
1367.                 h = this._E_[‘p‘] +‘->‘+ h;  
1368.             }  
1369.             if (this._M_ && j <= this._H_ ) {  
1370.                 this._L_(h);  
1371.             }  
1372.         },  
1373.         addO: function(s, z) {  
1374.             this._O_[s] = z;  
1375.         },  
1376.         getStatus: function() {  
1377.             return this._O_;  
1378.         },  
1379.         playTime: function() {  
1380.             var C = CKobject;  
1381.             var t = C._V_[‘currentTime‘];  
1382.             C._O_[‘time‘] = t;  
1383.             if(C._J_>0 && t>C._J_){  
1384.                 C._J_=0;  
1385.                 C.videoSeek(C._O_[‘totaltime‘]);  
1386.             }  
1387.             C.returnStatus(‘time:‘ + t, 1);  
1388.         }  
1389.     }  
1390.     window.CKobject = CKobject;  
1391. })();  

1. <?xml version="1.0" encoding="utf-8"?>  
2. <ckplayer>  
3.   <style>  
4.         <cpath></cpath>  
5.         <!--  
6.         播放器风格压缩包文件的路径，默认的是style.swf  
7.         如果调用不出来可以试着设置成绝对路径试试  
8.         如果不知道路径并且使用的是默认配置，可以直接留空，播放器会自动寻找  
9.         -->  
10.         <language></language>  
11.         <!-- 
12.         播放器所使用的语言配置文件，需要和播放器在同目录下，默认是language.xml 
13.         -->  
14.         <flashvars>{b->1}{p->1}</flashvars>  
15.         <!--  
16.         这里是用来做为对flashvars值的补充，除了c和x二个参数以外的设置都可以在这里进行配置  
17.                                  1 1 1 1   1 1 1 1 1 1 2 2 2  2 2 2 2 2    2 2 3 3 3 3 3 3 3 3 3   3 4  4 4 4  
18.                1 2 3 4 5 6 7 8 9 0 1 2 3   4 5 6 7 8 9 0 1 2  3 4 5 6 7    8 9 0 1 2 3 4 5 6 7 8   9 0  1 2 3  
19.         -->  
20.         <setup>1,1,1,1,1,2,0,1,2,0,0,1,200,0,2,1,0,1,1,1,0,10,3,0,1,2,3000,0,0,0,0,1,1,1,1,1,1,250,0,90,0,0,0</setup>  
21.         <!--  
22.         这是配置文件里比较重要的一个参数，共有N个功能控制参数，并且以后会继续的增加，各控制参数以英文逗号(,)隔开。下面列出各参数的说明：  
23.             1、鼠标经过按钮是否使用手型，0普通鼠标，1手型鼠标，2是只有按钮手型，3是控制栏手型  
24.             2、是否支持单击暂停，0不支持，1是支持  
25.             3、是否支持双击全屏，0不支持，1是支持  
26.             4、在播放前置广告时是否同时加载视频，0不加载，1加载  
27.             5、广告显示的参考对象，0是参考视频区域，1是参考播放器区域  
28.             6、广告大小的调整方式,只针对swf和图片有效,视频是自动缩放的  
29.                 =0是自动调整大小，意思是说大的话就变小，小的话就变大  
30.                 =1是大的化变小，小的话不变  
31.                 =2是什么也不变，就这么大  
32.                 =3是跟参考对像(第5个控制)参数设置的一样宽高  
33.             7、前置广告播放顺序，0是顺序播放，1是随机播放，>1则随机取所有广告中的(N-1)个进行播放  
34.             8、对于视频广告是否采用修正，0是不使用，1是使用，如果是1，则用户在网速慢的情况下会按设定的倒计时进行播放广告，计时结束则放正片（比较人性化），设置成0的话，则强制播放完广告才能播放正片  
35.             9、是否开启滚动文字广告，0是不开启，1是开启且不使用关闭按钮，2是开启并且使用关闭按钮，开启后将在加载视频的时候加载滚动文字广告  
36.             10、视频的调整方式  
37.                 =0是自动调整大小，意思是说大的话就变小，小的话就变大，同时保持长宽比例不变  
38.                 =1是大的化变小，小的话不变  
39.                 =2是什么也不变，就这么大  
40.                 =3是跟参考对像(pm_video的设置)参数设置的一样宽高  
41.             11、是否在多视频时分段加载，0不是，1是  
42.             12、缩放视频时是否进行平滑处理，0不是，1是  
43.             13、视频缓冲时间,单位：毫秒,建议不超过300  
44.             14、初始图片调整方式(  
45.                 =0是自动调整大小，意思是说大的话就变小，小的话就变大，同时保持长宽比例不变  
46.                 =1是大的化变小，小的话不变  
47.                 =2是什么也不变，就这么大  
48.                 =3是跟pm_video参数设置的一样宽高  
49.             15、暂停广告调整方式(  
50.                 =0是自动调整大小，意思是说大的话就变小，小的话就变大，同时保持长宽比例不变  
51.                 =1是大的化变小，小的话不变  
52.                 =2是什么也不变，就这么大  
53.                 =3是跟pm_video参数设置的一样宽  
54.             16、暂停广告是否使用关闭广告设置，0不使用，1使用  
55.             17、缓冲时是否播放广告，0是不显示，1是显示并同时隐藏掉缓冲图标和进度，2是显示并不隐藏缓冲图标  
56.             18、是否支持键盘空格键控制播放和暂停0不支持，1支持  
57.             19、是否支持键盘左右方向键控制快进快退0不支持，1支持  
58.             20、是否支持键盘上下方向键控制音量0不支持，1支持  
59.             21、播放器返回js交互函数的等级，0-2,等级越高，返回的参数越多  
60.                 0是返回少量常用交互  
61.                 1返回播放器在播放的时候的参数，不返回广告之类的参数  
62.                 2返回全部参数  
63.                 3返回全部参数，并且在参数前加上"播放器ID->"，用于多播放器的监听  
64.             22、快进和快退的秒数  
65.             23、界面上图片元素加载失败重新加载次数  
66.             24、开启加载皮肤压缩文件包的加载进度提示  
67.             25、使用隐藏控制栏时显示简单进度条的功能,0是不使用，1是使用，2是只在普通状态下使用  
68.             26、控制栏隐藏设置(0不隐藏，1全屏时隐藏，2都隐藏  
69.             27、控制栏隐藏延时时间，即在鼠标离开控制栏后多少毫秒后隐藏控制栏  
70.             28、左右滚动时是否采用无缝，默认0采用，1是不采用  
71.             29、0是正常状态，1是控制栏默认隐藏，播放状态下鼠标经过播放器显示控制栏，2是一直隐藏控制栏  
72.             30、在播放rtmp视频时暂停后点击播放是否采用重新链接的方式,这里一共分0-3四个等级  
73.             31、当采用网址形式(flashvars里s=1/2时)读取视频地址时是采用默认0=get方法，1=post方式  
74.             32、是否启用播放按钮和暂停按钮  
75.             33、是否启用中间暂停按钮  
76.             34、是否启用静音按钮  
77.             35、是否启用全屏按钮  
78.             36、是否启用进度调节栏,0不启用，1是启用，2是只能前进（向右拖动），3是只能后退，4是只能前进但能回到第一次拖动时的位置，5是看过的地方可以随意拖动，  
79.             37、是否启用调节音量  
80.             38、计算时间的间隔，毫秒  
81.             39、前置logo至少显示的时间，单位：毫秒  
82.             40、前置视频广告的默认音量  
83.             41、当s=3/4时加载插件是否从压缩包里加载，0不是，1是  
84.             42、加载风格是否采用加密方式传送，该功能普通用户不能使用  
85.             43、在s=1/2时，调用地址里的地址是否是相对地址（相对于调用文件），0不是，1是  
86.         -->  
87.         <pm_bg>0x000000,100,230,180</pm_bg>  
88.         <!--播放器整体的背景配置  
89.             1、整体背景颜色  
90.             2、背景透明度  
91.             3、播放器最小宽度  
92.             4、播放器最小高度  
93.             这里只是初始化时的设置，最终加载完播放器后显示的效果需要在style.swf/style.xml里设置该参数  
94.         -->  
95.         <mylogo>null</mylogo>  
96.         <!-- 
97.         视频加载前显示的logo文件，不使用设置成<mylogo>null</mylogo> 
98.         -->  
99.         <pm_mylogo>1,1,-100,-55</pm_mylogo>  
100.         <!--  
101.         视频加载前显示的logo文件(mylogo参数的)的位置  
102.         本软件所有的四个参数控制位置的方式全部都是统一的意思，如下  
103.             1、水平对齐方式，0是左，1是中，2是右  
104.             2、垂直对齐方式，0是上，1是中，2是下  
105.             3、水平偏移量，举例说明，如果第1个参数设置成0左对齐，第3个偏移量设置成10，就是离左边10个像素，第一个参数设置成2，偏移量如果设置的是正值就会移到播放器外面，只有设置成负值才行，设置成-1，按钮就会跑到播放器外面  
106.             4、垂直偏移量   
107.         -->  
108.         <logo>null</logo>  
109.         <!-- 
110.         默认右上角一直显示的logo，不使用设置成<logo>null</logo> 
111.         -->  
112.         <pm_logo>2,0,-100,20</pm_logo>  
113.         <!--  
114.         播放器右上角的logo的位置  
115.             1、水平对齐方式，0是左，1是中，2是右  
116.             2、垂直对齐方式，0是上，1是中，2是下  
117.             3、水平偏移量  
118.             4、垂直偏移量   
119.         以下是播放器自带的二个插件  
120.         -->  
121.         <control_rel>related.swf,related.xml,0</control_rel>  
122.         <!--  
123.             1、视频播放结束后显示相关精彩视频的插件文件（注意，视频结束动作设置成3时(即var flashvars={e:3})有效），  
124.             2、xml文件是调用精彩视频的示例文件，可以自定义文件类型（比如asp,php,jsp,.net只要输出的是xml格式就行）,实际使用中一定要注意第二个参数的路径要正确  
125.             3、第三个参数是设置配置文件的编码，0是默认的utf-8,1是gbk2312   
126.         -->  
127.         <control_pv>Preview.swf,105,2000</control_pv>  
128.         <!--  
129.         视频预览插件  
130.             1、插件文件名称(该插件和上面的精彩视频的插件都是放在风格压缩包里的)  
131.             2、离进度栏的高(指的是插件的顶部离进度栏的位置)  
132.             3、延迟时间(该处设置鼠标经过进度栏停顿多少毫秒后才显示插件)  
133.             建议一定要设置延时时间，不然当鼠标在进度栏上划过的时候就会读取视频地址进行预览，很占资源   
134.         -->  
135.         <pm_repc></pm_repc>  
136.         <!-- 
137.         视频地址替换符，该功能主要是用来做简单加密的功能，使用方法很简单，请注意，只针对f值是视频地址的时候有效，其它地方不能使用。具体的请查看http://www.ckplayer.com/manual.php?id=4#title_25 
138.         -->  
139.         <pm_spac>|</pm_spac>  
140.         <!-- 
141.         视频地址间隔符，这里主要是播放多段视频时使用普通调用方式或网址调用方式时使用的。默认使用|，如果视频地址里本身存在|的话需要另外设置一个间隔符，注意，即使只有一个视频也需要设置。另外在使用rtmp协议播放视频的时候，如果视频存在多级目录的话，这里要改成其它的符号，因为rtmp协议的视频地址多级的话也需要用到|隔开流地址和实例地址  
142.         -->  
143.         <pm_fpac>file->f</pm_fpac>  
144.         <!-- 
145.         该参数的功能是把自定义的flashvars里的变量替换成ckplayer里对应的变量，默认的参数的意思是把flashvars里的file值替换成f值，因为ckplayer里只认f值，多个替换之间用竖线隔开 
146.         -->  
147.         <pm_advtime>2,0,-110,10,0,300,0</pm_advtime>  
148.         <!--  
149.         前置广告倒计时文本位置，播放前置 广告时有个倒计时的显示文本框，这里是设置该文本框的位置和宽高，对齐方式的。一共7个参数，分别表示：  
150.             1、水平对齐方式，0是左对齐，1是中间对齐，2是右对齐  
151.             2、垂直对齐方式，0是上对齐，1是中间对齐，2是低部对齐  
152.             3、水平位置偏移量  
153.             4、垂直位置偏移量  
154.             5、文字对齐方式，0是左对齐，1是中间对齐，2是右对齐，3是默认对齐  
155.             6、文本框宽席  
156.             7、文本框高度   
157.         -->  
158.         <pm_advstatus>1,2,2,-200,-40</pm_advstatus>  
159.         <!--  
160.         前置广告静音按钮，静音按钮只在是视频广告时显示，当然也可以控制不显示   
161.             1、是否显示0不显示，1显示  
162.             2、水平对齐方式  
163.             3、垂直对齐方式  
164.             4、水平偏移量  
165.             5、垂直偏移量  
166.         -->  
167.         <pm_advjp>0,0,2,2,-100,-40</pm_advjp>  
168.         <!--  
169.         前置广告跳过广告按钮的位置  
170.             1、是否显示0不显示，1是显示  
171.             2、跳过按钮触发对象(值0/1,0是直接跳转,1是触发js:function ckadjump(){})  
172.             3、水平对齐方式  
173.             4、垂直对齐方式  
174.             5、水平偏移量  
175.             6、垂直偏移量  
176.         -->  
177.         <pm_padvc>2,0,-10,-10</pm_padvc>  
178.         <!--  
179.         暂停广告的关闭按钮的位置  
180.             1、水平对齐方式  
181.             2、垂直对齐方式  
182.             3、水平偏移量  
183.             4、垂直偏移量  
184.         -->  
185.         <pm_advms>2,2,-46,-56</pm_advms>  
186.         <!--  
187.         滚动广告关闭按钮位置  
188.             1、水平对齐方式  
189.             2、垂直对齐方式  
190.             3、水平偏移量  
191.             4、垂直偏移量  
192.         -->  
193.         <pm_zip>1,1,-20,-8,1,0,0</pm_zip>  
194.         <!--  
195.         加载皮肤压缩包时提示文字的位置  
196.             1、水平对齐方式，0是左对齐，1是中间对齐，2是右对齐  
197.             2、垂直对齐方式，0是上对齐，1是中间对齐，2是低部对齐  
198.             3、水平位置偏移量  
199.             4、垂直位置偏移量  
200.             5、文字对齐方式，0是左对齐，1是中间对齐，2是右对齐，3是默认对齐  
201.             6、文本框宽席  
202.             7、文本框高度  
203.         -->  
204.         <pm_advmarquee>1,2,50,-60,50,18,0,0x000000,50,0,20,1,30,2000</pm_advmarquee>  
205.         <!--  
206.         滚动广告的控制，要使用的话需要在setup里的第9个参数设置成1  
207.         这里分二种情况,前六个参数是定位控制，第7个参数是设置定位方式(0：相对定位，1：绝对定位)  
208.         第一种情况：第7个参数是0的时候，相对定位，就是播放器长宽变化的时候，控制栏也跟着变  
209.             1、默认1:中间对齐  
210.             2、上中下对齐（0是上，1是中，2是下）  
211.             3、离左边的距离  
212.             4、Y轴偏移量  
213.             5、离右边的距离  
214.             6、高度  
215.             7、定位方式  
216.         第二种情况：第7个参数是1的时候，绝对定位，就是播放器长宽变化的时候，控制栏不跟着变，这种方式一般使用在控制栏大小不变的时候  
217.             1、左中右对齐方式（0是左，1是中间，2是右）  
218.             2、上中下对齐（0是上，1是中，2是下）  
219.             3、x偏移量  
220.             4、y偏移量  
221.             5、宽度  
222.             6、高度  
223.             7、定位方式  
224.         以上是前7个参数的作用  
225.             8、是文字广告的背景色  
226.             9、置背景色的透明度  
227.             10、控制滚动方向，0是水平滚动（包括左右），1是上下滚动（包括向上和向下）  
228.             11、移动的单位时长，即移动单位像素所需要的时长，毫秒  
229.             12、移动的单位像素,正数同左/上，负数向右/下  
230.             13、是行高，这个在设置向上或向下滚动的时候有用处  
231.             14、控制向上或向下滚动时每次停止的时间  
232.         -->  
233.         <pm_glowfilter>0,0x01485d, 100, 6, 3, 10, 1, 0, 0</pm_glowfilter>  
234.         <!--滚动文字广告是否采用发光滤镜  
235.             1、是否使用发光滤镜，0是不采用，1是使用  
236.             2、(default = 0xFF0000) — 光晕颜色，采用十六进制格式 0xRRGGBB。 默认值为 0xFF0000    
237.             3、(default = 100) — 颜色的 Alpha 透明度值。 有效值为 0 到 100。 例如，25 设置透明度为 25%    
238.             4、(default = 6.0) — 水平模糊量。 有效值为 0 到 255（浮点）。 2 的乘方值（如 2、4、8、16 和 32）经过优化，呈现速度比其它值更快    
239.             5、(default = 6.0) — 垂直模糊量。 有效值为 0 到 255（浮点）。 2 的乘方值（如 2、4、8、16 和 32）经过优化，呈现速度比其它值更快    
240.             6、(default = 2) — 印记或跨页的强度。 该值越高，压印的颜色越深，而且发光与背景之间的对比度也越强。 有效值为 0 到 255    
241.             7、(default = 1) — 应用滤镜的次数  
242.             8、(default = 0) — 指定发光是否为内侧发光。 值 1 指定发光是内侧发光。 值 0 指定发光是外侧发光（对象外缘周围的发光）    
243.             9、(default = 0) — 指定对象是否具有挖空效果。 值为 1 将使对象的填充变为透明，并显示文档的背景颜色背景颜色。   
244.         -->  
245.         <advmarquee></advmarquee>  
246.         <!-- 
247.         该处是滚动文字广告的内容，如果不想在这里设置，就把这里清空并且在页面中使用js的函数定义function ckmarqueeadv(){return ‘广告内容‘} 
248.         -->  
249.         <mainfuntion></mainfuntion>  
250.         <!-- 
251.         当flashvars里s=3/4时，调用的函数包名称，默认为空，调用时间轴上的函数setAppObj 
252.         -->  
253.         <flashplayer></flashplayer>  
254.         <!-- 
255.         当flashvars里的s=3/4时，也可以把swf文件放在这里 
256.         -->  
257.         <calljs>ckplayer_status,ckadjump,playerstop,ckmarqueeadv</calljs>  
258.         <!-- 
259.         跳过广告和播放结束时调用的js函数 
260.         -->  
261.         <myweb></myweb>  
262.           
263.         <!--  
264.         以下内容部份是和插件相关的配置，请注意，自定义插件以及其配置的命名方式要注意，不要和系统的相重复，不然就会替换掉系统的相关设置，删除相关插件的话也可以同时删除相关的配置  
265.         以下内容定义自定义插件的相关配置，这里也可以自定义任何自己的插件需要配置的内容，当然，如果你某个插件不使用的话，也可以删除相关的配置  
266.         -->  
267.         <cpt_lights>0</cpt_lights>  
268.         <!-- 
269.         该处定义是否使用开关灯，和right.swf插件配合作用,使用开灯效果时调用页面的js函数function closelights(){}; 
270.         -->  
271.         <!--<cpt_share>ckplayer/ckplayer/share.xml</cpt_share>-->  
272.         <!--  
273.         分享插件调用的配置文件地址  
274.         调用插件开始  
275.         -->  
276.         <!--<cpt>right.swf,2,1,0,0,2,0</cpt>右边开关灯，调整，分享按钮的插件-->  
277.         <!--<cpt>share.swf,1,1,-180,-100,3,0</cpt>分享插件-->  
278.         <!--<cpt>adjustment.swf,1,1,-180,-100,3,0</cpt>调整大小和颜色的插件-->  
279.     </style>  
280. </ckplayer>  

1.     function videoLoadJs(s){  
2.         alert("执行了播放");  
3.     }  
4.     function playerstop(){  
5.         //只有当调用视频播放器时设置e=0或4时会有效果  
6.         alert(‘播放完成‘);    
7.     }  
8.     var _nn=0;//用来计算实时监听的条数的，超过100条记录就要删除，不然会消耗内存  
9.       
10.     function getstart(){  
11.         var a=CKobject.getObjectById(‘ckplayer_1‘).getStatus();  
12.         var ss=‘‘;  
13.         for (var k in a){  
14.             ss+=k+":"+a[k]+‘\n‘;  
15.         }  
16.         alert(ss);  
17.     }  
18.   
19.     function changePrompt(){  
20.         CKobject.getObjectById(‘ckplayer_1‘).promptUnload();//卸载掉目前的  
21.         CKobject.getObjectById(‘ckplayer_1‘).changeFlashvars(‘{k->10|20|30}{n->重设提示点一|重设提示点二|重设提示点三}‘);  
22.         CKobject.getObjectById(‘ckplayer_1‘).promptLoad();//重新加载  
23.     }  
24.     function addflash(){  
25.         if(CKobject.Flash()[‘f‘]){  
26.             CKobject._K_(‘player1‘).innerHTML=‘‘;  
27.             CKobject.embedSWF(‘ckplayer/ckplayer/ckplayer.swf‘,‘player1‘,‘ckplayer_1‘,‘600‘,‘400‘,flashvars,params);  
28.         }  
29.         else{  
30.             alert(‘该环境中没有安装flash插件，无法切换‘);  
31.         }  
32.     }  
33.     function addhtml5(){  
34.         if(CKobject.isHTML5()){  
35.             support=[‘all‘];  
36.             CKobject._K_(‘player1‘).innerHTML=‘‘;  
37.             CKobject.embedHTML5(‘player1‘,‘ckplayer_1‘,600,400,video,flashvars,support);  
38.         }  
39.         else{  
40.             alert(‘该环境不支持html5，无法切换‘);  
41.         }  
42.     }  
43.     function addListener(){  
44.         if(CKobject.getObjectById(‘ckplayer_1‘).getType()){//说明使用html5播放器  
45.             CKobject.getObjectById(‘ckplayer_1‘).addListener(‘play‘,playHandler);  
46.         }  
47.         else{  
48.             CKobject.getObjectById(‘ckplayer_1‘).addListener(‘play‘,‘playHandler‘);  
49.         }  
50.     }  
51.     function playHandler(){  
52.         alert(‘因为注册了监听播放，所以弹出此内容，删除监听将不再弹出‘);  
53.     }  
54.     function removeListener(){//删除监听事件  
55.         if(CKobject.getObjectById(‘ckplayer_1‘).getType()){//说明使用html5播放器  
56.             CKobject.getObjectById(‘ckplayer_1‘).removeListener(‘play‘,playHandler);  
57.         }  
58.         else{  
59.             CKobject.getObjectById(‘ckplayer_1‘).removeListener(‘play‘,‘playHandler‘);  
60.         }  
61.     }  
62. </script>  
63. <input type="button" name="button23" value="切换到flash播放器" onClick="addflash();" />  
64.   <input type="button" name="button24" value="切换到html5播放器" onClick="addhtml5();" />  
65. </p>  
66. <p>以下的操作对flash播放器和html5播放器都有效</p>  
67. <p>  
68. <input type="button" name="button5" value="播放" onClick="CKobject.getObjectById(‘ckplayer_1‘).videoPlay();" />  
69.   <input type="button" name="button6" value="暂停" onClick="CKobject.getObjectById(‘ckplayer_1‘).videoPause();" />  
70.   <input type="button" name="button7" value="播放/暂停" onClick="CKobject.getObjectById(‘ckplayer_a1‘).playOrPause();" />  
71.   <input type="button" name="button8" value="快进" onClick="CKobject.getObjectById(‘ckplayer_1‘).fastNext();" />  
72.   <input type="button" name="button9" value="快退" onClick="CKobject.getObjectById(‘ckplayer_1‘).fastBack();" />  
73.   <input type="button" name="button15" value="暂停监听" onClick="CKobject.getObjectById(‘ckplayer_1‘).changeStatus(0);" />  
74.   <input type="button" name="button16" value="加ID的监听" onClick="CKobject.getObjectById(‘ckplayer_1‘).changeStatus(3);" />  
75.   <input type="button" name="button21" value="获取播放器当前相关属性" onClick="getstart();" />  
76.   <input type="button" name="button13" value="注册监听播放事件" onClick="addListener();" />  
77.   <input type="button" name="button14" value="删除监听播放事件" onClick="removeListener();" />  
78. </p>  
79. <p>  
80.   播放新参数地址：  
81.   <input name="newaddress" type="text" id="newaddress" value="" size="60" maxlength="300" />  
82.   <input type="button" name="button" id="button" value="跳转" onClick="CKobject.getObjectById(‘ckplayer_1‘).newAddress(document.getElementById(‘newaddress‘).value);" /><br>  
83. </p>  
84. <p id="aboutme"></p>  
85. <script type="text/javascript">  
86. var aboutme=‘‘;  
87. aboutme+=‘平台(浏览器)内核：‘+CKobject.Platform()+‘<br />‘;  
88. aboutme+=‘浏览器：‘+CKobject.browser()[‘B‘]+‘<br />‘;  
89. aboutme+=‘浏览器版本：‘+CKobject.browser()[‘V‘]+‘<br />‘;  
90. aboutme+=‘是否安装了flash插件：‘+CKobject.Flash()[‘f‘]+‘<br />‘;  
91. if(CKobject.Flash()[‘f‘]){  
92.     aboutme+=‘flash插件版本：‘+CKobject.Flash()[‘v‘]+‘<br />‘;  
93. }  
94. aboutme+=‘是否支持HTML5：‘+CKobject.isHTML5()+‘<br />‘;  
95. CKobject._K_(‘aboutme‘).innerHTML=aboutme;  

from:https://blog.csdn.net/eguid_1/article/details/51898912