blob: 1ae60da16d6a123bab354c1a81c066e14b98317f [file] [log] [blame]
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cast/streaming/rtp_packetizer.h"
#include <algorithm>
#include <limits>
#include <random>
#include "cast/streaming/packet_util.h"
#include "platform/api/time.h"
#include "util/big_endian.h"
#include "util/integer_division.h"
#include "util/osp_logging.h"
namespace openscreen {
namespace cast {
namespace {
// Returns a random sequence number to start with. The reason for using a random
// number instead of zero is unclear, but this has existed both in several
// versions of the Cast Streaming spec and in other implementations for many
// years.
uint16_t GenerateRandomSequenceNumberStart() {
// Use a statically-allocated generator, instantiated upon first use, and
// seeded with the current time tick count. This generator was chosen because
// it is light-weight and does not need to produce unguessable (nor
// crypto-secure) values.
static std::minstd_rand generator(static_cast<std::minstd_rand::result_type>(
return std::uniform_int_distribution<uint16_t>()(generator);
} // namespace
RtpPacketizer::RtpPacketizer(RtpPayloadType payload_type,
Ssrc sender_ssrc,
int max_packet_size)
: payload_type_7bits_(static_cast<uint8_t>(payload_type)),
sequence_number_(GenerateRandomSequenceNumberStart()) {
OSP_DCHECK_GT(max_packet_size_, kMaxRtpHeaderSize);
RtpPacketizer::~RtpPacketizer() = default;
absl::Span<uint8_t> RtpPacketizer::GeneratePacket(const EncryptedFrame& frame,
FramePacketId packet_id,
absl::Span<uint8_t> buffer) {
OSP_CHECK_GE(static_cast<int>(buffer.size()), max_packet_size_);
const int num_packets = ComputeNumberOfPackets(frame);
OSP_DCHECK_GT(num_packets, 0);
OSP_DCHECK_LT(int{packet_id}, num_packets);
const bool is_last_packet = int{packet_id} == (num_packets - 1);
// Compute the size of this packet, which is the number of bytes of header
// plus the number of bytes of payload. Note that the optional Adaptive
// Latency information is only added to the first packet.
int packet_size = kBaseRtpHeaderSize;
const bool include_adaptive_latency_change =
(packet_id == 0 &&
frame.new_playout_delay > std::chrono::milliseconds(0));
if (include_adaptive_latency_change) {
packet_size += kAdaptiveLatencyHeaderSize;
int data_chunk_size = max_payload_size();
const int data_chunk_start = data_chunk_size * int{packet_id};
if (is_last_packet) {
data_chunk_size = static_cast<int>( - data_chunk_start;
packet_size += data_chunk_size;
OSP_DCHECK_LE(packet_size, max_packet_size_);
const absl::Span<uint8_t> packet(, packet_size);
// RTP Header.
AppendField<uint8_t>(kRtpRequiredFirstByte, &buffer);
(is_last_packet ? kRtpMarkerBitMask : 0) | payload_type_7bits_, &buffer);
AppendField<uint16_t>(sequence_number_++, &buffer);
AppendField<uint32_t>(frame.rtp_timestamp.lower_32_bits(), &buffer);
AppendField<uint32_t>(sender_ssrc_, &buffer);
// Cast Header.
((frame.dependency == EncodedFrame::KEY_FRAME) ? kRtpKeyFrameBitMask
: 0) |
kRtpHasReferenceFrameIdBitMask |
(include_adaptive_latency_change ? 1 : 0),
AppendField<uint8_t>(frame.frame_id.lower_8_bits(), &buffer);
AppendField<uint16_t>(packet_id, &buffer);
AppendField<uint16_t>(num_packets - 1, &buffer);
AppendField<uint8_t>(frame.referenced_frame_id.lower_8_bits(), &buffer);
// Extension of Cast Header for Adaptive Latency change.
if (include_adaptive_latency_change) {
(kAdaptiveLatencyRtpExtensionType << kNumExtensionDataSizeFieldBits) |
AppendField<uint16_t>(frame.new_playout_delay.count(), &buffer);
// Sanity-check the pointer math, to ensure the packet is being entirely
// populated, with no underrun or overrun.
OSP_DCHECK_EQ( + data_chunk_size, packet.end());
// Copy the encrypted payload data into the packet.
memcpy(, + data_chunk_start, data_chunk_size);
return packet;
int RtpPacketizer::ComputeNumberOfPackets(const EncryptedFrame& frame) const {
// The total number of packets is computed by assuming the payload will be
// split-up across as few packets as possible.
int num_packets = DividePositivesRoundingUp(
static_cast<int>(, max_payload_size());
// Edge case: There must always be at least one packet, even when there are no
// payload bytes. Some audio codecs, for example, use zero bytes to represent
// a period of silence.
num_packets = std::max(1, num_packets);
// Ensure that the entire range of FramePacketIds can be represented.
return num_packets <= int{kMaxAllowedFramePacketId} ? num_packets : -1;
} // namespace cast
} // namespace openscreen