Cast: Reshuffle files under media/cast

media/cast/sender/vp8_encoder.cc

 // 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.
-//
-// TODO (pwestin): add a link to the design document describing the generic
-// protocol and the VP8 specific details.
-#include "media/cast/video_sender/codecs/vp8/vp8_encoder.h"
+
+#include "media/cast/sender/vp8_encoder.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/transport/cast_transport_config.h"
+#include "media/cast/net/cast_transport_config.h"
 #include "third_party/libvpx/source/libvpx/vpx/vp8cx.h"
 
 namespace media {
 namespace cast {
 
 static const uint32 kMinIntra = 300;
 
 static int ComputeMaxNumOfRepeatedBuffes(int max_unacked_frames) {
   if (max_unacked_frames > kNumberOfVp8VideoBuffers)
     return (max_unacked_frames - 1) / kNumberOfVp8VideoBuffers;
@@ skipping 103 matching lines @@
     return;
   }
   vpx_codec_control(encoder_.get(), VP8E_SET_STATIC_THRESHOLD, 1);
   vpx_codec_control(encoder_.get(), VP8E_SET_NOISE_SENSITIVITY, 0);
   vpx_codec_control(encoder_.get(), VP8E_SET_CPUUSED, -6);
   vpx_codec_control(
       encoder_.get(), VP8E_SET_MAX_INTRA_BITRATE_PCT, rc_max_intra_target);
 }
 
 bool Vp8Encoder::Encode(const scoped_refptr<media::VideoFrame>& video_frame,
-                        transport::EncodedFrame* encoded_image) {
+                        EncodedFrame* encoded_image) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Image in vpx_image_t format.
   // Input image is const. VP8's raw image is not defined as const.
   raw_image_->planes[PLANE_Y] =
       const_cast<uint8*>(video_frame->data(VideoFrame::kYPlane));
   raw_image_->planes[PLANE_U] =
       const_cast<uint8*>(video_frame->data(VideoFrame::kUPlane));
   raw_image_->planes[PLANE_V] =
       const_cast<uint8*>(video_frame->data(VideoFrame::kVPlane));
 
@@ skipping 60 matching lines @@
     is_key_frame = !!(pkt->data.frame.flags & VPX_FRAME_IS_KEY);
     break;  // Done, since all data is provided in one CX_FRAME_PKT packet.
   }
   // Don't update frame_id for zero size frames.
   if (encoded_image->data.empty())
     return true;
 
   // Populate the encoded frame.
   encoded_image->frame_id = ++last_encoded_frame_id_;
   if (is_key_frame) {
-    encoded_image->dependency = transport::EncodedFrame::KEY;
+    encoded_image->dependency = EncodedFrame::KEY;
     encoded_image->referenced_frame_id = encoded_image->frame_id;
   } else {
-    encoded_image->dependency = transport::EncodedFrame::DEPENDENT;
+    encoded_image->dependency = EncodedFrame::DEPENDENT;
     encoded_image->referenced_frame_id = latest_frame_id_to_reference;
   }
 
   DVLOG(1) << "VP8 encoded frame_id " << encoded_image->frame_id
            << ", sized:" << encoded_image->data.size();
 
   if (is_key_frame) {
     key_frame_requested_ = false;
 
     for (int i = 0; i < kNumberOfVp8VideoBuffers; ++i) {
@@ skipping 173 matching lines @@
   float scale_parameter = 0.5;
   uint32 target_pct = optimal_buffer_size_ms * scale_parameter *
                       cast_config_.max_frame_rate / 10;
 
   // Don't go below 3 times the per frame bandwidth.
   return std::max(target_pct, kMinIntra);
 }
 
 }  // namespace cast
 }  // namespace media