LibRTMP源代码分析8：发送消息(Send RTMPPacket)
在详细分析函数RTMP_SendPacket()之前，让我们来看看RTMPPacket结构体的定义：
typedef struct RTMPPacket
{
uint8_t m_headerType; // ChunkMsgHeader类型(4种)
uint8_t m_packetType; // Message type ID（1-7协议控制；8，9音视频；10以后为AMF编码消息）
uint8_t m_hasAbsTimestamp; // Timestamp 是绝对值还是相对值？
int m_nChannel; // 块流ID (3 <= ID <= 65599)
uint32_t m_nTimeStamp; // Timestamp，时间戳
int32_t m_nInfoField2; // last 4 bytes in a long header，消息流ID
uint32_t m_nBodySize; // 消息长度
uint32_t m_nBytesRead; // 该RTMP包数据已经读取到m_body中的字节数
RTMPChunk *m_chunk;
char *m_body; // 存放实际消息数据的缓冲区
} RTMPPacket;
下面我们来看看RTMP_SendPacket()，各种RTMPPacket（即各种Chunk）都需要用这个函数进行发送。
/**
* @brief 将RTMP包按照协议分块发送出去
*
* @param r ：RTMP上下文参数
* @param packet ： RTMP包，含有带发送的消息负载数据。
* @param queue ：远程方法队列，仅当packet的类型为invoke时使用。
*
* @return 1 成功，失败返回0。
*/
int RTMP_SendPacket(RTMP *r, RTMPPacket *packet, int queue)
{
const RTMPPacket *prevPacket = r->m_vecChannelsOut[packet->m_nChannel];
uint32_t last = 0, t;
char *header, *hptr, *hend, hbuf[RTMP_MAX_HEADER_SIZE], c;
char *buffer, *tbuf = NULL, *toff = NULL;
int nSize, hSize, cSize;
int nChunkSize, tlen;
// 前一个packet存在且不是完整的ChunkMsgHeader，因此有可能需要调整块消息头的类型
if (prevPacket && packet->m_headerType != RTMP_PACKET_SIZE_LARGE)
{
/* compress a bit by using the prev packet's attributes */
// 获取ChunkMsgHeader类型，前一个Chunk与当前Chunk比较
// 如果前后两个块的大小、包类型及块头类型都相同，则将块头类型fmt设为2，
// 即可省略消息长度、消息类型id、消息流id
// 可以参考官方协议：流的分块 --- 6.1.2.3节
if (prevPacket->m_nBodySize == packet->m_nBodySize &&
prevPacket->m_packetType == packet->m_packetType &&
packet->m_headerType == RTMP_PACKET_SIZE_MEDIUM )
packet->m_headerType = RTMP_PACKET_SIZE_SMALL;
// 前后两个块的时间戳相同，且块头类型fmt为2，则相应的时间戳也可省略，因此将块头类型置为3
// 可以参考官方协议：流的分块 --- 6.1.2.4节
if (prevPacket->m_nTimeStamp == packet->m_nTimeStamp &&
packet->m_headerType == RTMP_PACKET_SIZE_SMALL)
packet->m_headerType == RTMP_PACKET_SIZE_SMALL)
packet->m_headerType = RTMP_PACKET_SIZE_MINIMUM;
// 前一个包的时间戳
last = prevPacket->m_nTimeStamp;
}
// 块头类型fmt取值0、1、2、3，超过3就表示出错
if (packet->m_headerType > 3) /* sanity */
{
RTMP_Log(RTMP_LOGERROR, "sanity failed!! trying to send header of type: 0x%02x.",
(unsigned char)packet->m_headerType);
(unsigned char)packet->m_headerType);
return FALSE;
}
// 块头初始大小 = 基本头(1字节) + 块消息头大小(11/7/3/0) = [12, 8, 4, 1]
// 块基本头是1-3字节，因此用变量cSize来表示剩下的0-2字节
// nSize 表示块头初始大小， hSize表示块头大小
nSize = packetSize[packet->m_headerType];
hSize = nSize;
cSize = 0;
// 时间戳增量
t = packet->m_nTimeStamp - last;
if (packet->m_body)
{
// m_body是指向负载数据首地址的指针；“-”号用于指针前移
header = packet->m_body - nSize; // 块头的首指针
hend = packet->m_body; // 块头的尾指针
}
else
{
header = hbuf + 6;
hend = hbuf + sizeof(hbuf);
}
// 块流id(cs id)大于319，则块基本头占3个字节
if (packet->m_nChannel > 319)
cSize = 2;
// 块流id(cs id)在64与319之间，则块基本头占2个字节
else if (packet->m_nChannel > 63)
cSize = 1;
// ChunkBasicHeader的长度比初始长度还要长
if (cSize)
{
header -= cSize; // header指向块头
hSize += cSize; // hSize加上ChunkBasicHeader的长度（比初始长度多出来的长度）
}
// nSize > 1表示块消息头至少有3个字节，即存在timestamp字段
// 相对TimeStamp大于0xffffff，此时需要使用ExtendTimeStamp
if (nSize > 1 && t >= 0xffffff)
{
header -= 4;
hSize += 4;
}
hptr = header;
c = packet->m_headerType << 6; // 把ChunkBasicHeader的Fmt类型左移6位
// 设置basic header的第一个字节值，前两位为fmt. 可以参考官方协议：流的分块 --- 6.1.1节
switch (cSize)
{
case 0: // 把ChunkBasicHeader的低6位设置成ChunkStreamID( cs id )
c |= packet->m_nChannel;
break;
case 1: // 同理，但低6位设置成000000
break;
case 2: // 同理，但低6位设置成000001
c |= 1;
break;
}
// 可以拆分成两句*hptr=c; hptr++，此时hptr指向第2个字节
*hptr++ = c;
// 设置basic header的第二(三)个字节值
if (cSize)
{
// 将要放到第2字节的内容tmp
int tmp = packet->m_nChannel - 64;
// 获取低位存储与第2字节
*hptr++ = tmp & 0xff;
// ChunkBasicHeader是最大的3字节时
if (cSize == 2)
*hptr++ = tmp >> 8; // 获取高位存储于最后1个字节（注意：排序使用大端序列，和主机相反）
}
// ChunkMsgHeader长度为11、7、3, 都含有timestamp（3字节）
if (nSize > 1)
{
// 将时间戳(相对或绝对)转化为3个字节存入hptr，如果时间戳超过0xffffff,则后面还要填入Extend Timestamp
hptr = AMF_EncodeInt24(hptr, hend, t > 0xffffff ? 0xffffff : t);
}
// ChunkMsgHeader长度为11、7，都含有 msg length + msg type id
if (nSize > 4)
{
// 将消息长度(msg length)转化为3个字节存入hptr
hptr = AMF_EncodeInt24(hptr, hend, packet->m_nBodySize);
*hptr++ = packet->m_packetType; // msg type id
}
// ChunkMsgHeader长度为11, 含有msg stream id（ 小端）
if (nSize > 8)
hptr += EncodeInt32LE(hptr, packet->m_nInfoField2);
// 如果时间戳大于0xffffff，则需要写入Extend Timestamp
if (nSize > 1 && t >= 0xffffff)
hptr = AMF_EncodeInt32(hptr, hend, t);
// 到此为止，已经将块头填写好了
// 此时nSize表示负载数据的长度, buffer是指向负载数据区的指针
nSize = packet->m_nBodySize;
buffer = packet->m_body;
nChunkSize = r->m_outChunkSize; //Chunk大小，默认是128字节
RTMP_Log(RTMP_LOGDEBUG2, "%s: fd=%d, size=%d", __FUNCTION__, r->m_sb.sb_socket, nSize);
/* send all chunks in one HTTP request，使用HTTP协议 */
if (r->Link.protocol & RTMP_FEATURE_HTTP)
{
// nSize:Message负载长度；nChunkSize：Chunk长度；
// 例nSize：307，nChunkSize:128；
// 可分为（307 + 128 - 1）/128 = 3个
// 为什么加 nChunkSize - 1？因为除法会只取整数部分！
int chunks = (nSize + nChunkSize - 1) / nChunkSize;
// Chunk个数超过一个
if (chunks > 1)
{
// 注意：ChunkBasicHeader的长度 = cSize + 1
// 消息分n块后总的开销：
// n个ChunkBasicHeader，1个ChunkMsgHeader，1个Message负载
// 实际上只有第一个Chunk是完整的，剩下的只有ChunkBasicHeader
tlen = chunks * (cSize + 1) + nSize + hSize;
tbuf = (char *)malloc(tlen);
if (!tbuf)
return FALSE;
toff = tbuf;
}
}
// 消息的负载 + 头
while (nSize + hSize)
{
int wrote;
// 消息负载大小 < Chunk大小（不用分块）
if (nSize < nChunkSize)
nChunkSize = nSize; // Chunk可能小于设定值
RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)header, hSize);
RTMP_LogHexString(RTMP_LOGDEBUG2, (uint8_t *)buffer, nChunkSize);
// 如果r->Link.protocol采用Http协议，则将RTMP包数据封装成多个Chunk，然后一次性发送。
// 否则每封装成一个块，就立即发送出去
if (tbuf)
{
// 将从Chunk头开始的nChunkSize + hSize个字节拷贝至toff中，
// 这些拷贝的数据包括块头数据(hSize字节)和nChunkSize个负载数据
memcpy(toff, header, nChunkSize + hSize);
toff += nChunkSize + hSize;
}
else // 负载数据长度不超过设定的块大小，不需要分块，因此tbuf为NULL；或者r->Link.protocol不采用Http
{
// 直接将负载数据和块头数据发送出去
wrote = WriteN(r, header, nChunkSize + hSize);
if (!wrote)
return FALSE;
}
nSize -= nChunkSize; // 消息负载长度 - Chunk负载长度
buffer += nChunkSize; // buffer指针前移1个Chunk负载长度
hSize = 0; // 重置块头大小为0，后续的块只需要有基本头(或加上扩展时间戳)即可
// 如果消息负载数据还没有发完，准备填充下一个块的块头数据
if (nSize > 0)
{
// 根据是否含有扩展时间戳及cSize的值，确定块头大小和块头指针
if(t >= 0xffffff)
{
// 初始块头 = 初始 Basic Header(1字节) + Extended Timestamp(4字节)
header = buffer - 5;
hSize = 5;
}
else
{
// 初始块头 = 初始 Basic Header(1字节)
header = buffer - 1;
hSize = 1;
}
// 如果Basic Header还有额外字节，调整块头大小
if (cSize)
{
header -= cSize;
hSize += cSize;
}
// ChunkBasicHeader第1个字节
*header = (0xc0 | c);
// 设置basic header的第二(三)个字节值
if (cSize)
{
int tmp = packet->m_nChannel - 64;
header[1] = tmp & 0xff;
if (cSize == 2)
header[2] = tmp >> 8;
}
// 如果时间戳大于0xffffff，则将Extend Timestamp(4字节)写入进去
if(t >= 0xffffff)
{
hptr = header + 1 + cSize;
hptr = AMF_EncodeInt32(hptr, hend, t);
}
}
} // while (nSize + hSize)结束
// 如果tbuf为空，说明负载数据长度小于Chunk大小（采用RTMP_FEATURE_HTTP），只有一个块。
// 或者每封装好一个块就立即发送出去（在上面while中数据已经发送了）；
// 如果tbuf非空，则把所有的块都封装好之后，一次性发送出去
if (tbuf)
{
int wrote = WriteN(r, tbuf, toff - tbuf);
free(tbuf);
tbuf = NULL;
if (!wrote)
return FALSE;
}
/* we invoked a remote method */
if (packet->m_packetType == RTMP_PACKET_TYPE_INVOKE)
{
AVal method;
char *ptr;
ptr = packet->m_body + 1;
AMF_DecodeString(ptr, &method); // ptr处存放数据格式： | 字符串长度(2字节) | 实际字符串 |
RTMP_Log(RTMP_LOGDEBUG, "Invoking %s", method.av_val);
/* keep it in call queue till result arrives */
if (queue)
{
int txn;
ptr += 3 + method.av_len; // 解码前面的字符串占去了 2 + method.av_len 个字节
txn = (int)AMF_DecodeNumber(ptr);
AV_queue(&r->m_methodCalls, &r->m_numCalls, &method, txn);
}
}
if (!r->m_vecChannelsOut[packet->m_nChannel])
r->m_vecChannelsOut[packet->m_nChannel] = malloc(sizeof(RTMPPacket));
memcpy(r->m_vecChannelsOut[packet->m_nChannel], packet, sizeof(RTMPPacket));
return TRUE;
}
上面的数据块最终是通过函数WriteN()发送出去，接下来分析一下WriteN()函数：
/**
* @brief 发送数据报
*
* @param r : 一个RTMP连接
* @param buffer : 待发送的数据
* @param n : 待发送的数据长度
*
* @热return 发送成功返回true，否则返回false.
*/
static int WriteN(RTMP *r, const char *buffer, int n)
{
const char *ptr = buffer;
while (n > 0)
{
int nBytes;
// 因使用的协议不同而调用不同的函数
if (r->Link.protocol & RTMP_FEATURE_HTTP) // 使用Http协议进行连接
nBytes = HTTP_Post(r, RTMPT_SEND, ptr, n);
else
nBytes = RTMPSockBuf_Send(r, &r->m_sb, ptr, n);
/*RTMP_Log(RTMP_LOGDEBUG, "%s: %d\n", __FUNCTION__, nBytes); */
// 成功发送字节数 < 0, 表示发送失败
if (nBytes < 0)
{
int sockerr = r->m_sock.getsockerr();
RTMP_Log(RTMP_LOGERROR, "%s, RTMP send error %d (%d bytes)", __FUNCTION__, sockerr, n);
// 被中断的系统调用，但不是Ctrl+C,重新发送
if (sockerr == EINTR && !RTMP_ctrlC)
continue;
RTMP_Close(r);
n = 1;
break;
}
if (nBytes == 0)
break;
n -= nBytes;
ptr += nBytes;
}
return n == 0;
}
函数WriteN()的数据是通过调用函数HTTP_Post或者RTMPSockBuf_Send发送数据的，查看HTTP_Post的代码发现该函数只是在函数WriteN()待发送的数据前添加了一些http连接信息后一起通过函数RTMPSockBuf_Send发送出去。接下来看看这两个函数：
/**
* @brief 在待发送的数据buf前面添加http连接信息，一起发送出去。
* 返回原始数据区buf中被发送的字节数。
*/
static int HTTP_Post(RTMP *r, RTMPTCmd cmd, const char *buf, int len)
{
char hbuf[512];
int hlen = snprintf(hbuf, sizeof(hbuf), "POST /%s%s/%d HTTP/1.1\r\n"
"Host: %.*s:%d\r\n"
"Accept: */*\r\n"
"User-Agent: Shockwave Flash\n"
"Connection: Keep-Alive\n"
"Cache-Control: no-cache\r\n"
"Content-type: application/x-fcs\r\n"
"Content-length: %d\r\n\r\n", RTMPT_cmds[cmd],
r->m_clientID.av_val ? r->m_clientID.av_val : "",
r->m_msgCounter, r->Link.hostname.av_len, r->Link.hostname.av_val,
r->Link.port, len);
RTMPSockBuf_Send(r, &r->m_sb, hbuf, hlen);
hlen = RTMPSockBuf_Send(r, &r->m_sb, buf, len);
r->m_msgCounter++;
r->m_unackd++;
return hlen;
}
/**
* @brief Socket发送（指明套接字，buffer缓冲区，数据长度）. 返回所发数据量
*/
int RTMPSockBuf_Send(RTMP *r, RTMPSockBuf *sb, const char *buf, int len)
{
int rc;
//#ifdef _DEBUG
// fwrite(buf, 1, len, netstackdump);
//#endif
{
// 向一个已连接的套接口发送数据。
// int send( SOCKET s, const char * buf, int len, int flags);
// s：一个用于标识已连接套接口的描述字。
// buf ：包含待发送数据的缓冲区。
// len ：缓冲区中数据的长度。
// flags：调用执行方式。
// rc : 所发数据量。
rc = r->m_sock.send(sb->sb_socket, buf, len, 0);
}
return rc;
}
到这个函数的时候，发现一层层的调用终于完成了，最后调用了系统Socket的send()函数完成了数据的发送功能。
Socket的关闭调用也是调用了系统Socket的closesocket()函数完成关闭功能。
/**
* @brief 关闭socket
*/
int RTMPSockBuf_Close(RTMP *r, RTMPSockBuf *sb)
{
if (sb->sb_socket != -1)
return r->m_sock.
closesocket(sb->sb_socket);
return 0;
}