使用librtmp库进行推流与拉流

最新推荐文章于 2024-07-02 20:42:00 发布
最新推荐文章于 2024-07-02 20:42:00 发布
阅读量2.9k 收藏 21
点赞数 2
分类专栏： linux开发笔记 文章标签： 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuerongdeng/article/details/126422803
版权
本文详细介绍了如何使用librtmp库进行RTMP协议的推流和拉流操作，包括RTMP协议原理、音视频编解码、FLV封装格式，以及提供了一个基于librtmp的推流和拉流示例代码，帮助开发者理解其实现细节。
摘要由CSDN通过智能技术生成

使用librtmp库进行推流与拉流

目前比较主流的直播技术有RTMP、HLS，其中RTMP主要基于TCP协议，HLS主要基于HTTP协议，二者在实施成本、延迟性等方面有较大差异。本文主要讲解RTMP的推流与拉流技术的应用。

理论知识：

原则上说，开发RTMP的推拉流应用，除具备基本的语言及工具链外，还需要掌握以下知识：
a) RTMP协议原理
b) 基本的音视频编解码知识
c) FLV等流媒体封装格式技巧

RTMP协议原理：

与大多的协议格式一样，RTMP也遵循TLV范式，以及其远程过程调用的指令构造格式AMF。

RTMP基于TCP，在TCP三次握手完成后，RTMP也定义了自己的六次握手，主要用于版本适配、RTT计算，解析这块需要较大篇幅，感兴趣的朋友请百度搜索“RTMP协议详解”。

完成握手之后，传输的报文都基于RTMP分块格式，如下：

+---------------------+-----------------------------------+----------------------+----------------------+
 |  1~3字节基本块头    |        0~11字节的消息块头            | 可选4字节扩展时间戳 |      变长消息负载        |
+---------------------+-----------------------------------+----------------------+----------------------+

采用分块技术原于分时复用的思想，不同的上层消息交错地在一条TCP链路中传输，通常一个块不会太长，避免因为某一个应用消息过多的占用网络资源而造成其它应用饿死。

基本块头介绍：
基本块头定义了两个关键要素：消息块头格式、块流ID。

先看基本块头的第一字节表示：

+-位7-+-位6-+-位5-+-位4-+-位3-+-位2-+-位1-+-位0-+
 |   块头格式   |             块流ID                                      |
+-------------+------------------------------------------+

块头格式占2个位，有4种表示：
00 —— 11字节完整的消息块头。
01 —— 7字节中等消息块头。
10 —— 3字节小型消息块头。
11 —— 0字节无消息块头。

首字节块流ID占6个位，有0~63种表示，每种表示一个块流通道。为了扩展更多的字节表示块流通道，首字节的块流ID被划出0和1两个值用于表示扩展1或2个字节。
扩展1字节的表示法：

+-------------+--------------------+----------------------+
 |   块头格式   |           0                 |           扩展1字节       |
+-------------+--------------------+----------------------+

扩展2字节的表示法：

+-------------+--------------------+----------------------+----------------------+
 |   块头格式   |           1                 |                          扩展2字节                          |
+-------------+--------------------+----------------------+----------------------+

扩展1字节可以表示64+255=319个块流通道。
扩展1字节可以表示64+65525=65599个块流通道。

消息块头介绍：

11字节完整的消息块头格式：

+------------------+------------------+------------------+------------------+
 |                             3字节绝对时间戳                            |    负载消息长度   |
+------------------+------------------+------------------+------------------+
|                3字节负载消息长度           |    1字节消息类型  |        块流ID         |
+------------------+------------------+------------------+------------------+
|                               4字节块流ID                                 |
+------------------+------------------+------------------+

7字节中等消息块头：

+------------------+------------------+------------------+------------------+
 |                             3字节相对时间戳                            |    负载消息长度   |
+------------------+------------------+------------------+------------------+
|                3字节负载消息长度           |    1字节消息类型  |
+------------------+------------------+------------------+

3字节小型消息块头：

+------------------+------------------+------------------+
 |                             3字节相对时间戳                            | 
+------------------+------------------+------------------+

对于不完整的消息块头，省略的字段表示与上次的相同，这可以起到很好的压缩传输效果。

可选扩展时间戳：
只有当块消息头中的普通时间戳设置为0x00ffffff时，本字段才被传送。

变长消息负载：

在RTMP协议规范中在块协议基础上又进一步定义了消息协议，格式如下：

+------------------+------------------+------------------+------------------+
 |  1字节消息类型   |                          3字节负载消息长度                             |
+------------------+------------------+------------------+------------------+
|                                              4字节时间戳                                              |
+------------------+------------------+------------------+------------------+
|                               3字节消息流ID                              |
+------------------+------------------+------------------+

消息协议仍然遵循TLV范式，这种套娃式的结构在协议设计模式中也是主流，然而令疑惑的是，消息头的字段设计，与块头过于重合，并且还定义了一个消息流ID。官方对此的解释是，消息头旨在规范开发者应用层消息的设计，与块头属于两个不同的维度，各字段既使同名也互不影响。事实上，如果我们深入分析librtmp的实现，或者抓包分析RTMP的拉流过程，这个消息头规范是没有被采纳的。

基本的音视频编解码知识：

流媒体传输的音视频格式一般采用主流的压缩协议，如音频采用AAC、MP3，视频采用H264、MPEG4。对直播推流来说，我们需要从摄像头抓取YUV或者Bayer格式的视频，从声卡抓取PCM格式的音频，这些数据都是没有经过压缩的，数据量非常大，不便于网络传输。使用压缩协议执行压缩与解压缩的过程称为编解码。编解码可以使用当下流行的FFMpeg工具，开发者遵循其接口调用规范，将原始音视频数据打包，交给指定的编码模块，生成压缩后的编码帧。压缩后的数据大小通常不到原始数据的1/10，对视频来说，由于采用了P帧和B帧前后向预测技术，压缩效率更高。编码帧通过网络传输到目的端如播放器，交给解码器解码还原，当然，通常采用的编码算法都是有损的，解码后的音视频数据既使不能还原到100%的程度，由于人脑视觉和听觉系统的特殊性，大多数情况下仍然不会影响我们对消息的解读。

FLV等流媒体封装格式技巧：

编码器输出的裸音视频数据是不能直接用于推拉流的，RTMP直播通常采用FLV格式，FLV格式要求：
对于音频数据，在裸数据之前，必须增加1个字节的元格式，这个格式定义了采样率、采样精度、通道布局，对于AAC格式，还需要增加ADTS头。
对于视频数据，在裸数据之前，也必须增加1个字节的元格式，这个格式定义了编码器、帧格式，对于H264，还需要增加SPS和PPS。

librtmp库接口介绍：

官网下载：http://rtmpdump.mplayerhq.hu/download

结构定义：

与开发者最直接相关结构包括：

RTMP报文格式：

  typedef struct RTMPPacket
  {
    uint8_t m_headerType;   // 块头类型
    uint8_t m_packetType;   // 负载格式
    uint8_t m_hasAbsTimestamp;   // 是否绝对时间戳
    int m_nChannel;   // 块流ID
    uint32_t m_nTimeStamp;    // 时间戳
    int32_t m_nInfoField2;    // 块流ID
    uint32_t m_nBodySize;   // 负载大小
    uint32_t m_nBytesRead;   // 读入负载大小
    RTMPChunk *m_chunk;  // 在RTMP_ReadPacket()调用时，若该字段非NULL，表示关心原始块的信息，通常设为NULL
    char *m_body;   // 负载指针
  } RTMPPacket;

RTMP上下文格式：

  typedef struct RTMP
  {
    int m_inChunkSize;    // 最大接收块大小
    int m_outChunkSize;    // 最大发送块大小
    int m_nBWCheckCounter;    // 带宽检测计数器
    int m_nBytesIn;    // 接收数据计数器
    int m_nBytesInSent;    // 当前数据已回应计数器
    int m_nBufferMS;    // 当前缓冲的时间长度，以MS为单位
    int m_stream_id;    // 当前连接的流ID
    int m_mediaChannel;    // 当前连接媒体使用的块流ID
    uint32_t m_mediaStamp;    // 当前连接媒体最新的时间戳
    uint32_t m_pauseStamp;    // 当前连接媒体暂停时的时间戳
    int m_pausing;    // 是否暂停状态
    int m_nServerBW;    // 服务器带宽
    int m_nClientBW;    // 客户端带宽
    uint8_t m_nClientBW2;    // 客户端带宽调节方式
    uint8_t m_bPlaying;    // 当前是否推流或连接中
    uint8_t m_bSendEncoding;    // 连接服务器时发送编码
    uint8_t m_bSendCounter;    // 设置是否向服务器发送接收字节应答

    int m_numInvokes;    // 0x14命令远程过程调用计数
    int m_numCalls;    // 0x14命令远程过程请求队列数量
    RTMP_METHOD *m_methodCalls;    // 远程过程调用请求队列

    RTMPPacket *m_vecChannelsIn[RTMP_CHANNELS];    // 对应块流ID上一次接收的报文
    RTMPPacket *m_vecChannelsOut[RTMP_CHANNELS];    // 对应块流ID上一次发送的报文
    int m_channelTimestamp[RTMP_CHANNELS];    // 对应块流ID媒体的最新时间戳

    double m_fAudioCodecs;    // 音频编码器代码
    double m_fVideoCodecs;    // 视频编码器代码
    double m_fEncoding;         /* AMF0 or AMF3 */

    double m_fDuration;    // 当前媒体的时长

    int m_msgCounter;    // 使用HTTP协议发送请求的计数器
    int m_polling;    // 使用HTTP协议接收消息主体时的位置
    int m_resplen;    // 使用HTTP协议接收消息主体时的未读消息计数
    int m_unackd;    // 使用HTTP协议处理时无响应的计数
    AVal m_clientID;    // 使用HTTP协议处理时的身份ID

    RTMP_READ m_read;    // RTMP_Read()操作的上下文
    RTMPPacket m_write;    // RTMP_Write()操作使用的可复用报文对象
    RTMPSockBuf m_sb;    // RTMP_ReadPacket()读包操作的上下文
    RTMP_LNK Link;    // RTMP连接上下文
  } RTMP;

函数定义：

关于返回值为int类型的函数，大多数其实是bool语义，即1表示成功，0表示失败，但是仍然也有少部分函数可以返回负值。

RTMP报文操作：

// 重置报文
void RTMPPacket_Reset(RTMPPacket *p);
// 为报文分配负载空间
int RTMPPacket_Alloc(RTMPPacket *p, int nSize);
// 释放负载空间
void RTMPPacket_Free(RTMPPacket *p);

// 检查报文是否可读，当报文被分块，且接收未完成时不可读
#define RTMPPacket_IsReady(a)   ((a)->m_nBytesRead == (a)->m_nBodySize)

地址解析操作：

// 解析流地址
int RTMP_ParseURL(const char *url, int *protocol, AVal *host, unsigned int *port, AVal *playpath, AVal *app);

媒体缓存时长设置操作：

// 连接前，设置服务器发送给客户端的媒体缓存时长
void RTMP_SetBufferMS(RTMP *r, int size);
// 连接后，更新服务器发送给客户端的媒体缓存时长
void RTMP_UpdateBufferMS(RTMP *r);

RTMP播放地址及上下文选项操作：

// 更新RTMP上下文中的相应选项
int RTMP_SetOpt(RTMP *r, const AVal *opt, AVal *arg);
// 设置流地址
int RTMP_SetupURL(RTMP *r, char *url);
// 设置RTMP上下文播放地址和相应选项，不关心的可以设为NULL
void RTMP_SetupStream(RTMP *r, int protocol,
                        AVal *hostname,
                        unsigned int port,
                        AVal *sockshost,
                        AVal *playpath,
                        AVal *tcUrl,
                        AVal *swfUrl,
                        AVal *pageUrl,
                        AVal *app,
                        AVal *auth,
                        AVal *swfSHA256Hash,
                        uint32_t swfSize,
                        AVal *flashVer,
                        AVal *subscribepath,
                        int dStart,
                        int dStop, int bLiveStream, long int timeout);

RTMP连接及握手操作：

// 客户端连接及握手
int RTMP_Connect(RTMP *r, RTMPPacket *cp);
// 服务端握手
int RTMP_Serve(RTMP *r);

收发报文操作：

// 接收一个报文
int RTMP_ReadPacket(RTMP *r, RTMPPacket *packet);
// 发送一个报文，queue为1表示当包类型为0x14时，将加入队列等待响应
int RTMP_SendPacket(RTMP *r, RTMPPacket *packet, int queue);
// 直接发送块
int RTMP_SendChunk(RTMP *r, RTMPChunk *chunk);

其他操作，不分类了，解释如下：

// 检查网络是否连接
int RTMP_IsConnected(RTMP *r);
// 返回套接字
int RTMP_Socket(RTMP *r);
// 检查连接是否超时
int RTMP_IsTimedout(RTMP *r);

// 获取当前媒体的时长
double RTMP_GetDuration(RTMP *r);

// 暂停与播放切换控制
int RTMP_ToggleStream(RTMP *r);

// 连接流，并指定开始播放的位置
int RTMP_ConnectStream(RTMP *r, int seekTime);
// 重新创建流
int RTMP_ReconnectStream(RTMP *r, int seekTime);
// 删除当前流
void RTMP_DeleteStream(RTMP *r);

// 获取第一个媒体包
int RTMP_GetNextMediaPacket(RTMP *r, RTMPPacket *packet);

// 处理客户端的报文交互，即处理报文分派逻辑
int RTMP_ClientPacket(RTMP *r, RTMPPacket *packet);

// 分配RTMP上下文
RTMP *RTMP_Alloc(void);
// 初使化RTMP上下文，设默认值
void RTMP_Init(RTMP *r);
// 关闭RTMP上下文
void RTMP_Close(RTMP *r);
// 释放RTMP上下文
void RTMP_Free(RTMP *r)

// 开启客户端的RTMP写开关，用于推流
void RTMP_EnableWrite(RTMP *r);

// 返回RTMP的版本
int RTMP_LibVersion(void);

// 开启RTMP工作中断
void RTMP_UserInterrupt(void);

// 发送0x04号命令的控制消息
int RTMP_SendCtrl(RTMP *r, short nType, unsigned int nObject, unsigned int nTime);

// 发送0x14号远程调用控制暂停
int RTMP_SendPause(RTMP *r, int DoPause, int dTime);
int RTMP_Pause(RTMP *r, int DoPause);

// 递归在一个对象中搜索指定的属性
int RTMP_FindFirstMatchingProperty(AMFObject *obj, const AVal *name, AMFObjectProperty * p);

// 底层套接口的网络读取、发送、关闭连接操作
int RTMPSockBuf_Fill(RTMPSockBuf *sb);
int RTMPSockBuf_Send(RTMPSockBuf *sb, const char *buf, int len);
int RTMPSockBuf_Close(RTMPSockBuf *sb);

// 发送建流操作
int RTMP_SendCreateStream(RTMP *r);

// 发送媒体时间定位操作
int RTMP_SendSeek(RTMP *r, int dTime);

// 发送设置服务器应答窗口大小操作
int RTMP_SendServerBW(RTMP *r);
// 发送设置服务器输出带宽操作
int RTMP_SendClientBW(RTMP *r);

// 删除0x14命令远程调用队列中的请求
void RTMP_DropRequest(RTMP *r, int i, int freeit);

// 读取FLV格式数据
int RTMP_Read(RTMP *r, char *buf, int size);
// 发送FLV格式数据
int RTMP_Write(RTMP *r, const char *buf, int size);

推流用法：

推流流程：

步骤：

  1. 初使化RTMP上下文
  2. 设置推流地址
  3. 开启推流标志
  4. 连接服务器
  5. 连接流地址
  6. 若从文件推流，循环读TAG，组织报文发送
  7. 若发送太快，适当做延迟
  8. 推流完毕，释放资源

简单例子：

下面这个例子演示了使用librtmp库将本地flv文件推流到服务器，代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>

#include <librtmp/rtmp.h>

// 大小端字节序转换
#define HTON16(x) ( (x >> 8 & 0x00FF) | (x << 8 & 0xFF00) )
#define HTON24(x) ( (x >> 16 & 0x0000FF) | (x & 0x00FF00) | (x << 16 & 0xFF0000) )
#define HTON32(x) ( (x >> 24 & 0x000000FF) | (x >> 8 & 0x0000FF00) | (x << 8 & 0x00FF0000) | (x << 24 & 0xFF000000) )
#define HTONTIME(x) ( (x >> 16 & 0x000000FF) | (x & 0x0000FF00) | (x << 16 & 0x00FF0000) | (x & 0xFF000000) )

// 从文件读取指定字节
bool ReadFP(char* pBuf, int nSize, FILE* pFile)
{
    return (fread(pBuf, 1, nSize, pFile) == nSize);
}

// 从文件读取1个字节整数
bool ReadU8(uint8_t* u8, FILE* fp)
{
    return ReadFP((char*)u8, 1, fp);
}

// 从文件读取2个字节整数
bool ReadU16(uint16_t* u16, FILE* fp)
{
    if (!ReadFP((char*)u16, 2, fp))
        return false;

    *u16 = HTON16(*u16);
    return true;
}

// 从文件读取3个字节整数
bool ReadU24(uint32_t* u24, FILE* fp)
{
    if (!ReadFP((char*)u24, 3, fp))
        return false;

    *u24 = HTON24(*u24);
    return true;
}

// 从文件读取4个字节整数
bool ReadU32(uint32_t* u32, FILE* fp)
{
    if (!ReadFP((char*)u32, 4, fp))
        return false;

    *u32 = HTON32(*u32);
    return true;
}

// 从文件读取4个字节时间戳
bool ReadTime(uint32_t* utime, FILE* fp)
{
    if (!ReadFP((char*)utime, 4, fp))
        return false;

    *utime = HTONTIME(*utime);
    return true;
}

// 从文件预读1个字节整数
bool PeekU8(uint8_t* u8, FILE* fp)
{
    if (!ReadFP((char*)u8, 1, fp))
        return false;

    fseek(fp, -1, SEEK_CUR);
    return true;
}

int main(int argc, char* argv[])
{
    FILE* pFile = fopen("1.flv", "rb");

    // 初使化RTMP上下文
    RTMP* pRTMP = RTMP_Alloc();
    RTMP_Init(pRTMP);

    // 设置推流地址
    pRTMP->Link.timeout = 10;
    RTMP_SetupURL(pRTMP, (char*)"rtmp://127.0.0.1:1935/live/a");

    // 开启推流标志
    RTMP_EnableWrite(pRTMP);

    // 连接服务器
    bool b = RTMP_Connect(pRTMP, NULL);
    if (!b)
    {
        printf("connect failed! \n");
        return -1;
    }
        
    // 连接流地址
    b = RTMP_ConnectStream(pRTMP, 0);
    if (!b)
    {
        printf("connect stream failed! \n");
        return -1;
    }

    // 跳过FLV文件头的13个字节
    fseek(pFile, 9, SEEK_SET);
    fseek(pFile, 4, SEEK_CUR);

    // 初使化RTMP报文
    RTMPPacket packet;
    RTMPPacket_Reset(&packet);
    packet.m_body = NULL;
    packet.m_chunk = NULL;

    packet.m_nInfoField2 = pRTMP->m_stream_id;

    uint32_t starttime = RTMP_GetTime();

    while (true)
    {
        // 读取TAG头

        uint8_t type = 0;
        if (!ReadU8(&type, pFile))
            break;

        uint32_t datalen = 0;
        if (!ReadU24(&datalen, pFile))
            break;

        uint32_t timestamp = 0;
        if (!ReadTime(&timestamp, pFile))
            break;

        uint32_t streamid = 0;
        if (!ReadU24(&streamid, pFile))
            break;

/*
        // 跳过0x12 Script
        if (type != 0x08 && type != 0x09)
        {
            fseek(pFile, datalen + 4, SEEK_CUR);
            continue;
        }
*/

        RTMPPacket_Alloc(&packet, datalen);

        if (fread(packet.m_body, 1, datalen, pFile) != datalen)
            break;

        // 组织报文并发送
        packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
        packet.m_packetType = type;
        packet.m_hasAbsTimestamp = 0;
        packet.m_nChannel = 6;
        packet.m_nTimeStamp = timestamp;
        packet.m_nBodySize = datalen;

        if (!RTMP_SendPacket(pRTMP, &packet, 0))
        {
            printf("Send Error! \n");
            break;
        }

        printf("send type:[%d] timestamp:[%d] datasize:[%d] \n", type, timestamp, datalen);

        // 跳过PreTag
        uint32_t pretagsize = 0;
        if (!ReadU32(&pretagsize, pFile))
            break;

        // 延时，避免发送太快
        uint32_t timeago = (RTMP_GetTime() - starttime);
        if (timestamp > 1000 && timeago < timestamp - 1000)
        {
            printf("sleep...\n");
            usleep(100000);
        }

        RTMPPacket_Free(&packet);
    }

    // 关闭连接，释放RTMP上下文
    RTMP_Close(pRTMP);
    RTMP_Free(pRTMP);

    fclose(pFile);

    return 0;
}

运行输出：

g++ -o testrtmp2 testrtmp2.cpp -lrtmp
./testrtmp2
send type:[18] timestamp:[0] datasize:[371] 
send type:[8] timestamp:[0] datasize:[209] 
send type:[9] timestamp:[25] datasize:[9838] 
send type:[8] timestamp:[26] datasize:[210] 
send type:[8] timestamp:[52] datasize:[210] 
send type:[8] timestamp:[78] datasize:[210] 
send type:[9] timestamp:[88] datasize:[11181] 
send type:[8] timestamp:[104] datasize:[210] 
send type:[8] timestamp:[131] datasize:[210] 
send type:[9] timestamp:[150] datasize:[11820] 
send type:[8] timestamp:[157] datasize:[210] 
send type:[8] timestamp:[183] datasize:[210] 
send type:[8] timestamp:[209] datasize:[210] 
send type:[9] timestamp:[213] datasize:[11995] 
send type:[8] timestamp:[235] datasize:[210] 
send type:[8] timestamp:[261] datasize:[210] 
send type:[9] timestamp:[275] datasize:[11809] 
send type:[8] timestamp:[287] datasize:[210] 
send type:[8] timestamp:[313] datasize:[210] 
send type:[9] timestamp:[338] datasize:[6124] 
send type:[8] timestamp:[340] datasize:[210] 
send type:[8] timestamp:[366] datasize:[210] 
send type:[8] timestamp:[392] datasize:[210] 
send type:[9] timestamp:[400] datasize:[4500] 
send type:[8] timestamp:[418] datasize:[210] 
send type:[8] timestamp:[444] datasize:[210] 
send type:[9] timestamp:[463] datasize:[2850] 
send type:[8] timestamp:[470] datasize:[210]

拉流用法：

拉流流程：

步骤：

  1. 初使化RTMP上下文
  2. 设置拉流地址
  3. 连接服务器
  4. 连接流地址
  5. 循环拉流，提取媒体数据，保存为文件或者交给解码模块
  6. 拉流完毕，释放资源

简单例子：

下面这个例子演示了使用librtmp库从服务器拉流到本地保存为flv/mp3文件，代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

#include <librtmp/rtmp.h>

int main(int argc, char* argv[])
{
    // 初使化RTMP上下文
    RTMP* pRTMP = RTMP_Alloc();
    RTMP_Init(pRTMP);

    // 设置拉流地址
    RTMP_SetupURL(pRTMP, (char*)"rtmp://127.0.0.1:1935/live/a");

    // 连接服务器
    pRTMP->Link.timeout = 10;
    pRTMP->Link.lFlags |= RTMP_LF_LIVE;
    bool b = RTMP_Connect(pRTMP, NULL);
    if (!b)
    {
        printf("connect failed! \n");
        return -1;
    }

    // 连接流地址
    b = RTMP_ConnectStream(pRTMP, 0);
    if (!b)
    {
        printf("connect stream failed! \n");
        return -1;
    }

    bool bSaveMP3 = true;
    FILE* pFile = fopen(bSaveMP3 ? "testrtmp.mp3" : "testrtmp.flv", "wb");

    while (RTMP_IsConnected(pRTMP))
    {
        if (bSaveMP3)
        {
            RTMPPacket packet;
            RTMPPacket_Reset(&packet);
            packet.m_body = NULL;
            packet.m_chunk = NULL;
            b = RTMP_ReadPacket(pRTMP, &packet);

            if (!b)
                break;

            if (!RTMPPacket_IsReady(&packet))
                continue;

            printf("\t headerType:[%d] \n", packet.m_headerType);
            printf("\t packetType:[%d] \n", packet.m_packetType);
            printf("\t hasAbsTimestamp:[%d] \n", packet.m_hasAbsTimestamp);
            printf("\t nChannel:[%d] \n", packet.m_nChannel);
            printf("\t nTimeStamp:[%d] \n", packet.m_nTimeStamp);
            printf("\t nInfoField2:[%d] \n", packet.m_nInfoField2);
            printf("\t nBodySize:[%d] \n", packet.m_nBodySize);
            printf("\t nBytesRead:[%d] \n", packet.m_nBytesRead);

            //fwrite(packet.m_body, 1, packet.m_nBodySize, pFile);
            //fwrite("AAAAAAAAAAAAAAAA", 1, 16, pFile);

            if (packet.m_packetType == 0x08)
            {
                fwrite(packet.m_body + 1, 1, packet.m_nBodySize - 1, pFile);
            }

            RTMPPacket_Free(&packet);
        }
        else
        {
            char sBuf[4096] = {0};
            int bytes = RTMP_Read(pRTMP, sBuf, sizeof(sBuf));
            printf("RTMP_Read() ret:[%d] \n", bytes);

            if (bytes <= 0)
                break;

            fwrite(sBuf, 1, bytes, pFile);
        }
    }

    fclose(pFile);
  
    RTMP_Close(pRTMP);
    RTMP_Free(pRTMP);

    return 0;
}

运行输出：

g++ -o testrtmp testrtmp.cpp -lrtmp
./testrtmp
RTMP_Read() ret:[640] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[4096] 
RTMP_Read() ret:[4096] 
RTMP_Read() ret:[1304] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[952] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[1705] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[1142] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[225] 
RTMP_Read() ret:[1957] 
RTMP_Read() ret:[225]

 

xrdeng
关注
  • 2
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最简单的基于libRTMP的示例
12-23
本工程包含了LibRTMP的使用示例，包含如下子工程： simplest_librtmp_receive: 接收RTMP流媒体并在本地保存成FLV格式的文件。 simplest_librtmp_send_flv: 将FLV格式的视音频文件使用RTMP推送至RTMP流媒体服务器。 simplest_librtmp_send264: 将内存中的H.264数据推送至RTMP流媒体服务器。
librtmp源码详解
xuerongdeng的专栏
08-17 1557
实时流协议（Real-TimeMessaging Protocol，RTMP）是用于互联网上传输视音频数据的网络协议。本API提供了支持RTMP， RTMPT，RTMPE，RTMPS及以上几种协议的变种(RTMPTE, RTMPTS)协议所需的大部分客户端功能以及少许的服务器功能。尽管Adobe公司已经公布了RTMP协议规范（RTMP specification），可是本工程并非经过Adobe的协议规范而是经过逆向工程的方式完成的。...
使用librtmp推h264、aac实时流
codeofcc的博客
03-06 5141
librtmp可以用于推rtmp流，有时候我们需要将采集的摄像头或桌面的视频数据以及麦克风的音频数据推流出去，这时候就需要使用librtmp的推流功能了，其推流流程比较简单，只是一些细节需要注意即可。
RTMP协议
最新发布
weixin_37543822的博客
07-02 428
与RTSP 不同，RTSP(Real-Time Streaming Protocol)是一个控制协议，负责控制媒体流的传输，但不传输媒体数据本身。RTSP 可以通过 TCP 或 UDP 传输 RTP 包来传输音视频数据。 RTMP(Real-Time Messaging Protocol)是一个综合性的协议，不仅可以传输音视频数据，还可以...
librtmp库API介绍及其结构概述
qq_34305316的博客
10-31 6503
文章目录librtmp库API介绍及其结构概述1、librtmp API的使用1.1 librtmp API的使用流程1.2 librtmp的实例1.3 librtmp API详解1.3.1 librtmp中的chunk和message1.3.2 RTMP基本API1.3.3 设置RTMP的属性1.3.4 连接服务器1.3.5 创建rtmp流1.3.6 对RTMP流的操作1.3.6.1 控制类API1.3.6.2 查询类API1.3.6.3 读写类API2. librtmp数据流的读写流程2.1 传输层
librtmp优化
深之JohnChen的专栏
02-16 1851
librtmp优化
librtmp学习
langzi113的专栏
02-22 1385
学习雷博士的文章环境：Ubuntu 16.04.7ffmpeg-6.1。
T31开发笔记：librtmp编译测试及推流测试
11-12 1796
T31上实现RTMP推流测试
基于librtmp对MP3音频文件推流实现代码
06-11
最近在做一个基于RTMP推流的项目，将实现的代码整理了供大家参考，推流环境使用ffmpeg进行推流，nginx做流媒体服务器，VLC进行拉流。
rtmp推拉流源码.zip
07-16
本文将深入探讨基于librtmp库的RTMP推流与拉流技术，以及如何在X86环境下借助nginx或SRS服务器进行实践。 首先，librtmp是一个开源库，由Adobe Systems开发，主要用于实现RTMP协议。它提供了API接口，使得开发者...
Android直播(rtmp推流拉流),适配Android到9.0
07-07
Android直播(rtmp推流拉流),一个是推流module,一个是拉流demo,适配到Android9.0,demo中可以直接使用,很方便集成.推流使用libWsLive,拉流使用vitamio.非常稳定.
SRS4.0音视频推流拉流技术.rar
05-13
《SRS4.0音视频推流拉流技术详解》 在现代的互联网技术中，音视频流媒体已经成为不可或缺的一部分，广泛应用于在线教育、直播、远程会议等领域。SRS（Simple Real-Time Streaming System，简单实时流系统）作为一款...
Android摄像头RTMP推流
03-01
在Android平台上进行实时流媒体传输，尤其是通过摄像头进行RTMP推流，是一项常见的技术需求，尤其是在视频直播应用中。本文将深入探讨如何使用FFmpeg库实现这一功能。 FFmpeg是一款强大的开源多媒体处理工具，它...
基于librtmp的推流实现
热门推荐
Mr_xkHuang的专栏
04-23 1万+
1.推流 配置好rtmpdump库后，我们可以先用命令行来推流看下效果 2.流程图 使用librtmp发布RTMP流的可以使用两种API：RTMP_SendPacket()和RTMP_Write()。 使用RTMP_SendPacket()发布流的时候的函数执行流程图如下图所示。 流程图中关键函数的作用如下所列： InitSockets()：初始化Socket RTMP_Alloc()：为结构...
【视频编解码】使用librtmp实现本地推流
helixiao的博客
08-13 2440
这个文档详细介绍了，如何在本地ubuntu上搭建自己的流服务器。并通过librtmp进行测试。 1.0 背景 客户需要我们提供rtmp推流的源代码，然后他们DVR的供应商会负责移植到盒子中。这个demo演示了如何用c实现rtmp推流。 2.0 安装配置流服务器 下面详细介绍如何在ubuntu14.04上安装配置流服务器 2.1 安装 nginx $ sudo apt-get install bui...
libRTMP使用说明
dianyimo9099的博客
11-07 721
名称 librtmp − RTMPDump Real-Time Messaging Protocol API 库 RTMPDump RTMP(librtmp, -lrtmp) 简介 #include<librtmp/rtmp.h> 描述 实时流协议（Real-TimeMessaging Protocol，RTMP）是用于互联网...
基于librtmp，进行网络推流（264和flv）
FDmitnick的博客
01-19 1638
一、RTMP传输（大部分借鉴雷神的RTMP传输） 1、简介 librtmp 这个开源库本身就是基于flv格式的数据进行传输，所以flv 上传会比较简单， 相关介绍可以看这个链接 https://blog.csdn.net/leixiaohua1020/article/details/14229543 2、rtmp 传输h.264视频的相关知识 想要深入理解的看一下： https:...
librtmp使用方法
深之JohnChen的专栏
02-13 1047
rtmp是常见的一种流媒体协议，它是由Adobe公司提出的一种应用层协议。rtmp传输的是flv格式的封装数据，flv中保存的一般是H.264视频流和AAC音频流。//播放流过程中服务器断开，重连处理。调用ReConnect函数或者RTMP_ReconnectStream函数。//写入流过程中服务器断开，重连处理。调用ReConnect函数或者RTMP_ReconnectStream函数。1、rtmp播放流步骤。3)是否连接服务器成功。2、rtmp发布流步骤。3)是否连接服务器成功。
基于librtmp的安卓小项目：投屏摄像头和手机拼屏幕视频：推流rtmp到服务器上并显示在其它设备上（比如电脑或者其它直播平台）
m0_62602360的博客
01-25 1090
基于librtmp的安卓小项目：投屏摄像头视频：推流rtmp到服务器上并显示在其它设备上（比如电脑或者其它直播平台）
srs-librtmp 如何推流rgb数据 c++
06-08
推流 RGB 数据需要进行以下步骤： 1. 通过 srs-librtmp 库创建一个 RTMP 推流客户端。 2. 设置 RTMP 推流客户端的推流地址、帧率、分辨率等参数。 3. 通过 ffmpeg 或其他库将 RGB 数据转换成 H.264 或者其他格式的视频数据。 4. 将转换后的视频数据通过 srs-librtmp 库发送给推流客户端。 以下是一个简单的 C++ 代码示例，演示了如何使用 srs-librtmp 推流 RGB 数据： ```c++ #include <srs_librtmp.h> int main() { // 初始化 srs-librtmp 库 srs_librtmp_context_t rtmp = srs_librtmp_create("rtmp://example.com/live/stream"); // 设置推流参数 srs_librtmp_set_video_resolution(rtmp, 640, 480); srs_librtmp_set_video_framerate(rtmp, 30); // 发送 RGB 数据 uint8_t* rgb_data = ...; // 假设这是 RGB 数据 int width = 640; int height = 480; uint8_t* h264_data = ...; // 假设这是 H.264 数据 int h264_size = ...; // 假设这是 H.264 数据的大小 srs_librtmp_write_video(rtmp, h264_data, h264_size, width, height); // 释放资源 srs_librtmp_destroy(rtmp); return 0; } ``` 这个示例演示了如何将 RGB 数据转换为 H.264 数据，并通过 srs-librtmp 库进行推流。在实际应用中，你可能需要使用其他库进行 RGB 到 H.264 的转换，或者使用其他视频编码格式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值