程序博客网 > 学日语的游戏知乎

android视频监控的解决方案探讨

来源：互联网 发布：学日语的游戏知乎 编辑：程序博客网 时间：2024/06/15 14:14

目录(?)[-]

  1. Android中抓取手机视频流数据
  2. h264中avc和flv数据的解析
  3. 关于h264的avc box中数据的提取sps pps的获取
  4. Android使用VideoView播放RTSP视频
    1. Android用MediaRecorder实现MPEG4视频监控

1. camera YUV420数据直接socket发送到服务器端，转换成RGB显示 占用带宽较多。

      原理阐述：基于socket，wifi。 android客户端获取的帧数据的格式为yuv420格式，本来将此data数据流直接传输到另一android端，由接收端完成图像的解码转换工作，但是发现如果直接传数据流数据量太大，还不如直接在本地解码转换完毕生成图片，然后将图片传到另外一android端进行重绘排列。

     考虑到效率，可将核心的解码转换封装成c实现.so，速度好些

     改进： 项目采用多播协议，即如果在多台电脑上同时运行服务端，则一台手机可以同时控制多台电脑做同样的事情，同时操作所有开启服务端电脑的ppt。

    “   谈下实现思路：
1 socket实现传输，目前网络用的wifi
2 java端的视频获取我采用的是jmf框架
3 逻辑比较简单：总体实现无非就是android端视频捕获发送yuv原格式到pc端进行解码而后在pc上显示，
同时pc通过jmf上获取camera摄像头的数据，通过socket传输到android端进行重绘。


2. RTP SDP结合+

    The following network protocols are supported for audio and video playback:
RTSP (RTP, SDP)
HTTP/HTTPS progressive streaming
HTTP/HTTPS live streaming draft protocol:



+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

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，可以获取编码后的视频数据传输；

代码如下：

[java] view plaincopy
  1. package com.pei;  
  2.   
  3. import java.io.DataInputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import android.app.Activity;  
  7. import android.os.Bundle;  
  8. import android.graphics.PixelFormat;  
  9. import android.media.MediaRecorder;  
  10. import android.net.LocalServerSocket;  
  11. import android.net.LocalSocket;  
  12. import android.net.LocalSocketAddress;  
  13. import android.view.SurfaceHolder;  
  14. import android.view.SurfaceView;  
  15. import android.view.View;  
  16. import android.view.Window;  
  17. import android.view.WindowManager;  
  18.   
  19. /** 
  20.  * class name：VideoCameraActivity<BR> 
  21.  * class description：CATCH THE VIDEODATA SEND TO RED5<BR> 
  22.  * PS： <BR> 
  23.  *  
  24.  * @version 1.00 2011/11/05 
  25.  * @author CODYY)peijiangping 
  26.  */  
  27. public class VideoCameraActivity extends Activity implements  
  28.         SurfaceHolder.Callback, MediaRecorder.OnErrorListener,  
  29.         MediaRecorder.OnInfoListener {  
  30.     private static final int mVideoEncoder = MediaRecorder.VideoEncoder.H264;  
  31.     private LocalSocket receiver, sender;  
  32.     private LocalServerSocket lss;  
  33.     private MediaRecorder mMediaRecorder = null;  
  34.     private boolean mMediaRecorderRecording = false;  
  35.     private SurfaceView mSurfaceView = null;  
  36.     private SurfaceHolder mSurfaceHolder = null;  
  37.     private Thread t;  
  38.   
  39.     @Override  
  40.     public void onCreate(Bundle savedInstanceState) {  
  41.         super.onCreate(savedInstanceState);  
  42.         getWindow().setFormat(PixelFormat.TRANSLUCENT);  
  43.         requestWindowFeature(Window.FEATURE_NO_TITLE);  
  44.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,  
  45.                 WindowManager.LayoutParams.FLAG_FULLSCREEN);  
  46.         setContentView(R.layout.main);  
  47.         mSurfaceView = (SurfaceView) this.findViewById(R.id.surface_camera);  
  48.         SurfaceHolder holder = mSurfaceView.getHolder();  
  49.         holder.addCallback(this);  
  50.         holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);  
  51.         mSurfaceView.setVisibility(View.VISIBLE);  
  52.         receiver = new LocalSocket();  
  53.         try {  
  54.             lss = new LocalServerSocket("VideoCamera");  
  55.             receiver.connect(new LocalSocketAddress("VideoCamera"));  
  56.             receiver.setReceiveBufferSize(500000);  
  57.             receiver.setSendBufferSize(500000);  
  58.             sender = lss.accept();  
  59.             sender.setReceiveBufferSize(500000);  
  60.             sender.setSendBufferSize(500000);  
  61.         } catch (IOException e) {  
  62.             finish();  
  63.             return;  
  64.         }  
  65.     }  
  66.   
  67.     @Override  
  68.     public void onPause() {  
  69.         super.onPause();  
  70.         if (mMediaRecorderRecording) {  
  71.             stopVideoRecording();  
  72.             try {  
  73.                 lss.close();  
  74.                 receiver.close();  
  75.                 sender.close();  
  76.             } catch (IOException e) {  
  77.                 e.printStackTrace();  
  78.             }  
  79.         }  
  80.         finish();  
  81.     }  
  82.   
  83.     private void stopVideoRecording() {  
  84.         System.out.println("stopVideoRecording");  
  85.         if (mMediaRecorderRecording || mMediaRecorder != null) {  
  86.             if (t != null)  
  87.                 t.interrupt();  
  88.             releaseMediaRecorder();  
  89.         }  
  90.     }  
  91.   
  92.     private void startVideoRecording() {  
  93.         (t = new Thread() {  
  94.             public void run() {  
  95.                 int frame_size = 20000;  
  96.                 byte[] buffer = new byte[1024 * 64];  
  97.                 int num, number = 0;  
  98.                 InputStream fis = null;  
  99.                 try {  
  100.                     fis = receiver.getInputStream();  
  101.                 } catch (IOException e1) {  
  102.                     return;  
  103.                 }  
  104.                 number = 0;  
  105.                 releaseMediaRecorder();  
  106.                 while (true) {  
  107.                     System.out.println("ok");  
  108.                     try {  
  109.                         num = fis.read(buffer, number, frame_size);  
  110.                         number += num;  
  111.                         if (num < frame_size) {  
  112.                             System.out.println("recoend break");  
  113.                             break;  
  114.                         }  
  115.                     } catch (IOException e) {  
  116.                         System.out.println("exception break");  
  117.                         break;  
  118.                     }  
  119.                 }  
  120.                 initializeVideo();  
  121.                 number = 0;  
  122.                 Consumer consumer = new Publisher();// Publisher继承了Consumer  
  123.                 Thread consumerThread = new Thread((Runnable) consumer);  
  124.                 consumer.setRecording(true);// 设置线程状态;  
  125.                 consumerThread.start();// 开始发布数据流  
  126.                 DataInputStream dis = new DataInputStream(fis);  
  127.                 try {  
  128.                     dis.read(buffer, 0, 32);  
  129.                 } catch (IOException e1) {  
  130.                     e1.printStackTrace();  
  131.                 }  
  132.                 byte[] aa = { 0x01, 0x42, (byte) 0x80, 0x0A, (byte) 0xFF,  
  133.                         (byte) 0xE1, 0x00, 0x12, 0x67, 0x42, (byte) 0x80, 0x0A,  
  134.                         (byte) 0xE9, 0x02, (byte) 0xC1, 0x29, 0x08, 0x00, 0x00,  
  135.                         0x1F, 0x40, 0x00, 0x04, (byte) 0xE2, 0x00, 0x20, 0x01,  
  136.                         0x00, 0x04, 0x68, (byte) 0xCE, 0x3C, (byte) 0x80 };  
  137.                 consumer.putData(System.currentTimeMillis(), aa, 33);  
  138.                 while (true) {  
  139.                     try {  
  140.                         int h264length = dis.readInt();  
  141.                         number = 0;  
  142.                         while (number < h264length) {  
  143.                             int lost = h264length - number;  
  144.                             num = fis.read(buffer, 0,  
  145.                                     frame_size < lost ? frame_size : lost);  
  146.                             number += num;  
  147.                             consumer.putData(System.currentTimeMillis(),  
  148.                                     buffer, num);  
  149.                         }  
  150.                     } catch (IOException e) {  
  151.                         break;  
  152.                     }  
  153.                 }  
  154.                 consumer.setRecording(false);// 设置线程状态;  
  155.             }  
  156.         }).start();  
  157.     }  
  158.   
  159.     private boolean initializeVideo() {  
  160.         System.out.println("initializeVideo");  
  161.         if (mSurfaceHolder == null)  
  162.             return false;  
  163.         mMediaRecorderRecording = true;  
  164.         if (mMediaRecorder == null)  
  165.             mMediaRecorder = new MediaRecorder();  
  166.         else  
  167.             mMediaRecorder.reset();  
  168.         mMediaRecorder.setVideoSource(MediaRecorder.VideoSource.CAMERA);  
  169.         mMediaRecorder.setOutputFormat(MediaRecorder.OutputFormat.THREE_GPP);  
  170.         mMediaRecorder.setVideoFrameRate(20);  
  171.         mMediaRecorder.setVideoSize(352, 288);  
  172.         mMediaRecorder.setVideoEncoder(mVideoEncoder);  
  173.         mMediaRecorder.setPreviewDisplay(mSurfaceHolder.getSurface());  
  174.         mMediaRecorder.setMaxDuration(0);  
  175.         mMediaRecorder.setMaxFileSize(0);  
  176.         mMediaRecorder.setOutputFile(sender.getFileDescriptor());  
  177.         try {  
  178.             mMediaRecorder.setOnInfoListener(this);  
  179.             mMediaRecorder.setOnErrorListener(this);  
  180.             mMediaRecorder.prepare();  
  181.             mMediaRecorder.start();  
  182.         } catch (IOException exception) {  
  183.             releaseMediaRecorder();  
  184.             finish();  
  185.             return false;  
  186.         }  
  187.         return true;  
  188.     }  
  189.   
  190.     private void releaseMediaRecorder() {  
  191.         System.out.println("Releasing media recorder.");  
  192.         if (mMediaRecorder != null) {  
  193.             if (mMediaRecorderRecording) {  
  194.                 try {  
  195.                     mMediaRecorder.setOnErrorListener(null);  
  196.                     mMediaRecorder.setOnInfoListener(null);  
  197.                     mMediaRecorder.stop();  
  198.                 } catch (RuntimeException e) {  
  199.                     System.out.println("stop fail: " + e.getMessage());  
  200.                 }  
  201.                 mMediaRecorderRecording = false;  
  202.             }  
  203.             mMediaRecorder.reset();  
  204.             mMediaRecorder.release();  
  205.             mMediaRecorder = null;  
  206.         }  
  207.     }  
  208.   
  209.     @Override  
  210.     public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {  
  211.         System.out.println("surfaceChanged");  
  212.         mSurfaceHolder = holder;  
  213.         if (!mMediaRecorderRecording) {  
  214.             initializeVideo();  
  215.             startVideoRecording();  
  216.         }  
  217.     }  
  218.   
  219.     @Override  
  220.     public void surfaceCreated(SurfaceHolder holder) {  
  221.         System.out.println("surfaceCreated");  
  222.         mSurfaceHolder = holder;  
  223.     }  
  224.   
  225.     @Override  
  226.     public void surfaceDestroyed(SurfaceHolder holder) {  
  227.         System.out.println("surfaceDestroyed");  
  228.         mSurfaceView = null;  
  229.         mSurfaceHolder = null;  
  230.         mMediaRecorder = null;  
  231.         if (t != null) {  
  232.             t.interrupt();  
  233.         }  
  234.     }  
  235.   
  236.     @Override  
  237.     public void onInfo(MediaRecorder mr, int what, int extra) {  
  238.         switch (what) {  
  239.         case MediaRecorder.MEDIA_RECORDER_INFO_UNKNOWN:  
  240.             System.out.println("MEDIA_RECORDER_INFO_UNKNOWN");  
  241.             break;  
  242.        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();  
        }  
    }  


h264中avc和flv数据的解析

  1. 计算 AVCDecoderConfigurationRecord  得到 CodecPrivateData 数据（只有第一帧需要）；
  2. 计算 NALUs 得到帧数据。

 

计算 AVCDecoderConfigurationRecord  得到 CodecPrivateData 数据

H.264 视频流的CodecPrivateData 实际上就是 AVCDecoderConfigurationRecord 中 SequenceParameterSets（SPS）和 PictureParameterSets（PPS）使用 byte[] {00, 00, 01} 连接的字节数组。

注意！FLV 文件中第一个 VIDEOTAG 的 VIDEODATA 的 AVCVIDEOPACKET 的 Data 总是 AVCDecoderConfigurationRecord（在 ISO/IEC 14496-15 中定义），解码的时候注意跳过这个 VIDOETAG。

 

AVCDecoderConfigurationRecord 结构的定义：

aligned(8) class AVCDecoderConfigurationRecord { 
unsigned int(8) configurationVersion = 1; 
unsigned int(8) AVCProfileIndication; 
unsigned int(8) profile_compatibility; 
unsigned int(8) AVCLevelIndication; 
bit(6) reserved = ‘111111’b; 
unsigned int(2) lengthSizeMinusOne; 
bit(3) reserved = ‘111’b; 
unsigned int(5) numOfSequenceParameterSets; 
for (i=0; i< numOfSequenceParameterSets; i++) { 
unsigned int(16) sequenceParameterSetLength ; 
bit(8*sequenceParameterSetLength) sequenceParameterSetNALUnit; 
} 
unsigned int(8) numOfPictureParameterSets; 
for (i=0; i< numOfPictureParameterSets; i++) { 
unsigned int(16) pictureParameterSetLength; 
bit(8*pictureParameterSetLength) pictureParameterSetNALUnit; 
} 
}

 

下面蓝色的部分就是 FLV 文件中的 AVCDecoderConfigurationRecord 部分。

00000130h: 00 00 00 17 00 00 00 00 01 4D 40 15 FF E1 00 0A ; .........M@.?. 
00000140h: 67 4D 40 15 96 53 01 00 4A 20 01 00 05 68 E9 23 ; gM@.朣..J ...h? 
00000150h: 88 00 00 00 00 2A 08 00 00 52 00 00 00 00 00 00 ; ?...*...R......

 

根据 AVCDecoderConfigurationRecord 结构的定义：

  • configurationVersion = 01
  • AVCProfileIndication = 4D
  • profile_compatibility = 40
  • AVCLevelIndication = 15
  • lengthSizeMinusOne = FF <- 非常重要，是 H.264 视频中 NALU 的长度，计算方法是 1 + (lengthSizeMinusOne & 3)
  • numOfSequenceParameterSets = E1 <- SPS 的个数，计算方法是 numOfSequenceParameterSets & 0x1F
  • sequenceParameterSetLength = 00 0A <- SPS 的长度
  • sequenceParameterSetNALUnits = 67 4D 40 15 96 53 01 00 4A 20 <- SPS
  • numOfPictureParameterSets = 01 <- PPS 的个数
  • pictureParameterSetLength = 00 05 <- PPS 的长度
  • pictureParameterSetNALUnits = 68 E9 23 88 00 <- PPS

 

因此 CodecPrivateData 的字符串表示就是 000001674D4015965301004A2000000168E9238800

 

但是设置 MediaStreamAttributeKeys.CodecPrivateData 是没用的（只有 H.264 是这样，其他类型的视频流仍然需要设置），只有将 CodecPrivateData 写入 H.264 视频流第一帧数据的前面 Silverlight 才能正常解码。

也就是说，Silverlight 的 H.264 解码器会读取第一帧前面的 CodecPrivateData 数据来进行配置。

因为 CodecPrivateData 数据已经包含视频流的解码器参数（包括视频的宽高），所以就不需要设置 MediaStreamAttributeKeys.CodecPrivateData、MediaStreamAttributeKeys.Width 和 MediaStreamAttributeKeys.Height 了。

 

计算 NALU 得到帧数据

FLV 文件中 VIDEOTAG 的 VIDEODATA 的 AVCVIDEOPACKET 的 Data 不是原始视频帧数据，而是一个或更多个 NALU 数据片段。在这篇文章中，你认为 H.264 视频帧数据是由多个 NALU 组成的。当然实际上并不是这样，关于这部分的概念请自行 Google，本文将不做讨论。

 

下面是 FLV 文件中 VIDEOTAG 的 VIDEODATA 的 AVCVIDEOPACKET 的 Data 属性的数据（第一帧数据）。

  • 红色的部分是 NALU 数据的长度，而红色部分的长度则由 lengthSizeMinusOne 决定。
  • 蓝色的部分是 NALU 数据部分。
  • 删除的部分是废弃的数据。

00000300h: 00 00 00 00 00 17 01 00 00 22 00 00 00 31 65 88 ; ........."...1e? 
00000310h: 80 40 05 B7 95 53 67 FF 84 6C 07 EB 00 F8 45 FB ; €@.窌Sg刲.?鳨? 
00000320h: F9 15 71 0D A4 C5 2C 00 00 03 00 00 03 00 3F 2B ; ?q.づ,.......?+ 
00000330h: 5B 06 57 48 29 F4 08 00 00 0A 10 02 D0 7A FE 00 ; [.WH)?.....衵? 
00000340h: 00 00 38 65 01 22 22 01 00 17 B7 95 53 67 FF 84 ; ..8e.""...窌Sg? 
00000350h: 6C 07 EB 00 F8 45 FB F9 15 71 0D A4 C5 2C 00 E8 ; l.?鳨.q.づ,.? 
00000360h: F3 37 75 43 90 00 00 03 00 15 EF AA A8 53 86 01 ; ?uC?....铼⊿? 
00000370h: DD 57 60 00 00 03 01 59 0C F4 3C 00 00 00 33 65 ; 軼`....Y.?...3e 
00000380h: 00 90 88 80 40 05 B7 95 53 67 FF 84 6C 07 EB 00 ; .悎€@.窌Sg刲.? 
00000390h: F8 45 FB F9 15 71 0D A4 C5 2C 00 00 03 00 00 03 ; 鳨.q.づ,...... 
000003a0h: 00 3F 2B 5B 06 57 48 29 F4 08 00 00 0A 10 02 D0 ; .?+[.WH)?.....? 
000003b0h: 7A FE 00 00 00 38 65 00 D8 88 80 40 05 B7 95 53 ; z?..8e.貓€@.窌S 
000003c0h: 67 FF 84 6C 07 EB 00 F8 45 FB F9 15 71 0D A4 C5 ; g刲.?鳨.q.づ 
000003d0h: 2C 00 E8 F3 37 75 43 90 00 00 03 00 15 EF AA A8 ; ,.梵7uC?....铼? 
000003e0h: 53 86 01 DD 57 60 00 00 03 01 59 0C F4 3C 00 00 ; S?軼`....Y.?.. 
000003f0h: 00 F4 08 00 01 33 00 00 17 00 00 00 00 AF 01 27 ; .?..3.......?'

 

帧数据是将多个 NALU 使用 byte[] {00, 00, 01} 连接的字节数组。

 

byte[] = {

00,00,01,65,88, 
80,40,05,B7,95,53,67,FF,84,6C,07,EB,00,F8,45,FB, 
F9,15,71,0D,A4,C5,2C,00,00,03,00,00,03,00,3F,2B, 
5B,06,57,48,29,F4,08,00,00,0A,10,02,D0,7A,FE,

00,00,01,65,01,22,22,01,00,17,B7,95,53,67,FF,84, 
6C,07,EB,00,F8,45,FB,F9,15,71,0D,A4,C5,2C,00,E8, 
F3,37,75,43,90,00,00,03,00,15,EF,AA,A8,53,86,01, 
DD,57,60,00,00,03,01,59,0C,F4,3C,

00,00,01,65, 
00,90,88,80,40,05,B7,95,53,67,FF,84,6C,07,EB,00, 
F8,45,FB,F9,15,71,0D,A4,C5,2C,00,00,03,00,00,03, 
00,3F,2B,5B,06,57,48,29,F4,08,00,00,0A,10,02,D0, 
7A,FE,

00,00,01,65,00,D8,88,80,40,05,B7,95,53, 
67,FF,84,6C,07,EB,00,F8,45,FB,F9,15,71,0D,A4,C5, 
2C,00,E8,F3,37,75,43,90,00,00,03,00,15,EF,AA,A8, 
53,86,01,DD,57,60,00,00,03,01,59,0C,F4,3C

};


如果是第一帧数据，那么前面还要加上 CodecPrivateData 数据。

 

byte[] = {

00,00,01,67,4D,40,15,96,53,01,00,4A,20,

00,00,01,68,E9,23,88,00,

00,00,01,65,88, 
80,40,05,B7,95,53,67,FF,84,6C,07,EB,00,F8,45,FB, 
F9,15,71,0D,A4,C5,2C,00,00,03,00,00,03,00,3F,2B, 
5B,06,57,48,29,F4,08,00,00,0A,10,02,D0,7A,FE,

00,00,01,65,01,22,22,01,00,17,B7,95,53,67,FF,84, 
6C,07,EB,00,F8,45,FB,F9,15,71,0D,A4,C5,2C,00,E8, 
F3,37,75,43,90,00,00,03,00,15,EF,AA,A8,53,86,01, 
DD,57,60,00,00,03,01,59,0C,F4,3C,

00,00,01,65, 
00,90,88,80,40,05,B7,95,53,67,FF,84,6C,07,EB,00, 
F8,45,FB,F9,15,71,0D,A4,C5,2C,00,00,03,00,00,03, 
00,3F,2B,5B,06,57,48,29,F4,08,00,00,0A,10,02,D0, 
7A,FE,

00,00,01,65,00,D8,88,80,40,05,B7,95,53, 
67,FF,84,6C,07,EB,00,F8,45,FB,F9,15,71,0D,A4,C5, 
2C,00,E8,F3,37,75,43,90,00,00,03,00,15,EF,AA,A8, 
53,86,01,DD,57,60,00,00,03,01,59,0C,F4,3C

};


关于h264的avc box中数据的提取。sps pps的获取。

如果你想获取视频中的avc数据，而不要音频的数据，你就需要录制一段不带音频的视频。

录制完成后保存视频，然后用WinHex打开。如果你是手机需要的视频就录制3gp格式。

然后CTRL+F搜索avc.可以看到如图：


把鼠标点击到avc附近，左边也就在01这个数据附近了。

好了avc box的内容就是从01开始，比如上图就是：

{ 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 };

sps信息就是67开头 67-20  pps就是68-80 具体数据意义可以看上篇博客。



+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Android使用VideoView播放RTSP视频


昨天经过编译配置live555MediaServer.exe，然后通过VLC播放rtsp://88.88.88.200:554/1.mp3后，本以为很简单的就可以通过Android的VideoView播放音频。很纠结的提示不支持。

经过一天的搜索，得出了结论。
官方文档：Android Supported Media Formats提到

The following network protocols are supported for audio and video playback:

RTSP (RTP, SDP)
HTTP/HTTPS progressive streaming
HTTP/HTTPS live streaming draft protocol:
MPEG-2 TS media files only
Protocol version 3 (Android 4.0 and above)
Protocol version 2 (Android 3.x)
Not supported before Android 3.0

第一条说明了支持RTSP后面包含了RTP和SDP流。其他的流可能暂时不支持。

而对于网上一个代码例子

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >
    <TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="@string/hello" />
    <VideoView
        android:id="@+id/videoView1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
</LinearLayout>
package com.jouhu.live;
import android.app.Activity;
import android.net.Uri;
import android.os.Bundle;
import android.widget.VideoView;
public class Live555RTSPActivity extends Activity {
    /** Called when the activity is first created. */
    VideoView videoView ;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        videoView = (VideoView)findViewById(R.id.videoView1);
        PlayRtspStream("rtsp://218.204.223.237:554/live/1/66251FC11353191F/e7ooqwcfbqjoo80j.sdp");
    }
    private void PlayRtspStream(String rtspUrl)
    {
        videoView = (VideoView)findViewById(R.id.videoView1);
        videoView.setVideoURI(Uri.parse(rtspUrl));
        videoView.requestFocus();
        videoView.start();
    }
}

从代码编译结果，的确可以显示出来。跟后面使用的SDP应该有关。

然后开始搜索如何生成SDP的问题。
使用FFmpeg可以生成相应的SDP文件，相应的命令行为

F:\AndroidDevelop\LiveVideoSolution\FFmpeg-FFServer\ffmpeg-git-d049257-win32-static\bin>ffmpeg -fflags +genpts -re -i 1.avi -vcodec copy -an -f rtp rtp://127.0.0.1:10000 -vn -acodec copy -f rtp rtp://127.0.0.1:20000 > 2.sdp

SDP:
v=0
o=- 0 0 IN IP4 127.0.0.1
s=No Name
t=0 0
a=tool:libavformat 53.17.0
m=video 10000 RTP/AVP 96
c=IN IP4 127.0.0.1
a=rtpmap:96 H264/90000
a=fmtp:96 packetization-mode=1; sprop-parameter-sets=Z2QAM6w07AgDHlkwEQAAAwPpAAC7gI8YMTg=,aO68sA==
m=audio 20000 RTP/AVP 14
c=IN IP4 127.0.0.1
b=AS:48

参考文章：
1 http://www.cuitu.net/content/ffmpegzai-windowsxia-bu-huo-she-xiang-tou-shi-pin
2 http://developer.android.com/guide/appendix/media-formats.html

 

目前在做视频应用的时候，比较先进的技术就是RTSP流媒体了，那么如果利用Android的播放控件VideoView来播放RTSP的流呢?

RTSP流媒体链接:
http://218.204.223.237:8081/wap/

这个链接含有所有的RTSP流媒体的链接，现在咱们就用VideoView来播放里面的RTSP的流,咱们以其中的一个链接来测试下好了:

rtsp://218.204.223.237:554/live/1/66251FC11353191F/e7ooqwcfbqjoo80j.sdp.

效果截图:

VideoView播放RTSP流

核心代码如下:

  1. package com.video.rtsp;
  2. import android.app.Activity;
  3. import android.net.Uri;
  4. import android.os.Bundle;
  5. import android.view.View;
  6. import android.widget.Button;
  7. import android.widget.EditText;
  8. import android.widget.VideoView;
  9. public class rtspActivity extends Activity {
  10. /** Called when the activity is first created. */
  11. Button playButton ;
  12. VideoView videoView ;
  13. EditText rtspUrl ;
  14. @Override
  15. public void onCreate(Bundle savedInstanceState) {
  16. super.onCreate(savedInstanceState);
  17. setContentView(R.layout.main);
  18. rtspUrl = (EditText)this.findViewById(R.id.url);
  19. playButton = (Button)this.findViewById(R.id.start_play);
  20. playButton.setOnClickListener(new Button.OnClickListener(){
  21. public void onClick(View v) {
  22. PlayRtspStream(rtspUrl.getEditableText().toString());
  23. }
  24. });
  25. videoView = (VideoView)this.findViewById(R.id.rtsp_player);
  26. }
  27. //play rtsp stream
  28. private void PlayRtspStream(String rtspUrl){
  29. videoView.setVideoURI(Uri.parse(rtspUrl));
  30. videoView.requestFocus();
  31. videoView.start();
  32. }
  33. }

复制代码

在点击开始播放后，一般要等个10几秒中才开始播放的，直接的设置需要播放的RTSP的地址:setVideoURI(rtsp的地址)

 VideoViewRtsp.rar (23.4

lonpo 在 2012 年 3 月 17 日下午 3:09 说道：

非常谢谢了，这篇文章给我很大的启示。为什么要使用
rtsp://218.204.223.237:554/live/1/66251FC11353191F/e7ooqwcfbqjoo80j.sdp
而不是rtsp://。。。。.mp4 为什么要后缀sdp呢？不能直接调用视频文件吗？



+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Android用MediaRecorder实现MPEG4视频监控

AndroidSocketHTC网络应用框架
都是摸着石头过河，花了整整一个星期，终于把技术难点给突破了，貌似网上对这个讨论的较少。 

主要需要实现的功能是在android手机上实时采集视频，并在远程比如PC机上实时显示出来，也就是以android手机作为监控摄像头。 

一开始查到的是smartcam的一个开源项目，看了下源代码，发现其实现原理是利用android 的camera图像的预采集，通过实现PreviewCallback类的回调函数onPreviewFrame，获得camera采集的原始图像数据之后，压成jpeg格式传到pc端。pc端对接收到的jpeg图像序列进行实时解压和显示，就达到了预想的效果。 

虽然这种方式稍微显得比较笨拙，这个方式还可以接受。但是不可接受的是jpeg只是帧内压缩，320x280的图片序列，FPS大概是10上下，网络流量就到达了100kb/s以上。这个几乎是无法实际应用的。 

于是必须直接传视频流，MPEG4或者H.264格式。貌似我的开发机上(HTC G8)只支持到MPEG4，所以还是选取MPEG4。但是如何实时采集视频流是一个大问题，毕竟在video方面，android并没有提供一个类似于OnPreviewFrame的回调函数。 

想到用opencore或者更为新一点的stagefright，大概看看了其sdk的框架后，马上泄气了，这个太庞大了。在http://blog.csdn.net/zblue78/archive/2010/12/18/6083374.aspx的帖子中提到一个很好的解决方案，就是利用MediaRecorder：MediaRecorder的输出路径（其实叫file descriptor）除了是本地文件路径之外，还可以绑定socket端口。也就是说，通过一个socket端口，就可以实时获得MediaRecorder的视频流数据。 
（其实上面博客的内容可以在开源项目sipdroid 的 videocamera文件中找到，但是非常感谢博客主人zhangzhenj对网友提问的回答，赞一个。） 

通过socket接收的视频流与直接写在本地文件的视频流数据有点不一样，因为是通过socket传输，就无法对视频文件的回写，通常MediaRecorder结束录像的时候都会对视频文件进行回写处理，这样才可以被播放器播放。所以通过socket接受到的数据，保存下来是无法播放的。16进制方式查看了一下其输出文件，发现其前32byte都是00，紧接着就是mdat。问题就出现在这了：缺少了一个ftyp box 的描述（28 bytes）以及mdat的长度描述(4 bytes).网上已经有人顺利解决这样的问题，在数据中查找moov的起始位置，发现前面会有ftyp的描述，长度刚刚好28bytes。你可以copy这28bytes到文件开始的28byte中。这ftyp的描述是从moov的起始位置 的前32byte开始一直到前4byte(后面4byte是moov的长度描述)。然后mdat的长度就是 moov的起始位置 减去 0x20，道理就不解释了。然后把这个值写到mdat的前面4byte。刚刚好填满32byte，之后就能顺利播放了。 

保存好的文件能播放之后，最后一个问题，如何在实时显示这个视频流呢？查看一下mpeg4的文件格式，很快就会知道答案，答案就在mdat中。mdat之后紧跟的就是视频媒体数据，每一帧以 00 00 01 b6 为开始标志，貌似没有结束标志，分帧的话估计要用这个。开始标志后紧接着的两bit就是I、P、B帧的标志了，分别对应值为00,01,10，记住是两bit不是两byte 

好了，把mdat的一帧数据取出来，可以用ffmpeg解码，然后显示，这样的路子是可行的，不过细节还是有点麻烦，关键是ffmpeg在解码mpeg4的时候一定要先指定width和height，否则解码失败。 

0 0
学日语的游戏知乎 学日语的游戏知乎
原创粉丝点击
热门IT博客
android存储数据的方式android存储数据的方式
数据物理结构原理数据物理结构原理
手机淘宝账号登录不上
手机淘宝领取淘金币
设计软件下载大全
我的世界工业js
为什么淘宝黑搜要四天
三星mac地址怎么修改
毁童年h知世本子图片
网络强国 三步走
淘宝美宝莲有假货吗
用友软件数据怎么恢复
淘宝白菜群怎么弄的
输出数组元素 15 分
java编程思想笔记
linux查看打开的端口
苹果7蜂窝数据上不了网
java tomcat作用
安兔兔数据作假
知乎专栏怎么样
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 毛戈平学化妆多少钱 毛戈平化妆学校在哪里 毛戈平造型化妆学校 重庆毛戈平化妆学校学费 北京毛戈平学校怎么样 北京毛戈平形象设计学校 运城化妆学校 银川化妆学校 韩国化妆学校 maogeping 徐汇化妆培训学校 化妆师技能培训学校 美容化妆师培训 昆明哪个化妆学校好 广东化妆学校 成都化妆培训学校 洛阳化妆学校 成都化妆培训班 佛山化妆学校 济南化妆学校 临汾化妆学校 广州化妆培训学校 北京有名的化妆学校 重庆化妆培训学校 郑州化妆培训学校 上海哪里有化妆学校 西安化妆学校 毛戈平高光粉膏 毛戈平生活妆 毛成语 什么毛什么什么成语 毛的成语 毛开头的成语 什么毛什么血成语 什么毛大什么成语 毛开头的成语接龙 带毛字的成语 毛的成语有哪些 毛字开头的成语 毛字开头的成语接龙 什么毛什么成语

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里