H264通过RTMP发布 V2.0 (Red5 Wowza 测试通过）

最新推荐文章于 2017-11-06 15:14:05 发布
最新推荐文章于 2017-11-06 15:14:05 发布
阅读量782 收藏
点赞数
分类专栏： H264

直接上代码

 

[cpp]  view plain copy
  1. // demo.cpp : 定义控制台应用程序的入口点。  
  2. //  
  3. #include "stdafx.h"  
  4. #include <MqOaI.h>  
  5. extern "C"   
  6. {  
  7. #include "../../common/common.h"  
  8. #include "../../common/cpu.h""  
  9. #include "../../x264.h"  
  10. #include "../../encoder/set.h"  
  11. }  
  12. #include "librtmp/rtmp_sys.h"  
  13. #include "librtmp/log.h"  
  14. #include "librtmp/amf.h"  
  15. #include "CameraDS.h"  
  16. void ConvertYCbCr2BGR(unsigned char *pYUV,unsigned char *pBGR,int iWidth,int iHeight);  
  17. void ConvertRGB2YUV(int w,int h,unsigned char *bmp,unsigned char *yuv);  
  18. int InitSockets()  
  19. {  
  20. #ifdef WIN32  
  21.     WORD version;  
  22.     WSADATA wsaData;  
  23.     version = MAKEWORD(1, 1);  
  24.     return (WSAStartup(version, &wsaData) == 0);  
  25. #else  
  26.     return TRUE;  
  27. #endif  
  28. }  
  29. inline void CleanupSockets()  
  30. {  
  31. #ifdef WIN32  
  32.     WSACleanup();  
  33. #endif  
  34. }  
  35. #define HEX2BIN(a)      (((a)&0x40)?((a)&0xf)+9:((a)&0xf))  
  36. int hex2bin(char *str, char **hex)  
  37. {  
  38.     char *ptr;  
  39.     int i, l = strlen(str);  
  40.     if (l & 1)  
  41.         return 0;  
  42.     *hex = (char *)malloc(l/2);  
  43.     ptr = *hex;  
  44.     if (!ptr)  
  45.         return 0;  
  46.     for (i=0; i<l; i+=2)  
  47.         *ptr++ = (HEX2BIN(str[i]) << 4) | HEX2BIN(str[i+1]);  
  48.     return l/2;  
  49. }  
  50. char * put_byte( char *output, uint8_t nVal )  
  51. {  
  52.     output[0] = nVal;  
  53.     return output+1;  
  54. }  
  55. char * put_be16(char *output, uint16_t nVal )  
  56. {  
  57.     output[1] = nVal & 0xff;  
  58.     output[0] = nVal >> 8;  
  59.     return output+2;  
  60. }  
  61. char * put_be24(char *output,uint32_t nVal )  
  62. {  
  63.     output[2] = nVal & 0xff;  
  64.     output[1] = nVal >> 8;  
  65.     output[0] = nVal >> 16;  
  66.     return output+3;  
  67. }  
  68. char * put_be32(char *output, uint32_t nVal )  
  69. {  
  70.     output[3] = nVal & 0xff;  
  71.     output[2] = nVal >> 8;  
  72.     output[1] = nVal >> 16;  
  73.     output[0] = nVal >> 24;  
  74.     return output+4;  
  75. }  
  76. char *  put_be64( char *output, uint64_t nVal )  
  77. {  
  78.     output=put_be32( output, nVal >> 32 );  
  79.     output=put_be32( output, nVal );  
  80.     return output;  
  81. }  
  82. char * put_amf_string( char *c, const char *str )  
  83. {  
  84.     uint16_t len = strlen( str );  
  85.     c=put_be16( c, len );  
  86.     memcpy(c,str,len);  
  87.     return c+len;  
  88. }  
  89. char * put_amf_double( char *c, double d )  
  90. {  
  91.     *c++ = AMF_NUMBER;  /* type: Number */  
  92.     {  
  93.         unsigned char *ci, *co;  
  94.         ci = (unsigned char *)&d;  
  95.         co = (unsigned char *)c;  
  96.         co[0] = ci[7];  
  97.         co[1] = ci[6];  
  98.         co[2] = ci[5];  
  99.         co[3] = ci[4];  
  100.         co[4] = ci[3];  
  101.         co[5] = ci[2];  
  102.         co[6] = ci[1];  
  103.         co[7] = ci[0];  
  104.     }  
  105.     return c+8;  
  106. }  
  107. int main(int argc, char * argv[])  
  108. {  
  109.     if (argc<2)   
  110.     {  
  111.         RTMP_LogPrintf("RTMP_URL IS NULL!!!/n");  
  112.         //return -1;  
  113.     }  
  114.     if (!InitSockets())  
  115.     {  
  116.         RTMP_LogPrintf("InitSockets Error!/n");  
  117.         return -1;  
  118.     }  
  119.     RTMP_LogPrintf("InitSockets!/n");  
  120.     CoInitialize(NULL);  
  121.     CCameraDS camera;  
  122.     if (!camera.OpenCamera(0,320,240,false))  
  123.     {  
  124.         RTMP_LogPrintf("Open Camera Error/n");  
  125.         return -1;  
  126.     }  
  127.     int nHeight=camera.GetHeight();  
  128.     int nWidth=camera.GetWidth();  
  129.     unsigned char * szRGBBuffer=new unsigned char[nHeight*nWidth * 3];  
  130.     RTMP_LogPrintf("Camera Open Scuess！  Picture Size[%2dx%d]/n",nWidth,nHeight);  
  131.     RTMP_debuglevel = RTMP_LOGINFO;  
  132.     RTMP *r;  
  133.     //char uri[]="rtmp://127.0.0.1/live/test";  
  134.     //char uri[]="rtmp://192.199.15.223/live/test";  
  135.     //char uri[]="rtmp://221.9.244.4/live/jltv";  
  136.     //char uri[]="rtmp://192.199.15.223/oflaDemo/red5StreamDemo";  
  137.     //char uri[]="rtmp://192.199.15.151/live/test";  
  138.     char uri[]="rtmp://127.0.0.1/live/zzj";  
  139.     r= RTMP_Alloc();  
  140.     RTMP_Init(r);  
  141.     RTMP_SetupURL(r, (char*)uri);  
  142.     RTMP_EnableWrite(r);  
  143.     RTMP_Connect(r, NULL);  
  144.     RTMP_ConnectStream(r,0);  
  145.     unsigned char szNalBuffer[1024*32];  
  146.     unsigned char szBodyBuffer[1024*32];  
  147.     x264_nal_t  *p264Nal;  
  148.     int         i264Nal;  
  149.     x264_param_t * p264Param;  
  150.     x264_picture_t * p264Pic;  
  151.     x264_t *p264Handle;   
  152.     p264Param = new x264_param_t();  
  153.     p264Pic  = new x264_picture_t();  
  154.     memset(p264Pic,0,sizeof(x264_picture_t));  
  155.     x264_param_default(p264Param);  //set default param  
  156.     p264Param->i_threads=2;  
  157.     p264Param->i_width   = nWidth;   //set frame width  
  158.     p264Param->i_height  = nHeight;  //set frame height  
  159.     /*baseline level 1.1*/  
  160.     p264Param->b_cabac =0;   
  161.     p264Param->i_bframe =0;  
  162.     p264Param->b_interlaced=0;  
  163.     p264Param->rc.i_rc_method=X264_RC_ABR;//X264_RC_CQP  
  164.     p264Param->i_level_idc=21;  
  165.     p264Param->rc.i_bitrate=200;  
  166.     p264Param->i_fps_num=30;  
  167.     p264Param->i_keyint_max=p264Param->i_fps_num*3;  
  168.     if((p264Handle = x264_encoder_open(p264Param)) == NULL)  
  169.     {  
  170.         fprintf( stderr, "x264_encoder_open failed/n" );  
  171.         return -2;  
  172.     }  
  173.     bs_t bs={0};  
  174.     x264_picture_alloc(p264Pic, X264_CSP_YV12, p264Param->i_width, p264Param->i_height);  
  175.     p264Pic->i_type = X264_TYPE_AUTO;  
  176.     x264_picture_t pic_out;  
  177.     RTMPPacket packet={0};  
  178.     memset(&packet,0,sizeof(RTMPPacket));  
  179.     packet.m_nChannel = 0x04;  
  180.     packet.m_headerType = RTMP_PACKET_SIZE_LARGE;  
  181.     packet.m_nTimeStamp = 0;  
  182.     packet.m_nInfoField2 = r->m_stream_id;  
  183.     packet.m_hasAbsTimestamp = 0;  
  184.     packet.m_body =(char *) szBodyBuffer;  
  185.     char * szTmp=(char *)szBodyBuffer;  
  186.     packet.m_packetType = RTMP_PACKET_TYPE_INFO;  
  187.     szTmp=put_byte(szTmp, AMF_STRING );  
  188.     szTmp=put_amf_string(szTmp, "@setDataFrame" );  
  189.     szTmp=put_byte(szTmp, AMF_STRING );  
  190.     szTmp=put_amf_string(szTmp, "onMetaData" );  
  191.     szTmp=put_byte(szTmp, AMF_OBJECT );  
  192.     szTmp=put_amf_string( szTmp, "author" );  
  193.     szTmp=put_byte(szTmp, AMF_STRING );  
  194.     szTmp=put_amf_string( szTmp, "" );  
  195.     szTmp=put_amf_string( szTmp, "copyright" );  
  196.     szTmp=put_byte(szTmp, AMF_STRING );  
  197.     szTmp=put_amf_string( szTmp, "" );  
  198.     szTmp=put_amf_string( szTmp, "description" );  
  199.     szTmp=put_byte(szTmp, AMF_STRING );  
  200.     szTmp=put_amf_string( szTmp, "" );  
  201.     szTmp=put_amf_string( szTmp, "keywords" );  
  202.     szTmp=put_byte(szTmp, AMF_STRING );  
  203.     szTmp=put_amf_string( szTmp, "" );  
  204.     szTmp=put_amf_string( szTmp, "rating" );  
  205.     szTmp=put_byte(szTmp, AMF_STRING );  
  206.     szTmp=put_amf_string( szTmp, "" );  
  207.     szTmp=put_amf_string( szTmp, "presetname" );  
  208.     szTmp=put_byte(szTmp, AMF_STRING );  
  209.     szTmp=put_amf_string( szTmp, "Custom" );  
  210.     szTmp=put_amf_string( szTmp, "width" );  
  211.     szTmp=put_amf_double( szTmp, p264Param->i_width );  
  212.     szTmp=put_amf_string( szTmp, "width" );  
  213.     szTmp=put_amf_double( szTmp, p264Param->i_width );  
  214.     szTmp=put_amf_string( szTmp, "height" );  
  215.     szTmp=put_amf_double( szTmp, p264Param->i_height );  
  216.     szTmp=put_amf_string( szTmp, "framerate" );  
  217.     szTmp=put_amf_double( szTmp, (double)p264Param->i_fps_num / p264Param->i_fps_den );  
  218.     szTmp=put_amf_string( szTmp, "videocodecid" );  
  219.     szTmp=put_byte(szTmp, AMF_STRING );  
  220.     szTmp=put_amf_string( szTmp, "avc1" );  
  221.     szTmp=put_amf_string( szTmp, "videodatarate" );  
  222.     szTmp=put_amf_double( szTmp, p264Param->rc.i_bitrate );   
  223.     szTmp=put_amf_string( szTmp, "avclevel" );  
  224.     szTmp=put_amf_double( szTmp, p264Param->i_level_idc );   
  225.     szTmp=put_amf_string( szTmp, "avcprofile" );  
  226.     szTmp=put_amf_double( szTmp, 0x42 );   
  227.     szTmp=put_amf_string( szTmp, "videokeyframe_frequency" );  
  228.     szTmp=put_amf_double( szTmp, 3 );   
  229.     szTmp=put_amf_string( szTmp, "" );  
  230.     szTmp=put_byte( szTmp, AMF_OBJECT_END );  
  231.     packet.m_nBodySize=szTmp-(char *)szBodyBuffer;  
  232.     RTMP_SendPacket(r,&packet,1);  
  233.     packet.m_packetType = RTMP_PACKET_TYPE_VIDEO;   /* VIDEO */  
  234.     szBodyBuffer[ 0]=0x17;  
  235.     szBodyBuffer[ 1]=0x00;  
  236.     szBodyBuffer[ 2]=0x00;  
  237.     szBodyBuffer[ 3]=0x00;  
  238.     szBodyBuffer[ 4]=0x00;  
  239.     szBodyBuffer[ 5]=0x01;  
  240.     szBodyBuffer[ 6]=0x42;  
  241.     szBodyBuffer[ 7]=0xC0;  
  242.     szBodyBuffer[ 8]=0x15;  
  243.     szBodyBuffer[ 9]=0x03;  
  244.     szBodyBuffer[10]=0x01;  
  245.     szTmp=(char *)szBodyBuffer+11;  
  246.     short slen=0;  
  247.     bs_init(&bs,szNalBuffer,16);//初始话bs  
  248.     x264_sps_write(&bs, p264Handle->sps);//读取编码器的SPS  
  249.     slen=bs.p-bs.p_start+1;//spslen（short）  
  250.     slen=htons(slen);  
  251.     memcpy(szTmp,&slen,sizeof(short));  
  252.     szTmp+=sizeof(short);  
  253.     *szTmp=0x67;  
  254.     szTmp+=1;  
  255.     memcpy(szTmp,bs.p_start,bs.p-bs.p_start);  
  256.     szTmp+=bs.p-bs.p_start;  
  257.     *szTmp=0x01;  
  258.     szTmp+=1;  
  259.     bs_init(&bs,szNalBuffer,16);//初始话bs  
  260.     x264_pps_write(&bs, p264Handle->pps);//读取编码器的PPS  
  261.     slen=bs.p-bs.p_start+1;//spslen（short）  
  262.     slen=htons(slen);  
  263.     memcpy(szTmp,&slen,sizeof(short));  
  264.     szTmp+=sizeof(short);  
  265.     *szTmp=0x68;  
  266.     szTmp+=1;  
  267.     memcpy(szTmp,bs.p_start,bs.p-bs.p_start);  
  268.     szTmp+=bs.p-bs.p_start;  
  269.     packet.m_nBodySize=szTmp-(char *)szBodyBuffer;  
  270.     RTMP_SendPacket(r,&packet,0);  
  271.     unsigned int nTimes=0;  
  272.     unsigned int oldTick=GetTickCount();  
  273.     unsigned int newTick=0;  
  274.     packet.m_nTimeStamp=0;  
  275.       
  276.     while(true)  
  277.     {  
  278.         szBodyBuffer[ 0]=0x17;  
  279.         szBodyBuffer[ 1]=0x01;  
  280.         szBodyBuffer[ 2]=0x00;  
  281.         szBodyBuffer[ 3]=0x00;  
  282.         szBodyBuffer[ 4]=0x42;  
  283.         unsigned char * szTmp=szBodyBuffer+5;  
  284.         unsigned  char * pNal=szNalBuffer;  
  285.         nTimes++;  
  286.         int nFramsInPack=0;  
  287.         while(true)  
  288.         {  
  289.             nFramsInPack++;  
  290.             unsigned char * pCameraBuf = camera.QueryFrame();  
  291.             if (!pCameraBuf)  
  292.             {  
  293.                 return -1;  
  294.             }  
  295.             for(int ii=0;ii<nHeight;ii++)  
  296.             {  
  297.                 memcpy(szRGBBuffer+(nWidth*3)*(nHeight-ii-1),pCameraBuf+(nWidth*3)*ii,nWidth*3);  
  298.                 //memcpy(pCameraBuf+nWidth*(nHeight-ii-1),pCameraBuf+nWidth*ii,nWidth*3);  
  299.                 //memcpy(szLineBuffer,pCameraBuf+nWidth*(nHeight-ii-1),nWidth*3);  
  300.             }  
  301.             ConvertRGB2YUV(nWidth,nHeight,szRGBBuffer,p264Pic->img.plane[0]);  
  302.             //memcpy(p264Pic->img.plane[0],szNalBuffer,nWidth*nHeight);  
  303.             //memcpy(p264Pic->img.plane[1],szNalBuffer+nWidth*nHeight,nWidth*nHeight/4);  
  304.             //memcpy(p264Pic->img.plane[2],szNalBuffer+nWidth*nHeight*5/4,nWidth*nHeight/4);  
  305.             /* 
  306.             int nCount; 
  307.             nCount=fread(p264Pic->img.plane[0],1,176*144,yuv); 
  308.             if (nCount<176*144) 
  309.             { 
  310.             fseek(yuv,SEEK_SET,0); 
  311.             continue; 
  312.             } 
  313.             nCount=fread(p264Pic->img.plane[1],1,176*144/4,yuv); 
  314.             if (nCount<176*144/4) 
  315.             { 
  316.             fseek(yuv,SEEK_SET,0); 
  317.             continue; 
  318.             } 
  319.             nCount=fread(p264Pic->img.plane[2],1,176*144/4,yuv); 
  320.             if (nCount<176*144/4) 
  321.             { 
  322.             fseek(yuv,SEEK_SET,0); 
  323.             continue; 
  324.             } 
  325.             */  
  326.             if( x264_encoder_encode( p264Handle, &p264Nal, &i264Nal, p264Pic ,&pic_out) < 0 )  
  327.             {  
  328.                 fprintf( stderr, "x264_encoder_encode failed/n" );  
  329.             }  
  330.             for( int i = 0; i < i264Nal; i++ )  
  331.             {  
  332.                 int i_size;  
  333.                 int i_data;  
  334.                 i_data = 1024*32;  
  335.                 if( ( i_size = x264_nal_encode( pNal, &i_data, 1, &p264Nal[i] ) ) > 0 )  
  336.                 {  
  337.                     if ((pNal[4]&0x60)==0)  
  338.                     {  
  339.                         continue;  
  340.                     }  
  341.                     if (pNal[4]==0x67)  
  342.                     {  
  343.                         continue;  
  344.                     }  
  345.                     if (pNal[4]==0x68)  
  346.                     {  
  347.                         continue;  
  348.                     }  
  349.                     memmove(pNal,pNal+4,i_size-4);  
  350.                     pNal+=i_size-4;  
  351.                 }  
  352.                 else if( i_size < 0 )  
  353.                 {  
  354.                     fprintf( stderr,"need to increase buffer size (size=%d)/n", -i_size );  
  355.                 }  
  356.             }  
  357.             unsigned int nSize=pNal-szNalBuffer;  
  358.             packet.m_nBodySize=nSize+9;  
  359.             if (i264Nal>1)  
  360.             {  
  361.                 szBodyBuffer[ 0]=0x17;  
  362.             }  
  363.             else  
  364.             {  
  365.                 szBodyBuffer[ 0]=0x27;  
  366.             }  
  367.             put_be32((char *)szBodyBuffer+5,nSize);  
  368.             memcpy(szBodyBuffer+9,szNalBuffer,pNal-szNalBuffer);  
  369.             RTMP_SendPacket(r,&packet,0);  
  370.             Sleep(20);  
  371.             newTick=GetTickCount();  
  372.             //RTMP_LogStatus("/rInfo NAUL Type:0x%02x size: %5d Tick:%03d %03d",szNalBuffer[0], nSize,33-nSleep,GetTickCount()-oldTick+nSleep);  
  373.             packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;  
  374.             packet.m_nTimeStamp+=newTick-oldTick;  
  375.             oldTick=newTick;  
  376.             break;  
  377.         }  
  378.     }  
  379.     return 0;  
  380. }  
 

 



原作者出处 http://blog.csdn.net/zblue78/article/details/6406707/

cityhunter2008
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
red5使用教程
一万年太久 - 只争朝夕
04-08 1万+
首先是对red5的一个简单介绍，此处主要介绍关键点： Red5 是一个开源服务器用Java编写的,它支持: 流媒体视频(FLV F4V、MP4、3 gp)， 流式音频(MP3、F4A M4A格式,AAC)， 记录客户端流(AVC + AAC FLV容器)， 共享对象 直播发布 远程处理 RTMP协议:RTMP RTMPT,RTMPE 支持的插件有： WebSocke
h264视频流可用于rtmp和rtsp推流测试
09-13
1、本视频流为h264编码，流来源为海康摄像头。 2、本视频播放时长为3分03秒，几乎可以满足所有测试需要。 3、本视频以原有电影为素材进行剪辑加工而成。 4、本视频分辨率为：1920*1080，帧率为25。 5、本视频下载...
推送h264流到red5服务器
07-19
h264测试文件，通过rtmpdump库推送到red5服务器
转：H264通过RTMP发布(Red5 wowza测试通过)
wmnmtm的专栏
10-07 180
    // demo.cpp : 定义控制台应用程序的入口点。   //   #include "stdafx.h"   #include &lt;MqOaI.h&gt;   extern "C"   {  #include "../../common/common.h"   #include "../../common/cpu.h""   #include "../../x26
H264视频通过RTMP直播
heng615975867的专栏
03-20 9758
前面的文章中提到了通过RTSP（Real Time Streaming Protocol）的方式来实现视频的直播，但RTSP方式的一个弊端是如果需要支持客户端通过网页来访问，就需要在在页面中嵌入一个ActiveX控件，而ActiveX一般都需要签名才能正常使用，否则用户在使用时还需要更改浏览器设置，并且ActiveX还只支持IE内核的浏览器，Chrome、FireFox需要IE插件才能运行，因此会
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。
h264文件通过rtmp发布
06-22
将h264裸流封装成flv格式后，通过rtmp协议发布到rtmp流服务器
通过RTMP播放H265 H264 OCX控件
11-21
通过RTMP播放H265,H264控件，最多支持十六路窗口，接口丰富。VC,VB,网页，.net都能调用
h264-to-rtmp.copy-frame
02-20
使用了FFmpeg SDK的最新版实现； 能完整地逐帧读取h.264的码流文件， 并帧数据复制的模式封装成RTMP流并推送； 有详细的代码注释； 亲测可用，很方便整合到生产工程中；
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 类在速度上快得多。
通过rtmpdump推送海康视频流到red5服务器
Mtour's blog
10-10 7399
现在主流的网络摄像机都支持标准H264视频格式，例如 海康网络摄像机， 通过海康提供的网络SDK可以获取到视频码流。我测试的这款相机，视频编码采用的是H264，音频编码采用的是G711a。 这里，我仅测试了视频。 通过海康SDK获取到视频流为PS流，根据PS协议格式，抽取其中的H264帧数据，SPS PPS 信息。             推送RTMP流采用开源库 rtmpdump， RTM
FMS/wowza/red5/SRS流媒体服务器产品对比
阿酷tony
11-06 4632
一、FMS(AMS)流媒体服务器介绍： 二、wowza流媒体服务器介绍： 三、red5流媒体服务器介绍： 四、SRS流媒体服务器介绍：
node-v14.17.3-darwin-x64.tar.xz
04-22
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
c语言UDP传输系统源码.rar
04-22
c语言UDP传输系统源码.rar
node-v16.2.0-darwin-x64.tar.xz
最新发布
04-22
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
基于matlab多目标遗传算法matlab程序.rar
04-22
基于matlab多目标遗传算法matlab程序.rar
ffmpeg 推流RTMP流为h264/PCMU
02-24
下面是使用FFmpeg推流RTMP流为h264/PCMU的步骤： 1. 安装FFmpeg：首先需要在你的系统上安装FFmpeg。你可以从FFmpeg官方网站下载并按照它们的安装指南进行安装。 2. 准备输入文件：准备一个包含h264视频和PCMU音频...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值