Cast: Reshuffle files under media/cast

media/cast/framer/frame_id_map.cc

Index: media/cast/framer/frame_id_map.cc
diff --git a/media/cast/framer/frame_id_map.cc b/media/cast/framer/frame_id_map.cc
deleted file mode 100644
index b4389fd53234069cff9690246b4affcc6f4cbd8b..0000000000000000000000000000000000000000
--- a/media/cast/framer/frame_id_map.cc
+++ /dev/null
@@ -1,247 +0,0 @@
-// Copyright 2013 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 "media/cast/framer/frame_id_map.h"
-
-#include "base/logging.h"
-#include "media/cast/rtp_receiver/rtp_receiver_defines.h"
-
-namespace media {
-namespace cast {
-
-FrameInfo::FrameInfo(uint32 frame_id,
-                     uint32 referenced_frame_id,
-                     uint16 max_packet_id,
-                     bool key_frame)
-    : is_key_frame_(key_frame),
-      frame_id_(frame_id),
-      referenced_frame_id_(referenced_frame_id),
-      max_received_packet_id_(0) {
-  // Create the set with all packets missing.
-  for (uint16 i = 0; i <= max_packet_id; i++) {
-    missing_packets_.insert(i);
-  }
-}
-
-FrameInfo::~FrameInfo() {}
-
-PacketType FrameInfo::InsertPacket(uint16 packet_id) {
-  if (missing_packets_.find(packet_id) == missing_packets_.end()) {
-    return kDuplicatePacket;
-  }
-  // Update the last received packet id.
-  if (IsNewerPacketId(packet_id, max_received_packet_id_)) {
-    max_received_packet_id_ = packet_id;
-  }
-  missing_packets_.erase(packet_id);
-  return missing_packets_.empty() ? kNewPacketCompletingFrame : kNewPacket;
-}
-
-bool FrameInfo::Complete() const { return missing_packets_.empty(); }
-
-void FrameInfo::GetMissingPackets(bool newest_frame,
-                                  PacketIdSet* missing_packets) const {
-  if (newest_frame) {
-    // Missing packets capped by max_received_packet_id_.
-    PacketIdSet::const_iterator it_after_last_received =
-        missing_packets_.lower_bound(max_received_packet_id_);
-    missing_packets->insert(missing_packets_.begin(), it_after_last_received);
-  } else {
-    missing_packets->insert(missing_packets_.begin(), missing_packets_.end());
-  }
-}
-
-FrameIdMap::FrameIdMap()
-    : waiting_for_key_(true),
-      last_released_frame_(kStartFrameId),
-      newest_frame_id_(kStartFrameId) {}
-
-FrameIdMap::~FrameIdMap() {}
-
-PacketType FrameIdMap::InsertPacket(const RtpCastHeader& rtp_header) {
-  uint32 frame_id = rtp_header.frame_id;
-  uint32 reference_frame_id;
-  reference_frame_id = rtp_header.reference_frame_id;
-
-  if (rtp_header.is_key_frame && waiting_for_key_) {
-    last_released_frame_ = static_cast<uint32>(frame_id - 1);
-    waiting_for_key_ = false;
-  }
-
-  VLOG(3) << "InsertPacket frame:" << frame_id
-          << " packet:" << static_cast<int>(rtp_header.packet_id)
-          << " max packet:" << static_cast<int>(rtp_header.max_packet_id);
-
-  if (IsOlderFrameId(frame_id, last_released_frame_) && !waiting_for_key_) {
-    return kTooOldPacket;
-  }
-
-  // Update the last received frame id.
-  if (IsNewerFrameId(frame_id, newest_frame_id_)) {
-    newest_frame_id_ = frame_id;
-  }
-
-  // Does this packet belong to a new frame?
-  FrameMap::iterator it = frame_map_.find(frame_id);
-  PacketType packet_type;
-  if (it == frame_map_.end()) {
-    // New frame.
-    linked_ptr<FrameInfo> frame_info(new FrameInfo(frame_id,
-                                                   reference_frame_id,
-                                                   rtp_header.max_packet_id,
-                                                   rtp_header.is_key_frame));
-    std::pair<FrameMap::iterator, bool> retval =
-        frame_map_.insert(std::make_pair(frame_id, frame_info));
-
-    packet_type = retval.first->second->InsertPacket(rtp_header.packet_id);
-  } else {
-    // Insert packet to existing frame.
-    packet_type = it->second->InsertPacket(rtp_header.packet_id);
-  }
-  return packet_type;
-}
-
-void FrameIdMap::RemoveOldFrames(uint32 frame_id) {
-  FrameMap::iterator it = frame_map_.begin();
-
-  while (it != frame_map_.end()) {
-    if (IsNewerFrameId(it->first, frame_id)) {
-      ++it;
-    } else {
-      // Older or equal; erase.
-      frame_map_.erase(it++);
-    }
-  }
-  last_released_frame_ = frame_id;
-}
-
-void FrameIdMap::Clear() {
-  frame_map_.clear();
-  waiting_for_key_ = true;
-  last_released_frame_ = kStartFrameId;
-  newest_frame_id_ = kStartFrameId;
-}
-
-uint32 FrameIdMap::NewestFrameId() const { return newest_frame_id_; }
-
-bool FrameIdMap::NextContinuousFrame(uint32* frame_id) const {
-  FrameMap::const_iterator it;
-
-  for (it = frame_map_.begin(); it != frame_map_.end(); ++it) {
-    if (it->second->Complete() && ContinuousFrame(it->second.get())) {
-      *frame_id = it->first;
-      return true;
-    }
-  }
-  return false;
-}
-
-bool FrameIdMap::HaveMultipleDecodableFrames() const {
-  // Find the oldest decodable frame.
-  FrameMap::const_iterator it;
-  bool found_one = false;
-  for (it = frame_map_.begin(); it != frame_map_.end(); ++it) {
-    if (it->second->Complete() && DecodableFrame(it->second.get())) {
-      if (found_one) {
-        return true;
-      } else {
-        found_one = true;
-      }
-    }
-  }
-  return false;
-}
-
-uint32 FrameIdMap::LastContinuousFrame() const {
-  uint32 last_continuous_frame_id = last_released_frame_;
-  uint32 next_expected_frame = last_released_frame_;
-
-  FrameMap::const_iterator it;
-
-  do {
-    next_expected_frame++;
-    it = frame_map_.find(next_expected_frame);
-    if (it == frame_map_.end())
-      break;
-    if (!it->second->Complete())
-      break;
-
-    // We found the next continuous frame.
-    last_continuous_frame_id = it->first;
-  } while (next_expected_frame != newest_frame_id_);
-  return last_continuous_frame_id;
-}
-
-bool FrameIdMap::NextFrameAllowingSkippingFrames(uint32* frame_id) const {
-  // Find the oldest decodable frame.
-  FrameMap::const_iterator it_best_match = frame_map_.end();
-  FrameMap::const_iterator it;
-  for (it = frame_map_.begin(); it != frame_map_.end(); ++it) {
-    if (it->second->Complete() && DecodableFrame(it->second.get())) {
-      if (it_best_match == frame_map_.end() ||
-          IsOlderFrameId(it->first, it_best_match->first)) {
-        it_best_match = it;
-      }
-    }
-  }
-  if (it_best_match == frame_map_.end())
-    return false;
-
-  *frame_id = it_best_match->first;
-  return true;
-}
-
-bool FrameIdMap::Empty() const { return frame_map_.empty(); }
-
-int FrameIdMap::NumberOfCompleteFrames() const {
-  int count = 0;
-  FrameMap::const_iterator it;
-  for (it = frame_map_.begin(); it != frame_map_.end(); ++it) {
-    if (it->second->Complete()) {
-      ++count;
-    }
-  }
-  return count;
-}
-
-bool FrameIdMap::FrameExists(uint32 frame_id) const {
-  return frame_map_.end() != frame_map_.find(frame_id);
-}
-
-void FrameIdMap::GetMissingPackets(uint32 frame_id,
-                                   bool last_frame,
-                                   PacketIdSet* missing_packets) const {
-  FrameMap::const_iterator it = frame_map_.find(frame_id);
-  if (it == frame_map_.end())
-    return;
-
-  it->second->GetMissingPackets(last_frame, missing_packets);
-}
-
-bool FrameIdMap::ContinuousFrame(FrameInfo* frame) const {
-  DCHECK(frame);
-  if (waiting_for_key_ && !frame->is_key_frame())
-    return false;
-  return static_cast<uint32>(last_released_frame_ + 1) == frame->frame_id();
-}
-
-bool FrameIdMap::DecodableFrame(FrameInfo* frame) const {
-  if (frame->is_key_frame())
-    return true;
-  if (waiting_for_key_ && !frame->is_key_frame())
-    return false;
-  // Self-reference?
-  if (frame->referenced_frame_id() == frame->frame_id())
-    return true;
-
-  // Current frame is not necessarily referencing the last frame.
-  // Do we have the reference frame?
-  if (IsOlderFrameId(frame->referenced_frame_id(), last_released_frame_)) {
-    return true;
-  }
-  return frame->referenced_frame_id() == last_released_frame_;
-}
-
-}  //  namespace cast
-}  //  namespace media