842 lines
24 KiB
C++
842 lines
24 KiB
C++
/********************************************************************************
|
|
Copyright (C) 2012 Hugh Bailey <obs.jim@gmail.com>
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
|
|
********************************************************************************/
|
|
|
|
|
|
#include "Main.h"
|
|
#include "RTMPStuff.h"
|
|
#include "RTMPPublisher.h"
|
|
|
|
|
|
void rtmp_log_output(int level, const char *format, va_list vl)
|
|
{
|
|
int size = _vscprintf(format, vl);
|
|
LPSTR lpTemp = (LPSTR)Allocate(size+1);
|
|
vsprintf_s(lpTemp, size+1, format, vl);
|
|
|
|
// OSDebugOut(TEXT("%S\r\n"), lpTemp);
|
|
Log(TEXT("%S\r\n"), lpTemp);
|
|
|
|
Free(lpTemp);
|
|
}
|
|
|
|
|
|
RTMPPublisher::RTMPPublisher(RTMP *rtmpIn, BOOL bUseSendBuffer, UINT sendBufferSize)
|
|
{
|
|
//traceIn(RTMPPublisher::RTMPPublisher);
|
|
|
|
rtmp = rtmpIn;
|
|
|
|
sendBuffer.SetSize(sendBufferSize);
|
|
curSendBufferLen = 0;
|
|
|
|
this->bUseSendBuffer = bUseSendBuffer;
|
|
|
|
if(bUseSendBuffer)
|
|
{
|
|
Log(TEXT("Send Buffer Size: %u"), sendBufferSize);
|
|
|
|
rtmp->m_customSendFunc = (CUSTOMSEND)RTMPPublisher::BufferedSend;
|
|
rtmp->m_customSendParam = this;
|
|
rtmp->m_bCustomSend = TRUE;
|
|
}
|
|
else
|
|
Log(TEXT("Not using send buffering"));
|
|
|
|
hSendSempahore = CreateSemaphore(NULL, 0, 0x7FFFFFFFL, NULL);
|
|
if(!hSendSempahore)
|
|
CrashError(TEXT("RTMPPublisher: Could not create semaphore"));
|
|
|
|
hDataMutex = OSCreateMutex();
|
|
if(!hDataMutex)
|
|
CrashError(TEXT("RTMPPublisher: Could not create mutex"));
|
|
|
|
hSendThread = OSCreateThread((XTHREAD)RTMPPublisher::SendThread, this);
|
|
if(!hSendThread)
|
|
CrashError(TEXT("RTMPPublisher: Could not create thread"));
|
|
|
|
packetWaitType = 0;
|
|
|
|
maxBitRate = (UINT)AppConfig->GetInt(TEXT("Video Encoding"), TEXT("MaxBitrate"), 1000);
|
|
bufferSize = (UINT)AppConfig->GetInt(TEXT("Video Encoding"), TEXT("BufferSize"), 1000);
|
|
bufferTime = (UINT)(min(1.0, float(bufferSize)/float(maxBitRate))*1000);
|
|
|
|
//traceOut;
|
|
}
|
|
|
|
RTMPPublisher::~RTMPPublisher()
|
|
{
|
|
//traceIn(RTMPPublisher::~RTMPPublisher);
|
|
|
|
bStopping = true;
|
|
ReleaseSemaphore(hSendSempahore, 1, NULL);
|
|
OSTerminateThread(hSendThread, 20000);
|
|
|
|
CloseHandle(hSendSempahore);
|
|
OSCloseMutex(hDataMutex);
|
|
|
|
//flush the last of the data
|
|
if(bUseSendBuffer && RTMP_IsConnected(rtmp))
|
|
FlushSendBuffer();
|
|
|
|
//--------------------------
|
|
|
|
for(UINT i=0; i<Packets.Num(); i++)
|
|
Packets[i].data.Clear();
|
|
Packets.Clear();
|
|
|
|
Log(TEXT("Number of b-frames dropped: %u, Number of p-frames dropped: %u"), numBFramesDumped, numPFramesDumped);
|
|
|
|
//--------------------------
|
|
|
|
if(rtmp)
|
|
{
|
|
RTMP_Close(rtmp);
|
|
RTMP_Free(rtmp);
|
|
}
|
|
|
|
//traceOut;
|
|
}
|
|
|
|
UINT RTMPPublisher::BitsPerTime(List<BitRecord> *list)
|
|
{
|
|
// remove old bits
|
|
if (!bPacketDumpMode)
|
|
{
|
|
DWORD cutoffTime = OSGetTime()-bufferTime;
|
|
|
|
while((list->Num() > 0) && (list->GetElement(0).timestamp < cutoffTime))
|
|
list->Remove(0);
|
|
}
|
|
|
|
UINT accumulator = 1;
|
|
for(UINT i = 0; i < list->Num(); i++)
|
|
{
|
|
BitRecord bitRecord = list->GetElement(i);
|
|
accumulator += bitRecord.bits;
|
|
}
|
|
|
|
return accumulator;
|
|
}
|
|
|
|
void RTMPPublisher::AddBits(List<BitRecord> *list, UINT bits, DWORD timestamp)
|
|
{
|
|
BitRecord bitRecord;
|
|
bitRecord.bits = bits;
|
|
bitRecord.timestamp = timestamp;
|
|
list->Add(bitRecord);
|
|
}
|
|
|
|
void RTMPPublisher::SendPacket(BYTE *data, UINT size, DWORD timestamp, PacketType type)
|
|
{
|
|
//traceIn(RTMPPublisher::SendPacket);
|
|
|
|
if(!bStopping)
|
|
{
|
|
List<BYTE> paddedData;
|
|
paddedData.SetSize(size+RTMP_MAX_HEADER_SIZE);
|
|
mcpy(paddedData.Array()+RTMP_MAX_HEADER_SIZE, data, size);
|
|
|
|
OSEnterMutex(hDataMutex);
|
|
|
|
bitsInPerTime = BitsPerTime(&bitsIn);
|
|
bitsOutPerTime = BitsPerTime(&bitsOut);
|
|
// debug stuff // if (bPacketDumpMode)
|
|
// Log(TEXT("BitsIn: %u, BitsOut: %u"), BitsPerTime(&bitsIn, t), BitsPerTime(&bitsOut, t));
|
|
if(bPacketDumpMode && (bitsInPerTime <= bitsOutPerTime))
|
|
{
|
|
bPacketDumpMode = false;
|
|
bDroppingPFrames = false;
|
|
}
|
|
|
|
bool bAddPacket = false;
|
|
if(type >= packetWaitType)
|
|
{
|
|
if(type != PacketType_Audio)
|
|
{
|
|
packetWaitType = (bPacketDumpMode) ? PacketType_VideoLow : PacketType_VideoDisposable;
|
|
|
|
if(type <= PacketType_VideoHigh)
|
|
{
|
|
AddBits(&bitsIn, size*8, OSGetTime());
|
|
numVideoPackets++;
|
|
}
|
|
}
|
|
|
|
bAddPacket = true;
|
|
}
|
|
|
|
if(bAddPacket)
|
|
{
|
|
NetworkPacket &netPacket = *Packets.CreateNew();
|
|
netPacket.type = type;
|
|
netPacket.timestamp = timestamp;
|
|
netPacket.data.TransferFrom(paddedData);
|
|
|
|
bitsQueued += netPacket.data.Num()*8;
|
|
Log(TEXT("bitsQueued: %u"), bitsQueued);
|
|
|
|
UINT maxVidyaPackets = App->GetFPS()/10;
|
|
|
|
//begin dumping b frames if there's signs of lag
|
|
if (bitsQueued > sendBuffer.Num()*8 &&
|
|
bitsQueued > bitsInPerTime &&
|
|
numVideoPackets > maxVidyaPackets)
|
|
{
|
|
if(bitsInPerTime > bitsOutPerTime)
|
|
{
|
|
if(!bPacketDumpMode)
|
|
{
|
|
bPacketDumpMode = true;
|
|
if(packetWaitType == PacketType_VideoDisposable)
|
|
packetWaitType = PacketType_VideoLow;
|
|
}
|
|
DumpBFrame();
|
|
|
|
if(packetWaitType >= PacketType_VideoHigh)
|
|
bDroppingPFrames = true;
|
|
}
|
|
|
|
//begin dumping p frames if b frames aren't enough
|
|
if (bitsInPerTime > bitsOutPerTime*13/10 && numVideoPacketsBuffered) // TODO: Tweak this
|
|
{
|
|
DoIFrameDelay();
|
|
bDroppingPFrames = true;
|
|
}
|
|
}
|
|
|
|
//-----------------
|
|
|
|
ReleaseSemaphore(hSendSempahore, 1, NULL);
|
|
}
|
|
else
|
|
{
|
|
AddBits(&bitsOut, size*8, OSGetTime());
|
|
//bitsQueued -= size*8;
|
|
numBFramesDumped++;
|
|
}
|
|
|
|
OSLeaveMutex(hDataMutex);
|
|
|
|
/*RTMPPacket packet;
|
|
packet.m_nChannel = 0x4;
|
|
packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
|
|
packet.m_packetType = bAudio ? RTMP_PACKET_TYPE_AUDIO : RTMP_PACKET_TYPE_VIDEO;
|
|
packet.m_nTimeStamp = timestamp;
|
|
packet.m_nInfoField2 = rtmp->m_stream_id;
|
|
packet.m_hasAbsTimestamp = TRUE;
|
|
|
|
List<BYTE> paddedData;
|
|
paddedData.SetSize(size+RTMP_MAX_HEADER_SIZE);
|
|
mcpy(paddedData.Array()+RTMP_MAX_HEADER_SIZE, data, size);
|
|
|
|
packet.m_nBodySize = size;
|
|
packet.m_body = (char*)paddedData.Array()+RTMP_MAX_HEADER_SIZE;
|
|
|
|
if(!RTMP_SendPacket(rtmp, &packet, FALSE))
|
|
{
|
|
if(!RTMP_IsConnected(rtmp))
|
|
App->PostStopMessage();
|
|
}*/
|
|
}
|
|
|
|
//traceOut;
|
|
}
|
|
|
|
void RTMPPublisher::BeginPublishing()
|
|
{
|
|
//traceIn(RTMPPublisher::BeginPublishing);
|
|
|
|
RTMPPacket packet;
|
|
|
|
char pbuf[2048], *pend = pbuf+sizeof(pbuf);
|
|
|
|
packet.m_nChannel = 0x03; // control channel (invoke)
|
|
packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
|
|
packet.m_packetType = RTMP_PACKET_TYPE_INFO;
|
|
packet.m_nTimeStamp = 0;
|
|
packet.m_nInfoField2 = rtmp->m_stream_id;
|
|
packet.m_hasAbsTimestamp = TRUE;
|
|
packet.m_body = pbuf + RTMP_MAX_HEADER_SIZE;
|
|
|
|
char *enc = packet.m_body;
|
|
enc = AMF_EncodeString(enc, pend, &av_setDataFrame);
|
|
enc = AMF_EncodeString(enc, pend, &av_onMetaData);
|
|
enc = App->EncMetaData(enc, pend);
|
|
|
|
packet.m_nBodySize = enc - packet.m_body;
|
|
if(!RTMP_SendPacket(rtmp, &packet, FALSE))
|
|
{
|
|
App->PostStopMessage();
|
|
return;
|
|
}
|
|
|
|
//----------------------------------------------
|
|
|
|
List<BYTE> packetPadding;
|
|
DataPacket mediaHeaders;
|
|
|
|
//----------------------------------------------
|
|
|
|
packet.m_nChannel = 0x05; // source channel
|
|
packet.m_packetType = RTMP_PACKET_TYPE_AUDIO;
|
|
|
|
App->GetAudioHeaders(mediaHeaders);
|
|
|
|
packetPadding.SetSize(RTMP_MAX_HEADER_SIZE);
|
|
packetPadding.AppendArray(mediaHeaders.lpPacket, mediaHeaders.size);
|
|
|
|
packet.m_body = (char*)packetPadding.Array()+RTMP_MAX_HEADER_SIZE;
|
|
packet.m_nBodySize = mediaHeaders.size;
|
|
if(!RTMP_SendPacket(rtmp, &packet, FALSE))
|
|
{
|
|
App->PostStopMessage();
|
|
return;
|
|
}
|
|
|
|
//----------------------------------------------
|
|
|
|
packet.m_nChannel = 0x04; // source channel
|
|
packet.m_headerType = RTMP_PACKET_SIZE_LARGE;
|
|
packet.m_packetType = RTMP_PACKET_TYPE_VIDEO;
|
|
|
|
App->GetVideoHeaders(mediaHeaders);
|
|
|
|
packetPadding.SetSize(RTMP_MAX_HEADER_SIZE);
|
|
packetPadding.AppendArray(mediaHeaders.lpPacket, mediaHeaders.size);
|
|
|
|
packet.m_body = (char*)packetPadding.Array()+RTMP_MAX_HEADER_SIZE;
|
|
packet.m_nBodySize = mediaHeaders.size;
|
|
if(!RTMP_SendPacket(rtmp, &packet, FALSE))
|
|
{
|
|
App->PostStopMessage();
|
|
return;
|
|
}
|
|
|
|
//traceOut;
|
|
}
|
|
|
|
double RTMPPublisher::GetPacketStrain() const
|
|
{
|
|
if(bDroppingPFrames)
|
|
return 100.0f;
|
|
else if(bPacketDumpMode)
|
|
return 50.f;
|
|
|
|
return 0.0f;
|
|
}
|
|
|
|
QWORD RTMPPublisher::GetCurrentSentBytes()
|
|
{
|
|
return bytesSent;
|
|
}
|
|
|
|
DWORD RTMPPublisher::NumDroppedFrames() const
|
|
{
|
|
return numBFramesDumped+numPFramesDumped;
|
|
}
|
|
|
|
|
|
void RTMPPublisher::SendLoop()
|
|
{
|
|
//traceIn(RTMPPublisher::SendLoop);
|
|
|
|
while(WaitForSingleObject(hSendSempahore, INFINITE) == WAIT_OBJECT_0 && !bStopping && RTMP_IsConnected(rtmp))
|
|
{
|
|
/*//--------------------------------------------
|
|
// read
|
|
|
|
DWORD pendingBytes = 0;
|
|
ioctlsocket(rtmp->m_sb.sb_socket, FIONREAD, &pendingBytes);
|
|
if(pendingBytes)
|
|
{
|
|
RTMPPacket packet;
|
|
zero(&packet, sizeof(packet));
|
|
|
|
while(RTMP_ReadPacket(rtmp, &packet) && !RTMPPacket_IsReady(&packet) && RTMP_IsConnected(rtmp));
|
|
|
|
if(!RTMP_IsConnected(rtmp))
|
|
{
|
|
App->PostStopMessage();
|
|
bStopping = true;
|
|
break;
|
|
}
|
|
|
|
RTMPPacket_Free(&packet);
|
|
}*/
|
|
|
|
//--------------------------------------------
|
|
// send
|
|
|
|
OSEnterMutex(hDataMutex);
|
|
if(Packets.Num() == 0)
|
|
{
|
|
OSLeaveMutex(hDataMutex);
|
|
continue;
|
|
}
|
|
|
|
PacketType type = Packets[0].type;
|
|
DWORD timestamp = Packets[0].timestamp;
|
|
|
|
List<BYTE> packetData;
|
|
packetData.TransferFrom(Packets[0].data);
|
|
|
|
Packets.Remove(0);
|
|
if(type <= PacketType_VideoHigh)
|
|
{
|
|
AddBits(&bitsOut, packetData.Num()*8, OSGetTime());
|
|
numVideoPackets--;
|
|
}
|
|
bitsQueued -= packetData.Num()*8;
|
|
Log(TEXT("bitsQueued: %u"), bitsQueued);
|
|
OSLeaveMutex(hDataMutex);
|
|
|
|
//--------------------------------------------
|
|
|
|
RTMPPacket packet;
|
|
packet.m_nChannel = (type == PacketType_Audio) ? 0x5 : 0x4;
|
|
packet.m_headerType = RTMP_PACKET_SIZE_MEDIUM;
|
|
packet.m_packetType = (type == PacketType_Audio) ? RTMP_PACKET_TYPE_AUDIO : RTMP_PACKET_TYPE_VIDEO;
|
|
packet.m_nTimeStamp = timestamp;
|
|
packet.m_nInfoField2 = rtmp->m_stream_id;
|
|
packet.m_hasAbsTimestamp = TRUE;
|
|
|
|
packet.m_nBodySize = packetData.Num()-RTMP_MAX_HEADER_SIZE;
|
|
packet.m_body = (char*)packetData.Array()+RTMP_MAX_HEADER_SIZE;
|
|
|
|
if(!RTMP_SendPacket(rtmp, &packet, FALSE))
|
|
{
|
|
if(!RTMP_IsConnected(rtmp))
|
|
{
|
|
App->PostStopMessage();
|
|
bStopping = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//make sure to flush the send buffer if surpassing max latency to keep frame data synced up on the server
|
|
if(bUseSendBuffer && type != PacketType_Audio)
|
|
{
|
|
if(!numVideoPacketsBuffered)
|
|
firstBufferedVideoFrameTimestamp = timestamp;
|
|
|
|
DWORD bufferedTime = timestamp-firstBufferedVideoFrameTimestamp;
|
|
if(bufferedTime > maxBufferTime)
|
|
{
|
|
if(!FlushSendBuffer())
|
|
{
|
|
App->PostStopMessage();
|
|
bStopping = true;
|
|
break;
|
|
}
|
|
|
|
firstBufferedVideoFrameTimestamp = timestamp;
|
|
}
|
|
|
|
numVideoPacketsBuffered++;
|
|
}
|
|
|
|
bytesSent += packetData.Num();
|
|
}
|
|
|
|
//traceOut;
|
|
}
|
|
|
|
DWORD RTMPPublisher::SendThread(RTMPPublisher *publisher)
|
|
{
|
|
publisher->SendLoop();
|
|
return 0;
|
|
}
|
|
|
|
//video packet count exceeding maximum. find lowest priority frame to dump
|
|
void RTMPPublisher::DoIFrameDelay()
|
|
{
|
|
int prevWaitType = packetWaitType;
|
|
|
|
while(packetWaitType < PacketType_VideoHighest)
|
|
{
|
|
if(packetWaitType == PacketType_VideoHigh)
|
|
{
|
|
UINT bestItem = INVALID;
|
|
bool bFoundIFrame = false, bFoundFrameBeforeIFrame = false;
|
|
|
|
for(int i=int(Packets.Num())-1; i>=0; i--)
|
|
{
|
|
NetworkPacket &packet = Packets[i];
|
|
if(packet.type == PacketType_Audio)
|
|
continue;
|
|
|
|
if(packet.type == packetWaitType)
|
|
{
|
|
if(bFoundIFrame)
|
|
{
|
|
bestItem = UINT(i);
|
|
bFoundFrameBeforeIFrame = true;
|
|
break;
|
|
}
|
|
else if(bestItem == INVALID)
|
|
bestItem = UINT(i);
|
|
}
|
|
else if(packet.type == PacketType_VideoHighest)
|
|
bFoundIFrame = true;
|
|
}
|
|
|
|
if(bestItem != INVALID)
|
|
{
|
|
NetworkPacket &bestPacket = Packets[bestItem];
|
|
|
|
AddBits(&bitsOut, bestPacket.data.Num()*8, OSGetTime());
|
|
bitsQueued -= bestPacket.data.Num()*8;
|
|
Log(TEXT("bitsQueued: %u"), bitsQueued);
|
|
bestPacket.data.Clear();
|
|
Packets.Remove(bestItem);
|
|
numVideoPackets--;
|
|
if(bestPacket.type >= PacketType_VideoHigh)
|
|
numPFramesDumped++;
|
|
else
|
|
numBFramesDumped++;
|
|
|
|
//disposing P-frames will corrupt the rest of the frame group, so you have to wait until another I-frame
|
|
if(!bFoundIFrame || !bFoundFrameBeforeIFrame)
|
|
packetWaitType = PacketType_VideoHighest;
|
|
else
|
|
packetWaitType = prevWaitType;
|
|
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool bRemovedPacket = false;
|
|
|
|
for(UINT i=0; i<Packets.Num(); i++)
|
|
{
|
|
NetworkPacket &packet = Packets[i];
|
|
if(packet.type == PacketType_Audio)
|
|
continue;
|
|
|
|
if(bRemovedPacket)
|
|
{
|
|
if(packet.type >= packetWaitType)
|
|
{
|
|
packetWaitType = PacketType_VideoDisposable;
|
|
break;
|
|
}
|
|
else //clear out following dependent packets of lower priority
|
|
{
|
|
AddBits(&bitsOut, packet.data.Num()*8, OSGetTime());
|
|
bitsQueued -= packet.data.Num()*8;
|
|
Log(TEXT("bitsQueued: %u"), bitsQueued);
|
|
packet.data.Clear();
|
|
Packets.Remove(i--);
|
|
numVideoPackets--;
|
|
if(packet.type >= PacketType_VideoHigh)
|
|
numPFramesDumped++;
|
|
else
|
|
numBFramesDumped++;
|
|
}
|
|
}
|
|
else if(packet.type == packetWaitType)
|
|
{
|
|
AddBits(&bitsOut, packet.data.Num()*8, OSGetTime());
|
|
bitsQueued -= packet.data.Num()*8;
|
|
Log(TEXT("bitsQueued: %u"), bitsQueued);
|
|
packet.data.Clear();
|
|
Packets.Remove(i--);
|
|
numVideoPackets--;
|
|
if(packet.type >= PacketType_VideoHigh)
|
|
numPFramesDumped++;
|
|
else
|
|
numBFramesDumped++;
|
|
|
|
bRemovedPacket = true;
|
|
}
|
|
}
|
|
|
|
if(bRemovedPacket)
|
|
break;
|
|
}
|
|
|
|
packetWaitType++;
|
|
}
|
|
}
|
|
|
|
void RTMPPublisher::DumpBFrame()
|
|
{
|
|
int prevWaitType = packetWaitType;
|
|
|
|
bool bRemovedPacket = false;
|
|
|
|
while(packetWaitType < PacketType_VideoHigh)
|
|
{
|
|
for(UINT i=0; i<Packets.Num(); i++)
|
|
{
|
|
NetworkPacket &packet = Packets[i];
|
|
if(packet.type == PacketType_Audio)
|
|
continue;
|
|
|
|
if(bRemovedPacket)
|
|
{
|
|
if(packet.type >= packetWaitType)
|
|
{
|
|
packetWaitType = (bPacketDumpMode) ? PacketType_VideoLow : PacketType_VideoDisposable;
|
|
break;
|
|
}
|
|
else //clear out following dependent packets of lower priority
|
|
{
|
|
AddBits(&bitsOut, packet.data.Num()*8, OSGetTime());
|
|
bitsQueued -= packet.data.Num()*8;
|
|
Log(TEXT("bitsQueued: %u"), bitsQueued);
|
|
packet.data.Clear();
|
|
Packets.Remove(i--);
|
|
numBFramesDumped++;
|
|
numVideoPackets--;
|
|
}
|
|
}
|
|
else if(packet.type == packetWaitType)
|
|
{
|
|
AddBits(&bitsOut, packet.data.Num()*8, OSGetTime());
|
|
bitsQueued -= packet.data.Num()*8;
|
|
Log(TEXT("bitsQueued: %u"), bitsQueued);
|
|
packet.data.Clear();
|
|
Packets.Remove(i--);
|
|
numBFramesDumped++;
|
|
numVideoPackets--;
|
|
|
|
bRemovedPacket = true;
|
|
}
|
|
}
|
|
|
|
if(bRemovedPacket)
|
|
break;
|
|
|
|
packetWaitType++;
|
|
}
|
|
|
|
if(!bRemovedPacket)
|
|
packetWaitType = prevWaitType;
|
|
}
|
|
|
|
int RTMPPublisher::FlushSendBuffer()
|
|
{
|
|
if(!curSendBufferLen)
|
|
return 1;
|
|
|
|
SOCKET sb_socket = rtmp->m_sb.sb_socket;
|
|
|
|
BYTE *lpTemp = sendBuffer.Array();
|
|
int totalBytesSent = curSendBufferLen;
|
|
while(totalBytesSent > 0)
|
|
{
|
|
int nBytes = send(sb_socket, (const char*)lpTemp, totalBytesSent, 0);
|
|
if(nBytes < 0)
|
|
return nBytes;
|
|
if(nBytes == 0)
|
|
return 0;
|
|
|
|
totalBytesSent -= nBytes;
|
|
lpTemp += nBytes;
|
|
}
|
|
|
|
int prevSendBufferSize = curSendBufferLen;
|
|
curSendBufferLen = 0;
|
|
|
|
return prevSendBufferSize;
|
|
}
|
|
|
|
int RTMPPublisher::BufferedSend(RTMPSockBuf *sb, const char *buf, int len, RTMPPublisher *network)
|
|
{
|
|
bool bComplete = false;
|
|
int fullLen = len;
|
|
|
|
do
|
|
{
|
|
int newTotal = network->curSendBufferLen+len;
|
|
|
|
//buffer full, send
|
|
if(newTotal >= int(network->sendBuffer.Num()))
|
|
{
|
|
int pendingBytes = newTotal-network->sendBuffer.Num();
|
|
int copyCount = network->sendBuffer.Num()-network->curSendBufferLen;
|
|
|
|
mcpy(network->sendBuffer.Array()+network->curSendBufferLen, buf, copyCount);
|
|
|
|
BYTE *lpTemp = network->sendBuffer.Array();
|
|
int totalBytesSent = network->sendBuffer.Num();
|
|
while(totalBytesSent > 0)
|
|
{
|
|
int nBytes = send(sb->sb_socket, (const char*)lpTemp, totalBytesSent, 0);
|
|
if(nBytes < 0)
|
|
return nBytes;
|
|
if(nBytes == 0)
|
|
return 0;
|
|
|
|
totalBytesSent -= nBytes;
|
|
lpTemp += nBytes;
|
|
}
|
|
|
|
network->curSendBufferLen = 0;
|
|
|
|
if(pendingBytes)
|
|
{
|
|
buf += copyCount;
|
|
len -= copyCount;
|
|
}
|
|
else
|
|
bComplete = true;
|
|
}
|
|
else
|
|
{
|
|
if(len)
|
|
{
|
|
mcpy(network->sendBuffer.Array()+network->curSendBufferLen, buf, len);
|
|
network->curSendBufferLen = newTotal;
|
|
}
|
|
|
|
bComplete = true;
|
|
}
|
|
} while(!bComplete);
|
|
|
|
return fullLen;
|
|
}
|
|
|
|
NetworkStream* CreateRTMPPublisher(String &failReason, bool &bCanRetry)
|
|
{
|
|
//traceIn(CreateRTMPPublisher);
|
|
|
|
//------------------------------------------------------
|
|
// set up URL
|
|
|
|
bCanRetry = false;
|
|
|
|
int serviceID = AppConfig->GetInt (TEXT("Publish"), TEXT("Service"));
|
|
String strURL = AppConfig->GetString(TEXT("Publish"), TEXT("URL"));
|
|
String strPlayPath = AppConfig->GetString(TEXT("Publish"), TEXT("PlayPath"));
|
|
|
|
if(!strURL.IsValid())
|
|
{
|
|
failReason = TEXT("No server specified to connect to");
|
|
return NULL;
|
|
}
|
|
|
|
if(serviceID != 0)
|
|
{
|
|
XConfig serverData;
|
|
if(!serverData.Open(TEXT("services.xconfig")))
|
|
{
|
|
failReason = TEXT("Could not open services.xconfig");
|
|
return NULL;
|
|
}
|
|
|
|
XElement *services = serverData.GetElement(TEXT("services"));
|
|
if(!services)
|
|
{
|
|
failReason = TEXT("Could not any services in services.xconfig");
|
|
return NULL;
|
|
}
|
|
|
|
XElement *service = services->GetElementByID(serviceID-1);
|
|
if(!service)
|
|
{
|
|
failReason = TEXT("Could not find the service specified in services.xconfig");
|
|
return NULL;
|
|
}
|
|
|
|
XElement *servers = service->GetElement(TEXT("servers"));
|
|
if(!servers)
|
|
{
|
|
failReason = TEXT("Could not find any servers for the service specified in services.xconfig");
|
|
return NULL;
|
|
}
|
|
|
|
XDataItem *item = servers->GetDataItem(strURL);
|
|
if(!item)
|
|
item = servers->GetDataItemByID(0);
|
|
|
|
strURL = item->GetData();
|
|
}
|
|
|
|
//------------------------------------------------------
|
|
|
|
RTMP *rtmp = RTMP_Alloc();
|
|
RTMP_Init(rtmp);
|
|
/*RTMP_LogSetCallback(rtmp_log_output);
|
|
RTMP_LogSetLevel(RTMP_LOGDEBUG2);*/
|
|
|
|
LPSTR lpAnsiURL = strURL.CreateUTF8String();
|
|
LPSTR lpAnsiPlaypath = strPlayPath.CreateUTF8String();
|
|
|
|
if(!RTMP_SetupURL2(rtmp, lpAnsiURL, lpAnsiPlaypath))
|
|
{
|
|
failReason = Str("Connection.CouldNotParseURL");
|
|
RTMP_Free(rtmp);
|
|
Free(lpAnsiURL);
|
|
Free(lpAnsiPlaypath);
|
|
return NULL;
|
|
}
|
|
|
|
RTMP_EnableWrite(rtmp); //set it to publish
|
|
|
|
/*rtmp->Link.swfUrl.av_len = rtmp->Link.tcUrl.av_len;
|
|
rtmp->Link.swfUrl.av_val = rtmp->Link.tcUrl.av_val;
|
|
rtmp->Link.pageUrl.av_len = rtmp->Link.tcUrl.av_len;
|
|
rtmp->Link.pageUrl.av_val = rtmp->Link.tcUrl.av_val;*/
|
|
rtmp->Link.flashVer.av_val = "FMLE/3.0 (compatible; FMSc/1.0)";
|
|
rtmp->Link.flashVer.av_len = (int)strlen(rtmp->Link.flashVer.av_val);
|
|
|
|
BOOL bUseSendBuffer = AppConfig->GetInt(TEXT("Publish"), TEXT("UseSendBuffer"), 1);
|
|
UINT sendBufferSize = AppConfig->GetInt(TEXT("Publish"), TEXT("SendBufferSize"), 1460);
|
|
|
|
if(sendBufferSize > 32120)
|
|
sendBufferSize = 32120;
|
|
else if(sendBufferSize < 536)
|
|
sendBufferSize = 536;
|
|
|
|
rtmp->m_outChunkSize = 4096;//RTMP_DEFAULT_CHUNKSIZE;//
|
|
rtmp->m_bSendChunkSizeInfo = TRUE;
|
|
|
|
if (!bUseSendBuffer)
|
|
rtmp->m_bUseNagle = TRUE;
|
|
|
|
if(!RTMP_Connect(rtmp, NULL))
|
|
{
|
|
failReason = Str("Connection.CouldNotConnect");
|
|
RTMP_Free(rtmp);
|
|
bCanRetry = true;
|
|
Free(lpAnsiURL);
|
|
Free(lpAnsiPlaypath);
|
|
return NULL;
|
|
}
|
|
|
|
if(!RTMP_ConnectStream(rtmp, 0))
|
|
{
|
|
failReason = Str("Connection.InvalidStream");
|
|
RTMP_Close(rtmp);
|
|
RTMP_Free(rtmp);
|
|
Free(lpAnsiURL);
|
|
Free(lpAnsiPlaypath);
|
|
return NULL;
|
|
}
|
|
|
|
Free(lpAnsiURL);
|
|
Free(lpAnsiPlaypath);
|
|
|
|
return new RTMPPublisher(rtmp, bUseSendBuffer, sendBufferSize);
|
|
|
|
//traceOut;
|
|
}
|