转：H264通过RTMP发布(Red5 wowza测试通过)

最新推荐文章于 2020-12-09 11:21:05 发布
最新推荐文章于 2020-12-09 11:21:05 发布
阅读量188 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmnmtm/article/details/82922109
版权

转：H264通过RTMP发布(Red5 wowza测试通过) - 加菲 - .

 

 

// demo.cpp : 定义控制台应用程序的入口点。   
//   
#include "stdafx.h"   
#include <MqOaI.h>   
extern "C"   
{  
#include "../../common/common.h"   
#include "../../common/cpu.h""   
#include "../../x264.h"   
#include "../../encoder/set.h"   
}  
#include "librtmp/rtmp_sys.h"   
#include "librtmp/log.h"   
#include "librtmp/amf.h"   
#include "CameraDS.h"   
void ConvertYCbCr2BGR(unsigned char *pYUV,unsigned char *pBGR,int iWidth,int iHeight);  
void ConvertRGB2YUV(int w,int h,unsigned char *bmp,unsigned char *yuv);  
int InitSockets()  
{  
#ifdef WIN32   
    WORD version;  
    WSADATA wsaData;  
    version = MAKEWORD(1, 1);  
    return (WSAStartup(version, &wsaData) == 0);  
#else   
    return TRUE;  
#endif   
}  
inline void CleanupSockets()  
{  
#ifdef WIN32   
    WSACleanup();  
#endif   
}  
#define HEX2BIN(a)      (((a)&0x40)?((a)&0xf)+9:((a)&0xf))   
int hex2bin(char *str, char **hex)  
{  
    char *ptr;  
    int i, l = strlen(str);  
    if (l & 1)  
        return 0;  
    *hex = (char *)malloc(l/2);  
    ptr = *hex;  
    if (!ptr)  
        return 0;  
    for (i=0; i<l; i+=2)  
        *ptr++ = (HEX2BIN(str[i]) << 4) | HEX2BIN(str[i+1]);  
    return l/2;  
}  
char * put_byte( char *output, uint8_t nVal )  
{  
    output[0] = nVal;  
    return output+1;  
}  
char * put_be16(char *output, uint16_t nVal )  
{  
    output[1] = nVal & 0xff;  
    output[0] = nVal >> 8;  
    return output+2;  
}  
char * put_be24(char *output,uint32_t nVal )  
{  
    output[2] = nVal & 0xff;  
    output[1] = nVal >> 8;  
    output[0] = nVal >> 16;  
    return output+3;  
}  
char * put_be32(char *output, uint32_t nVal )  
{  
    output[3] = nVal & 0xff;  
    output[2] = nVal >> 8;  
    output[1] = nVal >> 16;  
    output[0] = nVal >> 24;  
    return output+4;  
}  
char *  put_be64( char *output, uint64_t nVal )  
{  
    output=put_be32( output, nVal >> 32 );  
    output=put_be32( output, nVal );  
    return output;  
}  
char * put_amf_string( char *c, const char *str )  
{  
    uint16_t len = strlen( str );  
    c=put_be16( c, len );  
    memcpy(c,str,len);  
    return c+len;  
}  
char * put_amf_double( char *c, double d )  
{  
    *c++ = AMF_NUMBER;  /* type: Number */  
    {  
        unsigned char *ci, *co;  
        ci = (unsigned char *)&d;  
        co = (unsigned char *)c;  
        co[0] = ci[7];  
        co[1] = ci[6];  
        co[2] = ci[5];  
        co[3] = ci[4];  
        co[4] = ci[3];  
        co[5] = ci[2];  
        co[6] = ci[1];  
        co[7] = ci[0];  
    }  
    return c+8;  
}  
int main(int argc, char * argv[])  
{  
    if (argc<2)   
    {  
        RTMP_LogPrintf("RTMP_URL IS NULL!!!/n");  
        //return -1;   
    }  
    if (!InitSockets())  
    {  
        RTMP_LogPrintf("InitSockets Error!/n");  
        return -1;  
    }  
    RTMP_LogPrintf("InitSockets!/n");  
    CoInitialize(NULL);  
    CCameraDS camera;  
    if (!camera.OpenCamera(0,320,240,false))  
    {  
        RTMP_LogPrintf("Open Camera Error/n");  
        return -1;  
    }  
    int nHeight=camera.GetHeight();  
    int nWidth=camera.GetWidth();  
    unsigned char * szRGBBuffer=new unsigned char[nHeight*nWidth * 3];  
    RTMP_LogPrintf("Camera Open Scuess！  Picture Size[%2dx%d]/n",nWidth,nHeight);  
    RTMP_debuglevel = RTMP_LOGINFO;  
    RTMP *r;  
    //char uri[]="rtmp://127.0.0.1/live/test";   
    //char uri[]="rtmp://192.199.15.223/live/test";   
    //char uri[]="rtmp://221.9.244.4/live/jltv";   
    //char uri[]="rtmp://192.199.15.223/oflaDemo/red5StreamDemo";   
    //char uri[]="rtmp://192.199.15.151/live/test";   
    char uri[]="rtmp://127.0.0.1/live/zzj";  
    r= RTMP_Alloc();  
    RTMP_Init(r);  
    RTMP_SetupURL(r, (char*)uri);  
    RTMP_EnableWrite(r);  
    RTMP_Connect(r, NULL);  
    RTMP_ConnectStream(r,0);  
    unsigned char szNalBuffer[1024*32];  
    unsigned char szBodyBuffer[1024*32];  
    x264_nal_t  *p264Nal;  
    int         i264Nal;  
    x264_param_t * p264Param;  
    x264_picture_t * p264Pic;  
    x264_t *p264Handle;   
    p264Param = new x264_param_t();  
    p264Pic  = new x264_picture_t();  
    memset(p264Pic,0,sizeof(x264_picture_t));  
    x264_param_default(p264Param);  //set default param   
    p264Param->i_threads=2;  
    p264Param->i_width   = nWidth;   //set frame width   
    p264Param->i_height  = nHeight;  //set frame height   
    /*baseline level 1.1*/  
    p264Param->b_cabac =0;   
    p264Param->i_bframe =0;  
    p264Param->b_interlaced=0;  
    p264Param->rc.i_rc_method=X264_RC_ABR;//X264_RC_CQP   
    p264Param->i_level_idc=21;  
    p264Param->rc.i_bitrate=200;  
    p264Param->i_fps_num=30;  
    p264Param->i_keyint_max=p264Param->i_fps_num*3;  
    if((p264Handle = x264_encoder_open(p264Param)) == NULL)  
    {  
        fprintf( stderr, "x264_encoder_open failed/n" );  
        return -2;  
    }  
    bs_t bs={0};  
    x264_picture_alloc(p264Pic, X264_CSP_YV12, p264Param->i_width, p264Param->i_height);  
    p264Pic->i_type = X264_TYPE_AUTO;  
    x264_picture_t pic_out;  
    RTMPPacket packet={0};  
    memset(&packet,0,sizeof(RTMPPacket));  
    packet.m_nChannel = 0x04;  
    packet.m_headerType = RTMP_PACKET_SIZE_LARGE;  
    packet.m_nTimeStamp = 0;  
    packet.m_nInfoField2 = r->m_stream_id;  
    packet.m_hasAbsTimestamp = 0;  
    packet.m_body =(char *) szBodyBuffer;  
    char * szTmp=(char *)szBodyBuffer;  
    packet.m_packetType = RTMP_PACKET_TYPE_INFO;  
    szTmp=put_byte(szTmp, AMF_STRING );  
    szTmp=put_amf_string(szTmp, "@setDataFrame" );  
    szTmp=put_byte(szTmp, AMF_STRING );  
    szTmp=put_amf_string(szTmp, "onMetaData" );  
    szTmp=put_byte(szTmp, AMF_OBJECT );  
    szTmp=put_amf_string( szTmp, "author" );  
    szTmp=put_byte(szTmp, AMF_STRING );  
    szTmp=put_amf_string( szTmp, "" );  
    szTmp=put_amf_string( szTmp, "copyright" );  
    szTmp=put_byte(szTmp, AMF_STRING );  
    szTmp=put_amf_string( szTmp, "" );  
    szTmp=put_amf_string( szTmp, "description" );  
    szTmp=put_byte(szTmp, AMF_STRING );  
    szTmp=put_amf_string( szTmp, "" );  
    szTmp=put_amf_string( szTmp, "keywords" );  
    szTmp=put_byte(szTmp, AMF_STRING );  
    szTmp=put_amf_string( szTmp, "" );  
    szTmp=put_amf_string( szTmp, "rating" );  
    szTmp=put_byte(szTmp, AMF_STRING );  
    szTmp=put_amf_string( szTmp, "" );  
    szTmp=put_amf_string( szTmp, "presetname" );  
    szTmp=put_byte(szTmp, AMF_STRING );  
    szTmp=put_amf_string( szTmp, "Custom" );  
    szTmp=put_amf_string( szTmp, "width" );  
    szTmp=put_amf_double( szTmp, p264Param->i_width );  
    szTmp=put_amf_string( szTmp, "width" );  
    szTmp=put_amf_double( szTmp, p264Param->i_width );  
    szTmp=put_amf_string( szTmp, "height" );  
    szTmp=put_amf_double( szTmp, p264Param->i_height );  
    szTmp=put_amf_string( szTmp, "framerate" );  
    szTmp=put_amf_double( szTmp, (double)p264Param->i_fps_num / p264Param->i_fps_den );  
    szTmp=put_amf_string( szTmp, "videocodecid" );  
    szTmp=put_byte(szTmp, AMF_STRING );  
    szTmp=put_amf_string( szTmp, "avc1" );  
    szTmp=put_amf_string( szTmp, "videodatarate" );  
    szTmp=put_amf_double( szTmp, p264Param->rc.i_bitrate );   
    szTmp=put_amf_string( szTmp, "avclevel" );  
    szTmp=put_amf_double( szTmp, p264Param->i_level_idc );   
    szTmp=put_amf_string( szTmp, "avcprofile" );  
    szTmp=put_amf_double( szTmp, 0x42 );   
    szTmp=put_amf_string( szTmp, "videokeyframe_frequency" );  
    szTmp=put_amf_double( szTmp, 3 );   
    szTmp=put_amf_string( szTmp, "" );  
    szTmp=put_byte( szTmp, AMF_OBJECT_END );  
    packet.m_nBodySize=szTmp-(char *)szBodyBuffer;  
    RTMP_SendPacket(r,&packet,1);  
    packet.m_packetType = RTMP_PACKET_TYPE_VIDEO;   /* VIDEO */  
    szBodyBuffer[ 0]=0x17;  
    szBodyBuffer[ 1]=0x00;  
    szBodyBuffer[ 2]=0x00;  
    szBodyBuffer[ 3]=0x00;  
    szBodyBuffer[ 4]=0x00;  
    szBodyBuffer[ 5]=0x01;  
    szBodyBuffer[ 6]=0x42;  
    szBodyBuffer[ 7]=0xC0;  
    szBodyBuffer[ 8]=0x15;  
    szBodyBuffer[ 9]=0x03;  
    szBodyBuffer[10]=0x01;  
    szTmp=(char *)szBodyBuffer+11;  
    short slen=0;  
    bs_init(&bs,szNalBuffer,16);//初始话bs   
    x264_sps_write(&bs, p264Handle->sps);//读取编码器的SPS   
    slen=bs.p-bs.p_start+1;//spslen（short）   
    slen=htons(slen);  
    memcpy(szTmp,&slen,sizeof(short));  
    szTmp+=sizeof(short);  
    *szTmp=0x67;  
    szTmp+=1;  
    memcpy(szTmp,bs.p_start,bs.p-bs.p_start);  
    szTmp+=bs.p-bs.p_start;  
    *szTmp=0x01;  
    szTmp+=1;  
    bs_init(&bs,szNalBuffer,16);//初始话bs   
    x264_pps_write(&bs, p264Handle->pps);//读取编码器的PPS   
    slen=bs.p-bs.p_start+1;//spslen（short）   
    slen=htons(slen);  
    memcpy(szTmp,&slen,sizeof(short));  
    szTmp+=sizeof(short);  
    *szTmp=0x68;  
    szTmp+=1;  
    memcpy(szTmp,bs.p_start,bs.p-bs.p_start);  
    szTmp+=bs.p-bs.p_start;  
    packet.m_nBodySize=szTmp-(char *)szBodyBuffer;  
    RTMP_SendPacket(r,&packet,0);  
    unsigned int nTimes=0;  
    unsigned int oldTick=GetTickCount();  
    unsigned int newTick=0;  
    packet.m_nTimeStamp=0;  
      
    while(true)  
    {  
        szBodyBuffer[ 0]=0x17;  
        szBodyBuffer[ 1]=0x01;  
        szBodyBuffer[ 2]=0x00;  
        szBodyBuffer[ 3]=0x00;  
        szBodyBuffer[ 4]=0x42;  
        unsigned char * szTmp=szBodyBuffer+5;  
        unsigned  char * pNal=szNalBuffer;  
        nTimes++;  
        int nFramsInPack=0;  
        while(true)  
        {  
            nFramsInPack++;  
            unsigned char * pCameraBuf = camera.QueryFrame();  
            if (!pCameraBuf)  
            {  
                return -1;  
            }  
            for(int ii=0;ii<nHeight;ii++)  
            {  
                memcpy(szRGBBuffer+(nWidth*3)*(nHeight-ii-1),pCameraBuf+(nWidth*3)*ii,nWidth*3);  
                //memcpy(pCameraBuf+nWidth*(nHeight-ii-1),pCameraBuf+nWidth*ii,nWidth*3);   
                //memcpy(szLineBuffer,pCameraBuf+nWidth*(nHeight-ii-1),nWidth*3);   
            }  
            ConvertRGB2YUV(nWidth,nHeight,szRGBBuffer,p264Pic->img.plane[0]);  
            //memcpy(p264Pic->img.plane[0],szNalBuffer,nWidth*nHeight);   
            //memcpy(p264Pic->img.plane[1],szNalBuffer+nWidth*nHeight,nWidth*nHeight/4);   
            //memcpy(p264Pic->img.plane[2],szNalBuffer+nWidth*nHeight*5/4,nWidth*nHeight/4);   
            /* 
            int nCount; 
            nCount=fread(p264Pic->img.plane[0],1,176*144,yuv); 
            if (nCount<176*144) 
            { 
            fseek(yuv,SEEK_SET,0); 
            continue; 
            } 
            nCount=fread(p264Pic->img.plane[1],1,176*144/4,yuv); 
            if (nCount<176*144/4) 
            { 
            fseek(yuv,SEEK_SET,0); 
            continue; 
            } 
            nCount=fread(p264Pic->img.plane[2],1,176*144/4,yuv); 
            if (nCount<176*144/4) 
            { 
            fseek(yuv,SEEK_SET,0); 
            continue; 
            } 
            */  
            if( x264_encoder_encode( p264Handle, &p264Nal, &i264Nal, p264Pic ,&pic_out) < 0 )  
            {  
                fprintf( stderr, "x264_encoder_encode failed/n" );  
            }  
            for( int i = 0; i < i264Nal; i++ )  
            {  
                int i_size;  
                int i_data;  
                i_data = 1024*32;  
                if( ( i_size = x264_nal_encode( pNal, &i_data, 1, &p264Nal[i] ) ) > 0 )  
                {  
                    if ((pNal[4]&0x60)==0)  
                    {  
                        continue;  
                    }  
                    if (pNal[4]==0x67)  
                    {  
                        continue;  
                    }  
                    if (pNal[4]==0x68)  
                    {  
                        continue;  
                    }  
                    memmove(pNal,pNal+4,i_size-4);  
                    pNal+=i_size-4;  
                }  
                else if( i_size < 0 )  
                {  
                    fprintf( stderr,"need to increase buffer size (size=%d)/n", -i_size );  
                }  
            }  
            unsigned int nSize=pNal-szNalBuffer;  
            packet.m_nBodySize=nSize+9;  
            if (i264Nal>1)  
            {  
                szBodyBuffer[ 0]=0x17;  
            }  
            else  
            {  
                szBodyBuffer[ 0]=0x27;  
            }  
            put_be32((char *)szBodyBuffer+5,nSize);  
            memcpy(szBodyBuffer+9,szNalBuffer,pNal-szNalBuffer);  
            RTMP_SendPacket(r,&packet,0);  
            Sleep(20);  
            newTick=GetTickCount();  
            //RTMP_LogStatus("/rInfo NAUL Type:0x%02x size: %5d Tick:%03d %03d",szNalBuffer[0], nSize,33-nSleep,GetTickCount()-oldTick+nSleep);   
            packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;  
            packet.m_nTimeStamp+=newTick-oldTick;  
            oldTick=newTick;  
            break;  
        }  
    }  
    return 0;  
}  

wmnmtm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
推送h264流到red5服务器
07-19
h264测试文件，通过rtmpdump库推送到red5服务器
RTMP中FLV流到标准h264、aac的转换
10-11 3823
一、分析FLV数据     我们先拿一个flv文件来简单分析一下flv数据的格式     flv标准文档下载地址http://www.cnblogs.com/chef/archive/2012/07/18/2597003.html     flv文件分析器flvprase下载地址http://www.cnblogs.com/chef/archive/2012/07/18/2596
将H.264使用RTMP打包后发送给RED5/FMS进行实时发布
++ の 博客
02-25 7696
需要从硬压卡上获取的NALU封装成RTMP协议格式发送给RED5/FMS进行实时发布. RTMP中传送 H.264使用的视频封装格式既是 FLV规范 中的 VideoTag Frame Type UB [4] Type of video frame. The following values are defined:1 = key frame (for AVC, a seekable frame)
H264通过RTMP发布 V2.0 (Red5 Wowza 测试通过）
代码人生
05-09 1万+
直接上代码// demo.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include extern "C" { #include "../../common/common.h" #include "../../common/cpu.h"" #include "../../x264.h" #include "../../encoder/set.h" } #include "librtmp/rtmp_sys.h" #include "li
poor-man-transcoder:用于red5 wowza（基于Java的rtmp服务器）的实时流转码器
05-08
ffmpeg代码转换器 用于red5 / wowza（基于Java的rtmp服务器）的实时流的转码器 该项目 ffmpeg转码器是一个旨在为基于Java的rtmp服务器构建cli包装器计划的Maven项目。 该项目的目的是模仿流行的标准并创建一个自然的用户友好的外部转码系统，这将打开很多可能性，例如： 多比特率转码 多比特率hls转码 重新广播 将流记录到文件 广播文件流 转换文件到文件 将视频/音频过滤器应用于实时流 将视频/音频过滤器应用于录制的文件 将徽标添加到实时流 将徽标添加到录制的文件 多得多.... 该系统最好的部分是：“只需很少的编程就可以使您的转码过程继续进行” 概述 使用的库（依赖项） slf4j-simple-记录框架 commons-exec-命令行执行程序 commons-chain-命令链接实用程序 validation-api-自定义验证 hiberna
H264通过RTMP发布
08-25
在网上找到的将h264通过rtmp发布到flash media server。Red5 Wowza 测试通过。该代码使用到了x264和librtmp。如果要编译该源码，请先配置好x264和librtmp。
red5-server
10-09
Red5 Server支持RTMP，可以作为内容发布者与Flash Player之间的桥梁，使得用户可以通过Flash Player观看直播或点播内容。 2. **HLS协议**：HLS是由Apple公司提出的一种基于HTTP的流媒体网络传输协议，适合于移动...
red5-rtmp-push-master.zip
12-05
4. **RTMP推送**：处理完视频流并进行人脸识别后，项目将结果推送到支持RTMP（Real-Time Messaging Protocol）的流媒体服务器，如Red5、Wowza或Adobe Flash Media Server。RTMP是一种广泛应用于直播和点播服务的协议...
轻新视频录播程序，H264/AAC录制视音频，保存FLV，支持RTMP直播
05-29
本程序可以把摄像头视频和麦克风音频，录制为FLV文件，视频压缩采用H.264编码，音频压缩采用AAC编码，支持同步进行RTMP直播（服务器端需要FMS/WOWZA/RED5等）。可选择码率、分辨率、帧率、关键帧间隔等信息。1号教室...
基于Flex的实时H.264流转发平台之流转发服务端(Red5)
chenxupro的专栏
10-04 2290
这一篇实现流转发服务端，代码很简单，主要目的就是在red5中增加一个名为live的服务。 只需要在Red5安装目录的webapps文件夹下创建一个名为live的文件夹，再创建一个WEB-INF文件夹，里面放置服务相关的描述信息文件即可。 这里需要三个文件red5-web.properties+red5-web.xml+web.xml。 red5-web.properties的内容为：
RED5流媒体服务器（解压直接运行即可）
11-03
基于Flash的流媒体服务的一款基于Java的开源流媒体服务器
OpenCV图像视频采集 DirectShow 64位32位库
03-13
包含DirectShow 的依赖文件和库，64位、32位均有，以及CameraDS.h,CameraDS.cpp。用于基于opencv的摄像头/相机图像、视频采集程序，或将原X86平台程序移植至X64平台。 实践发现此DirectShow +CameraDS方法相比OpenCV自带videocapture 类在速度上快得多。
H264视频通过RTMP直播
heng615975867的专栏
03-20 9842
前面的文章中提到了通过RTSP（Real Time Streaming Protocol）的方式来实现视频的直播，但RTSP方式的一个弊端是如果需要支持客户端通过网页来访问，就需要在在页面中嵌入一个ActiveX控件，而ActiveX一般都需要签名才能正常使用，否则用户在使用时还需要更改浏览器设置，并且ActiveX还只支持IE内核的浏览器，Chrome、FireFox需要IE插件才能运行，因此会
red5使用教程
热门推荐
一万年太久 - 只争朝夕
04-08 1万+
首先是对red5的一个简单介绍，此处主要介绍关键点： Red5 是一个开源服务器用Java编写的,它支持: 流媒体视频(FLV F4V、MP4、3 gp)， 流式音频(MP3、F4A M4A格式,AAC)， 记录客户端流(AVC + AAC FLV容器)， 共享对象 直播发布 远程处理 RTMP协议:RTMP RTMPT,RTMPE 支持的插件有： WebSocke
FMS/wowza/red5/SRS流媒体服务器产品对比
阿酷tony
11-06 4898
一、FMS(AMS)流媒体服务器介绍： 二、wowza流媒体服务器介绍： 三、red5流媒体服务器介绍： 四、SRS流媒体服务器介绍：
ffmpeg java 实时视频流转码（ffmpeg-cli-wrapper）
gk
04-23 9624
开源地址https://github.com/bramp/ffmpeg-cli-wrapper 由于java部分关于ffmpeg的代码处理较少，本来是开子线程通过模拟命令行环境输入命令来实时视频流转码及视频流截取保存文件，由于无法在保存文件之后关闭线程，后使用该开源组件重构（虽然也是模拟命令行的方式，但是在线程的处理上会比自己手写更加精细），开贴记录下使用过程 pom导入及window...
python推流_树莓派使用python-librtmp实现rtmp推流h264的方法
weixin_39883065的博客
12-09 519
目的是能使用Python进行rtmp推流，方便在h264帧里加入弹幕等操作。librtmp使用的是0.3.0，使用树莓派noir官方摄像头适配的。通过wireshark抓ffmpeg的包一点点改动，最终可以在red5和斗鱼上推流了。没怎么写过python，有不恰当的地方请包涵。上代码：# -- coding: utf-8 --# http://blog.csdn.net/luhangleiimpo...
vod电影资源机器人 2010元旦第二版
weixin_33762130的博客
01-01 2905
程序演示图片http://vod.ahxh.info/vod.jpg 下载地址 http://www.236400.ah.cn/vod.rar下载地址 http://www.ahxh.info/vod.rar下载地址 http://bbs.dmnico.cn/vod.rar 国内知名×××站分流下载（以下地址下载的版本为1.2 最新版请关注程序官方论坛） ： ...
搭建rtmp流媒体服务器过程中遇到的又一个小问题
zxw_tiantan的博客
12-15 2198
rtmp流媒体服务器url地址的一般格式： rtmp://服务器IP地址/应用名称/流名称 其中，应用名称在相应的conf文件中定义，流名称可以没有，也可以任意指定一个，只要保证收流地址和推流地址一致即可。 比如： rtmp://1.2.3.4/live/mylive rtmp://1.2.3.4/live 发现以下问题： 1）在Win7环境下搭建的rtmp服
rtmp转gb28181
最新发布
04-28
比如可以使用第三方的流媒体服务器软件，如 Wowza、Nginx-rtmp、Red5 等，在服务器上部署这些软件，然后将 RTMP 视频流推送到服务器上，再使用转码器将 RTMP 流转换为 GB28181 格式的流，最后再将 GB28181 流推送到...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值