1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "media/cast/net/rtp_sender/rtp_sender.h"
6
7#include "base/logging.h"
8#include "base/rand_util.h"
9#include "media/cast/cast_defines.h"
10#include "media/cast/net/pacing/paced_sender.h"
11#include "media/cast/rtcp/rtcp_defines.h"
12#include "net/base/big_endian.h"
13
14namespace media {
15namespace cast {
16
17RtpSender::RtpSender(scoped_refptr<CastEnvironment> cast_environment,
18                     const AudioSenderConfig* audio_config,
19                     const VideoSenderConfig* video_config,
20                     PacedPacketSender* transport)
21    : cast_environment_(cast_environment),
22      config_(),
23      transport_(transport) {
24  // Store generic cast config and create packetizer config.
25  DCHECK(audio_config || video_config) << "Invalid argument";
26  if (audio_config) {
27    storage_.reset(new PacketStorage(cast_environment->Clock(),
28                                     audio_config->rtp_history_ms));
29    config_.audio = true;
30    config_.ssrc = audio_config->sender_ssrc;
31    config_.payload_type = audio_config->rtp_payload_type;
32    config_.frequency = audio_config->frequency;
33    config_.audio_codec = audio_config->codec;
34  } else {
35    storage_.reset(new PacketStorage(cast_environment->Clock(),
36                                     video_config->rtp_history_ms));
37    config_.audio = false;
38    config_.ssrc = video_config->sender_ssrc;
39    config_.payload_type = video_config->rtp_payload_type;
40    config_.frequency = kVideoFrequency;
41    config_.video_codec = video_config->codec;
42  }
43  // Randomly set start values.
44  config_.sequence_number = base::RandInt(0, 65535);
45  config_.rtp_timestamp = base::RandInt(0, 65535);
46  config_.rtp_timestamp += base::RandInt(0, 65535) << 16;
47  packetizer_.reset(new RtpPacketizer(transport, storage_.get(), config_));
48}
49
50RtpSender::~RtpSender() {}
51
52void RtpSender::IncomingEncodedVideoFrame(const EncodedVideoFrame* video_frame,
53    const base::TimeTicks& capture_time) {
54  packetizer_->IncomingEncodedVideoFrame(video_frame, capture_time);
55}
56
57void RtpSender::IncomingEncodedAudioFrame(const EncodedAudioFrame* audio_frame,
58    const base::TimeTicks& recorded_time) {
59  packetizer_->IncomingEncodedAudioFrame(audio_frame, recorded_time);
60}
61
62void RtpSender::ResendPackets(
63    const MissingFramesAndPacketsMap& missing_frames_and_packets) {
64  // Iterate over all frames in the list.
65  for (MissingFramesAndPacketsMap::const_iterator it =
66       missing_frames_and_packets.begin();
67       it != missing_frames_and_packets.end(); ++it) {
68    PacketList packets_to_resend;
69    uint8 frame_id = it->first;
70    const PacketIdSet& packets_set = it->second;
71    bool success = false;
72
73    if (packets_set.empty()) {
74      VLOG(1) << "Missing all packets in frame " << static_cast<int>(frame_id);
75
76      uint16 packet_id = 0;
77      do {
78        // Get packet from storage.
79        success = storage_->GetPacket(frame_id, packet_id, &packets_to_resend);
80
81        // Resend packet to the network.
82        if (success) {
83          VLOG(1) << "Resend " << static_cast<int>(frame_id)
84                  << ":" << packet_id;
85          // Set a unique incremental sequence number for every packet.
86          Packet& packet = packets_to_resend.back();
87          UpdateSequenceNumber(&packet);
88          // Set the size as correspond to each frame.
89          ++packet_id;
90        }
91      } while (success);
92    } else {
93      // Iterate over all of the packets in the frame.
94      for (PacketIdSet::const_iterator set_it = packets_set.begin();
95          set_it != packets_set.end(); ++set_it) {
96        uint16 packet_id = *set_it;
97        success = storage_->GetPacket(frame_id, packet_id, &packets_to_resend);
98
99        // Resend packet to the network.
100        if (success) {
101          VLOG(1) << "Resend " << static_cast<int>(frame_id)
102                  << ":" << packet_id;
103          Packet& packet = packets_to_resend.back();
104          UpdateSequenceNumber(&packet);
105        }
106      }
107    }
108    transport_->ResendPackets(packets_to_resend);
109  }
110}
111
112void RtpSender::UpdateSequenceNumber(Packet* packet) {
113  uint16 new_sequence_number = packetizer_->NextSequenceNumber();
114  int index = 2;
115  (*packet)[index] = (static_cast<uint8>(new_sequence_number));
116  (*packet)[index + 1] =(static_cast<uint8>(new_sequence_number >> 8));
117}
118
119void RtpSender::RtpStatistics(const base::TimeTicks& now,
120                              RtcpSenderInfo* sender_info) {
121  // The timestamp of this Rtcp packet should be estimated as the timestamp of
122  // the frame being captured at this moment. We are calculating that
123  // timestamp as the last frame's timestamp + the time since the last frame
124  // was captured.
125  uint32 ntp_seconds = 0;
126  uint32 ntp_fraction = 0;
127  ConvertTimeTicksToNtp(now, &ntp_seconds, &ntp_fraction);
128  sender_info->ntp_seconds = ntp_seconds;
129  sender_info->ntp_fraction = ntp_fraction;
130
131  base::TimeTicks time_sent;
132  uint32 rtp_timestamp;
133  if (packetizer_->LastSentTimestamp(&time_sent, &rtp_timestamp)) {
134    base::TimeDelta time_since_last_send = now - time_sent;
135    sender_info->rtp_timestamp = rtp_timestamp +
136        time_since_last_send.InMilliseconds() * (config_.frequency / 1000);
137  } else {
138    sender_info->rtp_timestamp = 0;
139  }
140  sender_info->send_packet_count = packetizer_->send_packets_count();
141  sender_info->send_octet_count = packetizer_->send_octet_count();
142}
143
144}  //  namespace cast
145}  // namespace media
146