media/cast/net/rtp/framer.cc

   1 // Copyright 2014 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/framer.h"
   6
   7 #include "base/logging.h"
   8
   9 namespace media {
  10 namespace cast {
  11
  12 typedef FrameList::const_iterator ConstFrameIterator;
  13
  14 Framer::Framer(base::TickClock* clock,
  15                RtpPayloadFeedback* incoming_payload_feedback,
  16                uint32 ssrc,
  17                bool decoder_faster_than_max_frame_rate,
  18                int max_unacked_frames)
  19     : decoder_faster_than_max_frame_rate_(decoder_faster_than_max_frame_rate),
  20       cast_msg_builder_(
  21           new CastMessageBuilder(clock,
  22                                  incoming_payload_feedback,
  23                                  this,
  24                                  ssrc,
  25                                  decoder_faster_than_max_frame_rate,
  26                                  max_unacked_frames)),
  27       waiting_for_key_(true),
  28       last_released_frame_(kStartFrameId),
  29       newest_frame_id_(kStartFrameId) {
  30   DCHECK(incoming_payload_feedback) << "Invalid argument";
  31 }
  32
  33 Framer::~Framer() {}
  34
  35 bool Framer::InsertPacket(const uint8* payload_data,
  36                           size_t payload_size,
  37                           const RtpCastHeader& rtp_header,
  38                           bool* duplicate) {
  39   *duplicate = false;
  40   uint32 frame_id = rtp_header.frame_id;
  41
  42   if (rtp_header.is_key_frame && waiting_for_key_) {
  43     last_released_frame_ = static_cast<uint32>(frame_id - 1);
  44     waiting_for_key_ = false;
  45   }
  46
  47   VLOG(1) << "InsertPacket frame:" << frame_id
  48           << " packet:" << static_cast<int>(rtp_header.packet_id)
  49           << " max packet:" << static_cast<int>(rtp_header.max_packet_id);
  50
  51   if (IsOlderFrameId(frame_id, last_released_frame_) && !waiting_for_key_) {
  52     // Packet is too old.
  53     return false;
  54   }
  55
  56   // Update the last received frame id.
  57   if (IsNewerFrameId(frame_id, newest_frame_id_)) {
  58     newest_frame_id_ = frame_id;
  59   }
  60
  61   // Does this packet belong to a new frame?
  62   FrameList::iterator it = frames_.find(frame_id);
  63   if (it == frames_.end()) {
  64     // New frame.
  65     linked_ptr<FrameBuffer> frame_info(new FrameBuffer);
  66     std::pair<FrameList::iterator, bool> retval =
  67         frames_.insert(std::make_pair(frame_id, frame_info));
  68     it = retval.first;
  69   }
  70
  71     // Insert packet.
  72   if (!it->second->InsertPacket(payload_data, payload_size, rtp_header)) {
  73     VLOG(3) << "Packet already received, ignored: frame "
  74             << static_cast<int>(rtp_header.frame_id) << ", packet "
  75             << rtp_header.packet_id;
  76     *duplicate = true;
  77     return false;
  78   }
  79
  80   return it->second->Complete();
  81 }
  82
  83 // This does not release the frame.
  84 bool Framer::GetEncodedFrame(EncodedFrame* frame,
  85                              bool* next_frame,
  86                              bool* have_multiple_decodable_frames) {
  87   *have_multiple_decodable_frames = HaveMultipleDecodableFrames();
  88
  89   uint32 frame_id;
  90   // Find frame id.
  91   if (NextContinuousFrame(&frame_id)) {
  92     // We have our next frame.
  93     *next_frame = true;
  94   } else {
  95     // Check if we can skip frames when our decoder is too slow.
  96     if (!decoder_faster_than_max_frame_rate_)
  97       return false;
  98
  99     if (!NextFrameAllowingSkippingFrames(&frame_id)) {
 100       return false;
 101     }
 102     *next_frame = false;
 103   }
 104
 105   ConstFrameIterator it = frames_.find(frame_id);
 106   DCHECK(it != frames_.end());
 107   if (it == frames_.end())
 108     return false;
 109
 110   return it->second->AssembleEncodedFrame(frame);
 111 }
 112
 113 void Framer::AckFrame(uint32 frame_id) {
 114   VLOG(2) << "ACK frame " << frame_id;
 115   cast_msg_builder_->CompleteFrameReceived(frame_id);
 116 }
 117
 118 void Framer::Reset() {
 119   waiting_for_key_ = true;
 120   last_released_frame_ = kStartFrameId;
 121   newest_frame_id_ = kStartFrameId;
 122   frames_.clear();
 123   cast_msg_builder_->Reset();
 124 }
 125
 126 void Framer::ReleaseFrame(uint32 frame_id) {
 127   RemoveOldFrames(frame_id);
 128   frames_.erase(frame_id);
 129
 130   // We have a frame - remove all frames with lower frame id.
 131   bool skipped_old_frame = false;
 132   FrameList::iterator it;
 133   for (it = frames_.begin(); it != frames_.end();) {
 134     if (IsOlderFrameId(it->first, frame_id)) {
 135       frames_.erase(it++);
 136       skipped_old_frame = true;
 137     } else {
 138       ++it;
 139     }
 140   }
 141   if (skipped_old_frame) {
 142     cast_msg_builder_->UpdateCastMessage();
 143   }
 144 }
 145
 146 bool Framer::TimeToSendNextCastMessage(base::TimeTicks* time_to_send) {
 147   return cast_msg_builder_->TimeToSendNextCastMessage(time_to_send);
 148 }
 149
 150 void Framer::SendCastMessage() { cast_msg_builder_->UpdateCastMessage(); }
 151
 152 void Framer::RemoveOldFrames(uint32 frame_id) {
 153   FrameList::iterator it = frames_.begin();
 154
 155   while (it != frames_.end()) {
 156     if (IsNewerFrameId(it->first, frame_id)) {
 157       ++it;
 158     } else {
 159       // Older or equal; erase.
 160       frames_.erase(it++);
 161     }
 162   }
 163   last_released_frame_ = frame_id;
 164 }
 165
 166 uint32 Framer::NewestFrameId() const { return newest_frame_id_; }
 167
 168 bool Framer::NextContinuousFrame(uint32* frame_id) const {
 169   FrameList::const_iterator it;
 170
 171   for (it = frames_.begin(); it != frames_.end(); ++it) {
 172     if (it->second->Complete() && ContinuousFrame(it->second.get())) {
 173       *frame_id = it->first;
 174       return true;
 175     }
 176   }
 177   return false;
 178 }
 179
 180 bool Framer::HaveMultipleDecodableFrames() const {
 181   // Find the oldest decodable frame.
 182   FrameList::const_iterator it;
 183   bool found_one = false;
 184   for (it = frames_.begin(); it != frames_.end(); ++it) {
 185     if (it->second->Complete() && DecodableFrame(it->second.get())) {
 186       if (found_one) {
 187         return true;
 188       } else {
 189         found_one = true;
 190       }
 191     }
 192   }
 193   return false;
 194 }
 195
 196 uint32 Framer::LastContinuousFrame() const {
 197   uint32 last_continuous_frame_id = last_released_frame_;
 198   uint32 next_expected_frame = last_released_frame_;
 199
 200   FrameList::const_iterator it;
 201
 202   do {
 203     next_expected_frame++;
 204     it = frames_.find(next_expected_frame);
 205     if (it == frames_.end())
 206       break;
 207     if (!it->second->Complete())
 208       break;
 209
 210     // We found the next continuous frame.
 211     last_continuous_frame_id = it->first;
 212   } while (next_expected_frame != newest_frame_id_);
 213   return last_continuous_frame_id;
 214 }
 215
 216 bool Framer::NextFrameAllowingSkippingFrames(uint32* frame_id) const {
 217   // Find the oldest decodable frame.
 218   FrameList::const_iterator it_best_match = frames_.end();
 219   FrameList::const_iterator it;
 220   for (it = frames_.begin(); it != frames_.end(); ++it) {
 221     if (it->second->Complete() && DecodableFrame(it->second.get())) {
 222       if (it_best_match == frames_.end() ||
 223           IsOlderFrameId(it->first, it_best_match->first)) {
 224         it_best_match = it;
 225       }
 226     }
 227   }
 228   if (it_best_match == frames_.end())
 229     return false;
 230
 231   *frame_id = it_best_match->first;
 232   return true;
 233 }
 234
 235 bool Framer::Empty() const { return frames_.empty(); }
 236
 237 int Framer::NumberOfCompleteFrames() const {
 238   int count = 0;
 239   FrameList::const_iterator it;
 240   for (it = frames_.begin(); it != frames_.end(); ++it) {
 241     if (it->second->Complete()) {
 242       ++count;
 243     }
 244   }
 245   return count;
 246 }
 247
 248 bool Framer::FrameExists(uint32 frame_id) const {
 249   return frames_.end() != frames_.find(frame_id);
 250 }
 251
 252 void Framer::GetMissingPackets(uint32 frame_id,
 253                                    bool last_frame,
 254                                    PacketIdSet* missing_packets) const {
 255   FrameList::const_iterator it = frames_.find(frame_id);
 256   if (it == frames_.end())
 257     return;
 258
 259   it->second->GetMissingPackets(last_frame, missing_packets);
 260 }
 261
 262 bool Framer::ContinuousFrame(FrameBuffer* frame) const {
 263   DCHECK(frame);
 264   if (waiting_for_key_ && !frame->is_key_frame())
 265     return false;
 266   return static_cast<uint32>(last_released_frame_ + 1) == frame->frame_id();
 267 }
 268
 269 bool Framer::DecodableFrame(FrameBuffer* frame) const {
 270   if (frame->is_key_frame())
 271     return true;
 272   if (waiting_for_key_ && !frame->is_key_frame())
 273     return false;
 274   // Self-reference?
 275   if (frame->last_referenced_frame_id() == frame->frame_id())
 276     return true;
 277
 278   // Current frame is not necessarily referencing the last frame.
 279   // Do we have the reference frame?
 280   if (IsOlderFrameId(frame->last_referenced_frame_id(), last_released_frame_)) {
 281     return true;
 282   }
 283   return frame->last_referenced_frame_id() == last_released_frame_;
 284 }
 285
 286
 287 }  // namespace cast
 288 }  // namespace media