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<BR>
 * class description：CATCH THE VIDEODATA SEND TO RED5<BR>
 * PS： <BR>
 * 
 * @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();
		}
	}

}