void RTPEndpoint::onRTPPacket(RTPPacket &packet)
{
//Check
if (!sending)
//Exit
return;
//Get type
MediaFrame::Type packetType = packet.GetMedia();
//Check types
if (type!=packetType)
//Exit
return;
//Check type
if (packet.GetCodec()!=codec)
{
//Store it
codec = packet.GetCodec();
//Depending on the type
switch(packetType)
{
case MediaFrame::Audio:
//Set it
RTPSession::SetSendingAudioCodec((AudioCodec::Type)codec);
break;
case MediaFrame::Video:
//Set it
RTPSession::SetSendingVideoCodec((VideoCodec::Type)codec);
break;
case MediaFrame::Text:
//Set it
RTPSession::SetSendingTextCodec((TextCodec::Type)codec);
break;
}
}
//Get diference from latest frame
QWORD dif = getUpdDifTime(&prev);
//If was reseted
if (reseted)
{
//Get new time
timestamp += dif*freq/1000;
//Not reseted
reseted = false;
} else {
//Get dif from packet timestamp
timestamp += packet.GetTimestamp()-prevts;
}
//Update prev rtp ts
prevts = packet.GetTimestamp();
//Send it
RTPSession::SendPacket(packet,timestamp);
}
/****************************************
* RecText
* Obtiene los packetes y los muestra
*****************************************/
int MediaBridgeSession::RecText()
{
DWORD timeStamp=0;
DWORD lastSeq = RTPPacket::MaxExtSeqNum;
Log(">RecText\n");
//Mientras tengamos que capturar
while(receivingText)
{
//Get packet
RTPPacket *packet = rtpText.GetPacket();
//Check packet
if (!packet)
continue;
//Get data
BYTE* data = packet->GetMediaData();
//And length
DWORD size = packet->GetMediaLength();
//Get extended sequence number
DWORD seq = packet->GetExtSeqNum();
//Lost packets since last one
DWORD lost = 0;
//If not first
if (lastSeq!=RTPPacket::MaxExtSeqNum)
//Calculate losts
lost = seq-lastSeq-1;
//Update last sequence number
lastSeq = seq;
//Get type
TextCodec::Type type = (TextCodec::Type)packet->GetCodec();
//Check the type of data
if (type==TextCodec::T140RED)
{
//Get redundant packet
RTPRedundantPacket* red = (RTPRedundantPacket*)packet;
//Check lost packets count
if (lost == 0)
{
//Create text frame
TextFrame frame(timeStamp ,red->GetPrimaryPayloadData(),red->GetPrimaryPayloadSize());
//Create new timestamp associated to latest media time
RTMPMetaData meta(getDifTime(&first)/1000);
//Add text name
meta.AddParam(new AMFString(L"onText"));
//Set data
meta.AddParam(new AMFString(frame.GetWChar()));
//Send data
SendMetaData(&meta);
} else {
//Timestamp of first packet (either receovered or not)
DWORD ts = timeStamp;
//Check if we have any red pacekt
if (red->GetRedundantCount()>0)
//Get the timestamp of first redundant packet
ts = red->GetRedundantTimestamp(0);
//If we have lost too many
if (lost>red->GetRedundantCount())
//Get what we have available only
lost = red->GetRedundantCount();
//For each lonot recoveredt packet send a mark
for (int i=red->GetRedundantCount();i<lost;i++)
{
//Create frame of lost replacement
TextFrame frame(ts,LOSTREPLACEMENT,sizeof(LOSTREPLACEMENT));
//Create new timestamp associated to latest media time
RTMPMetaData meta(getDifTime(&first)/1000);
//Add text name
meta.AddParam(new AMFString(L"onText"));
//Set data
meta.AddParam(new AMFString(frame.GetWChar()));
//Send data
SendMetaData(&meta);
}
//Fore each recovered packet
for (int i=red->GetRedundantCount()-lost;i<red->GetRedundantCount();i++)
{
//Create frame from recovered data
TextFrame frame(red->GetRedundantTimestamp(i),red->GetRedundantPayloadData(i),red->GetRedundantPayloadSize(i));
//Create new timestamp associated to latest media time
RTMPMetaData meta(getDifTime(&first)/1000);
//Add text name
meta.AddParam(new AMFString(L"onText"));
//Set data
meta.AddParam(new AMFString(frame.GetWChar()));
//Send data
SendMetaData(&meta);
}
}
} else {
//Create frame
TextFrame frame(timeStamp,data,size);
//Create new timestamp associated to latest media time
RTMPMetaData meta(getDifTime(&first)/1000);
//Add text name
meta.AddParam(new AMFString(L"onText"));
//Set data
meta.AddParam(new AMFString(frame.GetWChar()));
//Send data
SendMetaData(&meta);
}
}
Log("<RecText\n");
}
/****************************************
* RecAudio
* Obtiene los packetes y los muestra
*****************************************/
int MediaBridgeSession::RecAudio()
{
DWORD firstAudio = 0;
DWORD timeStamp=0;
DWORD firstTS = 0;
SWORD raw[512];
DWORD rawSize = 512;
DWORD rawLen;
//Create new audio frame
RTMPAudioFrame *audio = new RTMPAudioFrame(0,RTPPAYLOADSIZE);
Log(">RecAudio\n");
//Mientras tengamos que capturar
while(receivingAudio)
{
//Obtenemos el paquete
RTPPacket *packet = rtpAudio.GetPacket();
//Check
if (!packet)
//Next
continue;
//Get type
AudioCodec::Type codec = (AudioCodec::Type)packet->GetCodec();
//Check rtp type
if (codec==AudioCodec::SPEEX16)
{
//TODO!!!!
}
//Check if we have a decoder
if (!rtpAudioDecoder || rtpAudioDecoder->type!=codec)
{
//Check
if (rtpAudioDecoder)
//Delete old one
delete(rtpAudioDecoder);
//Create new one
rtpAudioDecoder = AudioCodecFactory::CreateDecoder(codec);
}
//Decode it
rawLen = rtpAudioDecoder->Decode(packet->GetMediaData(),packet->GetMediaLength(),raw,rawSize);
//Delete packet
delete(packet);
//Rencode it
DWORD len;
while((len=rtmpAudioEncoder->Encode(raw,rawLen,audio->GetMediaData(),audio->GetMaxMediaSize()))>0)
{
//REset
rawLen = 0;
//Set length
audio->SetMediaSize(len);
switch(rtmpAudioEncoder->type)
{
case AudioCodec::SPEEX16:
//Set RTMP data
audio->SetAudioCodec(RTMPAudioFrame::SPEEX);
audio->SetSoundRate(RTMPAudioFrame::RATE11khz);
audio->SetSamples16Bits(1);
audio->SetStereo(0);
break;
case AudioCodec::NELLY8:
//Set RTMP data
audio->SetAudioCodec(RTMPAudioFrame::NELLY8khz);
audio->SetSoundRate(RTMPAudioFrame::RATE11khz);
audio->SetSamples16Bits(1);
audio->SetStereo(0);
break;
case AudioCodec::NELLY11:
//Set RTMP data
audio->SetAudioCodec(RTMPAudioFrame::NELLY);
audio->SetSoundRate(RTMPAudioFrame::RATE11khz);
audio->SetSamples16Bits(1);
audio->SetStereo(0);
break;
}
//If it is first
if (!firstTS)
{
//Get first audio time
firstAudio = getDifTime(&first)/1000;
//It is first
firstTS = timeStamp;
}
DWORD ts = firstAudio +(timeStamp-firstTS)/8;
//Set timestamp
audio->SetTimestamp(ts);
//Send packet
SendMediaFrame(audio);
}
}
//Check
if (audio)
//Delete it
delete(audio);
Log("<RecAudio\n");
}
/****************************************
* RecVideo
* Obtiene los packetes y los muestra
*****************************************/
int MediaBridgeSession::RecVideo()
{
//Coders
VideoDecoder* decoder = NULL;
VideoEncoder* encoder = VideoCodecFactory::CreateEncoder(VideoCodec::SORENSON);
//Create new video frame
RTMPVideoFrame frame(0,262143);
//Set codec
frame.SetVideoCodec(RTMPVideoFrame::FLV1);
int width=0;
int height=0;
DWORD numpixels=0;
Log(">RecVideo\n");
//Mientras tengamos que capturar
while(receivingVideo)
{
///Obtenemos el paquete
RTPPacket* packet = rtpVideo.GetPacket();
//Check
if (!packet)
//Next
continue;
//Get type
VideoCodec::Type type = (VideoCodec::Type)packet->GetCodec();
if ((decoder==NULL) || (type!=decoder->type))
{
//Si habia uno nos lo cargamos
if (decoder!=NULL)
delete decoder;
//Creamos uno dependiendo del tipo
decoder = VideoCodecFactory::CreateDecoder(type);
//Check
if (!decoder)
{
delete(packet);
continue;
}
}
//Lo decodificamos
if(!decoder->DecodePacket(packet->GetMediaData(),packet->GetMediaLength(),0,packet->GetMark()))
{
delete(packet);
continue;
}
//Get mark
bool mark = packet->GetMark();
//Delete packet
delete(packet);
//Check if it is last one
if(!mark)
continue;
//Check size
if (decoder->GetWidth()!=width || decoder->GetHeight()!=height)
{
//Get dimension
width = decoder->GetWidth();
height = decoder->GetHeight();
//Set size
numpixels = width*height*3/2;
//Set also frame rate and bps
encoder->SetFrameRate(25,300,500);
//Set them in the encoder
encoder->SetSize(width,height);
}
//Encode next frame
VideoFrame *encoded = encoder->EncodeFrame(decoder->GetFrame(),numpixels);
//Check
if (!encoded)
break;
//Check size
if (frame.GetMaxMediaSize()<encoded->GetLength())
//Not enougth space
return Error("Not enought space to copy FLV encodec frame [frame:%d,encoded:%d",frame.GetMaxMediaSize(),encoded->GetLength());
//Get full frame
frame.SetVideoFrame(encoded->GetData(),encoded->GetLength());
//Set buffer size
frame.SetMediaSize(encoded->GetLength());
//Check type
if (encoded->IsIntra())
//Set type
frame.SetFrameType(RTMPVideoFrame::INTRA);
else
//Set type
frame.SetFrameType(RTMPVideoFrame::INTER);
//Let the connection set the timestamp
frame.SetTimestamp(getDifTime(&first)/1000);
//Send it
SendMediaFrame(&frame);
}
//Check
if (decoder)
//Delete
delete(decoder);
//Check
if (encoder)
//Delete
delete(encoder);
Log("<RecVideo\n");
}
/****************************************
* RecVideo
* Obtiene los packetes y los muestra
*****************************************/
int VideoStream::RecVideo()
{
VideoDecoder* videoDecoder = NULL;
VideoCodec::Type type;
timeval before;
timeval lastFPURequest;
DWORD lostCount=0;
DWORD frameTime = (DWORD)-1;
DWORD lastSeq = RTPPacket::MaxExtSeqNum;
bool waitIntra = false;
Log(">RecVideo\n");
//Get now
gettimeofday(&before,NULL);
//Not sent FPU yet
setZeroTime(&lastFPURequest);
//Mientras tengamos que capturar
while(receivingVideo)
{
//Get RTP packet
RTPPacket* packet = rtp.GetPacket();
//Check
if (!packet)
//Next
continue;
//Get extended sequence number and timestamp
DWORD seq = packet->GetExtSeqNum();
DWORD ts = packet->GetTimestamp();
//Get packet data
BYTE* buffer = packet->GetMediaData();
DWORD size = packet->GetMediaLength();
//Get type
type = (VideoCodec::Type)packet->GetCodec();
//Lost packets since last
DWORD lost = 0;
//If not first
if (lastSeq!=RTPPacket::MaxExtSeqNum)
//Calculate losts
lost = seq-lastSeq-1;
//Increase total lost count
lostCount += lost;
//Update last sequence number
lastSeq = seq;
//If lost some packets or still have not got an iframe
if(lostCount || waitIntra)
{
//Check if we got listener and more than 1/2 second have elapsed from last request
if (listener && getDifTime(&lastFPURequest)>minFPUPeriod)
{
//Debug
Debug("-Requesting FPU lost %d\n",lostCount);
//Reset count
lostCount = 0;
//Request it
listener->onRequestFPU();
//Request also over rtp
rtp.RequestFPU();
//Update time
getUpdDifTime(&lastFPURequest);
//Waiting for refresh
waitIntra = true;
}
}
//Check if it is a redundant packet
if (type==VideoCodec::RED)
{
//Get redundant packet
RTPRedundantPacket* red = (RTPRedundantPacket*)packet;
//Get primary codec
type = (VideoCodec::Type)red->GetPrimaryCodec();
//Check it is not ULPFEC redundant packet
if (type==VideoCodec::ULPFEC)
{
//Delete packet
delete(packet);
//Skip
continue;
}
//Update primary redundant payload
buffer = red->GetPrimaryPayloadData();
size = red->GetPrimaryPayloadSize();
}
//Check codecs
if ((videoDecoder==NULL) || (type!=videoDecoder->type))
{
//If we already got one
if (videoDecoder!=NULL)
//Delete it
delete videoDecoder;
//Create video decorder for codec
videoDecoder = VideoCodecFactory::CreateDecoder(type);
//Check
if (videoDecoder==NULL)
{
Error("Error creando nuevo decodificador de video [%d]\n",type);
//Delete packet
delete(packet);
//Next
continue;
}
}
//Check if we have lost the last packet from the previous frame by comparing both timestamps
if (ts>frameTime)
{
Debug("-lost mark packet ts:%u frameTime:%u\n",ts,frameTime);
//Try to decode what is in the buffer
videoDecoder->DecodePacket(NULL,0,1,1);
//Get picture
BYTE *frame = videoDecoder->GetFrame();
DWORD width = videoDecoder->GetWidth();
DWORD height = videoDecoder->GetHeight();
//Check values
if (frame && width && height)
{
//Set frame size
videoOutput->SetVideoSize(width,height);
//Check if muted
if (!muted)
//Send it
videoOutput->NextFrame(frame);
}
}
//Update frame time
frameTime = ts;
//Decode packet
if(!videoDecoder->DecodePacket(buffer,size,lost,packet->GetMark()))
{
//Check if we got listener and more than 1/2 seconds have elapsed from last request
if (listener && getDifTime(&lastFPURequest)>minFPUPeriod)
{
//Debug
Log("-Requesting FPU decoder error\n");
//Reset count
lostCount = 0;
//Request it
listener->onRequestFPU();
//Request also over rtp
rtp.RequestFPU();
//Update time
getUpdDifTime(&lastFPURequest);
//Waiting for refresh
waitIntra = true;
}
}
//Check if it is the last packet of a frame
if(packet->GetMark())
{
if (videoDecoder->IsKeyFrame())
Debug("-Got Intra\n");
//No frame time yet for next frame
frameTime = (DWORD)-1;
//Get picture
BYTE *frame = videoDecoder->GetFrame();
DWORD width = videoDecoder->GetWidth();
DWORD height = videoDecoder->GetHeight();
//Check values
if (frame && width && height)
{
//Set frame size
videoOutput->SetVideoSize(width,height);
//Check if muted
if (!muted)
//Send it
videoOutput->NextFrame(frame);
}
//Check if we got the waiting refresh
if (waitIntra && videoDecoder->IsKeyFrame())
//Do not wait anymore
waitIntra = false;
}
//Delete packet
delete(packet);
}
//Delete encoder
delete videoDecoder;
Log("<RecVideo\n");
}
