Android中抓取手机视频流数据

目前实时抓取手机视频数据有2种方法，一种是通过camera的回调获取源数据，这里获取的源数据是没有编码的数据。

有的人发送yuv数据然后在那绘制图片，也说视频聊天，真是可笑。这种方式是可是实现视频聊天的，但是需要移植编码库

目前可移植的有，android的opencore编码，参考http://www.shouyanwang.org/thread-184-1-1.html。

ffmpeg编码，这个网上很难找，但是也有人实现哦。（编码效率好，但是支持不了高清视频）

编码完成可以通过rtp协议发送。就可以视频啦。rtp协议什么的就不说了哦。

以上方法的代码，在这个链接最好回复我贴了代码，不是完整的。链接：http://www.eoeandroid.com/thread-51460-1-1.html

第2种方法，也就是我用的方法。

通过MediaRecorder录制。然后绑定一个localsocket，可以获取编码后的视频数据传输；

代码如下：

 package com.pei;

 import java.io.DataInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import android.app.Activity;
 import android.os.Bundle;
 import android.graphics.PixelFormat;
 import android.media.MediaRecorder;
 import android.net.LocalServerSocket;
 import android.net.LocalSocket;
 import android.net.LocalSocketAddress;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.View;
 import android.view.Window;
 import android.view.WindowManager;

 /**
  * class name：VideoCameraActivity
  * class description：CATCH THE VIDEODATA SEND TO RED5
  * PS：
  *
  * @version 1.00 2011/11/05
  * @author CODYY)peijiangping
  */
 public class VideoCameraActivity extends Activity implements
         SurfaceHolder.Callback, MediaRecorder.OnErrorListener,
         MediaRecorder.OnInfoListener {
     private static final int mVideoEncoder = MediaRecorder.VideoEncoder.H264;
     private LocalSocket receiver, sender;
     private LocalServerSocket lss;
     private MediaRecorder mMediaRecorder = null;
     private boolean mMediaRecorderRecording = false;
     private SurfaceView mSurfaceView = null;
     private SurfaceHolder mSurfaceHolder = null;
     private Thread t;

     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         getWindow().setFormat(PixelFormat.TRANSLUCENT);
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                 WindowManager.LayoutParams.FLAG_FULLSCREEN);
         setContentView(R.layout.main);
         mSurfaceView = (SurfaceView) this.findViewById(R.id.surface_camera);
         SurfaceHolder holder = mSurfaceView.getHolder();
         holder.addCallback(this);
         holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
         mSurfaceView.setVisibility(View.VISIBLE);
         receiver = new LocalSocket();
         try {
             lss = new LocalServerSocket("VideoCamera");
             receiver.connect(new LocalSocketAddress("VideoCamera"));
             receiver.setReceiveBufferSize(500000);
             receiver.setSendBufferSize(500000);
             sender = lss.accept();
             sender.setReceiveBufferSize(500000);
             sender.setSendBufferSize(500000);
         } catch (IOException e) {
             finish();
             return;
         }
     }

     @Override
     public void onPause() {
         super.onPause();
         if (mMediaRecorderRecording) {
             stopVideoRecording();
             try {
                 lss.close();
                 receiver.close();
                 sender.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         finish();
     }

     private void stopVideoRecording() {
         System.out.println("stopVideoRecording");
         if (mMediaRecorderRecording || mMediaRecorder != null) {
             if (t != null)
                 t.interrupt();
             releaseMediaRecorder();
         }
     }

     private void startVideoRecording() {
         (t = new Thread() {
             public void run() {
                 int frame_size = 20000;
                 byte[] buffer = new byte[1024 * 64];
                 int num, number = 0;
                 InputStream fis = null;
                 try {
                     fis = receiver.getInputStream();
                 } catch (IOException e1) {
                     return;
                 }
                 number = 0;
                 releaseMediaRecorder();
                 while (true) {
                     System.out.println("ok");
                     try {
                         num = fis.read(buffer, number, frame_size);
                         number += num;
                         if (num < frame_size) {
                             System.out.println("recoend break");
                             break;
                         }
                     } catch (IOException e) {
                         System.out.println("exception break");
                         break;
                     }
                 }
                 initializeVideo();
                 number = 0;
                 Consumer consumer = new Publisher();// Publisher继承了Consumer
                 Thread consumerThread = new Thread((Runnable) consumer);
                 consumer.setRecording(true);// 设置线程状态;
                 consumerThread.start();// 开始发布数据流
                 DataInputStream dis = new DataInputStream(fis);
                 try {
                     dis.read(buffer, 0, 32);
                 } catch (IOException e1) {
                     e1.printStackTrace();
                 }
                 byte[] aa = { 0x01, 0x42, (byte) 0x80, 0x0A, (byte) 0xFF,
                         (byte) 0xE1, 0x00, 0x12, 0x67, 0x42, (byte) 0x80, 0x0A,
                         (byte) 0xE9, 0x02, (byte) 0xC1, 0x29, 0x08, 0x00, 0x00,
                         0x1F, 0x40, 0x00, 0x04, (byte) 0xE2, 0x00, 0x20, 0x01,
                         0x00, 0x04, 0x68, (byte) 0xCE, 0x3C, (byte) 0x80 };
                 consumer.putData(System.currentTimeMillis(), aa, 33);
                 while (true) {
                     try {
                         int h264length = dis.readInt();
                         number = 0;
                         while (number < h264length) {
                             int lost = h264length - number;
                             num = fis.read(buffer, 0,
                                     frame_size < lost ? frame_size : lost);
                             number += num;
                             consumer.putData(System.currentTimeMillis(),
                                     buffer, num);
                         }
                     } catch (IOException e) {
                         break;
                     }
                 }
                 consumer.setRecording(false);// 设置线程状态;
             }
         }).start();
     }

     private boolean initializeVideo() {
         System.out.println("initializeVideo");
         if (mSurfaceHolder == null)
             return false;
         mMediaRecorderRecording = true;
         if (mMediaRecorder == null)
             mMediaRecorder = new MediaRecorder();
         else
             mMediaRecorder.reset();
         mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);
         mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);
         mMediaRecorder.setVideoFrameRate(20);
         mMediaRecorder.setVideoSize(352, 288);
         mMediaRecorder.setVideoEncoder(mVideoEncoder);
         mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
         mMediaRecorder.setMaxDuration(0);
         mMediaRecorder.setMaxFileSize(0);
         mMediaRecorder.setOutputFile(sender.getFileDescriptor());
         try {
             mMediaRecorder.setOnInfoListener(this);
             mMediaRecorder.setOnErrorListener(this);
             mMediaRecorder.prepare();
             mMediaRecorder.start();
         } catch (IOException exception) {
             releaseMediaRecorder();
             finish();
             return false;
         }
         return true;
     }

     private void releaseMediaRecorder() {
         System.out.println("Releasing media recorder.");
         if (mMediaRecorder != null) {
             if (mMediaRecorderRecording) {
                 try {
                     mMediaRecorder.setOnErrorListener(null);
                     mMediaRecorder.setOnInfoListener(null);
                     mMediaRecorder.stop();
                 } catch (RuntimeException e) {
                     System.out.println("stop fail: " + e.getMessage());
                 }
                 mMediaRecorderRecording = false;
             }
             mMediaRecorder.reset();
             mMediaRecorder.release();
             mMediaRecorder = null;
         }
     }

     @Override
     public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
         System.out.println("surfaceChanged");
         mSurfaceHolder = holder;
         if (!mMediaRecorderRecording) {
             initializeVideo();
             startVideoRecording();
         }
     }

     @Override
     public void surfaceCreated(SurfaceHolder holder) {
         System.out.println("surfaceCreated");
         mSurfaceHolder = holder;
     }

     @Override
     public void surfaceDestroyed(SurfaceHolder holder) {
         System.out.println("surfaceDestroyed");
         mSurfaceView = null;
         mSurfaceHolder = null;
         mMediaRecorder = null;
         if (t != null) {
             t.interrupt();
         }
     }

     @Override
     public void onInfo(MediaRecorder mr, int what, int extra) {
         switch (what) {
         case MediaRecorder.MEDIA_RECORDER_INFO_UNKNOWN:
             System.out.println("MEDIA_RECORDER_INFO_UNKNOWN");
             break;

     case MediaRecorder.MEDIA_RECORDER_INFO_MAX_DURATION_REACHED:
         System.out.println("MEDIA_RECORDER_INFO_MAX_DURATION_REACHED");
         break;
     case MediaRecorder.MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED:
         System.out.println("MEDIA_RECORDER_INFO_MAX_FILESIZE_REACHED");
         break;
     }
 }

 @Override
 public void onError(MediaRecorder mr, int what, int extra) {
     if (what == MediaRecorder.MEDIA_RECORDER_ERROR_UNKNOWN) {
         System.out.println("MEDIA_RECORDER_ERROR_UNKNOWN");
         finish();