onekopaka/Darwin-Streaming-Server
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Add even more of the source

Browse source 
This should be about everything needed to build so far?
This commit is contained in:
Darren VanBuren 2017-03-07 17:14:16 -08:00
parent af3619d4fa
commit 849723c9cf
547 changed files with 149239 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

241
RTPMetaInfoLib/RTPMetaInfoPacket.cpp Normal file
View file

@ -0,0 +1,241 @@
/*
*
* @APPLE_LICENSE_HEADER_START@
*
* Copyright (c) 1999-2008 Apple Inc. All Rights Reserved.
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The Original Code and all software distributed under the License are
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*
*/
//
// RTPMetaInfo.h:
// Some defs for RTP-Meta-Info payloads.
#include "RTPMetaInfoPacket.h"
#include "MyAssert.h"
#include "StringParser.h"
#include "OS.h"
#include <string.h>
#ifndef __Win32__
#include <netinet/in.h>
#endif
const RTPMetaInfoPacket::FieldName RTPMetaInfoPacket::kFieldNameMap[] =
{
TW0_CHARS_TO_INT('p', 'p'),
TW0_CHARS_TO_INT('t', 't'),
TW0_CHARS_TO_INT('f', 't'),
TW0_CHARS_TO_INT('p', 'n'),
TW0_CHARS_TO_INT('s', 'q'),
TW0_CHARS_TO_INT('m', 'd')
};
const UInt32 RTPMetaInfoPacket::kFieldLengthValidator[] =
{
8, //pp
8, //tt
2, //ft
8, //pn
2, //sq
0, //md
0 //illegal / unknown
};
RTPMetaInfoPacket::FieldIndex RTPMetaInfoPacket::GetFieldIndexForName(FieldName inName)
{
for (int x = 0; x < kNumFields; x++)
{
if (inName == kFieldNameMap[x])
return x;
}
return kIllegalField;
}
void RTPMetaInfoPacket::ConstructFieldIDArrayFromHeader(StrPtrLen* inHeader, FieldID* ioFieldIDArray)
{
for (UInt32 x = 0; x < kNumFields; x++)
ioFieldIDArray[x] = kFieldNotUsed;
//
// Walk through the fields in this header
StringParser theParser(inHeader);
UInt16 fieldNameValue = 0;
while (theParser.GetDataRemaining() > 0)
{
StrPtrLen theFieldP;
(void)theParser.GetThru(&theFieldP, ';');
//
// Corrupt or something... just bail
if (theFieldP.Len < 2)
break;
//
// Extract the Field Name and convert it to a Field Index
::memcpy (&fieldNameValue, theFieldP.Ptr, sizeof(UInt16));
FieldIndex theIndex = RTPMetaInfoPacket::GetFieldIndexForName(ntohs(fieldNameValue));
// FieldIndex theIndex = RTPMetaInfoPacket::GetFieldIndexForName(ntohs(*(UInt16*)theFieldP.Ptr));
//
// Get the Field ID if there is one.
FieldID theID = kUncompressed;
if (theFieldP.Len > 3)
{
StringParser theIDExtractor(&theFieldP);
theIDExtractor.ConsumeLength(NULL, 3);
theID = theIDExtractor.ConsumeInteger(NULL);
}
if (theIndex != kIllegalField)
ioFieldIDArray[theIndex] = theID;
}
}
Bool16 RTPMetaInfoPacket::ParsePacket(UInt8* inPacketBuffer, UInt32 inPacketLen, FieldID* inFieldIDArray)
{
UInt8* theFieldP = inPacketBuffer + 12; // skip RTP header
UInt8* theEndP = inPacketBuffer + inPacketLen;
SInt64 sInt64Val = 0;
UInt16 uInt16Val = 0;
while (theFieldP < (theEndP - 2))
{
FieldIndex theFieldIndex = kIllegalField;
UInt32 theFieldLen = 0;
FieldName* theFieldName = (FieldName*)theFieldP;
if (*theFieldName & 0x8000)
{
Assert(inFieldIDArray != NULL);
// If this is a compressed field, find to which field the ID maps
UInt8 theFieldID = *theFieldP & 0x7F;
for (int x = 0; x < kNumFields; x++)
{
if (theFieldID == inFieldIDArray[x])
{
theFieldIndex = x;
break;
}
}
theFieldLen = *(theFieldP + 1);
theFieldP += 2;
}
else
{
// This is not a compressed field. Make sure there is enough room
// in the packet for this to make sense
if (theFieldP >= (theEndP - 4))
break;
::memcpy(&uInt16Val, theFieldP, sizeof(uInt16Val));
theFieldIndex = this->GetFieldIndexForName(ntohs(uInt16Val));
::memcpy(&uInt16Val, theFieldP + 2, sizeof(uInt16Val));
theFieldLen = ntohs(uInt16Val);
theFieldP += 4;
}
//
// Validate the length of this field if possible.
// If the field is of the wrong length, return an error.
if ((kFieldLengthValidator[theFieldIndex] > 0) &&
(kFieldLengthValidator[theFieldIndex] != theFieldLen))
return false;
if ((theFieldP + theFieldLen) > theEndP)
return false;
//
// We now know what field we are dealing with, so store off
// the proper value depending on the field
switch (theFieldIndex)
{
case kPacketPosField:
{
::memcpy(&sInt64Val, theFieldP, sizeof(sInt64Val));
fPacketPosition = (UInt64)OS::NetworkToHostSInt64(sInt64Val);
break;
}
case kTransTimeField:
{
::memcpy(&sInt64Val, theFieldP, sizeof(sInt64Val));
fTransmitTime = (UInt64)OS::NetworkToHostSInt64(sInt64Val);
break;
}
case kFrameTypeField:
{
fFrameType = ntohs(*((FrameTypeField*)theFieldP));
break;
}
case kPacketNumField:
{
::memcpy(&sInt64Val, theFieldP, sizeof(sInt64Val));
fPacketNumber = (UInt64)OS::NetworkToHostSInt64(sInt64Val);
break;
}
case kSeqNumField:
{
::memcpy(&uInt16Val, theFieldP, sizeof(uInt16Val));
fSeqNum = ntohs(uInt16Val);
break;
}
case kMediaDataField:
{
fMediaDataP = theFieldP;
fMediaDataLen = theFieldLen;
break;
}
default:
break;
}
//
// Skip onto the next field
theFieldP += theFieldLen;
}
return true;
}
UInt8* RTPMetaInfoPacket::MakeRTPPacket(UInt32* outPacketLen)
{
if (fMediaDataP == NULL)
return NULL;
//
// Just move the RTP header to right before the media data.
::memmove(fMediaDataP - 12, fPacketBuffer, 12);
//
// Report the length of the resulting RTP packet
if (outPacketLen != NULL)
*outPacketLen = fMediaDataLen + 12;
return fMediaDataP - 12;
}