void Bwx::ReplaceThrow(const Brx& aBuf)
{
if (aBuf.Bytes() > MaxBytes()) {
THROW(BufferOverflow);
}
else
{
const TByte* dest = Ptr();
ASSERT(dest != NULL);
const TByte* src = aBuf.Ptr();
ASSERT(src != NULL);
(void)memmove(const_cast<TByte*>(dest), src, aBuf.Bytes());
iBytes = aBuf.Bytes();
}
}
void OhmSenderDriverWindows::Resend(const Brx& aFrames)
{
KSPROPERTY prop;
prop.Set = OHSOUNDCARD_GUID;
prop.Id = KSPROPERTY_OHSOUNDCARD_RESEND;
prop.Flags = KSPROPERTY_TYPE_SET;
DWORD returned;
LPVOID ptr = (LPVOID) aFrames.Ptr();
DWORD bytes = aFrames.Bytes();
DeviceIoControl(iHandle, IOCTL_KS_PROPERTY, &prop, sizeof(KSPROPERTY), ptr, bytes, &returned, 0);
}
const Brn CommandTokens::GetNextToken(const Brx& aValue, TUint& aIndex)
{
const TByte* start = aValue.Ptr() + aIndex;
TUint bytes = aValue.Bytes();
ASSERT(aIndex <= bytes)
for (;;)
{
if (aIndex == bytes)
{
return (Brn(start, 0));
}
if (*start != ' ')
{
break;
}
aIndex++;
start++;
}
const TByte* ptr = start;
aIndex++;
ptr++;
TUint count = 1;
for (;;)
{
if (aIndex == bytes)
{
break;
}
if (*ptr == ' ')
{
break;
}
aIndex++;
ptr++;
count++;
}
return (Brn(start, count));
}
TInt Log::Print(FunctorMsg& aOutput, const Brx& aMessage)
{
TUint remaining = aMessage.Bytes();
TInt ret = 0;
const TByte* ptr = aMessage.Ptr();
while (remaining > 0) {
TInt len = (remaining<kMaxPrintBytes? remaining : kMaxPrintBytes);
remaining -= len;
TChar temp[kMaxPrintBytes+1];
Bwn msg(temp, len, kMaxPrintBytes+1);
msg.Replace(ptr, len);
msg.PtrZ();
ret += DoPrint(aOutput, msg.Ptr());
ptr += len;
}
return ret;
}
void PcmProcessorLe::ProcessFragment24(const Brx& aData, TUint aNumChannels)
{
TByte *nData;
TUint bytes;
// 24 bit audio is not supported on the platform so it is converted
// to signed 16 bit audio for playback.
//
// Accordingly one third of the input data is discarded.
bytes = (aData.Bytes() * 2) / 3;
// If we are manually converting mono to stereo the data will double.
if (iDuplicateChannel)
{
bytes *= 2;
}
nData = new TByte[bytes];
ASSERT(nData != NULL);
TByte *ptr = (TByte *)(aData.Ptr() + 0);
TByte *ptr1 = (TByte *)nData;
TByte *endp = ptr1 + bytes;
ASSERT(bytes % 2 == 0);
while (ptr1 < endp)
{
// Store the data in little endian format.
*ptr1++ = *(ptr+1);
*ptr1++ = *(ptr+0);
if (iDuplicateChannel)
{
*ptr1++ = *(ptr+1);
*ptr1++ = *(ptr+0);
}
ptr += 3;
}
Brn fragment(nData, bytes);
Flush();
iSink.Write(fragment);
delete[] nData;
}
void PcmProcessorLe::ProcessFragment8(const Brx& aData, TUint aNumChannels)
{
TByte *nData;
TUint bytes;
// The input data is converted from unsigned 8 bit to signed 16 bit.
// to removes poor audio quality and glitches when part of a playlist
// with tracks of a different bit depth.
//
// Accordingly the amount of data is doubled.
bytes = aData.Bytes() * 2;
// If we are manually converting mono to stereo the data will double.
if (iDuplicateChannel)
{
bytes *= 2;
}
nData = new TByte[bytes];
ASSERT(nData != NULL);
TByte *ptr = (TByte *)(aData.Ptr() + 0);
TByte *ptr1 = (TByte *)nData;
TByte *endp = ptr1 + bytes;
while (ptr1 < endp)
{
// Convert U8 to S16 data in little endian format.
*ptr1++ = 0x00;
*ptr1++ = *ptr - 0x80;
if (iDuplicateChannel)
{
*ptr1++ = 0x00;
*ptr1++ = *ptr - 0x80;
}
ptr++;
}
Brn fragment(nData, bytes);
Flush();
iSink.Write(fragment);
delete[] nData;
}
void HeaderSoapAction::Process(const Brx& aValue)
{
SetReceived();
// remove quotes if present
Brn value(aValue);
TUint bytes = value.Bytes();
if (bytes >= 2 && value[0] == '\"' && value[bytes - 1] == '\"') {
value.Set(aValue.Ptr() + 1, bytes - 2);
}
Parser parser(value);
if (parser.Next(':') != Brn("urn")) {
THROW(HttpError);
}
Brn domain = parser.Next(':');
iDomain.Grow(domain.Bytes() + 10);
Ssdp::UpnpDomainToCanonical(domain, iDomain);
if (!iDomain.Bytes()) {
THROW(HttpError);
}
if (parser.Next(':') != Brn("service")) {
THROW(HttpError);
}
iType.Set(parser.Next(':'));
if (!iType.Bytes()) {
THROW(HttpError);
}
try {
iVersion = Ascii::Uint(parser.Next('#'));
}
catch (AsciiError) { // version not numeric
THROW(HttpError);
}
iAction.Set(Ascii::Trim(parser.Remaining()));
if (!iAction.Bytes()) {
THROW(HttpError);
}
}
void Swx::Write(const Brx& aBuffer)
{
TByte* ptr = Ptr();
TUint bytes = aBuffer.Bytes();
if (iBytes + bytes > iMaxBytes) { // would overflow, drain the buffer
WriteDrain();
if (bytes > iMaxBytes) { // would still overflow
try {
iWriter.Write(aBuffer); // pass it on
return;
}
catch (WriterError&) {
Error();
}
}
}
memcpy(ptr + iBytes, aBuffer.Ptr(), bytes);
iBytes += bytes;
}
void PcmProcessorLe::ProcessFragment16(const Brx& aData, TUint aNumChannels)
{
TByte *nData;
TUint bytes;
bytes = aData.Bytes();
// If we are manually converting mono to stereo the data will double.
if (iDuplicateChannel)
{
bytes *= 2;
}
nData = new TByte[bytes];
ASSERT(nData != NULL);
TByte *ptr = (TByte *)(aData.Ptr() + 0);
TByte *ptr1 = (TByte *)nData;
TByte *endp = ptr1 + bytes;
ASSERT(bytes % 2 == 0);
while (ptr1 < endp)
{
// Store the S16 data in little endian format.
*ptr1++ = *(ptr+1);
*ptr1++ = *(ptr);
if (iDuplicateChannel)
{
*ptr1++ = *(ptr+1);
*ptr1++ = *(ptr);
}
ptr +=2;
}
Brn fragment(nData, bytes);
Flush();
iSink.Write(fragment);
delete[] nData;
}
void OutputProcessorDv::ProcessUint(const Brx& aBuffer, TUint& aVal)
{
ASSERT(aBuffer.Bytes() == 4);
(void)memcpy(&aVal, aBuffer.Ptr(), 4);
}
void XmlParserBasic::NextTag(const Brx& aDocument, Brn& aName, Brn& aAttributes, Brn& aNamespace, TUint& aIndex, Brn& aRemaining, ETagType& aType)
{
aName.Set(Brx::Empty());
aAttributes.Set(Brx::Empty());
aNamespace.Set(Brx::Empty());
aRemaining.Set(Brx::Empty());
Parser parser(aDocument);
for (;;) {
Brn item = parser.Next('>');
TUint bytes = item.Bytes();
if (bytes > 0 && item[0] != '<') {
Parser valueParser(item);
Brn value = valueParser.Next('<');
bytes -= value.Bytes();
item.Set(item.Split(value.Bytes(), bytes));
item.Set(Ascii::Trim(item));
bytes = item.Bytes();
}
if (bytes < 2 || item[0] != '<') {
THROW(XmlError);
}
aIndex = (TUint)(item.Ptr() - aDocument.Ptr());
if (item[1] == '?') {
if (bytes < 3) { // catch special case of <?>
THROW(XmlError);
}
if (item[bytes - 1] == '?') { // processing instruction
continue;
}
THROW(XmlError);
}
aRemaining.Set(parser.Remaining());
TUint start = 1; // skip opening '<'
TUint len = bytes-1;
if (item[1] == '/') {
aType = eTagClose;
start++;
len--;
}
else if (item[bytes-1] == '/') {
aType = eTagOpenClose;
len--;
}
else {
aType = eTagOpen;
}
parser.Set(item.Split(start, len));
aName.Set(parser.NextWhiteSpace());
aAttributes.Set(parser.Remaining());
if (Ascii::Contains(aName, ':')) { // collect the namespace
parser.Set(aName);
aNamespace.Set(parser.Next(':'));
if (!aNamespace.Bytes()) {
THROW(XmlError);
}
aName.Set(parser.Remaining());
}
else {
aNamespace.Set(Brx::Empty());
}
if (!aName.Bytes()) {
THROW(XmlError);
}
return;
}
}
void Bwx::Append(const Brx& aB)
{
const TByte* ptr = aB.Ptr();
ASSERT(ptr != NULL);
Append(ptr, aB.Bytes());
}
