在android中进行视频的分割

      最近项目有个需求要对录制的视频进行分割，查了很多资料，看到ffmpeg可以对视频进行分割。上网找到别人基于android的开源ffmpeg，终于编译成功ffmpeg.so。但是要使用的话还要查ffmpeg的api，并且写jni的调用接口，非常麻烦。偶然情况下发现了开源软件mp4parser: http://code.google.com/p/mp4parser/ 一款非常棒的开源软件，可以对视频进行分割、组合等操作，而且使用起来非常简单。通过svn对其下载后可以看到里面带着视频分割的例子，但是是用java实现，将其稍微修改一下就可以用在Android上了。

      首先将例子中的代码修改为一个工具类，通过接口传进视频文件的路径和截取视频的开始、结束时间。需要注意的是，如果传的开始时间是10s，视频一般不会刚好是从10s开始的，要根据视频的关键帧做一下调整。截取出来的视频会放到存储卡的Clip目录下。代码如下：

点击(此处)折叠或打开

1. package com.example.mp4clip;
   
2. 
   
3. import java.io.File;
   
4. import java.io.FileOutputStream;
   
5. import java.io.IOException;
   
6. import java.nio.channels.FileChannel;
   
7. import java.util.Arrays;
   
8. import java.util.LinkedList;
   
9. import java.util.List;
   
10. 
    
11. import android.os.Environment;
    
12. import android.util.Log;
    
13. 
    
14. import com.coremedia.iso.boxes.Container;
    
15. import com.googlecode.mp4parser.authoring.Movie;
    
16. import com.googlecode.mp4parser.authoring.Track;
    
17. import com.googlecode.mp4parser.authoring.builder.DefaultMp4Builder;
    
18. import com.googlecode.mp4parser.authoring.container.mp4.MovieCreator;
    
19. import com.googlecode.mp4parser.authoring.tracks.CroppedTrack;
    
20. 
    
21. public class ClipUtil {
    
22.     private static final String TAG = "ClipUtil";
    
23. 
    
24.     /**
    
25.      * 截取指定时间段的视频
    
26.      * @param path 视频的路径
    
27.      * @param begin 需要截取的开始时间
    
28.      * @param end 截取的结束时间
    
29.      * @throws IOException
    
30.      */
    
31.     public static void clipVideo(String path, double begin, double end)
    
32.             throws IOException {
    
33.         File mSdCardDir = Environment.getExternalStorageDirectory();
    
34.         File f = new File(mSdCardDir.getAbsolutePath() + File.separator
    
35.                 + Util.SAVE_PATH);
    
36.         if (!f.exists()) {
    
37.             f.mkdir();
    
38.         }
    
39.         // Movie movie = new MovieCreator().build(new
    
40.         // RandomAccessFile("/home/sannies/suckerpunch-distantplanet_h1080p/suckerpunch-distantplanet_h1080p.mov",
    
41.         // "r").getChannel());
    
42.         Movie movie = MovieCreator.build(path);
    
43. 
    
44.         List<Track> tracks = movie.getTracks();
    
45.         movie.setTracks(new LinkedList<Track>());
    
46.         // remove all tracks we will create new tracks from the old
    
47. 
    
48.         double startTime1 = begin;
    
49.         double endTime1 = end;
    
50.         // double startTime2 = 30;
    
51.         // double endTime2 = 40;
    
52. 
    
53.         boolean timeCorrected = false;
    
54. 
    
55.         // Here we try to find a track that has sync samples. Since we can only
    
56.         // start decoding
    
57.         // at such a sample we SHOULD make sure that the start of the new
    
58.         // fragment is exactly
    
59.         // such a frame
    
60.         for (Track track : tracks) {
    
61.             if (track.getSyncSamples() != null
    
62.                     && track.getSyncSamples().length > 0) {
    
63.                 if (timeCorrected) {
    
64.                     // This exception here could be a false positive in case we
    
65.                     // have multiple tracks
    
66.                     // with sync samples at exactly the same positions. E.g. a
    
67.                     // single movie containing
    
68.                     // multiple qualities of the same video (Microsoft Smooth
    
69.                     // Streaming file)
    
70.                     Log.e(TAG,
    
71.                             "The startTime has already been corrected by another track with SyncSample. Not Supported.");
    
72.                     throw new RuntimeException(
    
73.                             "The startTime has already been corrected by another track with SyncSample. Not Supported.");
    
74.                 }
    
75.                 startTime1 = correctTimeToSyncSample(track, startTime1, false);
    
76.                 endTime1 = correctTimeToSyncSample(track, endTime1, true);
    
77.                 // startTime2 = correctTimeToSyncSample(track, startTime2,
    
78.                 // false);
    
79.                 // endTime2 = correctTimeToSyncSample(track, endTime2, true);
    
80.                 timeCorrected = true;
    
81.             }
    
82.         }
    
83. 
    
84.         for (Track track : tracks) {
    
85.             long currentSample = 0;
    
86.             double currentTime = 0;
    
87.             double lastTime = 0;
    
88.             long startSample1 = -1;
    
89.             long endSample1 = -1;
    
90.             // long startSample2 = -1;
    
91.             // long endSample2 = -1;
    
92. 
    
93.             for (int i = 0; i < track.getSampleDurations().length; i++) {
    
94.                 long delta = track.getSampleDurations()[i];
    
95. 
    
96.                 if (currentTime > lastTime && currentTime <= startTime1) {
    
97.                     // current sample is still before the new starttime
    
98.                     startSample1 = currentSample;
    
99.                 }
    
100.                 if (currentTime > lastTime && currentTime <= endTime1) {
     
101.                     // current sample is after the new start time and still
     
102.                     // before the new endtime
     
103.                     endSample1 = currentSample;
     
104.                 }
     
105.                 // if (currentTime > lastTime && currentTime
     
106.                 // // current sample is still before the new starttime
     
107.                 // startSample2 = currentSample;
     
108.                 // }
     
109.                 // if (currentTime > lastTime && currentTime
     
110.                 // // current sample is after the new start time and still
     
111.                 // before the new endtime
     
112.                 // endSample2 = currentSample;
     
113.                 // }
     
114.                 lastTime = currentTime;
     
115.                 currentTime += (double) delta
     
116.                         / (double) track.getTrackMetaData().getTimescale();
     
117.                 currentSample++;
     
118.             }
     
119.             movie.addTrack(new CroppedTrack(track, startSample1, endSample1));// new
     
120.                                                                                 // AppendTrack(new
     
121.                                                                                 // CroppedTrack(track,
     
122.                                                                                 // startSample1,
     
123.                                                                                 // endSample1),
     
124.                                                                                 // new
     
125.                                                                                 // CroppedTrack(track,
     
126.                                                                                 // startSample2,
     
127.                                                                                 // endSample2)));
     
128.         }
     
129.         long start1 = System.currentTimeMillis();
     
130.         Container out = new DefaultMp4Builder().build(movie);
     
131.         long start2 = System.currentTimeMillis();
     
132.         FileOutputStream fos = new FileOutputStream(f.getAbsolutePath()
     
133.                 + File.separator
     
134.                 + String.format("output-%f-%f.mp4", startTime1, endTime1));
     
135.         FileChannel fc = fos.getChannel();
     
136.         out.writeContainer(fc);
     
137. 
     
138.         fc.close();
     
139.         fos.close();
     
140.         long start3 = System.currentTimeMillis();
     
141.         Log.e(TAG, "Building IsoFile took : " + (start2 - start1) + "ms");
     
142.         Log.e(TAG, "Writing IsoFile took : " + (start3 - start2) + "ms");
     
143.         Log.e(TAG,
     
144.                 "Writing IsoFile speed : "
     
145.                         + (new File(String.format("output-%f-%f.mp4",
     
146.                                 startTime1, endTime1)).length()
     
147.                                 / (start3 - start2) / 1000) + "MB/s");
     
148.     }
     
149. 
     
150.     private static double correctTimeToSyncSample(Track track, double cutHere,
     
151.             boolean next) {
     
152.         double[] timeOfSyncSamples = new double[track.getSyncSamples().length];
     
153.         long currentSample = 0;
     
154.         double currentTime = 0;
     
155.         for (int i = 0; i < track.getSampleDurations().length; i++) {
     
156.             long delta = track.getSampleDurations()[i];
     
157. 
     
158.             if (Arrays.binarySearch(track.getSyncSamples(), currentSample + 1) >= 0) {
     
159.                 // samples always start with 1 but we start with zero therefore
     
160.                 // +1
     
161.                 timeOfSyncSamples[Arrays.binarySearch(track.getSyncSamples(),
     
162.                         currentSample + 1)] = currentTime;
     
163.             }
     
164.             currentTime += (double) delta
     
165.                     / (double) track.getTrackMetaData().getTimescale();
     
166.             currentSample++;
     
167. 
     
168.         }
     
169.         double previous = 0;
     
170.         for (double timeOfSyncSample : timeOfSyncSamples) {
     
171.             if (timeOfSyncSample > cutHere) {
     
172.                 if (next) {
     
173.                     return timeOfSyncSample;
     
174.                 } else {
     
175.                     return previous;
     
176.                 }
     
177.             }
     
178.             previous = timeOfSyncSample;
     
179.         }
     
180.         return timeOfSyncSamples[timeOfSyncSamples.length - 1];
     
181.     }
     
182. 
     
183. }

     

         有了工具类，下面就是增加一个操作界面了。我用一个列表列出所有的视频，点击视频后就会在后台截取出5s~15s总共10s的视频。当然也可以根据需要加上自己想要的开始结束时间，代码如下：

点击(此处)折叠或打开

1. package com.example.mp4clip;
   
2. 
   
3. import java.io.IOException;
   
4. import java.lang.ref.SoftReference;
   
5. 
   
6. import android.app.Activity;
   
7. import android.content.Context;
   
8. import android.content.Intent;
   
9. import android.database.Cursor;
   
10. import android.graphics.drawable.Drawable;
    
11. import android.net.Uri;
    
12. import android.os.Bundle;
    
13. import android.os.Environment;
    
14. import android.provider.MediaStore;
    
15. import android.util.Log;
    
16. import android.util.SparseArray;
    
17. import android.view.Menu;
    
18. import android.view.MenuItem;
    
19. import android.view.View;
    
20. import android.view.ViewGroup;
    
21. import android.widget.AdapterView;
    
22. import android.widget.AdapterView.OnItemClickListener;
    
23. import android.widget.ImageView;
    
24. import android.widget.ListView;
    
25. import android.widget.SimpleCursorAdapter;
    
26. import android.widget.TextView;
    
27. import edu.mit.mobile.android.imagecache.ImageCache;
    
28. import edu.mit.mobile.android.imagecache.ImageCache.OnImageLoadListener;
    
29. 
    
30. public class MainActivity extends Activity implements OnItemClickListener,
    
31.         OnImageLoadListener {
    
32. 
    
33.     private static final String TAG = "MainActivity";
    
34.     ListView mList;
    
35.     private Cursor mCursor;
    
36.     private final SparseArray<SoftReference<ImageView>> mImageViewsToLoad = new SparseArray<SoftReference<ImageView>>();
    
37.     private ImageCache mCache;
    
38. 
    
39.     @Override
    
40.     protected void onCreate(Bundle savedInstanceState) {
    
41.         super.onCreate(savedInstanceState);
    
42.         setContentView(R.layout.activity_main);
    
43.         mCache = ImageCache.getInstance(this);
    
44.         mCache.registerOnImageLoadListener(this);
    
45.         mList = (ListView) findViewById(R.id.list);
    
46.         mList.setOnItemClickListener(this);
    
47.         mCursor = getContentResolver().query(
    
48.                 MediaStore.Video.Media.EXTERNAL_CONTENT_URI, null, null, null,
    
49.                 MediaStore.Video.Media.DATE_MODIFIED + " desc");
    
50.         SimpleCursorAdapter adapter = new videoListAdapter(this,
    
51.                 R.layout.video_listitem, mCursor,
    
52.                 new String[] { MediaStore.Video.Media.TITLE },
    
53.                 new int[] { R.id.video_title });
    
54.         mList.setAdapter(adapter);
    
55.     }
    
56. 
    
57.     @Override
    
58.     public boolean onCreateOptionsMenu(Menu menu) {
    
59.         getMenuInflater().inflate(R.menu.main, menu);
    
60.         return true;
    
61.     }
    
62. 
    
63.     public boolean onOptionsItemSelected(MenuItem item) {
    
64.         // 扫描新多媒体文件,添加到数据库中
    
65.         sendBroadcast(new Intent(Intent.ACTION_MEDIA_MOUNTED,
    
66.                 Uri.parse("file://"
    
67.                         + Environment.getExternalStorageDirectory()
    
68.                                 .getAbsolutePath())));
    
69.         return false;
    
70.     }
    
71. 
    
72.     @Override
    
73.     public void onItemClick(AdapterView<?> parent, View view, int position,
    
74.             long id) {
    
75.         if (mCursor.moveToPosition(position)) {
    
76.             int index = -1;
    
77.             index = mCursor.getColumnIndex(MediaStore.Video.Media.DATA);
    
78.             String path = null;
    
79.             if (index >= 0) {
    
80.                 path = mCursor.getString(index);
    
81.                 try {
    
82.                     ClipUtil.clipVideo(path, 5, 15);
    
83.                 } catch (IOException e) {
    
84.                     // TODO Auto-generated catch block
    
85.                     e.printStackTrace();
    
86.                 }
    
87.             }
    
88.         }
    
89. 
    
90.     }
    
91. 
    
92.     private static final class ViewHolder {
    
93.         /** 视频名称 */
    
94.         TextView titleView;
    
95.         /** 视频时长 */
    
96.         TextView durationView;
    
97.         /** 文件大小 */
    
98.         TextView sizeView;
    
99.     }
    
100. 
     
101.     private class videoListAdapter extends SimpleCursorAdapter {
     
102. 
     
103.         /*
     
104.          * constructor.
     
105.          */
     
106.         public videoListAdapter(Context context, int layout, Cursor c,
     
107.                 String[] from, int[] to) {
     
108.             super(context, layout, c, from, to);
     
109.         }
     
110. 
     
111.         @Override
     
112.         public int getCount() {
     
113.             return super.getCount();
     
114.         }
     
115. 
     
116.         @Override
     
117.         public Object getItem(int position) {
     
118.             return super.getItem(position);
     
119.         }
     
120. 
     
121.         @Override
     
122.         public long getItemId(int position) {
     
123.             return super.getItemId(position);
     
124.         }
     
125. 
     
126.         @Override
     
127.         public View getView(int position, View convertView, ViewGroup parent) {
     
128.             View view = super.getView(position, convertView, parent);
     
129.             Cursor cursor = getCursor();
     
130.             cursor.moveToPosition(position);
     
131.             ViewHolder holder = (ViewHolder) view.getTag();
     
132.             if (holder == null) {
     
133.                 holder = new ViewHolder();
     
134.                 holder.titleView = (TextView) view
     
135.                         .findViewById(R.id.video_title);
     
136.                 holder.durationView = (TextView) view
     
137.                         .findViewById(R.id.video_duration);
     
138.                 holder.sizeView = (TextView) view.findViewById(R.id.video_size);
     
139.             }
     
140.             view.setTag(holder);
     
141.             final ImageView iv = (ImageView) view.findViewById(R.id.thumbnail);
     
142.             int index = -1;
     
143.             index = mCursor.getColumnIndex(MediaStore.Video.Media.DATA);
     
144.             String path = null;
     
145.             if (index >= 0) {
     
146.                 path = mCursor.getString(index);
     
147.                 try {
     
148.                     Drawable draw = mCache.loadImage(position, Uri.parse(path),
     
149.                             120, 120);
     
150.                     if (draw != null) {
     
151.                         iv.setBackground(draw);
     
152.                     } else {
     
153.                         mImageViewsToLoad.put(position,
     
154.                                 new SoftReference<ImageView>(iv));
     
155.                     }
     
156.                 } catch (IOException e) {
     
157.                     e.printStackTrace();
     
158.                 }
     
159.             }
     
160.             index = -1;
     
161.             index = cursor.getColumnIndex(MediaStore.Video.Media.TITLE);
     
162.             String title = null;
     
163.             if (index >= 0) {
     
164.                 title = cursor.getString(index);
     
165.                 holder.titleView.setText(title);
     
166.             }
     
167.             index = -1;
     
168.             index = cursor.getColumnIndex(MediaStore.Video.Media.DURATION);
     
169.             int duration;
     
170.             if (index >= 0) {
     
171.                 duration = cursor.getInt(index);
     
172.                 holder.durationView.setText(Util.durationFormat(duration));
     
173.             }
     
174.             index = -1;
     
175.             index = cursor.getColumnIndex(MediaStore.Video.Media.SIZE);
     
176.             long size;
     
177.             if (index >= 0) {
     
178.                 size = cursor.getLong(index);
     
179.                 holder.sizeView.setText(Util.sizeFormat(size));
     
180.             }
     
181.             return view;
     
182. 
     
183.         }
     
184. 
     
185.     }
     
186. 
     
187.     @Override
     
188.     public void onImageLoaded(int id, Uri imageUri, Drawable image) {
     
189.         Log.d(TAG, "onImageLoaded:" + id);
     
190.         final SoftReference<ImageView> ivRef = mImageViewsToLoad.get(id);
     
191.         if (ivRef == null) {
     
192.             Log.d(TAG, "ivRef=null");
     
193.             return;
     
194.         }
     
195.         final ImageView iv = ivRef.get();
     
196.         if (iv == null) {
     
197.             Log.d(TAG, "ivRef=null");
     
198.             mImageViewsToLoad.remove(id);
     
199.             return;
     
200.         }
     
201.         iv.setBackground(image);
     
202.     }
     
203. }