src/media/cast/framer/framer.cc

   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/framer/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_(new CastMessageBuilder(clock, incoming_payload_feedback,
  21           &frame_id_map_, ssrc, decoder_faster_than_max_frame_rate,
  22           max_unacked_frames)) {
  23   DCHECK(incoming_payload_feedback) << "Invalid argument";
  24 }
  25
  26 Framer::~Framer() {}
  27
  28 bool Framer::InsertPacket(const uint8* payload_data,
  29                           size_t payload_size,
  30                           const RtpCastHeader& rtp_header,
  31                           bool* duplicate) {
  32   *duplicate = false;
  33   PacketType packet_type = frame_id_map_.InsertPacket(rtp_header);
  34   if (packet_type == kTooOldPacket) {
  35     return false;
  36   }
  37   if (packet_type == kDuplicatePacket) {
  38     VLOG(3) << "Packet already received, ignored: frame "
  39             << static_cast<int>(rtp_header.frame_id) << ", packet "
  40             << rtp_header.packet_id;
  41     *duplicate = true;
  42     return false;
  43   }
  44
  45   // Does this packet belong to a new frame?
  46   FrameList::iterator it = frames_.find(rtp_header.frame_id);
  47   if (it == frames_.end()) {
  48     // New frame.
  49     linked_ptr<FrameBuffer> frame_buffer(new FrameBuffer());
  50     frame_buffer->InsertPacket(payload_data, payload_size, rtp_header);
  51     frames_.insert(std::make_pair(rtp_header.frame_id, frame_buffer));
  52   } else {
  53     // Insert packet to existing frame buffer.
  54     it->second->InsertPacket(payload_data, payload_size, rtp_header);
  55   }
  56
  57   bool complete = (packet_type == kNewPacketCompletingFrame);
  58   if (complete) {
  59     // ACK as soon as possible.
  60     VLOG(1) << "Complete frame " << static_cast<int>(rtp_header.frame_id);
  61     cast_msg_builder_->CompleteFrameReceived(rtp_header.frame_id,
  62                                              rtp_header.is_key_frame);
  63   }
  64   return complete;
  65 }
  66
  67 // This does not release the frame.
  68 bool Framer::GetEncodedAudioFrame(transport::EncodedAudioFrame* audio_frame,
  69                                   uint32* rtp_timestamp,
  70                                   bool* next_frame) {
  71   uint32 frame_id;
  72   // Find frame id.
  73   if (frame_id_map_.NextContinuousFrame(&frame_id)) {
  74     // We have our next frame.
  75     *next_frame = true;
  76   } else {
  77     if (!frame_id_map_.NextAudioFrameAllowingMissingFrames(&frame_id)) {
  78       return false;
  79     }
  80     *next_frame = false;
  81   }
  82
  83   ConstFrameIterator it = frames_.find(frame_id);
  84   DCHECK(it != frames_.end());
  85   if (it == frames_.end()) return false;
  86
  87   return it->second->GetEncodedAudioFrame(audio_frame, rtp_timestamp);
  88 }
  89
  90 // This does not release the frame.
  91 bool Framer::GetEncodedVideoFrame(transport::EncodedVideoFrame* video_frame,
  92                                   uint32* rtp_timestamp,
  93                                   bool* next_frame) {
  94   uint32 frame_id;
  95   // Find frame id.
  96   if (frame_id_map_.NextContinuousFrame(&frame_id)) {
  97     // We have our next frame.
  98     *next_frame = true;
  99   } else {
 100     // Check if we can skip frames when our decoder is too slow.
 101     if (!decoder_faster_than_max_frame_rate_) return false;
 102
 103     if (!frame_id_map_.NextVideoFrameAllowingSkippingFrames(&frame_id)) {
 104       return false;
 105     }
 106     *next_frame = false;
 107   }
 108
 109   ConstFrameIterator it = frames_.find(frame_id);
 110   DCHECK(it != frames_.end());
 111   if (it == frames_.end())  return false;
 112
 113   return it->second->GetEncodedVideoFrame(video_frame, rtp_timestamp);
 114 }
 115
 116 void Framer::Reset() {
 117   frame_id_map_.Clear();
 118   frames_.clear();
 119   cast_msg_builder_->Reset();
 120 }
 121
 122 void Framer::ReleaseFrame(uint32 frame_id) {
 123   frame_id_map_.RemoveOldFrames(frame_id);
 124   frames_.erase(frame_id);
 125
 126   // We have a frame - remove all frames with lower frame id.
 127   bool skipped_old_frame = false;
 128   FrameList::iterator it;
 129   for (it = frames_.begin(); it != frames_.end(); ) {
 130     if (IsOlderFrameId(it->first, frame_id)) {
 131       frames_.erase(it++);
 132       skipped_old_frame = true;
 133     } else {
 134       ++it;
 135     }
 136   }
 137   if (skipped_old_frame) {
 138     cast_msg_builder_->UpdateCastMessage();
 139   }
 140 }
 141
 142 bool Framer::TimeToSendNextCastMessage(base::TimeTicks* time_to_send) {
 143   return cast_msg_builder_->TimeToSendNextCastMessage(time_to_send);
 144 }
 145
 146 void Framer::SendCastMessage() {
 147   cast_msg_builder_->UpdateCastMessage();
 148 }
 149
 150 }  // namespace cast
 151 }  // namespace media