void RTMFPWriter::close(int code) {
if(state()==CLOSED)
return;
if(_stage>0 || _connectedSize>0 || _messages.size()>0)
createBufferedMessage(); // Send a MESSAGE_END just in the case where the receiver has been created (or will be created)
Writer::close(code);
}
AMFWriter& FlowWriter::writeAMFPacket(const string& name) {
MessageBuffered& message(createBufferedMessage());
BinaryWriter& writer = message.rawWriter;
writer.write8(Message::AMF);writer.write8(0);writer.write32(0);
writer.write8(AMF_STRING);writer.writeString16(name);
return message.amfWriter;
}
AMFWriter& RTMFPWriter::write(AMF::ContentType type,UInt32 time,PacketReader* pPacket) {
if(pPacket && !reliable) {
UInt8 headerRequired(type==AMF::DATA ? 6 : 5);
if(pPacket->position()>=headerRequired) {
pPacket->reset(pPacket->position()-headerRequired);
BinaryWriter writer((UInt8*)pPacket->current(),headerRequired);
writer.write8(type);
writer.write32(time);
if(type==AMF::DATA)
writer.write8(0);
writeRaw(pPacket->current(),pPacket->available());
return AMFWriter::Null;
}
DEBUG("Written unbuffered impossible, it requires 6 head bytes available on MemoryReader given");
}
AMFWriter& amf = createBufferedMessage().writer();
BinaryWriter& packet = amf.packet;
packet.write8(type);
packet.write32(time);
if(type==AMF::DATA)
packet.write8(0);
if(pPacket)
packet.writeRaw(pPacket->current(),pPacket->available());
return amf;
}
void FlowWriter::close() {
if(_closed)
return;
if(_stage>0 || _messages.size()>0)
createBufferedMessage(); // Send a MESSAGE_END just in the case where the receiver has been created (or will be created)
_closed=true;
flush();
}
BinaryWriter& FlowWriter::writeRawMessage(bool withoutHeader) {
MessageBuffered& message(createBufferedMessage());
if(!withoutHeader) {
message.rawWriter.write8(0x04);
message.rawWriter.write32(0);
}
return message.rawWriter;
}
void RTMFPWriter::writeRaw(const UInt8* data,UInt32 size) {
if(reliable || state()==CONNECTING) {
createBufferedMessage().writer().packet.writeRaw(data,size);
return;
}
if(state()==CLOSED || signature.empty() || _band.failed()) // signature.empty() means that we are on the writer of FlowNull
return;
_messages.emplace_back(new RTMFPMessageUnbuffered(data,size));
flush();
}
AMFObjectWriter FlowWriter::writeAMFResponse(const string& name,const string& code,const string& description) {
MessageBuffered& message(createBufferedMessage());
writeResponseHeader(message.rawWriter,name,_callbackHandle);
string entireCode(_obj);
if(!code.empty()) {
entireCode.append(".");
entireCode.append(code);
}
bool precValue = message.amfWriter.amf0Preference;
message.amfWriter.amf0Preference=true;
AMFObjectWriter object(message.amfWriter);
if(name=="_error")
object.write("level","error");
else
object.write("level","status");
object.write("code",entireCode);
if(!description.empty())
object.write("description",description);
message.amfWriter.amf0Preference = precValue;
return object;
}
void FlowWriter::clear() {
// delete messages
Message* pMessage;
while(!_messages.empty()) {
pMessage = _messages.front();
_lostCount += pMessage->fragments.size();
delete pMessage;
_messages.pop_front();
}
while(!_messagesSent.empty()) {
pMessage = _messagesSent.front();
_lostCount += pMessage->fragments.size();
if(pMessage->repeatable)
--_repeatable;
delete pMessage;
_messagesSent.pop_front();
}
if(_stage>0) {
createBufferedMessage(); // Send a MESSAGE_ABANDONMENT just in the case where the receiver has been created
flush();
_trigger.stop();
}
}
AMFWriter& FlowWriter::writeAMFResult() {
MessageBuffered& message(createBufferedMessage());
writeResponseHeader(message.rawWriter,"_result",_callbackHandle);
return message.amfWriter;
}
AMFWriter& FlowWriter::writeAMFMessage(const std::string& name) {
MessageBuffered& message(createBufferedMessage());
writeResponseHeader(message.rawWriter,name,0);
return message.amfWriter;
}
bool RTMFPWriter::writeMember(const Client& client) {
RTMFPMessageBuffered& message(createBufferedMessage());
message.writer().packet.write8(0x0b); // unknown
message.writer().packet.writeRaw(client.id,ID_SIZE);
return true;
}
