Android和C#实现实时视频传输Demo

上次说到的那个Demo，趁着今天有空整理一下。

原理很简单，虽然没有写过android应用，但是，嘛~ 高级语言都是相通的，自傲一下。所以简单研究了一下api后，发现相机对象有预览回调方法，

实现一下Camera.PreviewCallback接口，就可以得到一个每一帧画面的回调事件，那么思路就很简单了。

拿到画面后，进行下简单的压缩，然后把图像用Socket传输到服务器上，服务器上绑定到一个窗口的picBox上就可以了。

当然，这里还牵扯到多线程的问题，因为一个SocketServer可以实现和多个client建立连接，而每一个连接都需要独立的线程来实现监听。

安卓端代码：

package com.xwg.monitorclient;

import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.List;
import java.util.zip.DeflaterOutputStream;

import android.graphics.Rect;
import android.graphics.YuvImage;
import android.hardware.Camera;
import android.hardware.Camera.Size;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.app.Activity;
import android.content.SharedPreferences;
import android.view.Menu;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.WindowManager;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class MainActivity extends Activity implements SurfaceHolder.Callback,
Camera.PreviewCallback{
private SurfaceView mSurfaceview = null; // SurfaceView对象：(视图组件)视频显示
private SurfaceHolder mSurfaceHolder = null; // SurfaceHolder对象：(抽象接口)SurfaceView支持类
private Camera mCamera = null; // Camera对象，相机预览

/**服务器地址*/
private String pUsername="XZY";
/**服务器地址*/
private String serverUrl="192.168.0.3";
/**服务器端口*/
private int serverPort=9999;
/**视频刷新间隔*/
private int VideoPreRate=1;
/**当前视频序号*/
private int tempPreRate=0;
/**视频质量*/
private int VideoQuality=85;

/**发送视频宽度比例*/
private float VideoWidthRatio=1;
/**发送视频高度比例*/
private float VideoHeightRatio=1;

/**发送视频宽度*/
private int VideoWidth=320;
/**发送视频高度*/
private int VideoHeight=240;
/**视频格式索引*/
private int VideoFormatIndex=0;
/**是否发送视频*/
private boolean startSendVideo=false;
/**是否连接主机*/
private boolean connectedServer=false;

private Button myBtn01, myBtn02;

private EditText txtIP;

@Override
public void onStart()//重新启动的时候
{
mSurfaceHolder = mSurfaceview.getHolder(); // 绑定SurfaceView，取得SurfaceHolder对象
mSurfaceHolder.addCallback(this); // SurfaceHolder加入回调接口
mSurfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);// 设置显示器类型，setType必须设置
//读取配置文件
SharedPreferences preParas = PreferenceManager.getDefaultSharedPreferences(MainActivity.this);
pUsername=preParas.getString("Username", "XZY");
serverUrl=preParas.getString("ServerUrl", "192.168.0.3");
String tempStr=preParas.getString("ServerPort", "9999");
serverPort=Integer.parseInt(tempStr);
tempStr=preParas.getString("VideoPreRate", "1");
VideoPreRate=Integer.parseInt(tempStr);
tempStr=preParas.getString("VideoQuality", "85");
VideoQuality=Integer.parseInt(tempStr);
tempStr=preParas.getString("VideoWidthRatio", "100");
VideoWidthRatio=Integer.parseInt(tempStr);
tempStr=preParas.getString("VideoHeightRatio", "100");
VideoHeightRatio=Integer.parseInt(tempStr);
VideoWidthRatio=VideoWidthRatio/100f;
VideoHeightRatio=VideoHeightRatio/100f;

super.onStart();
}

@Override
protected void onResume() {
super.onResume();
InitCamera();
}

/**初始化摄像头*/
private void InitCamera(){
try{

mCamera = Camera.open();
List<Size> list = mCamera.getParameters().getSupportedPreviewSizes();
for(Size s : list)
{
if(s.width<=640)
{
Camera.Parameters params = mCamera.getParameters();
params.setPreviewSize(s.width, s.height);
mCamera.setParameters(params);
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
}

@Override
protected void onPause() {
try{
if (mCamera != null) {
mCamera.setPreviewCallback(null); // ！！这个必须在前，不然退出出错
mCamera.stopPreview();
mCamera.release();
mCamera = null;
}
} catch (Exception e) {
e.printStackTrace();
}

super.onPause();
}

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

//禁止屏幕休眠
getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

mSurfaceview = (SurfaceView) findViewById(R.id.camera_preview);
myBtn01=(Button)findViewById(R.id.button1);
myBtn02=(Button)findViewById(R.id.button2);
txtIP = (EditText)findViewById(R.id.editText1);
//开始连接主机按钮
myBtn01.setOnClickListener(new OnClickListener(){
public void onClick(View v) {
serverUrl = txtIP.getText().toString();
if(connectedServer){//停止连接主机，同时断开传输
startSendVideo=false;
connectedServer=false;
myBtn02.setEnabled(false);
myBtn01.setText("开始连接");
myBtn02.setText("开始传输");

//断开连接
//Thread th = new MySendCommondThread("PHONEDISCONNECT|"+pUsername+"|");
//th.start();

}
else//连接主机
{
//启用线程发送命令PHONECONNECT

connectedServer=true;
myBtn02.setEnabled(true);
myBtn01.setText("停止连接");
}
}});

myBtn02.setEnabled(false);
myBtn02.setOnClickListener(new OnClickListener(){
public void onClick(View v) {
if(startSendVideo)//停止传输视频
{
startSendVideo=false;
myBtn02.setText("开始传输");
}
else{ // 开始传输视频
Thread th = new MyThread();
th.start();
startSendVideo=true;
myBtn02.setText("停止传输");
}
}});
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}

@Override
public void surfaceChanged(SurfaceHolder arg0, int arg1, int arg2, int arg3) {
// TODO Auto-generated method stub
if (mCamera == null) {
return;
}
mCamera.stopPreview();
mCamera.setPreviewCallback(this);
mCamera.setDisplayOrientation(90); //设置横行录制

//获取摄像头参数
Camera.Parameters parameters = mCamera.getParameters();

Size size = parameters.getPreviewSize();
VideoWidth=size.width;
VideoHeight=size.height;

VideoFormatIndex=parameters.getPreviewFormat();

mCamera.startPreview();
}

@Override
public void surfaceCreated(SurfaceHolder holder) {
// TODO Auto-generated method stub
try {
if (mCamera != null) {
mCamera.setPreviewDisplay(mSurfaceHolder);
mCamera.startPreview();
}
} catch (IOException e) {
e.printStackTrace();
}
}

@Override
public void surfaceDestroyed(SurfaceHolder holder) {
// TODO Auto-generated method stub
if (null != mCamera) {
mCamera.setPreviewCallback(null); // ！！这个必须在前，不然退出出错
mCamera.stopPreview();
mCamera = null;
}
}

@Override
public void onPreviewFrame(byte[] data, Camera camera) {
// TODO Auto-generated method stub
//如果没有指令传输视频，就先不传
if(!startSendVideo)
return;
//		if(tempPreRate<VideoPreRate){
//			tempPreRate++;
//			return;
//		}
//		tempPreRate=0;
try {
if(data!=null)
{
YuvImage image = new YuvImage(data,VideoFormatIndex, VideoWidth, VideoHeight,null);
if(image!=null)
{
ByteArrayOutputStream outstream = new ByteArrayOutputStream();

//在此设置图片的尺寸和质量
image.compressToJpeg(new Rect(0, 0, (int)(VideoWidthRatio*VideoWidth),
(int)(VideoHeightRatio*VideoHeight)), VideoQuality, outstream);
outstream.flush();

SendMessage(outstream.toByteArray());

//启用线程将图像数据发送出去
//Thread th = new MySendFileThread(outstream.toByteArray());
//th.start();
}
}
} catch (IOException e) {
e.printStackTrace();
}
}

Socket client = null;

public void SendMessage(byte[] content)
{
if(client==null)
return;
OutputStream outsocket;
try{
outsocket = client.getOutputStream();

//BufferedOutputStream dos = new BufferedOutputStream(outsocket);
DataOutputStream dos = new DataOutputStream(outsocket);
int len = content.length;
byte[] header = Int2Byte(len);
//outsocket.write(header);

dos.write(header);
//outsocket.flush();
//outsocket.write(content);
//		byte byteBuffer[] = new byte[1024];
//		ByteArrayInputStream inputstream = new ByteArrayInputStream(content);
//
//		PrintWriter pw = new PrintWriter(outsocket);
//
//        int amount;
//        while ((amount = inputstream.read(byteBuffer)) != -1) {
//        	outsocket.write(byteBuffer, 0, amount);
//        }
//outsocket.write(content);
dos.write(content);
//dos.flush();
//dos.close();
//outsocket.flush();

}catch(Exception e)
{
e.printStackTrace();
}
}

public byte[] Int2Byte(int len)
{
byte[] rtn = new byte[5];
rtn[0] = (byte)0;
rtn[1] = (byte)(len&0xff);
rtn[2] = (byte)((len>>8)&0xff);
rtn[3] = (byte)((len>>16)&0xff);
rtn[4] = (byte)(len>>>24);
return rtn;

}

/**发送命令线程*/
class MyThread extends Thread{

public void run(){
//实例化Socket
try {
client=new Socket(serverUrl,serverPort);

} catch (UnknownHostException e) {
} catch (IOException e) {
}
}
}

/**发送文件线程*/
class MySendFileThread extends Thread{
byte[] content = null;
public MySendFileThread(byte[] content){
this.content = content;
}

public void run() {
try{
SendMessage(this.content);
//tempSocket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}

</pre><p></p><p>安卓端代码通过一个全局Socket创建连接，然后通过onPreviewFrame事件，捕获图像帧，然后压缩，处理成byte[]然后发送啦。</p><p>不过java这里没有int和byte[]的转换，很二有木有，鄙视一下java。还得自己写代码转换，这里直接生成了header[]，由于没设计其他操作，所以第一位默认0，</p><p>后4位是图片byte[]长度。</p><p>然后依次发送数据出去。</p><p>其他的相机设置的代码，来自baidu。</p><p>话说java这里不熟，所以比较乱，没有具体封装什么的。</p>C#代码<p>ClientInfo，一个用来保存连接的实体类，嘛~由于Demo吗，没仔细处理，一下也是相同原因，没有具体优化过，不过测试过wifi条件下，传600p左右画质，开2~3个客户端还是可以的。</p><p></p><pre code_snippet_id="419870" snippet_file_name="blog_20140707_3_9307192" name="code" class="csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Net.Sockets;

namespace com.xwg.net
{
public class ClientInfo
{
public Thread ReceiveThread;

public Socket Client;

public string ip;

public string name;

}
}

服务器Socket管理类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Net.Sockets;
using System.Net;
using xwg.common;
using System.IO;

namespace com.xwg.net
{
public class SocketServer
{
#region 变量定义
List<ClientInfo> clientList = null;

private Socket socketServer = null;

/// <summary>
/// 服务器IP
/// </summary>
private IPAddress serverIP;

/// <summary>
/// 监听端口号
/// </summary>
private int portNo = 15693;

/// <summary>
/// 完整终端地址包含端口
/// </summary>
private IPEndPoint serverFullAddr;

// Server监听线程
Thread accpetThread = null;

#endregion

#region 构造函数
public SocketServer(string ServerIP)
{
this.serverIP = IPAddress.Parse(ServerIP);
}

public SocketServer(string ServerIP, int portNo)
{
this.serverIP = IPAddress.Parse(ServerIP);
this.portNo = portNo;
}
#endregion

#region Event

// 客户端接入事件
public event ClientAccepted OnClientAccepted;

// 连接接收数据事件
public event StreamReceived OnStreamReceived;

public event ClientBreak OnClentBreak;

#endregion

public void StartListen()
{
//取得完整地址
serverFullAddr = new IPEndPoint(serverIP, portNo);//取端口号
try
{
// 实例化Server对象
socketServer = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

// 绑定监听端口
socketServer.Bind(serverFullAddr);

// 启动监听，制定最大20挂起
socketServer.Listen(20);

}
catch (Exception e)
{
Logger.Write("StartListen方法："+e.Message);
}

clientList = new List<ClientInfo>();

accpetThread = new Thread(new ThreadStart(AcceptSocket));
accpetThread.IsBackground = true;
accpetThread.Start();
}

private void AcceptSocket()
{
while (true)
{
// client Socket 获得客户端连接
Socket acceptSock = socketServer.Accept();

Logger.Write("接收到连接！");
string ip = ((IPEndPoint)acceptSock.RemoteEndPoint).Address.ToString();
Logger.Write("客户端IP：");
ClientInfo info = new ClientInfo();
info.Client = acceptSock;
info.ip = ip;
info.name = ip;

Thread recThread = new Thread(new ParameterizedThreadStart(ReceiveMsg));
recThread.IsBackground = true;
info.ReceiveThread = recThread;

clientList.Add(info);

recThread.Start(info);

// 客户端接入响应事件
if (OnClientAccepted != null)
OnClientAccepted(this, info);
}
}

private void ReceiveMsg(object obj)
{
ClientInfo info = (ClientInfo)obj;
Socket clientSock = info.Client;
try
{
while (true)
{
// 判断连接状态
if (!clientSock.Connected)
{
clientList.Remove(info);
info.ReceiveThread.Abort();
clientSock.Close();

}

try
{
byte[] header = new byte[5];
int len = clientSock.Receive(header,SocketFlags.None);
if (len != 5)
{
// 错误 终端连接
Logger.Write("数据头接收错误，长度不足：" + len);
clientSock.Close();
info.ReceiveThread.Abort();
return;
}

int conLen = BitConverter.ToInt32(header, 1);

//byte[] content = new byte[conLen];
//len = clientSock.Receive(content, SocketFlags.None);
MemoryStream stream = new MemoryStream();
//byte [] buffer = new byte[1024];
//while ((len = clientSock.Receive(buffer)) > 0)
//{
//    stream.Write(buffer,0,len);
//}
//if (conLen != stream.Length)
//{
//    Logger.Write("长度错误："+stream.Length+"/"+conLen);
//}
for (int i = 0; i < conLen; i++)
{
byte[] arr = new byte[1];
clientSock.Receive(arr,SocketFlags.None);
stream.Write(arr,0,1);
}

//stream.Write(content,0,content.Length);
stream.Flush();

//len = clientSock.Receive(content, SocketFlags.None);

//if (len != conLen)
//{
//    // 错误 终端连接
//    Logger.Write("header:" + header[1] + "," + header[2] + "," + header[3] + "," + header[4]);
//    Logger.Write("Content接收错误，长度不足：" + len+"/"+conLen);
//    clientSock.Close();
//    return;
//}

// 接收事件
if (OnStreamReceived != null)
{
OnStreamReceived(info, stream);
}
}
catch (Exception ex)
{
if (OnClentBreak != null)
{
OnClentBreak(this, info);
}
Logger.Write("Receive数据："+ex.Message);
clientSock.Close();
return;
}
}
}
catch (Exception e)
{
if (OnClentBreak != null)
{
OnClentBreak(this, info);
}
Logger.Write("ReceiveMsg：" + e.Message);
clientSock.Close();
return;
}
}
}

public delegate void ClientAccepted(object sender,ClientInfo info);

public delegate void StreamReceived(object sender,MemoryStream stream);

public delegate void ClientBreak(object sender,ClientInfo info);
}

这里面涉及了Socket和多线程处理的知识。

简单一说，Socket既可以做Server，也可以做Client，当然你用TCPListener也一样效果就是了。

这里由于是服务端，所以Socket被我Bind到了一个端口上面，启用了Listen，监听方法。

然后启用了一个accpet线程，总用时实现端口监听。

每当accpet到一个客户端的时候，会触发 OnClientAccepted 事件。accpet方法是会触发阻塞的，所以绝对不可以用主线程，否则就是程序无响应。

C#处理过程中，实现封装的最好方法就是使用事件机制了，这是我认为比Java方便的多的设计。可以把逻辑的实现，完全的抛出封装对象。

然后就是AcceptSocket 这个方法了，这个方法当中，一旦接收到客户端连接，会创建一个ClientInfo对象，把一些相关属性设置上去保存。

同时新建一个线程，实现ReceiveMessage的监听。IsBackground是一个小技巧，表示主线程结束时，把这些线程同时结束掉。比起手动结束方便多。如果你应用关闭，发现程序还在后台跑，那么多数是由于创建的线程没有结束的原因，这时候这个属性会起到关键作用。

ReceiveMsg是接收数据的方法，这里简单定义了一个数据协议，数据发送时，分成两部分发送，先发送一个5byte的header，然后是实际内容content。

header第一位表示操作标示（因为demo简单，所以没有具体设计协议，这个可以自定义的，也是通用的处理方法），后4位标示content内容流的长度，这样取数据的时候，就不至于乱掉。

正常来说，Socket.Receive是有阻塞的啦，不过这里不知道为什么，接收的时候有问题，怀疑安卓socket流导致的，所以没办法直接定义buffer，一次性接受所有content，由于时间紧，没仔细研究，反正总长度是一定不会变的，所以直接循环处理了...偷懒了有木有...

接受到信息后，通过事件OnStreamReceived 吧数据流返回出去。

服务端基本就这样了，因为不牵扯双向消息，所以没处理send啦。

然后就是界面：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using com.xwg.net;
using System.IO;
using xwg.common;

namespace MonitorServer
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

SocketServer server = null;
List<ViewForm> list = new List<ViewForm>();
//ViewForm vf = new ViewForm();

private void button1_Click(object sender, EventArgs e)
{

server = new SocketServer(txtIP.Text, int.Parse(txtPort.Text));
Logger.Write("server = new SocketServer(txtIP.Text, int.Parse(txtPort.Text));");
server.OnClientAccepted += ClientAccepted;
server.OnStreamReceived += StreamReceived;
server.OnClentBreak += ClientBreak;
server.StartListen();
Logger.Write("StartListen");
button1.Enabled = false;
}

public void AddClient(string ip)
{
try
{
this.Invoke((EventHandler)delegate
{
listBox1.Items.Add(ip);
});
}
catch (Exception e)
{

}
}

public void RemoveClient(string ip)
{
try
{
this.Invoke((EventHandler)delegate
{
listBox1.Items.Remove(ip);
});
}
catch (Exception e)
{

}
}

public void CloseViewForm(string ip)
{
try
{
ViewForm vf = GetViewByIP(ip);
if (vf == null)
return;
vf.Invoke((EventHandler)delegate
{
vf.Close();
});
}
catch (Exception e)
{

}
}

public void SetViewImage(ViewForm vf, MemoryStream stream)
{
try
{
vf.Invoke((EventHandler)delegate
{
Image img = Image.FromStream(stream);
vf.SetImage(img);
stream.Close();
});
}
catch (Exception e)
{

}
}

protected void ClientAccepted(object sender, ClientInfo info)
{
Logger.Write("ClientAccepted:"+info.ip);
AddClient(info.ip);

//ViewForm vf = new ViewForm();
//list.Add(vf);
//vf.SetTitle(info.ip);
//vf.Show();
}

private ViewForm GetViewByIP(string ip)
{
foreach (ViewForm vf in list)
{
if (vf.Text == ip)
return vf;
}
return null;
}

protected void StreamReceived(object sender, MemoryStream stream)
{
ClientInfo info = (ClientInfo) sender;
try
{
//Image img = Image.FromStream(stream);
////img.Save("a.jpg");
ViewForm vf = GetViewByIP(info.ip);
if (vf == null)
{
stream.Close();
return;
}
SetViewImage(vf, stream);

//vf.SetImage(img);
//stream.Close();
}
catch (Exception e)
{
Logger.Write("StreamReceived:"+e.Message);
}
}

protected void ClientBreak(object sender, ClientInfo info)
{
CloseViewForm(info.ip);
list.Remove(GetViewByIP(info.ip));
RemoveClient(info.ip);
}

private void listBox1_MouseDoubleClick(object sender, MouseEventArgs e)
{
if (listBox1.SelectedItem == null)
return;
string ip = listBox1.SelectedItem.ToString();
ViewForm vf = new ViewForm();
list.Add(vf);
vf.SetTitle(ip);
vf.Show();
}
}
}

界面实现了那几个事件，通过事件机制得到数据，进行UI设置。（界面嘛~就是UI层啦，一般只关注UI，不要放逻辑代码）

然后用来展示的窗体

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace MonitorServer
{
public partial class ViewForm : Form
{
public ViewForm()
{
InitializeComponent();
}

public void SetTitle(string title)
{
this.Text = title;
}

public void SetImage(Image img)
{
pictureBox1.Image = img;
}
}
}

其实就是绑定了一个pictureBox啦。

到此就结束了，启动服务器应用，开始监听，然后启动安卓端应用，输入服务器地址（要保证一个网络中），连接。

服务端就会发现客户端连接，这时，双击ip，就会打开预览窗口。

支持多客户端连接预览，但是打开多了会卡，毕竟演示demo，没处理优化。

实际上，应该是连接后，服务器发送命令给客户端，客户端才开始传图片流，现在没处理，所以比较卡哦。

并且这种图片帧传输的方法，虽然比较清晰，但是压缩比小，会产生大量流量，所以只能演示用哦。

对了，还一个原因，这里用的tcp协议，能够保证数据包丢失重发，但是该机制会导致性能瓶颈，重发就会有时间影响哦，网络不好，容易出现抖动等现象，其实是由于丢包引起的。这里可以换用udp，虽然可能会出现丢帧，但是抖动现象应该会有改善，速度也会比较快。

并且这里不支持音频哦，如果想要完美实现的话，还是用上一篇文章提到的方法吧。

做一个控制服务器，然后实现C#客户端和android客户端的直连，效果应该比较好。当然，这里也是由于spyroid这个项目，内置实现了rtsp协议服务器的原因啦。站在巨人身上总是会让事情变得简单。这里感谢国外开源项目组，同时鄙视一下国内人员，百度到有用的东西，都不放出源码，而是要收费。。。

希望对大家有用。

对了，源码我上传到资源里面了，大家可以去我空间下载，包含安卓和C#后台完整项目代码。

地址：http://download.csdn.net/detail/lanwilliam/7602669

10个资源分其实真心不高，毕竟调试了1天呢。