void LSBSoundCoder::SetMessage( Container* _container, const std::string& _message,
const Key* _key )
{
// Must be BMP container
if ( _container->IsWaveContainer() )
{
// Get container
const WAVContainer* container =
static_cast<const WAVContainer*>(_container);
// Setup Wave container
SetupContainer(container);
//Hide message length first
SetMessageLength( _message.length() );
// Hide message text
SetMessageText(_message);
}
}
// -----------------------------------------------------------------------------
// CNATFWUNSAFMessage::EncodeL
// -----------------------------------------------------------------------------
//
EXPORT_C CBufBase* CNATFWUNSAFMessage::EncodeL() const
{
CBufBase* msg = EncodeMessageHeaderLC();
for (TInt i = 0; i < iAttributes.Count(); ++i)
{
if (iAttributes[i]->Type() != CNATFWUNSAFAttribute::EMessageIntegrity &&
iAttributes[i]->Type() != CNATFWUNSAFAttribute::EFingerprint)
{
HBufC8* attribute = iAttributes[i]->EncodeL();
CleanupStack::PushL(attribute);
msg->InsertL(msg->Size(), *attribute);
CleanupStack::PopAndDestroy(attribute);
}
}
CleanupStack::Pop(msg);
msg->Compress();
SetMessageLength(*msg);
return msg;
}
// -----------------------------------------------------------------------------
// CNATFWUNSAFMessage::SetMessageLength
// UNSAF message length does not include the NATFWUNSAF header
// -----------------------------------------------------------------------------
//
void CNATFWUNSAFMessage::SetMessageLength(CBufBase& aNATFWUNSAFMessage)
{
SetMessageLength(aNATFWUNSAFMessage,
aNATFWUNSAFMessage.Size() - EHeaderSize);
}
DWORD RTMPChunkOutputStream::GetNextChunk(BYTE *data,DWORD size,DWORD maxChunkSize)
{
//lock now
pthread_mutex_lock(&mutex);
//Message basic header
RTMPChunkBasicHeader header;
//Set chunk stream id
header.SetStreamId(chunkStreamId);
//Chunk header
RTMPObject* chunkHeader = NULL;
//Extended timestamp
RTMPExtendedTimestamp extts;
//Use extended timestamp flag
bool useExtTimestamp = false;
//If we are not processing an object
if (!message)
{
//Check we hve still data
if (messages.empty())
{
//Unlock
pthread_mutex_unlock(&mutex);
//No more data to send here
return 0;
}
//Get the next message to send
message = messages.front();
//Remove from queue
messages.pop_front();
//Get message values
RTMPMessage::Type msgType = message->GetType();
DWORD msgStreamId = message->GetStreamId();
DWORD msgLength = message->GetLength();
DWORD msgTimestamp = message->GetTimestamp();
DWORD msgTimestampDelta = msgTimestamp-timestamp;
//Start sending
pos = 0;
//Allocate data for serialized message
msgBuffer = (BYTE*)malloc(msgLength);
//Serialize it
message->Serialize(msgBuffer,msgLength);
//Select wich header
if (!msgStreamId || msgStreamId!=streamId || msgTimestamp<timestamp)
{
//Create chunk header type 0 (last check is for backward time on Seek)
RTMPChunkType0* type0 = new RTMPChunkType0();
//Set header type
header.SetFmt(0);
//Check timestamp
if (msgTimestamp>=0xFFFFFF)
{
//Set flag
useExtTimestamp = true;
//Use extended header
type0->SetTimestamp(0xFFFFFF);
//Set it
extts.SetTimestamp(msgTimestamp);
} else {
//Set timestamp
type0->SetTimestamp(msgTimestamp);
}
//Set data in chunk header
type0->SetMessageLength(msgLength);
type0->SetMessageTypeId(msgType);
type0->SetMessageStreamId(msgStreamId);
//Not delta available for next packet
msgTimestampDelta = 0;
//Store object
chunkHeader = type0;
} else if (msgLength!=length || msgType!=type) {
//Create chunk header type 1
RTMPChunkType1* type1 = new RTMPChunkType1();
//Set header type
header.SetFmt(1);
//Set data in chunk header
type1->SetTimestampDelta(msgTimestampDelta);
type1->SetMessageLength(msgLength);
type1->SetMessageTypeId(msgType);
//Store object
chunkHeader = type1;
} else if (msgTimestampDelta!=timestampDelta) {
//Create chunk header type 1
RTMPChunkType2* type2 = new RTMPChunkType2();
//Set header type
header.SetFmt(2);
//Set data in chunk header
type2->SetTimestampDelta(msgTimestampDelta);
//Store object
chunkHeader = type2;
} else {
//Set header type 3 as it shares all data with previous
header.SetFmt(3);
//Store object
chunkHeader = NULL;
}
//And update the stream values with latest message values
SetTimestamp(msgTimestamp);
SetTimestampDelta(msgTimestampDelta);
SetMessageLength(msgLength);
SetMessageTypeId(msgType);
SetMessageStreamId(msgStreamId);
} else {
//Set header type 3 as it shares all data with previous
header.SetFmt(3);
//Store object
chunkHeader = NULL;
}
//Serialize header
DWORD headersLen = header.Serialize(data,size);
//Check if we need chunk header
if (chunkHeader)
//Serialize chunk header
headersLen += chunkHeader->Serialize(data+headersLen,size-headersLen);
//Check if need to use extended timestamp
if (useExtTimestamp)
//Serialize extened header
headersLen += extts.Serialize(data+headersLen,size-headersLen);
//Size of the msg data of the chunk
DWORD payloadLen = maxChunkSize;
//If we have more than needed
if (payloadLen>length-pos)
//Just copy until the oend of the object
payloadLen = length-pos;
//Copy
memcpy(data+headersLen,msgBuffer+pos,payloadLen);
//Increase sent data from msg
pos += payloadLen;
//Check if we have finished with this message
if (pos==length)
{
//Delete buffer
free(msgBuffer);
//Null
msgBuffer = NULL;
//Delete message
delete(message);
//Next one
message = NULL;
}
//Check
if (chunkHeader)
//Delete it
delete (chunkHeader);
//Unlock
pthread_mutex_unlock(&mutex);
//Return copied data
return headersLen+payloadLen;
}
