void RTMPConnection::OnStreamReset(DWORD id)
{
for (RTMPChunkOutputStreams::iterator it=chunkOutputStreams.begin(); it!=chunkOutputStreams.end();++it)
{
//Get stream
RTMPChunkOutputStream* chunkOutputStream = it->second;
//Get chunk id
DWORD chunkId = it->first;
//Check it it has data pending
if (chunkOutputStream->ResetStream(id))
//Send Abort message
SendControlMessage(RTMPMessage::AbortMessage, RTMPAbortMessage::Create(chunkId));
}
}
bool CGUIControlGroup::OnMessage(CGUIMessage& message)
{
switch (message.GetMessage() )
{
case GUI_MSG_ITEM_SELECT:
{
if (message.GetControlId() == GetID())
{
m_focusedControl = message.GetParam1();
return true;
}
break;
}
case GUI_MSG_ITEM_SELECTED:
{
if (message.GetControlId() == GetID())
{
message.SetParam1(m_focusedControl);
return true;
}
break;
}
case GUI_MSG_FOCUSED:
{ // a control has been focused
m_focusedControl = message.GetControlId();
SetFocus(true);
// tell our parent thatwe have focus
if (m_parentControl)
m_parentControl->OnMessage(message);
return true;
}
case GUI_MSG_SETFOCUS:
{
// first try our last focused control...
if (!m_defaultAlways && m_focusedControl)
{
CGUIControl *control = GetFirstFocusableControl(m_focusedControl);
if (control)
{
CGUIMessage msg(GUI_MSG_SETFOCUS, GetParentID(), control->GetID());
return control->OnMessage(msg);
}
}
// ok, no previously focused control, try the default control first
if (m_defaultControl)
{
CGUIControl *control = GetFirstFocusableControl(m_defaultControl);
if (control)
{
CGUIMessage msg(GUI_MSG_SETFOCUS, GetParentID(), control->GetID());
return control->OnMessage(msg);
}
}
// no success with the default control, so just find one to focus
CGUIControl *control = GetFirstFocusableControl(0);
if (control)
{
CGUIMessage msg(GUI_MSG_SETFOCUS, GetParentID(), control->GetID());
return control->OnMessage(msg);
}
// unsuccessful
return false;
break;
}
case GUI_MSG_LOSTFOCUS:
{
// set all subcontrols unfocused
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
(*it)->SetFocus(false);
if (!HasID(message.GetParam1()))
{ // we don't have the new id, so unfocus
SetFocus(false);
if (m_parentControl)
m_parentControl->OnMessage(message);
}
return true;
}
break;
case GUI_MSG_PAGE_CHANGE:
case GUI_MSG_REFRESH_THUMBS:
case GUI_MSG_REFRESH_LIST:
case GUI_MSG_WINDOW_RESIZE:
{ // send to all child controls (make sure the target is the control id)
for (iControls it = m_children.begin(); it != m_children.end(); ++it)
{
CGUIMessage msg(message.GetMessage(), message.GetSenderId(), (*it)->GetID(), message.GetParam1());
(*it)->OnMessage(msg);
}
return true;
}
break;
}
bool handled(false);
//not intented for any specific control, send to all childs and our base handler.
if (message.GetControlId() == 0)
{
for (iControls it = m_children.begin();it != m_children.end(); ++it)
{
CGUIControl* control = *it;
handled |= control->OnMessage(message);
}
return CGUIControl::OnMessage(message) || handled;
}
// if it's intended for us, then so be it
if (message.GetControlId() == GetID())
return CGUIControl::OnMessage(message);
return SendControlMessage(message);
}
/********************************
* ProcessCommandMessage
*
************************************/
void RTMPConnection::ProcessCommandMessage(DWORD streamId,RTMPCommandMessage* cmd)
{
//Get message values
std::wstring name = cmd->GetName();
QWORD transId = cmd->GetTransId();
AMFData* params = cmd->GetParams();
//Log
Log("-ProcessCommandMessage [streamId:%d,name:\"%ls\",transId:%ld]\n",streamId,name.c_str(),transId);
//Check message Stream
if (streamId)
{
//Check if a stream has been created with that id
RTMPStreams::iterator it = streams.find(streamId);
//If not found
if (it==streams.end())
//Send error
return SendCommandError(streamId,transId,NULL,NULL);
//Get media stream
RTMPStream* stream = it->second;
//Check command names
if (name.compare(L"play")==0)
{
//Get url to play
std::wstring url = *(cmd->GetExtra(0));
//Set played data listener
stream->SetPlayListener(this);
//Play
stream->Play(url);
//Publish
} else if (name.compare(L"publish")==0){
//Get url to play
std::wstring url = *(cmd->GetExtra(0));
//Publish
if (stream->Publish(url))
//OK
SendCommandResponse(streamId,L"onStatus",transId,NULL,new RTMPNetStatusEvent(L"NetStream.Publish.Start",L"status",L"Playback started"));
else
//Not found
SendCommandResponse(streamId,L"_error",transId,NULL,new RTMPNetStatusEvent(L"NetStream.Publish.Rejected",L"error",L"Stream not found"));
} else if (name.compare(L"deleteStream")==0) {
//Close stream just in case
stream->Close();
//Delete object
delete(stream);
//Remove from streams
streams.erase(it);
//And do not send a replay
return;
} else if (name.compare(L"seek")==0) {
//Get timestamp
double time = *(cmd->GetExtra(0));
//Play
stream->Seek(time);
} else if (name.compare(L"closeStream")==0) {
//Close stream
stream->Close();
//Send response
SendCommandResponse(streamId,L"onStatus",transId,NULL,new RTMPNetStatusEvent(L"NetStream.Connect.Closed",L"status",L"Netstream closed"));
} else {
//Debug
cmd->Dump();
//Send command
stream->PublishCommand(name.c_str(),cmd->GetParams());
}
} else if (name.compare(L"connect")==0) {
double objectEncoding = 0;
//Check if we already have an active media stream
if (app)
//Send error
return SendCommandError(streamId,transId);
//Check we have params
if (!params || !params->CheckType(AMFData::Object))
//Send error
return SendCommandError(streamId,transId);
//Get object
AMFObject *obj = (AMFObject*)params;
//Check if we have an app
if (!obj->HasProperty(L"app"))
//Send error
return SendCommandError(streamId,transId);
//Get url to connect
appName = (std::wstring)obj->GetProperty(L"app");
//Get peer video capabilities
if (obj->HasProperty(L"videoCodecs"))
//Get value
videoCodecs = (double)obj->GetProperty(L"videoCodecs");
//Check if we have peer audio capabilities
if (obj->HasProperty(L"audioCodecs"))
//Get peer audio capabilities
audioCodecs = (double)obj->GetProperty(L"audioCodecs");
//Check
if (obj->HasProperty(L"objectEncoding"))
//Get object encoding used by client
objectEncoding = (double)obj->GetProperty(L"objectEncoding");
//Call listener
app = listener->OnConnect(appName);
//If it is null
if (!app)
//Send error
return SendCommandError(streamId,transId);
//Send start stream
SendControlMessage(RTMPMessage::UserControlMessage,RTMPUserControlMessage::CreateStreamBegin(0));
//Send window acknoledgement
SendControlMessage(RTMPMessage::WindowAcknowledgementSize, RTMPWindowAcknowledgementSize::Create(512000));
//Send client bandwitdh
SendControlMessage(RTMPMessage::SetPeerBandwidth, RTMPSetPeerBandWidth::Create(512000,2));
//Increase chunk size
maxOutChunkSize = 1028;
//Send client bandwitdh
SendControlMessage(RTMPMessage::SetChunkSize, RTMPSetChunkSize::Create(maxOutChunkSize));
//Create params & extra info
AMFObject* params = new AMFObject();
AMFObject* extra = new AMFObject();
AMFEcmaArray* data = new AMFEcmaArray();
objectEncoding = 3;
//Add properties
params->AddProperty(L"fmsVer" ,L"FMS/3,5,1,525");
params->AddProperty(L"capabilities" ,31.0);
params->AddProperty(L"mode" ,1.0);
extra->AddProperty(L"level" ,L"status");
extra->AddProperty(L"code" ,L"NetConnection.Connect.Success");
extra->AddProperty(L"description" ,L"Connection succeded");
extra->AddProperty(L"data" ,data);
extra->AddProperty(L"objectEncoding" ,objectEncoding);
data->AddProperty(L"version" ,L"3,5,1,525");
//Create
SendCommandResult(streamId,transId,params,extra);
} else if (name.compare(L"createStream")==0 || name.compare(L"initStream")==0) {
//Check if we have an application
if (!app)
//Send error
return SendCommandError(streamId,transId);
//Assign the media string id
DWORD mediaStreamId = maxStreamId++;
//Call the application to create the stream
RTMPStream *stream = app->CreateStream(mediaStreamId,appName,audioCodecs,videoCodecs);
//Check if it was created correctly
if (!stream)
//Send error
return SendCommandError(streamId,transId);
//Add to the streams vector
streams[mediaStreamId] = stream;
//Create
SendCommandResult(streamId,transId,new AMFNull(),new AMFNumber((double)mediaStreamId));
/*
} else if (name.compare(L"FCPublish")==0) {
//Check if we have an application
if (!app)
//Send error
return SendCommandResponse(messageStreamId,new RTMPCommandError(transId,L"Not connected"));
//Get url to play
std::wstring url = *(cmd->GetExtra(0));
//Create return code
AMFString* params = new AMFString();
//Create params & extra info
AMFObject* extra = new AMFObject();
//Check publish
extra->AddProperty(L"code",L"NetStream.Publish.Start");
extra->AddProperty(L"code",L"NetStream.Publish.BadName");
//Create
SendCommandResponse(messageStreamId, new RTMPCommandResponse(L"onFCPublish",transId,NULL,extra));
*/
} else {
//Send
SendCommandError(streamId,transId);
}
}
void RTMPConnection::ProcessControlMessage(DWORD streamId,BYTE type,RTMPObject* msg)
{
Log("-ProcessControlMessage [streamId:%d,type:%d]\n",streamId,type);
RTMPUserControlMessage *event;
//Check type
switch((RTMPMessage::Type)type)
{
case RTMPMessage::SetChunkSize:
//Get new chunk size
maxChunkSize = ((RTMPSetChunkSize *)msg)->GetChunkSize();
Log("-Set new chunk size [%d]\n",maxChunkSize);
break;
case RTMPMessage::AbortMessage:
Log("AbortMessage [chunkId:%d]\n",((RTMPAbortMessage*)msg)->GetChunkStreamId());
break;
case RTMPMessage::Acknowledgement:
Log("Acknowledgement [seq:%d]\n",((RTMPAcknowledgement*)msg)->GetSeNumber());
break;
case RTMPMessage::UserControlMessage:
//Get event
event = (RTMPUserControlMessage*)msg;
//Depending on the event received
switch(event->GetEventType())
{
case RTMPUserControlMessage::StreamBegin:
Log("StreamBegin [stream:%d]\n",event->GetEventData());
break;
case RTMPUserControlMessage::StreamEOF:
Log("StreamEOF [stream:%d]\n",event->GetEventData());
break;
case RTMPUserControlMessage::StreamDry:
Log("StreamDry [stream:%d]\n",event->GetEventData());
break;
case RTMPUserControlMessage::SetBufferLength:
Log("SetBufferLength [stream:%d,size:%d]\n",event->GetEventData(),event->GetEventData2());
break;
case RTMPUserControlMessage::StreamIsRecorded:
Log("StreamIsRecorded [stream:%d]\n",event->GetEventData());
break;
case RTMPUserControlMessage::PingRequest:
Log("PingRequest [milis:%d]\n",event->GetEventData());
//Send ping response
SendControlMessage(RTMPMessage::UserControlMessage,RTMPUserControlMessage::CreatePingResponse(0));
break;
case RTMPUserControlMessage::PingResponse:
Log("PingResponse [milis:%d]\n",event->GetEventData());
break;
}
break;
case RTMPMessage::WindowAcknowledgementSize:
//Store new acknowledgement size
windowSize = ((RTMPWindowAcknowledgementSize*)msg)->GetWindowSize();
Log("WindowAcknowledgementSize [%d]\n",windowSize);
break;
case RTMPMessage::SetPeerBandwidth:
Log("SetPeerBandwidth\n");
break;
}
}
/***********************
* ParseData
* Process incomming data
**********************/
void RTMPConnection::ParseData(BYTE *data,const DWORD size)
{
RTMPChunkInputStreams::iterator it;
int len = 0;
int digesOffsetMethod = 0;
//Get pointer and data size
BYTE *buffer = data;
DWORD bufferSize = size;
DWORD digestPosServer = 0;
//Increase current window
curWindowSize += size;
//And total size
recvSize += size;
//Check current window
if (windowSize && curWindowSize>windowSize)
{
//Send
SendControlMessage(RTMPMessage::Acknowledgement,RTMPAcknowledgement::Create(recvSize));
//Reset window
curWindowSize = 0;
}
//While there is data
while(bufferSize>0)
{
//Check connection state
switch(state)
{
case HEADER_C0_WAIT:
//Parse c0
len = c0.Parse(buffer,bufferSize);
//Move
buffer+=len;
bufferSize-=len;
//If it is parsed
if (c0.IsParsed())
{
//Move to next state
state = HEADER_C1_WAIT;
//Debug
Log("Received c0 version: %d\n",c0.GetRTMPVersion());
}
break;
case HEADER_C1_WAIT:
//Parse c1
len = c1.Parse(buffer,bufferSize);
//Move
buffer+=len;
bufferSize-=len;
//If it is parsed
if (c1.IsParsed())
{
Log("-Received C1 client version [%d,%d,%d,%d]\n",c1.GetVersion()[0],c1.GetVersion()[1],c1.GetVersion()[2],c1.GetVersion()[3]);
//Set s0 data
s01.SetRTMPVersion(3);
//Set current timestamp
s01.SetTime(getDifTime(&startTime)/1000);
//Check which version are we using
if (c1.GetVersion()[3])
{
//Verify client
digesOffsetMethod = VerifyC1Data(c1.GetData(),c1.GetSize());
//Set version
s01.SetVersion(3,5,1,1);
//Check if found diggest ofset
digest = (digesOffsetMethod>0);
} else {
//Seet version to zero
s01.SetVersion(0,0,0,0);
//Do not calculate digest
digest = false;
}
//Set random data from memory
BYTE* random = s01.GetRandom();
//Fill it
for (int i=0;i<s01.GetRandomSize();i++)
//With random
random[i] = rand();
//If we have to calculate digest
if (digest)
//calculate digest for s1 only, skipping s0
digestPosServer = GenerateS1Data(digesOffsetMethod,s01.GetData()+1,s01.GetSize()-1);
//Send S01 data
WriteData(s01.GetData(),s01.GetSize());
//Move to next state
state = HEADER_C2_WAIT;
//Debug
Log("Sending s0 and s1 with digest %s offset method %d\n",digest?"on":"off",digesOffsetMethod);
}
break;
case HEADER_C2_WAIT:
//Parse c2
len = c2.Parse(buffer,bufferSize);
//Move
buffer+=len;
bufferSize-=len;
//If it is parsed
if (c2.IsParsed())
{
//Set s2 data
s2.SetTime(c1.GetTime());
//Set current timestamp
s2.SetTime2(getDifTime(&startTime)/1000);
//Echo c1 data
s2.SetRandom(c1.GetRandom(),c1.GetRandomSize());
//If we have to calculate digest
if (digest)
//calculate digest for s1
GenerateS2Data(digesOffsetMethod,s2.GetData(),s2.GetSize());
//Send S2 data
WriteData(s2.GetData(),s2.GetSize());
//Move to next state
state = CHUNK_HEADER_WAIT;
//Debug
Log("Received c2, sending c2. CONNECTED.\n");
}
break;
case CHUNK_HEADER_WAIT:
//Parse c2
len = header.Parse(buffer,bufferSize);
//Move
buffer+=len;
bufferSize-=len;
//If it is parsed
if (header.IsParsed())
{
//Clean all buffers
type0.Reset();
type1.Reset();
type2.Reset();
extts.Reset();
//Move to next state
state = CHUNK_TYPE_WAIT;
//Debug
//Log("Received header [fmt:%d,stream:%d]\n",header.GetFmt(),header.GetStreamId());
//header.Dump();
}
break;
case CHUNK_TYPE_WAIT:
//Get sream id
chunkStreamId = header.GetStreamId();
//Find chunk stream
it = chunkInputStreams.find(chunkStreamId);
//Check if we have a new chunk stream or already got one
if (it==chunkInputStreams.end())
{
//Log
//Log("Creating new chunk stream [id:%d]\n",chunkStreamId);
//Create it
chunkInputStream = new RTMPChunkInputStream();
//Append it
chunkInputStreams[chunkStreamId] = chunkInputStream;
} else
//Set the stream
chunkInputStream = it->second;
//Switch type
switch(header.GetFmt())
{
case 0:
//Check if the buffer type has been parsed
len = type0.Parse(buffer,bufferSize);
//Check if it is parsed
if (type0.IsParsed())
{
//Debug
//Debug("Got type 0 header [timestamp:%lu,messagelength:%d,type:%d,streamId:%d]\n",type0.GetTimestamp(),type0.GetMessageLength(),type0.GetMessageTypeId(),type0.GetMessageStreamId());
//type0.Dump();
//Set data for stream
chunkInputStream->SetMessageLength (type0.GetMessageLength());
chunkInputStream->SetMessageTypeId (type0.GetMessageTypeId());
chunkInputStream->SetMessageStreamId (type0.GetMessageStreamId());
//Check if we have extended timestamp
if (type0.GetTimestamp()!=0xFFFFFF)
{
//Set timesptamp
chunkInputStream->SetTimestamp(type0.GetTimestamp());
//No timestamp delta
chunkInputStream->SetTimestampDelta(0);
//Move to next state
state = CHUNK_DATA_WAIT;
} else
//We have to read 4 more bytes
state = CHUNK_EXT_TIMESTAMP_WAIT;
//Start data reception
chunkInputStream->StartChunkData();
//Reset sent bytes in buffer
chunkLen = 0;
}
break;
case 1:
//Check if the buffer type has been parsed
len = type1.Parse(buffer,bufferSize);
//Check if it is parsed
if (type1.IsParsed())
{
//Debug
//Debug("Got type 1 header [timestampDelta:%u,messagelength:%d,type:%d]\n",type1.GetTimestampDelta(),type1.GetMessageLength(),type1.GetMessageTypeId());
//type1.Dump();
//Set data for stream
chunkInputStream->SetMessageLength(type1.GetMessageLength());
chunkInputStream->SetMessageTypeId(type1.GetMessageTypeId());
//Check if we have extended timestam
if (type1.GetTimestampDelta()!=0xFFFFFF)
{
//Set timestamp delta
chunkInputStream->SetTimestampDelta(type1.GetTimestampDelta());
//Set timestamp
chunkInputStream->IncreaseTimestampWithDelta();
//Move to next state
state = CHUNK_DATA_WAIT;
} else
//We have to read 4 more bytes
state = CHUNK_EXT_TIMESTAMP_WAIT;
//Start data reception
chunkInputStream->StartChunkData();
//Reset sent bytes in buffer
chunkLen = 0;
}
break;
case 2:
//Check if the buffer type has been parsed
len = type2.Parse(buffer,bufferSize);
//Check if it is parsed
if (type2.IsParsed())
{
//Debug
//Debug("Got type 2 header [timestampDelta:%lu]\n",type2.GetTimestampDelta());
//type2.Dump();
//Check if we have extended timestam
if (type2.GetTimestampDelta()!=0xFFFFFF)
{
//Set timestamp delta
chunkInputStream->SetTimestampDelta(type2.GetTimestampDelta());
//Increase timestamp
chunkInputStream->IncreaseTimestampWithDelta();
//Move to next state
state = CHUNK_DATA_WAIT;
} else
//We have to read 4 more bytes
state = CHUNK_EXT_TIMESTAMP_WAIT;
//Start data reception
chunkInputStream->StartChunkData();
//Reset sent bytes in buffer
chunkLen = 0;
}
break;
case 3:
//Debug("Got type 3 header\n");
//No header chunck
len = 0;
//If it is the first chunk
if (chunkInputStream->IsFirstChunk())
//Increase timestamp with previous delta
chunkInputStream->IncreaseTimestampWithDelta();
//Start data reception
chunkInputStream->StartChunkData();
//Move to next state
state = CHUNK_DATA_WAIT;
//Reset sent bytes in buffer
chunkLen = 0;
break;
}
//Move pointer
buffer += len;
bufferSize -= len;
break;
case CHUNK_EXT_TIMESTAMP_WAIT:
//Parse extended timestamp
len = extts.Parse(buffer,bufferSize);
//Move
buffer+=len;
bufferSize-=len;
//If it is parsed
if (extts.IsParsed())
{
//Check header type
if (header.GetFmt()==1)
{
//Set the timestamp
chunkInputStream->SetTimestamp(extts.GetTimestamp());
//No timestamp delta
chunkInputStream->SetTimestampDelta(0);
} else {
//Set timestamp delta
chunkInputStream->SetTimestampDelta(extts.GetTimestamp());
//Increase timestamp
chunkInputStream->IncreaseTimestampWithDelta();
}
//Move to next state
state = CHUNK_DATA_WAIT;
}
break;
case CHUNK_DATA_WAIT:
//Check max buffer size
if (maxChunkSize && chunkLen+bufferSize>maxChunkSize)
//Parse only max chunk size
len = maxChunkSize-chunkLen;
else
//parse all data
len = bufferSize;
//Check size
if (!len)
{
//Debug
Error("Chunk data of size zero [maxChunkSize:%d,chunkLen:%d]\n");
//Skip
break;
}
//Parse data
len = chunkInputStream->Parse(buffer,len);
//Check if it has parsed a msg
if (chunkInputStream->IsParsed())
{
//Log("Got message [timestamp:%lu]\n",chunkInputStream->GetTimestamp());
//Get message
RTMPMessage* msg = chunkInputStream->GetMessage();
//Get message stream
DWORD messageStreamId = msg->GetStreamId();
//Check message type
if (msg->IsControlProtocolMessage())
{
//Get message type
BYTE type = msg->GetType();
//Get control protocl message
RTMPObject* ctrl = msg->GetControlProtocolMessage();
//Procces msg
ProcessControlMessage(messageStreamId,type,ctrl);
} else if (msg->IsCommandMessage()) {
//Get Command message
RTMPCommandMessage* cmd = msg->GetCommandMessage();
//Dump msg
cmd->Dump();
//Proccess msg
ProcessCommandMessage(messageStreamId,cmd);
} else if (msg->IsMedia()) {
//Get media frame
RTMPMediaFrame* frame = msg->GetMediaFrame();
//Check if we have it
if (frame)
//Process message
ProcessMediaData(messageStreamId,frame);
} else if (msg->IsMetaData() || msg->IsSharedObject()) {
//Get object
RTMPMetaData *meta = msg->GetMetaData();
//Debug it
meta->Dump();
//Process meta data
ProcessMetaData(messageStreamId,meta);
} else {
//UUh??
Error("Unknown rtmp message, should never happen\n");
}
//Delete msg
delete(msg);
//Move to next chunck
state = CHUNK_HEADER_WAIT;
//Clean header
header.Reset();
}
//Increase buffer length
chunkLen += len;
//Move pointer
buffer += len;
bufferSize -= len;
//Check max chunk size
if (maxChunkSize && chunkLen>=maxChunkSize)
{
//Wait for next buffer header
state = CHUNK_HEADER_WAIT;
//Clean header
header.Reset();
}
break;
}
}
}
void RTMPConnection::OnStreamEnd(DWORD streamId)
{
//Send control message
SendControlMessage(RTMPMessage::UserControlMessage,RTMPUserControlMessage::CreateStreamBegin(streamId));
}
