New VideoEngine API implementation on top of old one, first steps.
BUG=1668
R=mflodman@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/1360004
git-svn-id: http://webrtc.googlecode.com/svn/trunk/webrtc@4044 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/video_engine/internal/video_send_stream.cc b/video_engine/internal/video_send_stream.cc
new file mode 100644
index 0000000..c818258
--- /dev/null
+++ b/video_engine/internal/video_send_stream.cc
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "webrtc/video_engine/internal/video_send_stream.h"
+
+#include <vector>
+
+#include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
+#include "webrtc/video_engine/include/vie_base.h"
+#include "webrtc/video_engine/include/vie_capture.h"
+#include "webrtc/video_engine/include/vie_codec.h"
+#include "webrtc/video_engine/include/vie_network.h"
+#include "webrtc/video_engine/include/vie_rtp_rtcp.h"
+#include "webrtc/video_engine/new_include/video_send_stream.h"
+
+namespace webrtc {
+namespace internal {
+
+VideoSendStream::VideoSendStream(
+ newapi::Transport* transport, webrtc::VideoEngine* video_engine,
+ const newapi::VideoSendStreamConfig& send_stream_config)
+ : transport_(transport), config_(send_stream_config) {
+
+ if (config_.codec.numberOfSimulcastStreams > 0) {
+ assert(config_.rtp.ssrcs.size() == config_.codec.numberOfSimulcastStreams);
+ } else {
+ assert(config_.rtp.ssrcs.size() == 1);
+ }
+
+ video_engine_base_ = ViEBase::GetInterface(video_engine);
+ video_engine_base_->CreateChannel(channel_);
+ assert(channel_ != -1);
+
+ rtp_rtcp_ = ViERTP_RTCP::GetInterface(video_engine);
+ assert(rtp_rtcp_ != NULL);
+
+ assert(config_.rtp.ssrcs.size() == 1);
+ rtp_rtcp_->SetLocalSSRC(channel_, config_.rtp.ssrcs[0]);
+
+ capture_ = ViECapture::GetInterface(video_engine);
+ capture_->AllocateExternalCaptureDevice(capture_id_, external_capture_);
+ capture_->ConnectCaptureDevice(capture_id_, channel_);
+
+ network_ = ViENetwork::GetInterface(video_engine);
+ assert(network_ != NULL);
+
+ network_->RegisterSendTransport(channel_, *this);
+
+ codec_ = ViECodec::GetInterface(video_engine);
+ if (codec_->SetSendCodec(channel_, config_.codec) != 0) {
+ abort();
+ }
+}
+
+VideoSendStream::~VideoSendStream() {
+ network_->DeregisterSendTransport(channel_);
+ video_engine_base_->DeleteChannel(channel_);
+
+ capture_->DisconnectCaptureDevice(channel_);
+ capture_->ReleaseCaptureDevice(capture_id_);
+
+ video_engine_base_->Release();
+ capture_->Release();
+ codec_->Release();
+ network_->Release();
+ rtp_rtcp_->Release();
+}
+
+void VideoSendStream::PutFrame(const I420VideoFrame& frame,
+ int32_t delta_capture_time) {
+ I420VideoFrame frame_copy;
+ frame_copy.CopyFrame(frame);
+
+ if (config_.pre_encode_callback != NULL) {
+ config_.pre_encode_callback->FrameCallback(&frame_copy);
+ }
+
+ ViEVideoFrameI420 vf;
+
+ // TODO(pbos): This represents a memcpy step and is only required because
+ // external_capture_ only takes ViEVideoFrameI420s.
+ vf.y_plane = frame_copy.buffer(kYPlane);
+ vf.u_plane = frame_copy.buffer(kUPlane);
+ vf.v_plane = frame_copy.buffer(kVPlane);
+ vf.y_pitch = frame.stride(kYPlane);
+ vf.u_pitch = frame.stride(kUPlane);
+ vf.v_pitch = frame.stride(kVPlane);
+ vf.width = frame.width();
+ vf.height = frame.height();
+
+ external_capture_->IncomingFrameI420(vf, frame.timestamp());
+
+ if (config_.local_renderer != NULL) {
+ config_.local_renderer->RenderFrame(frame, 0);
+ }
+}
+
+newapi::VideoSendStreamInput* VideoSendStream::Input() { return this; }
+
+void VideoSendStream::StartSend() {
+ if (video_engine_base_->StartSend(channel_) != 0) abort();
+}
+
+void VideoSendStream::StopSend() {
+ if (video_engine_base_->StopSend(channel_) != 0) abort();
+}
+
+void VideoSendStream::GetSendStatistics(
+ std::vector<newapi::SendStatistics>* statistics) {
+ // TODO(pbos): Implement
+}
+
+bool VideoSendStream::SetTargetBitrate(
+ int min_bitrate, int max_bitrate,
+ const std::vector<SimulcastStream>& streams) {
+ return false;
+}
+
+void VideoSendStream::GetSendCodec(VideoCodec* send_codec) {
+ *send_codec = config_.codec;
+}
+
+int VideoSendStream::SendPacket(int /*channel*/, const void* packet,
+ int length) {
+ // TODO(pbos): Lock these methods and the destructor so it can't be processing
+ // a packet when the destructor has been called.
+ assert(length >= 0);
+ return transport_->SendRTP(packet, static_cast<size_t>(length)) ? 0 : -1;
+}
+
+int VideoSendStream::SendRTCPPacket(int /*channel*/, const void* packet,
+ int length) {
+ assert(length >= 0);
+ return transport_->SendRTCP(packet, static_cast<size_t>(length)) ? 0 : -1;
+}
+
+} // namespace internal
+} // namespace webrtc