Cast:Adding cast_transport_config and cleaning up

media/cast/video_sender/codecs/vp8/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 <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 "third_party/libvpx/source/libvpx/vpx/vp8cx.h"
 
 namespace media {
 namespace cast {
 
 static const uint32 kMinIntra = 300;
 
 Vp8Encoder::Vp8Encoder(const VideoSenderConfig& video_config,
                        uint8 max_unacked_frames)
     : cast_config_(video_config),
@@ skipping 96 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,
-                        EncodedVideoFrame* encoded_image) {
+                        transport::EncodedVideoFrame* encoded_image) {
   // 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));
 
   raw_image_->stride[VPX_PLANE_Y] = video_frame->stride(VideoFrame::kYPlane);
@@ skipping 48 matching lines @@
         encoded_image->key_frame = true;
       } else {
         encoded_image->key_frame = false;
       }
     }
   }
   // Don't update frame_id for zero size frames.
   if (total_size == 0) return true;
 
   // Populate the encoded frame.
-  encoded_image->codec = kVp8;
+  encoded_image->codec = transport::kVp8;
   encoded_image->last_referenced_frame_id = latest_frame_id_to_reference;
   encoded_image->frame_id = ++last_encoded_frame_id_;
 
   VLOG(1) << "VP8 encoded frame:" << static_cast<int>(encoded_image->frame_id)
           << " sized:" << total_size;
 
   if (encoded_image->key_frame) {
     key_frame_requested_ = false;
 
     for (int i = 0; i < kNumberOfVp8VideoBuffers; ++i) {
@@ skipping 161 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