QVariant MemoryPacketModel::data(const QModelIndex &index, int role) const
{
if (!index.isValid())
return QVariant();
int row = index.row();
int column = index.column();
const Packet * packet = packetsList.value(row,nullptr);
return payloadData(packet,column, role);
}
static void appTaskUARTWrite(void *pdata) {
uint8_t osStatus;
static xbeeBuffer_t packet;
char payload[256];
uint32_t packetLen;
payloadPublish(payload, NODE_DESCRIPTION);
packetLen = xbee.xbeeMkPacketFromString(packet, payload);
xbee.xbeeTxPacket(packet, packetLen);
while ( true ) {
OSSemPend(dataSem, 0, &osStatus);
payloadData(payload, nodeData);
packetLen = xbee.xbeeMkPacketFromString(packet, payload);
xbee.xbeeTxPacket(packet, packetLen);
}
}
bool
RTMP::readPacketPayload(RTMPPacket& packet)
{
RTMPHeader& hr = packet.header;
const size_t bytesRead = packet.bytesRead;
const int nToRead = hr.dataSize - bytesRead;
const int nChunk = std::min<int>(nToRead, _inChunkSize);
assert(nChunk >= 0);
// This is fine. We'll keep trying to read this payload until there
// is enough data.
if (readSocket(payloadData(packet) + bytesRead, nChunk) != nChunk) {
return false;
}
packet.bytesRead += nChunk;
return true;
}
InertialDataFields InertialParser::parseFields(InertialPacket& packet)
{
InertialDataFields result;
uint8 fieldDescriptor;
uint16 fieldType;
uint32 fieldLen;
uint8 descriptorSet = packet.descriptorSet();
//create a DataBuffer to make parsing easier
DataBuffer payloadData(packet.payload());
while(payloadData.moreToRead())
{
Bytes fieldBytes;
//read the field length byte
fieldLen = payloadData.read_uint8();
//read the field descriptor byte
fieldDescriptor = payloadData.read_uint8();
//read all the bytes for the current field (up to the field length)
for(uint32 itr = 0; itr < fieldLen - 2; itr++)
{
//add the field bytes to a container
fieldBytes.push_back(payloadData.read_uint8());
}
fieldType = Utils::make_uint16(descriptorSet, fieldDescriptor);
//add the field to the m_dataFields vector
InertialDataField tempField(fieldType, fieldBytes);
result.push_back(tempField);
}
return result;
}
const ConfigValue
FRTConfigResponseV3::readConfigValue() const
{
vespalib::string md5(_data->get()[RESPONSE_CONFIG_MD5].asString().make_string());
CompressionInfo info;
info.deserialize(_data->get()[RESPONSE_COMPRESSION_INFO]);
Slime * rawData = new Slime();
SlimePtr payloadData(rawData);
DecompressedData data(decompress(((*_returnValues)[1]._data._buf), ((*_returnValues)[1]._data._len), info.compressionType, info.uncompressedSize));
if (data.memRef.size > 0) {
size_t consumedSize = JsonFormat::decode(data.memRef, *rawData);
if (consumedSize == 0) {
std::string json(make_json(*payloadData, true));
LOG(error, "Error decoding JSON. Consumed size: %lu, uncompressed size: %u, compression type: %s, assumed uncompressed size(%u), compressed size: %u, slime(%s)", consumedSize, data.size, compressionTypeToString(info.compressionType).c_str(), info.uncompressedSize, ((*_returnValues)[1]._data._len), json.c_str());
LOG_ABORT("Error decoding JSON");
}
}
if (LOG_WOULD_LOG(spam)) {
LOG(spam, "read config value md5(%s), payload size: %lu", md5.c_str(), data.memRef.size);
}
return ConfigValue(PayloadPtr(new V3Payload(payloadData)), md5);
}
bool
RTMP::sendPacket(RTMPPacket& packet)
{
// Set the data size of the packet to send.
RTMPHeader& hr = packet.header;
hr.dataSize = payloadSize(packet);
// This is the timestamp for our message.
const std::uint32_t uptime = getUptime();
// Look at the previous packet on the channel.
bool prev = hasPacket(CHANNELS_OUT, hr.channel);
// The packet shall be large if it contains an absolute timestamp.
// * This is necessary if there is no previous packet, or if the
// timestamp is smaller than the last packet.
// Else it shall be medium if data size and packet type are the same
// It shall be small if ...
// It shall be minimal if it is exactly the same as its predecessor.
// All packets should start off as large. They will stay large if there
// is no previous packet.
assert(hr.headerType == RTMP_PACKET_SIZE_LARGE);
if (!prev) {
hr._timestamp = uptime;
}
else {
const RTMPPacket& prevPacket = getPacket(CHANNELS_OUT, hr.channel);
const RTMPHeader& oldh = prevPacket.header;
const std::uint32_t prevTimestamp = oldh._timestamp;
// If this timestamp is later than the other and the difference fits
// in 3 bytes, encode a relative one.
if (uptime >= oldh._timestamp && uptime - prevTimestamp < 0xffffff) {
//log_debug("Shrinking to medium");
hr.headerType = RTMP_PACKET_SIZE_MEDIUM;
hr._timestamp = uptime - prevTimestamp;
// It can be still smaller if the data size is the same.
if (oldh.dataSize == hr.dataSize &&
oldh.packetType == hr.packetType) {
//log_debug("Shrinking to small");
hr.headerType = RTMP_PACKET_SIZE_SMALL;
// If there is no timestamp difference, the minimum size
// is possible.
if (hr._timestamp == 0) {
//log_debug("Shrinking to minimum");
hr.headerType = RTMP_PACKET_SIZE_MINIMUM;
}
}
}
else {
// Otherwise we need an absolute one, so a large header.
hr.headerType = RTMP_PACKET_SIZE_LARGE;
hr._timestamp = uptime;
}
}
assert (hr.headerType < 4);
int nSize = packetSize[hr.headerType];
int hSize = nSize;
std::uint8_t* header;
std::uint8_t* hptr;
std::uint8_t* hend;
std::uint8_t c;
// If there is a payload, the same buffer is used to write the header.
// Otherwise a separate buffer is used. But as we write them separately
// anyway, why do we do that?
// Work out where the beginning of the header is.
header = payloadData(packet) - nSize;
hend = payloadData(packet);
// The header size includes only a single channel/type. If we need more,
// they have to be added on.
const int channelSize = hr.channel > 319 ? 3 : hr.channel > 63 ? 1 : 0;
header -= channelSize;
hSize += channelSize;
/// Add space for absolute timestamp if necessary.
if (hr.headerType == RTMP_PACKET_SIZE_LARGE && hr._timestamp >= 0xffffff) {
header -= 4;
hSize += 4;
}
hptr = header;
c = hr.headerType << 6;
switch (channelSize) {
case 0:
c |= hr.channel;
break;
case 1:
break;
case 2:
c |= 1;
break;
}
*hptr++ = c;
if (channelSize) {
const int tmp = hr.channel - 64;
*hptr++ = tmp & 0xff;
if (channelSize == 2) *hptr++ = tmp >> 8;
}
if (hr.headerType == RTMP_PACKET_SIZE_LARGE && hr._timestamp >= 0xffffff) {
// Signify that the extended timestamp field is present.
const std::uint32_t t = 0xffffff;
hptr = encodeInt24(hptr, hend, t);
}
else if (hr.headerType != RTMP_PACKET_SIZE_MINIMUM) {
// Write absolute or relative timestamp. Only minimal packets have
// no timestamp.
hptr = encodeInt24(hptr, hend, hr._timestamp);
}
/// Encode dataSize and packet type for medium packets.
if (nSize > 4) {
hptr = encodeInt24(hptr, hend, hr.dataSize);
*hptr++ = hr.packetType;
}
/// Encode streamID for large packets.
if (hr.headerType == RTMP_PACKET_SIZE_LARGE) {
hptr += encodeInt32LE(hptr, hr._streamID);
}
// Encode extended absolute timestamp if needed.
if (hr.headerType == RTMP_PACKET_SIZE_LARGE && hr._timestamp >= 0xffffff) {
hptr += encodeInt32LE(hptr, hr._timestamp);
}
nSize = hr.dataSize;
std::uint8_t *buffer = payloadData(packet);
int nChunkSize = _outChunkSize;
std::string hx = hexify(header, payloadEnd(packet) - header, false);
while (nSize + hSize) {
if (nSize < nChunkSize) nChunkSize = nSize;
// First write header.
if (header) {
const int chunk = nChunkSize + hSize;
if (_socket.write(header, chunk) != chunk) {
return false;
}
header = nullptr;
hSize = 0;
}
else {
// Then write data.
if (_socket.write(buffer, nChunkSize) != nChunkSize) {
return false;
}
}
nSize -= nChunkSize;
buffer += nChunkSize;
if (nSize > 0) {
header = buffer - 1;
hSize = 1;
if (channelSize) {
header -= channelSize;
hSize += channelSize;
}
*header = (0xc0 | c);
if (channelSize) {
int tmp = hr.channel - 64;
header[1] = tmp & 0xff;
if (channelSize == 2) header[2] = tmp >> 8;
}
}
}
void
RTMP::handlePacket(const RTMPPacket& packet)
{
const PacketType t = packet.header.packetType;
log_debug("Received %s", t);
switch (t) {
case PACKET_TYPE_CHUNK_SIZE:
handleChangeChunkSize(*this, packet);
break;
case PACKET_TYPE_BYTES_READ:
break;
case PACKET_TYPE_CONTROL:
handleControl(*this, packet);
break;
case PACKET_TYPE_SERVERBW:
handleServerBW(*this, packet);
break;
case PACKET_TYPE_CLIENTBW:
handleClientBW(*this, packet);
break;
case PACKET_TYPE_AUDIO:
if (!m_mediaChannel) m_mediaChannel = packet.header.channel;
break;
case PACKET_TYPE_VIDEO:
if (!m_mediaChannel) m_mediaChannel = packet.header.channel;
break;
case PACKET_TYPE_FLEX_STREAM_SEND:
LOG_ONCE(log_unimpl(_("unsupported packet received")));
break;
case PACKET_TYPE_FLEX_SHARED_OBJECT:
LOG_ONCE(log_unimpl(_("unsupported packet received")));
break;
case PACKET_TYPE_FLEX_MESSAGE:
{
LOG_ONCE(log_unimpl(_("partially supported packet %s received")));
_messageQueue.push_back(packet.buffer);
break;
}
case PACKET_TYPE_METADATA:
handleMetadata(*this, payloadData(packet), payloadSize(packet));
break;
case PACKET_TYPE_SHARED_OBJECT:
LOG_ONCE(log_unimpl(_("packet %s received")));
break;
case PACKET_TYPE_INVOKE:
_messageQueue.push_back(packet.buffer);
break;
case PACKET_TYPE_FLV:
_flvQueue.push_back(packet.buffer);
break;
default:
log_error(_("Unknown packet %s received"), t);
}
}
