一种视频预加载的方案

标签： geek | 发表时间：2017-01-06 08:00 | 作者：
出处：http://itindex.net/admin/pagedetail

前言：视频的预加载是提高用户体验的重要因素。预加载成为网络视频播放不可或缺的一个技术环节。


预加载的形式：

1.边存边播：下载多少播放多少。

优点：快速加载播放，实现简单；缺点：不能拖动未存区域；适合音频媒体

2.代理服务器：预先下载媒体的头部（头部Size为 s1 byte）->监听播放器的请求，当Request的是预加载的URL->代理把媒体头部作为Response返回给播放器，并改Ranage 为 s1 byte 发送Request->代理服务器纯粹作为透传。

优点：快速加载播放，支持拖动；缺点：实现非常复杂；适合视频媒体


影响预加载的因素：

  • 网络状态

  • 缓冲文件大小

  • 视频码率


码率低、网速快的情况没必要使用预加载，码率中等、网速一般的情况合适使用。另外，缓冲文件也不能设置太大：过大的缓冲区会刷爆MediaPlayer内置的缓冲区，影响正常播放；再者，读取缓冲文件也耗时。


预加载场景：

电视剧播放第1集时，在快要结束前5分钟，开始加载第2集。播放时就会连贯起来。缩短加载时间,如当系统检测您的网络环境较差时，会提示您开启预加载模式，开启预加载模式后，系统将为您缓冲整部影片。为了您流畅观看视频，建议您在开启预加载模式5分钟后，再次点击播放按钮，开始播放。这时就不会卡在缓冲中的状态。就是在视频播放的时候，在播放器通过本地URL，请求视频数据时，本地代理截取这次请求，经过本地代理逻辑，向服务器或本地缓存请求数据。本地代理在获得视频数据后，将数据转给播放器，实现播放。相比直接请求视频数据，本地代理的优势在于，buffer由本地控制，提大提升视频播放速度。提高用户体验。


一张图看清本地代理：



数据预加载：

不同rom上的MediaPlayer是不同的，会有一些差异，取决rom多媒体团队对MediaPlayer的定制程度，例如：有些MediaPlayer首次播放从头buffer，有些MdiaPlayer首次播放会多次Request，Range到网络媒体文件的头部、中间和文件尾，再从指定位置buffer。系统播放器需要下载5s的数据才开始把buffer进行播放出来。5s的数据，如果网络差的话，就处于是buffering中，一旦有5s的数据，就先播起来，而后，再在背后预加载，如一般播放panel的seekbar，有两种颜色，一种颜色（下图蓝色）是当前正在播的位置，还是一种颜色（灰色）走在前面，就是加载好的数据。



效果图1：


效果图2：



实现思路及部分代码：

MainActivity.用VideoView进行视频播放，url的视频为【鬼吹灯之精绝古城第1集】，会有一个开关，决定是否预加载。默认打开。


HttpProxy,就是启动一个本地代理，用127.0.0.1来替换视频源的服务器地址。 

   
        
  1.      
          packagecom.hejunlin.videopreloaded;
    2.     
  2.      
          
    3.     
  3.      
          importandroid.util.Log;
    4.     
  4.      
          
    5.     
  5.      
          
    6.     
  6.      
          
    7.     
  7.      
          publicclassHttpProxy{
    8.     
  8.      
          
    9.     
  9.      
             publicstaticfinalintSIZE = (int) (5*1024*1024);
    10.     
  10.      
             publicstaticfinalStringTAG =HttpProxy.class.getSimpleName();
    11.     
  11.      
             privateintremotePort = -1;
    12.     
  12.      
             privateStringremoteHost;
    13.     
  13.      
             privateintlocalPort;
    14.     
  14.      
             privateStringlocalHost;
    15.     
  15.      
             privateServerSocketlocalServer =null;
    16.     
  16.      
             privateSocketsckPlayer =null;
    17.     
  17.      
             privateSocketsckServer =null;
    18.     
  18.      
             privateSocketAddressserverAddress;
    19.     
  19.      
          
    20.     
  20.      
          
    21.     
  21.      
             privateHandleDownLoaddownload =null;
    22.     
  22.      
          
    23.     
  23.      
             /**
    24.     
  24.      
              * 初始化代理服务器
    25.     
  25.      
              *
    26.     
  26.      
              * @param localport
    27.     
  27.      
              *            代理服务器监听的端口
    28.     
  28.      
              */
    29.     
  29.      
             publicHttpProxy(intlocalport) {
    30.     
  30.      
                 try{
    31.     
  31.      
                     localPort = localport;
    32.     
  32.      
                     localHost =Contants.LOCAL_IP_ADDRESS;
    33.     
  33.      
                     localServer =newServerSocket(localport,1,
    34.     
  34.      
                             InetAddress.getByName(localHost));
    35.     
  35.      
                 }catch(Exceptione) {
    36.     
  36.      
                     System.exit(0);
    37.     
  37.      
                 }
    38.     
  38.      
                    URI tmpURI =newURI(urlString);
    39.     
  39.      
                 StringfileName =Utils.urlToFileName(tmpURI.getPath());
    40.     
  40.      
                 StringfilePath =Contants.getBufferDir() +"/"+ fileName;
    41.     
  41.      
          
    42.     
  42.      
                 download =newHandleDownLoad(urlString, filePath, size);
    43.     
  43.      
                 download.startThread();
    44.     
  44.      
          
    45.     
  45.      
                 returnfilePath;
    46.     
  46.      
             }
    47.     
  47.      
          
    48.     
  48.      
             /**
    49.     
  49.      
              * 把网络URL转为本地URL，127.0.0.1替换网络域名
    50.     
  50.      
              *
    51.     
  51.      
              * @param url网络URL
    52.     
  52.      
              * @return [0]:重定向后MP4真正URL，[1]:本地URL
    53.     
  53.      
              */
    54.     
  54.      
             publicString[] getLocalURL(StringurlString) {
    55.     
  55.      
          
    56.     
  56.      
                 
    57.     
  57.      
                 StringtargetUrl =Utils.getRedirectUrl(urlString);
    58.     
  58.      
                 // ----获取对应本地代理服务器的链接----//
    59.     
  59.      
                 StringlocalUrl =null;
    60.     
  60.      
                 URI originalURI = URI.create(targetUrl);
    61.     
  61.      
                 remoteHost = originalURI.getHost();
    62.     
  62.      
                 if(originalURI.getPort() != -1) {// URL带Port
    63.     
  63.      
                     serverAddress =newInetSocketAddress(remoteHost,
    64.     
  64.      
                             originalURI.getPort());// 使用默认端口
    65.     
  65.      
                     remotePort = originalURI.getPort();// 保存端口，中转时替换
    66.     
  66.      
                     localUrl = targetUrl.replace(
    67.     
  67.      
                             remoteHost +":"+ originalURI.getPort(), localHost +":"
    68.     
  68.      
                                     + localPort);
    69.     
  69.      
                 }else{// URL不带Port
    70.     
  70.      
                     serverAddress =newInetSocketAddress(remoteHost,Contants.HTTP_PORT);// 使用80端口
    71.     
  71.      
                     remotePort = -1;
    72.     
  72.      
                     localUrl = targetUrl.replace(remoteHost, localHost +":"
    73.     
  73.      
                             + localPort);
    74.     
  74.      
                 }
    75.     
  75.      
          
    76.     
  76.      
                 String[] result =newString[] { targetUrl, localUrl };
    77.     
  77.      
                 returnresult;
    78.     
  78.      
             }
    79.     
  79.      
          
    80.     
  80.      
             /**
    81.     
  81.      
              * 异步启动代理服务器
    82.     
  82.      
              *
    83.     
  83.      
              * @throws IOException
    84.     
  84.      
              */
    85.     
  85.      
             publicvoidasynStartProxy() {
    86.     
  86.      
                 newThread() {
    87.     
  87.      
                     publicvoidrun() {
    88.     
  88.      
                         startProxy();
    89.     
  89.      
                     }
    90.     
  90.      
                 }.start();
    91.     
  91.      
             }
    92.     
  92.      
          
    93.     
  93.      
             privatevoidstartProxy() {
    94.     
  94.      
                 HttpParserhttpParser =null;
    95.     
  95.      
                 HttpProxyUtilsutils =null;
    96.     
  96.      
                 intbytes_read;
    97.     
  97.      
          
    98.     
  98.      
                 byte[] local_request =newbyte[1024];
    99.     
  99.      
                 byte[] remote_reply =newbyte[1024];
    100.     
  100.      
          
    101.     
  101.      
                 while(true) {
    102.     
  102.      
                     booleansentResponseHeader =false;
    103.     
  103.      
                     try{// 开始新的request之前关闭过去的Socket
    104.     
  104.      
                         if(sckPlayer !=null)
    105.     
  105.      
                             sckPlayer.close();
    106.     
  106.      
                         if(sckServer !=null)
    107.     
  107.      
                             sckServer.close();
    108.     
  108.      
                     }catch(IOExceptione1) {
    109.     
  109.      
                     }
    110.     
  110.      
                     try{
    111.     
  111.      
                         // --------------------------------------
    112.     
  112.      
                         // 监听MediaPlayer的请求，MediaPlayer->代理服务器
    113.     
  113.      
                         // --------------------------------------
    114.     
  114.      
                         sckPlayer = localServer.accept();
    115.     
  115.      
                         Log.e(TAG,
    116.     
  116.      
                                 "------------------------------------------------------------------");
    117.     
  117.      
                         if(download !=null&& download.isDownloading())
    118.     
  118.      
                             download.stopThread(false);
    119.     
  119.      
          
    120.     
  120.      
                         httpParser =newHttpParser(remoteHost, remotePort, localHost,
    121.     
  121.      
                                 localPort);
    122.     
  122.      
                         utils =newHttpProxyUtils(sckPlayer, sckServer,
    123.     
  123.      
                                 serverAddress);
    124.     
  124.      
          
    125.     
  125.      
                         HttpParser.ProxyRequestrequest =null;
    126.     
  126.      
                         while((bytes_read = sckPlayer.getInputStream().read(
    127.     
  127.      
                                 local_request)) != -1) {
    128.     
  128.      
                             byte[] buffer = httpParser.getRequestBody(local_request,
    129.     
  129.      
                                     bytes_read);
    130.     
  130.      
                             if(buffer !=null) {
    131.     
  131.      
                                 request = httpParser.getProxyRequest(buffer);
    132.     
  132.      
                                 break;
    133.     
  133.      
                             }
    134.     
  134.      
                         }
    135.     
  135.      
          
    136.     
  136.      
                         booleanisExists =newFile(request._prebufferFilePath)
    137.     
  137.      
                                 .exists();
    138.     
  138.      
                         if(isExists)
    139.     
  139.      
                             Log.e(TAG,">> prebuffer size:"+ download.getDownloadedSize());
    140.     
  140.      
          
    141.     
  141.      
                         sckServer = utils.sentToServer(request._body);
    142.     
  142.      
                         // ------------------------------------------------------
    143.     
  143.      
                         // 把网络服务器的反馈发到MediaPlayer，网络服务器->代理服务器->MediaPlayer
    144.     
  144.      
                         // ------------------------------------------------------
    145.     
  145.      
                         while((bytes_read = sckServer.getInputStream().read(
    146.     
  146.      
                                 remote_reply)) != -1) {
    147.     
  147.      
                             if(sentResponseHeader) {
    148.     
  148.      
                                 try{// 拖动进度条时，容易在此异常，断开重连
    149.     
  149.      
                                     utils.sendToMP(remote_reply, bytes_read);
    150.     
  150.      
                                 }catch(Exceptione) {
    151.     
  151.      
                                     break;// 发送异常直接退出while
    152.     
  152.      
                                 }
    153.     
  153.      
                                 continue;// 退出本次while
    154.     
  154.      
                             }
    155.     
  155.      
          
    156.     
  156.      
                             List<byte[]> httpResponse = httpParser.getResponseBody(
    157.     
  157.      
                                     remote_reply, bytes_read);
    158.     
  158.      
                             if(httpResponse.size() ==0)
    159.     
  159.      
                                 continue;// 没Header则退出本次循环
    160.     
  160.      
          
    161.     
  161.      
                             sentResponseHeader =true;
    162.     
  162.      
                             StringresponseStr =newString(httpResponse.get(0));
    163.     
  163.      
                             Log.e(TAG,">> responseStr "+ responseStr);
    164.     
  164.      
                             // send http header to mediaplayer
    165.     
  165.      
                             utils.sendToMP(httpResponse.get(0));
    166.     
  166.      
          
    167.     
  167.      
                             if(isExists) {// 需要发送预加载到MediaPlayer
    168.     
  168.      
                                 isExists =false;
    169.     
  169.      
                                 intsentBufferSize =0;
    170.     
  170.      
                                 try{
    171.     
  171.      
                                     sentBufferSize = utils.sendPrebufferToMP(
    172.     
  172.      
                                             request._prebufferFilePath,
    173.     
  173.      
                                             request._rangePosition);
    174.     
  174.      
                                 }catch(Exceptionex) {
    175.     
  175.      
                                     break;
    176.     
  176.      
                                 }
    177.     
  177.      
                                 if(sentBufferSize >0) {// 成功发送预加载，重新发送请求到服务器
    178.     
  178.      
                                     intnewRange = (int) (sentBufferSize + request._rangePosition);
    179.     
  179.      
                                     StringnewRequestStr = httpParser
    180.     
  180.      
                                             .modifyRequestRange(request._body, newRange);
    181.     
  181.      
                                     Log.e(TAG +"-pre->", newRequestStr);
    182.     
  182.      
                                     // 修改Range后的Request发送给服务器
    183.     
  183.      
                                     sckServer = utils.sentToServer(newRequestStr);
    184.     
  184.      
                                     // 把服务器的Response的Header去掉
    185.     
  185.      
                                     utils.removeResponseHeader(httpParser);
    186.     
  186.      
                                     continue;
    187.     
  187.      
                                 }
    188.     
  188.      
                             }
    189.     
  189.      
          
    190.     
  190.      
                             // 发送剩余数据
    191.     
  191.      
                             if(httpResponse.size() ==2) {
    192.     
  192.      
                                 utils.sendToMP(httpResponse.get(1));
    193.     
  193.      
                             }
    194.     
  194.      
                         }
    195.     
  195.      
          
    196.     
  196.      
                         Log.e(TAG,">> preloaded over");
    197.     
  197.      
          
    198.     
  198.      
                         // 关闭 2个SOCKET
    199.     
  199.      
                         sckPlayer.close();
    200.     
  200.      
                         sckServer.close();
    201.     
  201.      
                     }catch(Exceptione) {
    202.     
  202.      
                         Log.e(TAG, e.toString());
    203.     
  203.      
                         Log.e(TAG,Utils.getExceptionMessage(e));
    204.     
  204.      
                     }
    205.     
  205.      
                 }
    206.     
  206.      
             }
    207.     
  207.      
          }

HttpPaser就是解析真实地址的类，这里就不再给出。

第一时间获得博客更新提醒，以及更多 android干货，源码分析，欢迎关注我的微信公众号，扫一扫下方二维码或者长按识别二维码，即可关注。



相关 [视频 加载] 推荐：

一种视频预加载的方案

- - IT瘾-geek
前言：视频的预加载是提高用户体验的重要因素. 预加载成为网络视频播放不可或缺的一个技术环节. 1.边存边播：下载多少播放多少. 优点：快速加载播放，实现简单；缺点：不能拖动未存区域；适合音频媒体. 2.代理服务器：预先下载媒体的头部（头部Size为 s1 byte）->监听播放器的请求，当Request的是预加载的URL->代理把媒体头部作为Response返回给播放器，并改Ranage 为 s1 byte 发送Request->代理服务器纯粹作为透传.

Android 视频缩略图的缓存机制和异步加载

- - 移动开发 - ITeye博客
关注微信号：javalearns   随时随地学Java. 在这次的工作开发项目中，涉及到一个视频缩略图的视频列表；这个在大家看来，制作视频缩略图就是两行代码就搞定的事. 确实是这样的，百度一下，每个 帖子都知道制作视频缩略图的方法，在这里确实也是一样的，但是我要实现的是让缩略图 在ListView上显示，而且不会出现卡顿，其实也不是特别难，确实很实用；.

宅视频：裸

- 小鱼儿 - 宅映像
明天公司组织去贵州走红路，唱红歌，一去就是三天，所以这三天俺估计就没法发博客了，等我被红歌洗脑后回来再给大家继续胸奴吧. 今天要给大家推荐的是一段视频，名字叫《裸》是不是很带感，至于内容，大家看了就知道了. 这段关于女优和AV的故事片是不是相当泪流满面（坑爹啊. 里面竟然没有我们想要的AV镜头，这才真是让我泪流满面）.

视频拍立得

- Jing - 设计｜生活｜发现新鲜
视频拍立得，像经典的Polaroid相机一样，按下快门拍摄一段美好时光，就可以即刻吐出一张可以播放动态视频的“照片”，与亲朋好友一起分享. 这种视频照片包含触摸显示屏、存储单元和微型电池，在摄影完成后的瞬间将数据写入电子相片的存储器. 这听起来很像是哈利波特里魔法城堡里的报纸，但是得益于今日发展迅速的显像技术和超薄电池，也许不久的将来我们就能在市场上看到它.

hold住姐视频

- xiaocaochong - 无聊哦
在2011年8月9日的《大学生了没》中，一位名叫miss lin的网友以夸张另类的造型、一口做作的英语、扭捏妖娆的姿态向大学生们介绍什么是Fashion. 其极度夸张搞笑的表演震撼了所有观众，miss lin的口头禅是“整个场面我要Hold住”. 因此得名“hold住姐”或“hold姐”而蹿红网络.

视频：Xoom2 vs iPad2

- - The Leying's Blog
iPad2是平板电脑的标杆，所以我们看到任何厂家的平板上市后首先就会浮想起一个问题：“这玩意和iPad2相比如何. ”于是乎，新上市的Xoom2还是和iPad2走到了一起，青梅煮酒，坐而论道. 评测来自国外媒体，对比内容包括两者的设计，系统，速度，摄像等方面. 　　不过作为平板，你也许更希望了解两者在网页浏览上的详细区别，那么下面这个视频会告诉你答案，虽然Xoom2屏幕看上去很花，但那是拍摄因素，与机器无关.

Android视频录制

- - CSDN博客移动开发推荐文章
/*下面设置Surface不维护自己的缓冲区，而是等待屏幕的渲染引擎将内容推送到用户面前*/. this.surfaceView.getHolder().setFixedSize(320, 240);//设置分辨率. mediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA); //从照相机采集视频.

动态加载HQL

- senyo - BlogJava-首页技术区
Java代码如下：(ReloadableDynamicHibernate.java). 135         private Map qlMap;                //查询的映射. 这样就实现了每次修改SQL or HQL语句后不用重启服务器，立刻看到结果，加快了开发速度.

java动态加载

- - Java - 编程语言 - ITeye博客
第一部分：Java虚拟机启动时，关于类加载方面的一些动作. 当使用java ProgramName.class运行程序时，Java找到JRE，接着找到jvm.dll，把该动态库载入内存，这就是JVM. 然后加载其它动态库， 并激活JVM. JVM激活之后会进行一些初始化工作，之后生成BootstrapLoader，该Class Loader是由C++写的.

spring 加载顺序

- - 企业架构 - ITeye博客
web.xml文件加载顺序.      1 、启动一个 WEB 项目的时候， WEB 容器会去读取它的配置文件 web.xml ，读取 和 两个结点.      2 、紧急着，容创建一个 ServletContext （ servlet 上下文），这个 web 项目的所有部分都将共享这个上下文.