基本信息

---

下载

   友情提示：（无需注册或充值，赞助后即可获取资源下载链接）

---

     嘿，亲！知识可是无价之宝呢，但咱这精心整理的资料也耗费了不少心血呀。小小地破费一下，绝对物超所值哦！如有下载和支付问题，请联系我们QQ(微信同号)：813200300

本次赞助数额为： 2 元　

支付宝支付

微信支付

   源码介绍

---

说明：该android代码h263硬编码rtp打包发送服务器，pc端建立sdp文件用vlc播放
1、服务器ip为192.168.1.6
2、android手机ip为192.168.1.17，在小米1s测试通过，像三星等手机不支持h263编码
3、android端修改net.config包下的Config类的url
4、pc端用已有的sdp文件播放，修改ip为手机ip

android视频录制上传到服务器

package com.lee.h263recorder.activity;

import java.io.IOException;
import java.net.InetAddress;

import net.config.Config;
import net.majorkernelpanic.rtp.AbstractPacketizer;
import net.majorkernelpanic.rtp.H263Packetizer;

import android.media.MediaRecorder;
import android.net.LocalServerSocket;
import android.net.LocalSocket;
import android.net.LocalSocketAddress;
import android.os.Bundle;
import android.app.Activity;
import android.content.SharedPreferences;
import android.util.Log;
import android.view.Menu;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.SurfaceHolder.Callback;

	public class Main extends Activity implements Callback{

		private static final String TAG = "VideoCamera";

			SharedPreferences sharedPreferences;
			private final String mediaShare = "media";
			
			
		//初始化LocalServerSocket LocalSocket
			    LocalServerSocket lss;
			    LocalSocket receiver, sender;
			
			 
				protected AbstractPacketizer packetizer = null;
				protected boolean streaming = false, modeDefaultWasUsed = false;
				
	    @Override
	    public void onCreate(Bundle savedInstanceState) {
	        super.onCreate(savedInstanceState);
	        setContentView(R.layout.main);
	        InitSurfaceView();
	        InitMediaSharePreference();
	        InitAbstractPacketizer();
	    }
	    
	      private void InitAbstractPacketizer()    {
	    	  try {
				packetizer = new H263Packetizer();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	      }
	      
	    //初始化SurfaceView
	    private SurfaceView mSurfaceView;
		private void InitSurfaceView() {
			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);
		}
		
		
	    private void InitMediaSharePreference() {
			sharedPreferences = this.getSharedPreferences(mediaShare, MODE_PRIVATE);		
		}


	    private SurfaceHolder mSurfaceHolder;
	    private boolean mMediaRecorderRecording = false;
	    
		public void surfaceCreated(SurfaceHolder holder) {
			mSurfaceHolder = holder;
		}

		public void surfaceChanged(SurfaceHolder holder, int format, int width,
				int height) {
			mSurfaceHolder = holder;
			if(!mMediaRecorderRecording) {
				InitLocalSocket();
				initializeVideo();
				startVideoRecording();		
			}
			
		}

		public void surfaceDestroyed(SurfaceHolder holder) {
			// TODO Auto-generated method stub
			
		}
		
		
		
		private void InitLocalSocket(){
			try {
				lss = new LocalServerSocket("H263");
				receiver = new LocalSocket();
				
				receiver.connect(new LocalSocketAddress("H263"));
				receiver.setReceiveBufferSize(500000);			
				sender = lss.accept();			
				sender.setSendBufferSize(500000);
				
			} catch (IOException e) {
				Log.e(TAG, e.toString());
				this.finish();
				return;
			}
			
		}
		
		
		//初始化MediaRecorder
		private MediaRecorder mMediaRecorder = null;
		private int videoWidth = 640;    //352
		private int videoHeight = 480;    //288
		private int videoRate = 24; //15		
		private boolean 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(videoRate);
			mMediaRecorder.setVideoSize(videoWidth, videoHeight);
			mMediaRecorder.setVideoEncoder(MediaRecorder.VideoEncoder.H263);
			mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());
			mMediaRecorder.setMaxDuration(0);
			mMediaRecorder.setMaxFileSize(Integer.MAX_VALUE);
				mMediaRecorder.setOutputFile(sender.getFileDescriptor());


			try {
				mMediaRecorder.prepare();
				mMediaRecorder.start();
			} catch (IllegalStateException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
				releaseMediaRecorder();
			}
			
			return true;
		}

		//释放MediaRecorder资源
		private void releaseMediaRecorder(){
			if(mMediaRecorder != null) {
				if(mMediaRecorderRecording) {
					mMediaRecorder.stop();
					mMediaRecorderRecording = false;
				}
				mMediaRecorder.reset();
				mMediaRecorder.release();
				mMediaRecorder = null;
			}
		}
		
		//开始录像，启动线程
		private void startVideoRecording() {
			  try {
				  setDestination(InetAddress.getByName(Config.host),Config.video_port);
				  packetizer.setInputStream(receiver.getInputStream());
					packetizer.start();
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
		
		@Override
	    public boolean onCreateOptionsMenu(Menu menu) {
	    
	        return true;
	    }

		@Override
		protected void onPause() {
			// TODO Auto-generated method stub
			super.onPause();
			if(mMediaRecorderRecording)
			{
				releaseMediaRecorder();
				
				try {
					lss.close();
					receiver.close();
					sender.close();
				} catch (IOException e) {
					Log.e(TAG, e.toString());
				}
				
				mMediaRecorderRecording = false;
			}
			finish();
		}

		
		
		/** The stream will be sent to the address specified by this function **/
		public void setDestination(InetAddress dest, int dport) {
			this.packetizer.setDestination(dest, dport);
		}
		
		/** Set the Time To Live of the underlying RtpSocket 
		 * @throws IOException **/
		public void setTimeToLive(int ttl) throws IOException {
			this.packetizer.setTimeToLive(ttl);
		}
		
		public int getDestinationPort() {
			return this.packetizer.getRtpSocket().getPort();
		}
		
		public int getLocalPort() {
			return this.packetizer.getRtpSocket().getLocalPort();
		}
		
		public void setMode(int mode) throws IllegalStateException {
			if (!streaming) {
			modeDefaultWasUsed = true;
			}
			else {
				throw new IllegalStateException("You can't call setMode() while streaming !");
			}
		}
		
		public AbstractPacketizer getPacketizer() { 
			return packetizer;
		}
		
		public boolean isStreaming() {
			return streaming;
		}
		
		
		
		
		
	}