先分享一下4幅图片，分别为播放前的缓存，正常播放中，跳转缓冲和跳转以后的正常播放。

代码解析

视频断点分隔的数据结构定义

定义了每一段视频的时间偏移点，文件位移偏移点，文件段的大小和当前的缓存状态

class VideoInfo {
        double timestart;
        long offsetstart;
        long offsetend;
        long downloadsize;
        DownloadStatus status;

        public VideoInfo() {
            status = DownloadStatus.NOTSTART;
        }

        @Override
        public String toString() {
            String s = "beginTime:

缓存状态的定义

分别为还未缓存，正在下载中和缓存完毕

    enum DownloadStatus {
        NOTSTART, DOWNLOADING, FINISH,
    }

分段视频的下载

利用了Http协议的 Range 属性，下载部分文件

private void downloadbyvideoinfo(VideoInfo vi) throws IOException {
        System.out.println("download -> " + vi.toString());

        URL url = new URL(this.url);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(3000);
        conn.setRequestProperty("Range", "bytes=" + vi.offsetstart + "-"
                + vi.offsetend);

        RandomAccessFile raf = new RandomAccessFile(new File(localFilePath),
                "rws");
        raf.seek(vi.offsetstart);

        InputStream in = conn.getInputStream();

        byte[] buf = new byte[1024 * 10];
        int len;
        vi.downloadsize = 0;
        while ((len = in.read(buf)) != -1) {
            raf.write(buf, 0, len);
            vi.downloadsize += len;
            Message msg = handler.obtainMessage();
            msg.what = MSG_DOWNLOADUPDATE;
            msg.obj = vi.offsetstart + vi.downloadsize;
            handler.sendMessage(msg);
        }

        in.close();
        raf.close();
    }

检测指定时间点的视频数据是否已经缓存完毕

    public boolean checkIsBuffered(long time) {
        int index = -1;

        for (VideoDownloder.VideoInfo tvi : vilists) {
            if (tvi.timestart > time) {
                break;
            }

            index++;
        }

        if (index < 0 || index >= this.vilists.size()) {
            return true;
        }

        final VideoInfo vi = this.vilists.get(index);

        if (vi.status == DownloadStatus.FINISH) {
            return true;
        } else if (vi.status == DownloadStatus.NOTSTART) {
            return false;
        } else if (vi.status == DownloadStatus.DOWNLOADING) {
            return (vi.downloadsize * 100 / (vi.offsetend - vi.offsetstart)) > ((time - vi.timestart) * 100 / SEP_SECOND);
        }

        return true;
    }

跳转后加载指定时间点的视频数据

    public synchronized void seekLoadVideo(long time) {
        int index = -1;

        for (VideoDownloder.VideoInfo tvi : vilists) {
            if (tvi.timestart > time) {
                break;
            }
            index++;
        }

        if (index < 0 || index >= this.vilists.size()) {
            return;
        }

        final VideoInfo vi = this.vilists.get(index);

        if (vi.status == DownloadStatus.NOTSTART) {
            executorService.submit(new Runnable() {

                @Override
                public void run() {
                    try {
                        vi.status = DownloadStatus.DOWNLOADING;
                        downloadbyvideoinfo(vi);
                        vi.status = DownloadStatus.FINISH;
                    } catch (IOException e) {
                        vi.status = DownloadStatus.NOTSTART;
                        e.printStackTrace();
                    }
                }
            });
        }

        downloadvideoindex = index;
    }

视频分割数据结构的初始化

目前以5s进行视频的分段处理

    private static final int SEP_SECOND = 5;

    public void initVideoDownloder(final long startoffset, final long totalsize) {
        if (isinitok) {
            return;
        }

        this.executorService.submit(new Runnable() {

            @Override
            public void run() {
                IsoFile isoFile = null;
                try {
                    isoFile = new IsoFile(new RandomAccessFile(localFilePath,
                            "r").getChannel());
                } catch (Exception e) {
                    e.printStackTrace();
                }

                if (isoFile == null) {
                    return;
                }

                CareyMp4Parser cmp4p = new CareyMp4Parser(isoFile);
                cmp4p.printinfo();

                vilists.clear();

                VideoInfo vi = null;
                for (int i = 0; i < cmp4p.syncSamples.length; i++) {
                    if (vi == null) {
                        vi = new VideoInfo();
                        vi.timestart = cmp4p.timeOfSyncSamples[i];
                        vi.offsetstart = cmp4p.syncSamplesOffset[i];
                    }

                    if (cmp4p.timeOfSyncSamples[i] < (vilists.size() + 1)
                            * SEP_SECOND) {
                        continue;
                    }

                    vi.offsetend = cmp4p.syncSamplesOffset[i];
                    vilists.add(vi);
                    vi = null;
                    i--;
                }

                if (vi != null) {
                    vi.offsetend = totalsize;
                    vilists.add(vi);
                    vi = null;
                }

                isinitok = true;

                downloadvideo(startoffset);
            }
        });
    }

MP4视频头部数据的缓存

    private void prepareVideo() throws IOException {
        URL url = new URL(remoteUrl);
        HttpURLConnection httpConnection = (HttpURLConnection) url
                .openConnection();
        httpConnection.setConnectTimeout(3000);
        httpConnection.setRequestProperty("RANGE", "bytes=" + 0 + "-");

        InputStream is = httpConnection.getInputStream();

        videoTotalSize = httpConnection.getContentLength();
        if (videoTotalSize == -1) {
            return;
        }

        File cacheFile = new File(localUrl);

        if (!cacheFile.exists()) {
            cacheFile.getParentFile().mkdirs();
            cacheFile.createNewFile();
        }

        RandomAccessFile raf = new RandomAccessFile(cacheFile, "rws");
        raf.setLength(videoTotalSize);
        raf.seek(0);

        byte buf[] = new byte[10 * 1024];
        int size = 0;

        videoCacheSize = 0;
        int buffercnt = 0;
        while ((size = is.read(buf)) != -1 && (!isready)) {
            try {
                raf.write(buf, 0, size);
                videoCacheSize += size;
            } catch (Exception e) {
                e.printStackTrace();
            }

            if (videoCacheSize > READY_BUFF && (buffercnt++ % 20 == 0)) {
                mHandler.sendEmptyMessage(CACHE_VIDEO_READY);
            }
        }

        if (!isready) {
            mHandler.sendEmptyMessage(CACHE_VIDEO_READY);
        }

        is.close();
        raf.close();
    }

主程序的状态控制

主要就是首先缓冲mp4的文件头，然后进行解析和播放，初始化播放器控制界面，同时为了提高用户体验，动态监测当前播放的进度和当前缓存的进度，目前的做法是至少缓存了超前5s的数据流，即如果当前播放在00:02:05，则理论上缓存的数据已经在00:02:10之后了，如果没有达到这个状态，则暂停当前的视频播放，先进行一段缓存，然后再接着播放，这样就不会出现视频播放的过程中出现一卡一卡的情况。

    private final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case VIDEO_STATE_UPDATE:
                int cachepercent = (int) (videoCacheSize * 100 / (videoTotalSize == 0 ? 1
                        : videoTotalSize));
                videoseekbar.setSecondaryProgress(cachepercent);

                int positon = mediaPlayer.getCurrentPosition();
                int duration = mediaPlayer.getDuration();
                int playpercent = positon * 100
                        / (duration == 0 ? 1 : duration);

                if (mediaPlayer.isPlaying()) {
                    playbtn.setImageResource(R.drawable.player_pad_button_pause_normal);

                    tvcurtime.setText(transtimetostr(positon));
                    tvtotaltime.setText(transtimetostr(duration));
                    videoseekbar.setProgress(playpercent);

                    int next2sec = positon + 2 * 1000;
                    if (next2sec > duration) {
                        next2sec = duration;
                    }

                    if (!vdl.checkIsBuffered(next2sec / 1000)) {
                        mediaPlayer.pause();
                        showLoading();
                    }
                } else {
                    playbtn.setImageResource(R.drawable.player_pad_button_play_normal);

                    if (!userpaused && isloading) {
                        int next5sec = positon + 5 * 1000;
                        if (next5sec > duration) {
                            next5sec = duration;
                        }

                        if (vdl.checkIsBuffered(next5sec / 1000)) {
                            mediaPlayer.start();
                            hideLoading();
                        }
                    }
                }

                mHandler.sendEmptyMessageDelayed(VIDEO_STATE_UPDATE, 1000);
                break;

            case CACHE_VIDEO_READY:
                try {
                    mediaPlayer.setDataSource(localUrl);
                    mediaPlayer.prepareAsync();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                break;

            case VideoDownloder.MSG_DOWNLOADFINISH:
                videoCacheSize = videoTotalSize;
                break;

            case VideoDownloder.MSG_DOWNLOADUPDATE:
                if ((Long) msg.obj > videoCacheSize) {
                    videoCacheSize = (Long) msg.obj;
                }
                break;
            }

            super.handleMessage(msg);
        }
    };

后续

大体的代码流程就是这个样子,鉴于代码量比较大，就不全部贴出来了，相信大家整体浏览一遍也清楚了，源代码文件可以在点击这里下载，如果还有相关的问题，请给我留言。

Android 流媒体播放之缓冲跳转实现，首发于润物无声。

至于如何实现视频的边缓存边播放，可以参照我的博文《Android视频播放之边缓存边播放》和 《Android 视频播放之流媒体格式处理》，本文的目的是给大家展示怎么样进行视频数据流的解析.

前期准备

依赖的第三方解析包 mp4parser，Google的项目地址为 http://code.google.com/p/mp4parser/,它主要实现了mp4和其他格式媒体数据的解析，本文的解析代码就是依赖于它底层的数据解析,项目中有一个图形化界面的解析器，下载地址为 http://mp4parser.googlecode.com/files/isoviewer-2.0-RC-7.jar，可以通过它来查看视频文件的整体编码结构。

通过在命令行执行

F:\workspace\mp4parser-read-only>java -jar isoviewer-2.0-RC-7.jar

来启动程序，然后通过菜单的File导入需要解析的视频文件就好了

截图如下：

本文代码依赖的jar包如下：

1. http://carey-blog-image.googlecode.com/files/aspectjrt.jar
2. http://carey-blog-image.googlecode.com/files/isoparser-1.0-RC-6-20120510.091755-1.jar

关键代码解析

1. 计算视频的总时长

视频的总时间轴 Duration 除以时间轴的比例 Timescale，结果就是当前视频的总秒数

lengthInSeconds = (double) isoFile.getMovieBox().getMovieHeaderBox().getDuration() / isoFile.getMovieBox().getMovieHeaderBox().getTimescale();

2. 获取音频和视频的box数据

一般的流媒体数据有两个TrackBox，第一个为音频，第二个为视频

List<TrackBox> trackBoxes = isoFile.getMovieBox().getBoxes(TrackBox.class);

3. 解析视频的box数据

取得关键帧的信息，因为视频的跳转只能在关键帧之间跳转，所以我们需要重点关注关键帧对应的时间点

Iterator<TrackBox> iterator = trackBoxes.iterator();

SampleTableBox stbl = null;
TrackBox trackBox = null;
while (iterator.hasNext()) {
  trackBox = iterator.next();
  stbl = trackBox.getMediaBox().getMediaInformationBox().getSampleTableBox();
  // 我们只处理视频的关键帧，音频数据略过
  if (stbl.getSyncSampleBox() != null) {
    syncSamples = stbl.getSyncSampleBox().getSampleNumber();
    syncSamplesSize = new long[syncSamples.length];
    syncSamplesOffset = new long[syncSamples.length];
    timeOfSyncSamples = new double[syncSamples.length];
    break;
  }
}

4. 获取视频box中内部的详细参数

包括帧与时间的对应关系，即每一帧对应视频的时间点是第几秒，帧与chunk的对应关系，mp4为了进行视频的压缩，都是把一系列连续的帧放到一个chunk中，每个chunk中帧的数量不等，chunk与数据流文件偏移的关系，即每个chunk对应的视频流数据在文件的具体偏移位置。

// first we get all sample from the 'normal' MP4 part. if there are none - no problem.
SampleSizeBox sampleSizeBox = trackBox.getSampleTableBox().getSampleSizeBox();
ChunkOffsetBox chunkOffsetBox = trackBox.getSampleTableBox().getChunkOffsetBox();
SampleToChunkBox sampleToChunkBox = trackBox.getSampleTableBox().getSampleToChunkBox();

5. 计算偏移量

根据视频的上述信息计算每一个帧对应的具体时间点，以及其数据流在文件中的偏移量

if (sampleToChunkBox != null
&& sampleToChunkBox.getEntries().size() > 0
&& chunkOffsetBox != null
&& chunkOffsetBox.getChunkOffsets().length > 0
&& sampleSizeBox != null && sampleSizeBox.getSampleCount() > 0) {
long[] numberOfSamplesInChunk = sampleToChunkBox.blowup(chunkOffsetBox.getChunkOffsets().length);
if (sampleSizeBox.getSampleSize() > 0) {
// Every sample has the same size! no need to store each size separately
// this happens when people use raw audio formats in MP4 (are you stupid guys???)
int sampleIndex = 0;
long sampleSize = sampleSizeBox.getSampleSize();
for (int i = 0; i < numberOfSamplesInChunk.length; i++) {
long thisChunksNumberOfSamples = numberOfSamplesInChunk[i];
long sampleOffset = chunkOffsetBox.getChunkOffsets()[i];
for (int j = 0; j < thisChunksNumberOfSamples; j++) {
   // samples always start with 1 but we start with zero
   // therefore +1
   int syncSamplesIndex = Arrays.binarySearch(syncSamples,sampleIndex + 1);
   if (syncSamplesIndex >= 0) {
      syncSamplesOffset[syncSamplesIndex] = sampleOffset;
      syncSamplesSize[syncSamplesIndex] = sampleSize;
   }
  sampleOffset += sampleSize;
  sampleIndex++;
}
}
} else {
// the normal case where all samples have different sizes
int sampleIndex = 0;
long sampleSizes[] = sampleSizeBox.getSampleSizes();
for (int i = 0; i < numberOfSamplesInChunk.length; i++) {
   long thisChunksNumberOfSamples = numberOfSamplesInChunk[i];
   long sampleOffset = chunkOffsetBox.getChunkOffsets()[i];
   for (int j = 0; j < thisChunksNumberOfSamples; j++) {
      long sampleSize = sampleSizes[sampleIndex];
      // samples always start with 1 but we start with zero therefore +1
      int syncSamplesIndex = Arrays.binarySearch(syncSamples, sampleIndex + 1);
      if (syncSamplesIndex >= 0) {
         syncSamplesOffset[syncSamplesIndex] = sampleOffset;
         syncSamplesSize[syncSamplesIndex] = sampleSize;
      }
      sampleOffset += sampleSize;
      sampleIndex++;
   }
}
}

MediaHeaderBox mdhd = trackBox.getMediaBox().getMediaHeaderBox();
TrackHeaderBox tkhd = trackBox.getTrackHeaderBox();

trackMetaData.setTrackId(tkhd.getTrackId());
trackMetaData.setCreationTime(DateHelper.convert(mdhd.getCreationTime()));
trackMetaData.setLanguage(mdhd.getLanguage());
trackMetaData.setModificationTime(DateHelper.convert(mdhd.getModificationTime()));
trackMetaData.setTimescale(mdhd.getTimescale());
trackMetaData.setHeight(tkhd.getHeight());
trackMetaData.setWidth(tkhd.getWidth());
trackMetaData.setLayer(tkhd.getLayer());

List<TimeToSampleBox.Entry> decodingTimeEntries = null;
if (trackBox.getParent().getBoxes(MovieExtendsBox.class).size() > 0) {
    decodingTimeEntries = new LinkedList<TimeToSampleBox.Entry>();
    for (MovieFragmentBox movieFragmentBox : trackBox.getIsoFile().getBoxes(MovieFragmentBox.class)) {
     List<TrackFragmentBox> trafs = movieFragmentBox.getBoxes(TrackFragmentBox.class);
       for (TrackFragmentBox traf : trafs) {
        if (traf.getTrackFragmentHeaderBox().getTrackId() == trackBox.getTrackHeaderBox().getTrackId()) {
          List<TrackRunBox> truns = traf.getBoxes(TrackRunBox.class);
          for (TrackRunBox trun : truns) {
             for (TrackRunBox.Entry entry : trun.getEntries()) {
               if (trun.isSampleDurationPresent()) {
                 if (decodingTimeEntries.size() == 0 || decodingTimeEntries.get(decodingTimeEntries.size() - 1).getDelta() != entry.getSampleDuration()) {
                    decodingTimeEntries.add(new TimeToSampleBox.Entry(1,entry.getSampleDuration()));
                 } else {
                    TimeToSampleBox.Entry e = decodingTimeEntries.get(decodingTimeEntries.size() - 1);
                    e.setCount(e.getCount() + 1);
               }
            }
         }
      }
    }
  }
}
} else {
    decodingTimeEntries = stbl.getTimeToSampleBox().getEntries();
}

long currentSample = 0;
double currentTime = 0;
for (TimeToSampleBox.Entry entry : decodingTimeEntries) {
   for (int j = 0; j < entry.getCount(); j++) {
      int syncSamplesIndex = Arrays.binarySearch(syncSamples,currentSample + 1);
      if (syncSamplesIndex >= 0) {
        // samples always start with 1 but we start with zero therefore +1
        timeOfSyncSamples[syncSamplesIndex] = currentTime;
   }
  currentTime += (double) entry.getDelta() / (double) trackMetaData.getTimescale();
  currentSample++;
 }
}
}

6. 在android中运行

public void printinfo() {
System.out.println("视频总时长(秒): " + lengthInSeconds);
System.out.println("关键帧 \t 帧偏移 \t 帧大小 \t 帧对应的时间");

int size = syncSamples.length;

for (int i = 0; i < size; i++) {
   System.out.println(syncSamples[i] + " " + syncSamplesOffset[i] + " " + syncSamplesSize[i] + " " + timeOfSyncSamples[i]);
}
}

解析的结果如下：

05-22 15:21:03.750: I/System.out(5291): remoteUrl: http://bbfile.b0.upaiyun.com/data/videos/2/vid_20120510_090204.mp4
05-22 15:21:03.757: I/System.out(5291): localUrl: /mnt/sdcard/VideoCache/1337671263394.mp4
05-22 15:21:16.343: I/System.out(5291): 视频总时长(秒): 123.636
05-22 15:21:16.343: I/System.out(5291): 关键帧 帧偏移 帧大小 帧对应的时间
05-22 15:21:16.343: I/System.out(5291): 1 405032 1449 0.0
05-22 15:21:16.343: I/System.out(5291): 16 423325 3058 0.5002777777777777
05-22 15:21:16.351: I/System.out(5291): 31 441936 2886 1.0
05-22 15:21:16.351: I/System.out(5291): 46 467978 3575 1.4996777777777774
05-22 15:21:16.351: I/System.out(5291): 61 498237 5578 1.9993999999999998
05-22 15:21:16.351: I/System.out(5291): 76 562086 7654 2.4993444444444437
。。。。。。
05-22 15:21:16.585: I/System.out(5291): 3676 15952210 13153 122.43723333333335
05-22 15:21:16.585: I/System.out(5291): 3691 16050289 11484 122.93692222222225
05-22 15:21:16.585: I/System.out(5291): 3706 16131270 12718 123.4366666666667

通过以上数据可以分析出：
a. 视频的总时长为 123.636s
b. 1s钟时长的视频大约有30个帧，其中有2个关键帧，就拿第1s的视频数据来说，第1和16帧为关键帧，
其对应的时间点分别为0s和0.5s，帧对应的数据流在当前视频文件内部的偏移量分别为 405032
和 423325，视频流数据的大小分别为1449和3058

源代码文件下载 http://carey-blog-image.googlecode.com/files/CareyMp4Parser%2820120522%29.java

好了，视频的解析部分就讲到这里，有什么问题可以给我留言，后续再更新跳转实现的代码部分.

Android 视频播放之流媒体解析，首发于润物无声。

项目的需求要实现流媒体的播放，简言之就是视频可以支持边下载边播放。鉴于MP4/h.264编码的优势，视频采用MP4文件格式存储，因为mp4只是一个存储的规范，像国内的优酷主要采用flv文件格式，其内部也是MP4编码，flv是 Adobe 支持的格式，这样的话，不论是在网站端，通过pc浏览器浏览，借助于Flash Player，还是手持设备，借助于ffmpeg的解码库，都能实现视频的无缝播放，算是一个比较完美的解决方案。

在实际视频的处理中，发现一个问题，利用Android手机自己拍摄录制的视频，可以完美支持边下载边播放，通过Iphone手机录制的视频，然后转码成mp4格式的视频就不能支持边下载边播放了，问题困扰了两三天，没办法，开始研究mp4的存储格式，最后终于找到了问题的所在。

了解mp4格式的应该知道，mp4是采用一种box数据结构来存储视频数据的，理想的情况是，box的顺序为ftyp，moov，free和mdat，通过moov的解析就能获取该视频的关键信息，比如播放时长，关键帧数，sample存储情况，在mdat中对应的编码数据偏移量等等。这样只要视频缓存完头部信息，即moov之后，就能知道当前视频的关键数据了，随着mdat的逐渐下载，就能完美实现视频的边缓存边播放，具体的实例教程请参见我的博文《Android视频播放之边缓存边播放》。

但是通过第三方软件的编码转换，有的就把moov放置到mdat之后了，这样只有把视频全部下载完成之后才能获取该视频的关键信息，才能开始播放，理论上也就没法实现视频的边缓存边播放，找到问题的关键点之后，就开始寻找解决办法，终于找到qt-faststart，它能解析原视频格式，并将moov信息尽可能的提前，这样就能及早解析和播放视频了。

格式转换

下载地址：

• qt-faststart.exe binary for Windows
• qt-faststart written in Python
• qtindexswapper written for Adobe AIR

我使用的是window的客户端，使用命令如下：

Usage: qt-faststart （转换前的视频文件） (转换后的视频文件)

参考文章

• how-to-make-mp4-progressive-with-qt-faststart
• improving-qt-faststart
• 移动流媒体协议综述

Android 视频播放之流媒体格式处理，首发于润物无声。