logging/rtc_event_log/events/rtc_event_field_encoding_parser.cc - src - Git at Google


 /*
  *  Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */

 #include "logging/rtc_event_log/events/rtc_event_field_encoding_parser.h"

 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 #include "logging/rtc_event_log/encoder/var_int.h"
 #include "logging/rtc_event_log/events/rtc_event_field_encoding.h"
 #include "rtc_base/bitstream_reader.h"
 #include "rtc_base/checks.h"

 namespace {
 absl::optional<webrtc::FieldType> ConvertFieldType(uint64_t value) {
   switch (value) {
     case static_cast<uint64_t>(webrtc::FieldType::kFixed8):
       return webrtc::FieldType::kFixed8;
     case static_cast<uint64_t>(webrtc::FieldType::kFixed32):
       return webrtc::FieldType::kFixed32;
     case static_cast<uint64_t>(webrtc::FieldType::kFixed64):
       return webrtc::FieldType::kFixed64;
     case static_cast<uint64_t>(webrtc::FieldType::kVarInt):
       return webrtc::FieldType::kVarInt;
     case static_cast<uint64_t>(webrtc::FieldType::kString):
       return webrtc::FieldType::kString;
     default:
       return absl::nullopt;
   }
 }
 }  // namespace

 namespace webrtc {

 uint64_t EventParser::ReadLittleEndian(uint8_t bytes) {
   RTC_DCHECK_LE(bytes, sizeof(uint64_t));
   RTC_DCHECK_GE(bytes, 1);

   uint64_t value = 0;

   if (bytes > pending_data_.length()) {
     SetError();
     return value;
   }

   const uint8_t* p = reinterpret_cast<const uint8_t*>(pending_data_.data());
   unsigned int shift = 0;
   uint8_t remaining = bytes;
   while (remaining > 0) {
     value += (static_cast<uint64_t>(*p) << shift);
     shift += 8;
     ++p;
     --remaining;
   }

   pending_data_ = pending_data_.substr(bytes);
   return value;
 }

 uint64_t EventParser::ReadVarInt() {
   uint64_t output = 0;
   bool success;
   std::tie(success, pending_data_) = DecodeVarInt(pending_data_, &output);
   if (!success) {
     SetError();
   }
   return output;
 }

 uint64_t EventParser::ReadOptionalValuePositions(std::vector<bool>* positions) {
   if (!positions) {
     return CountAndIgnoreOptionalValuePositions();
   }

   size_t bits_to_read = NumEventsInBatch();
   RTC_DCHECK(positions->empty());
   if (pending_data_.size() * 8 < bits_to_read) {
     SetError();
     return 0;
   }

   BitstreamReader reader(pending_data_);
   for (size_t i = 0; i < bits_to_read; i++) {
     positions->push_back(reader.ReadBit());
   }
   if (!reader.Ok()) {
     SetError();
     return 0;
   }

   size_t num_existing_values =
       std::count(positions->begin(), positions->end(), true);
   pending_data_ = pending_data_.substr((bits_to_read + 7) / 8);
   return num_existing_values;
 }

 uint64_t EventParser::CountAndIgnoreOptionalValuePositions() {
   size_t bits_to_read = NumEventsInBatch();
   if (pending_data_.size() * 8 < bits_to_read) {
     SetError();
     return 0;
   }

   BitstreamReader reader(pending_data_);
   size_t num_existing_values = 0;
   for (size_t i = 0; i < bits_to_read; i++) {
     if (reader.ReadBit()) {
       ++num_existing_values;
     }
   }
   if (!reader.Ok()) {
     SetError();
     return 0;
   }

   pending_data_ = pending_data_.substr((bits_to_read + 7) / 8);
   return num_existing_values;
 }

 uint64_t EventParser::ReadSingleValue(FieldType field_type) {
   switch (field_type) {
     case FieldType::kFixed8:
       return ReadLittleEndian(/*bytes=*/1);
     case FieldType::kFixed32:
       return ReadLittleEndian(/*bytes=*/4);
     case FieldType::kFixed64:
       return ReadLittleEndian(/*bytes=*/8);
     case FieldType::kVarInt:
       return ReadVarInt();
     case FieldType::kString:
       RTC_NOTREACHED();
       SetError();
       return 0;
   }
 }

 void EventParser::ReadDeltasAndPopulateValues(
     FixedLengthEncodingParametersV3 params,
     uint64_t num_deltas,
     uint64_t base,
     std::vector<uint64_t>* values) {
   RTC_CHECK(values != nullptr);
   RTC_DCHECK(values->empty());
   values->reserve(num_deltas + 1);
   values->push_back(base);

   if (pending_data_.size() * 8 < num_deltas * params.delta_bit_width()) {
     SetError();
     return;
   }

   BitstreamReader reader(pending_data_);
   const uint64_t top_bit = static_cast<uint64_t>(1)
                            << (params.delta_bit_width() - 1);

   uint64_t value = base;
   for (uint64_t i = 0; i < num_deltas; ++i) {
     uint64_t delta = reader.ReadBits(params.delta_bit_width());
     RTC_DCHECK_LE(value, webrtc_event_logging::MaxUnsignedValueOfBitWidth(
                              params.value_bit_width()));
     RTC_DCHECK_LE(delta, webrtc_event_logging::MaxUnsignedValueOfBitWidth(
                              params.delta_bit_width()));
     bool negative_delta = params.signed_deltas() && ((delta & top_bit) != 0);
     if (negative_delta) {
       uint64_t delta_abs = (~delta & params.delta_mask()) + 1;
       value = (value - delta_abs) & params.value_mask();
     } else {
       value = (value + delta) & params.value_mask();
     }
     values->push_back(value);
   }

   if (!reader.Ok()) {
     SetError();
     return;
   }

   pending_data_ =
       pending_data_.substr((num_deltas * params.delta_bit_width() + 7) / 8);
 }

 RtcEventLogParseStatus EventParser::Initialize(absl::string_view s,
                                                bool batched) {
   pending_data_ = s;
   num_events_ = 1;

   if (batched) {
     num_events_ = ReadVarInt();
     if (!Ok()) {
       return RtcEventLogParseStatus::Error(
           "Failed to read number of events in batch.", __FILE__, __LINE__);
     }
   }
   return RtcEventLogParseStatus::Success();
 }

 RtcEventLogParseStatus EventParser::ParseField(const FieldParameters& params,
                                                std::vector<uint64_t>* values,
                                                std::vector<bool>* positions) {
   RTC_CHECK(values != nullptr);

   // Verify that the event parses fields in increasing order.
   if (params.field_id == FieldParameters::kTimestampField) {
     RTC_DCHECK_EQ(last_field_id_, FieldParameters::kTimestampField);
   } else {
     RTC_DCHECK_GT(params.field_id, last_field_id_);
   }
   last_field_id_ = params.field_id;

   // Initialization for positional fields that don't encode field ID and type.
   uint64_t field_id = params.field_id;
   FieldType field_type = params.field_type;

   // Fields are encoded in increasing field_id order.
   // Skip unknown fields with field_id < params.field_id until we either
   // find params.field_id or a field with higher id, in which case we know that
   // params.field_id doesn't exist.
   while (!pending_data_.empty()) {
     absl::string_view field_start = pending_data_;
     values->clear();
     if (positions) {
       positions->clear();
     }

     // Read tag for non-positional fields.
     if (params.field_id != FieldParameters::kTimestampField) {
       uint64_t field_tag = ReadVarInt();
       if (!Ok())
         return RtcEventLogParseStatus::Error("Failed to read field tag",
                                              __FILE__, __LINE__);
       // Split tag into field ID and field type.
       field_id = field_tag >> 3;
       absl::optional<FieldType> conversion = ConvertFieldType(field_tag & 7u);
       if (!conversion.has_value())
         return RtcEventLogParseStatus::Error("Failed to parse field type",
                                              __FILE__, __LINE__);
       field_type = conversion.value();
     }

     if (field_id > params.field_id) {
       // We've passed all fields with ids less than or equal to what we are
       // looking for. Reset pending_data_ to first field with id higher than
       // params.field_id, since we didn't find the field we were looking for.
       pending_data_ = field_start;
       return RtcEventLogParseStatus::Success();
     }

     if (num_events_ == 1) {
       // Just a single value in the batch.
       uint64_t base = ReadSingleValue(field_type);
       if (!Ok())
         return RtcEventLogParseStatus::Error("Failed to read value", __FILE__,
                                              __LINE__);
       if (positions) {
         positions->push_back(true);
       }
       values->push_back(base);
     } else {
       // Delta compressed batch.
       // Read delta header.
       uint64_t header_value = ReadVarInt();
       if (!Ok())
         return RtcEventLogParseStatus::Error("Failed to read delta header",
                                              __FILE__, __LINE__);
       // NB: value_width may be incorrect for the field, if this isn't the field
       // we are looking for.
       absl::optional<FixedLengthEncodingParametersV3> delta_header =
           FixedLengthEncodingParametersV3::ParseDeltaHeader(header_value,
                                                             params.value_width);
       if (!delta_header.has_value()) {
         return RtcEventLogParseStatus::Error("Failed to parse delta header",
                                              __FILE__, __LINE__);
       }

       uint64_t num_existing_deltas = NumEventsInBatch() - 1;
       if (delta_header->values_optional()) {
         size_t num_nonempty_values = ReadOptionalValuePositions(positions);
         if (!Ok()) {
           return RtcEventLogParseStatus::Error(
               "Failed to read positions of optional values", __FILE__,
               __LINE__);
         }
         if (num_nonempty_values < 1 ||
             NumEventsInBatch() < num_nonempty_values) {
           return RtcEventLogParseStatus::Error(
               "Expected at least one non_empty value", __FILE__, __LINE__);
         }
         num_existing_deltas = num_nonempty_values - 1;
       } else {
         // All elements in the batch have values.
         if (positions) {
           positions->assign(NumEventsInBatch(), true);
         }
       }

       // Read base.
       uint64_t base = ReadSingleValue(field_type);
       if (!Ok()) {
         return RtcEventLogParseStatus::Error("Failed to read value", __FILE__,
                                              __LINE__);
       }

       if (delta_header->values_equal()) {
         // Duplicate the base value num_existing_deltas times.
         values->assign(num_existing_deltas + 1, base);
       } else {
         // Read deltas; ceil(num_existing_deltas*delta_width/8) bits
         ReadDeltasAndPopulateValues(delta_header.value(), num_existing_deltas,
                                     base, values);
         if (!Ok()) {
           return RtcEventLogParseStatus::Error("Failed to decode deltas",
                                                __FILE__, __LINE__);
         }
       }
     }

     if (field_id == params.field_id) {
       // The field we're looking for has been found and values populated.
       return RtcEventLogParseStatus::Success();
     }
   }

   // Field not found because the event ended.
   values->clear();
   if (positions) {
     positions->clear();
   }
   return RtcEventLogParseStatus::Success();
 }

 }  // namespace webrtc

	/*
	* Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/

	#include "logging/rtc_event_log/events/rtc_event_field_encoding_parser.h"

	#include "absl/strings/string_view.h"
	#include "absl/types/optional.h"
	#include "logging/rtc_event_log/encoder/var_int.h"
	#include "logging/rtc_event_log/events/rtc_event_field_encoding.h"
	#include "rtc_base/bitstream_reader.h"
	#include "rtc_base/checks.h"

	namespace {
	absl::optional<webrtc::FieldType> ConvertFieldType(uint64_t value) {
	switch (value) {
	case static_cast<uint64_t>(webrtc::FieldType::kFixed8):
	return webrtc::FieldType::kFixed8;
	case static_cast<uint64_t>(webrtc::FieldType::kFixed32):
	return webrtc::FieldType::kFixed32;
	case static_cast<uint64_t>(webrtc::FieldType::kFixed64):
	return webrtc::FieldType::kFixed64;
	case static_cast<uint64_t>(webrtc::FieldType::kVarInt):
	return webrtc::FieldType::kVarInt;
	case static_cast<uint64_t>(webrtc::FieldType::kString):
	return webrtc::FieldType::kString;
	default:
	return absl::nullopt;
	}
	}
	} // namespace

	namespace webrtc {

	uint64_t EventParser::ReadLittleEndian(uint8_t bytes) {
	RTC_DCHECK_LE(bytes, sizeof(uint64_t));
	RTC_DCHECK_GE(bytes, 1);

	uint64_t value = 0;

	if (bytes > pending_data_.length()) {
	SetError();
	return value;
	}

	const uint8_t* p = reinterpret_cast<const uint8_t*>(pending_data_.data());
	unsigned int shift = 0;
	uint8_t remaining = bytes;
	while (remaining > 0) {
	value += (static_cast<uint64_t>(*p) << shift);
	shift += 8;
	++p;
	--remaining;
	}

	pending_data_ = pending_data_.substr(bytes);
	return value;
	}

	uint64_t EventParser::ReadVarInt() {
	uint64_t output = 0;
	bool success;
	std::tie(success, pending_data_) = DecodeVarInt(pending_data_, &output);
	if (!success) {
	SetError();
	}
	return output;
	}

	uint64_t EventParser::ReadOptionalValuePositions(std::vector<bool>* positions) {
	if (!positions) {
	return CountAndIgnoreOptionalValuePositions();
	}

	size_t bits_to_read = NumEventsInBatch();
	RTC_DCHECK(positions->empty());
	if (pending_data_.size() * 8 < bits_to_read) {
	SetError();
	return 0;
	}

	BitstreamReader reader(pending_data_);
	for (size_t i = 0; i < bits_to_read; i++) {
	positions->push_back(reader.ReadBit());
	}
	if (!reader.Ok()) {
	SetError();
	return 0;
	}

	size_t num_existing_values =
	std::count(positions->begin(), positions->end(), true);
	pending_data_ = pending_data_.substr((bits_to_read + 7) / 8);
	return num_existing_values;
	}

	uint64_t EventParser::CountAndIgnoreOptionalValuePositions() {
	size_t bits_to_read = NumEventsInBatch();
	if (pending_data_.size() * 8 < bits_to_read) {
	SetError();
	return 0;
	}

	BitstreamReader reader(pending_data_);
	size_t num_existing_values = 0;
	for (size_t i = 0; i < bits_to_read; i++) {
	if (reader.ReadBit()) {
	++num_existing_values;
	}
	}
	if (!reader.Ok()) {
	SetError();
	return 0;
	}

	pending_data_ = pending_data_.substr((bits_to_read + 7) / 8);
	return num_existing_values;
	}

	uint64_t EventParser::ReadSingleValue(FieldType field_type) {
	switch (field_type) {
	case FieldType::kFixed8:
	return ReadLittleEndian(/bytes=/1);
	case FieldType::kFixed32:
	return ReadLittleEndian(/bytes=/4);
	case FieldType::kFixed64:
	return ReadLittleEndian(/bytes=/8);
	case FieldType::kVarInt:
	return ReadVarInt();
	case FieldType::kString:
	RTC_NOTREACHED();
	SetError();
	return 0;
	}
	}

	void EventParser::ReadDeltasAndPopulateValues(
	FixedLengthEncodingParametersV3 params,
	uint64_t num_deltas,
	uint64_t base,
	std::vector<uint64_t>* values) {
	RTC_CHECK(values != nullptr);
	RTC_DCHECK(values->empty());
	values->reserve(num_deltas + 1);
	values->push_back(base);

	if (pending_data_.size() * 8 < num_deltas * params.delta_bit_width()) {
	SetError();
	return;
	}

	BitstreamReader reader(pending_data_);
	const uint64_t top_bit = static_cast<uint64_t>(1)
	<< (params.delta_bit_width() - 1);

	uint64_t value = base;
	for (uint64_t i = 0; i < num_deltas; ++i) {
	uint64_t delta = reader.ReadBits(params.delta_bit_width());
	RTC_DCHECK_LE(value, webrtc_event_logging::MaxUnsignedValueOfBitWidth(
	params.value_bit_width()));
	RTC_DCHECK_LE(delta, webrtc_event_logging::MaxUnsignedValueOfBitWidth(
	params.delta_bit_width()));
	bool negative_delta = params.signed_deltas() && ((delta & top_bit) != 0);
	if (negative_delta) {
	uint64_t delta_abs = (~delta & params.delta_mask()) + 1;
	value = (value - delta_abs) & params.value_mask();
	} else {
	value = (value + delta) & params.value_mask();
	}
	values->push_back(value);
	}

	if (!reader.Ok()) {
	SetError();
	return;
	}

	pending_data_ =
	pending_data_.substr((num_deltas * params.delta_bit_width() + 7) / 8);
	}

	RtcEventLogParseStatus EventParser::Initialize(absl::string_view s,
	bool batched) {
	pending_data_ = s;
	num_events_ = 1;

	if (batched) {
	num_events_ = ReadVarInt();
	if (!Ok()) {
	return RtcEventLogParseStatus::Error(
	"Failed to read number of events in batch.", __FILE__, __LINE__);
	}
	}
	return RtcEventLogParseStatus::Success();
	}

	RtcEventLogParseStatus EventParser::ParseField(const FieldParameters& params,
	std::vector<uint64_t>* values,
	std::vector<bool>* positions) {
	RTC_CHECK(values != nullptr);

	// Verify that the event parses fields in increasing order.
	if (params.field_id == FieldParameters::kTimestampField) {
	RTC_DCHECK_EQ(last_field_id_, FieldParameters::kTimestampField);
	} else {
	RTC_DCHECK_GT(params.field_id, last_field_id_);
	}
	last_field_id_ = params.field_id;

	// Initialization for positional fields that don't encode field ID and type.
	uint64_t field_id = params.field_id;
	FieldType field_type = params.field_type;

	// Fields are encoded in increasing field_id order.
	// Skip unknown fields with field_id < params.field_id until we either
	// find params.field_id or a field with higher id, in which case we know that
	// params.field_id doesn't exist.
	while (!pending_data_.empty()) {
	absl::string_view field_start = pending_data_;
	values->clear();
	if (positions) {
	positions->clear();
	}

	// Read tag for non-positional fields.
	if (params.field_id != FieldParameters::kTimestampField) {
	uint64_t field_tag = ReadVarInt();
	if (!Ok())
	return RtcEventLogParseStatus::Error("Failed to read field tag",
	__FILE__, __LINE__);
	// Split tag into field ID and field type.
	field_id = field_tag >> 3;
	absl::optional<FieldType> conversion = ConvertFieldType(field_tag & 7u);
	if (!conversion.has_value())
	return RtcEventLogParseStatus::Error("Failed to parse field type",
	__FILE__, __LINE__);
	field_type = conversion.value();
	}

	if (field_id > params.field_id) {
	// We've passed all fields with ids less than or equal to what we are
	// looking for. Reset pending_data_ to first field with id higher than
	// params.field_id, since we didn't find the field we were looking for.
	pending_data_ = field_start;
	return RtcEventLogParseStatus::Success();
	}

	if (num_events_ == 1) {
	// Just a single value in the batch.
	uint64_t base = ReadSingleValue(field_type);
	if (!Ok())
	return RtcEventLogParseStatus::Error("Failed to read value", __FILE__,
	__LINE__);
	if (positions) {
	positions->push_back(true);
	}
	values->push_back(base);
	} else {
	// Delta compressed batch.
	// Read delta header.
	uint64_t header_value = ReadVarInt();
	if (!Ok())
	return RtcEventLogParseStatus::Error("Failed to read delta header",
	__FILE__, __LINE__);
	// NB: value_width may be incorrect for the field, if this isn't the field
	// we are looking for.
	absl::optional<FixedLengthEncodingParametersV3> delta_header =
	FixedLengthEncodingParametersV3::ParseDeltaHeader(header_value,
	params.value_width);
	if (!delta_header.has_value()) {
	return RtcEventLogParseStatus::Error("Failed to parse delta header",
	__FILE__, __LINE__);
	}

	uint64_t num_existing_deltas = NumEventsInBatch() - 1;
	if (delta_header->values_optional()) {
	size_t num_nonempty_values = ReadOptionalValuePositions(positions);
	if (!Ok()) {
	return RtcEventLogParseStatus::Error(
	"Failed to read positions of optional values", __FILE__,
	__LINE__);
	}
	if (num_nonempty_values < 1 \|\|
	NumEventsInBatch() < num_nonempty_values) {
	return RtcEventLogParseStatus::Error(
	"Expected at least one non_empty value", __FILE__, __LINE__);
	}
	num_existing_deltas = num_nonempty_values - 1;
	} else {
	// All elements in the batch have values.
	if (positions) {
	positions->assign(NumEventsInBatch(), true);
	}
	}

	// Read base.
	uint64_t base = ReadSingleValue(field_type);
	if (!Ok()) {
	return RtcEventLogParseStatus::Error("Failed to read value", __FILE__,
	__LINE__);
	}

	if (delta_header->values_equal()) {
	// Duplicate the base value num_existing_deltas times.
	values->assign(num_existing_deltas + 1, base);
	} else {
	// Read deltas; ceil(num_existing_deltas*delta_width/8) bits
	ReadDeltasAndPopulateValues(delta_header.value(), num_existing_deltas,
	base, values);
	if (!Ok()) {
	return RtcEventLogParseStatus::Error("Failed to decode deltas",
	__FILE__, __LINE__);
	}
	}
	}

	if (field_id == params.field_id) {
	// The field we're looking for has been found and values populated.
	return RtcEventLogParseStatus::Success();
	}
	}

	// Field not found because the event ended.
	values->clear();
	if (positions) {
	positions->clear();
	}
	return RtcEventLogParseStatus::Success();
	}

	} // namespace webrtc