WebRtc libjingle_PeerConnection层（一） 显示本地视频

只做本地显示，在PeerConnection层调用流程比较简单。代码由Peerconnection_Client扣出来的。

1. 获得摄像头
cricket::VideoCapturer* OpenVideoCaptureDevice()

2. 设置Render
StartLocalRenderer(video_track);

3. 取并显示

//#include "talk/examples/peerconnection/client/conductor.h"

#include <utility>
#include <vector>

#ifdef WIN32
#include <Windows.h>

#endif

//#include "opencv2\opencv.hpp"

#include "talk/app/webrtc/videosourceinterface.h"
#include "talk/app/webrtc/mediastreaminterface.h"
#include "talk/app/webrtc/peerconnectioninterface.h"
#include "talk/media/devices/devicemanager.h"
//#include "talk/app/webrtc/test/fakeconstraints.h"
#include "talk/media/base/videorenderer.h"
#include "talk/media/base/videoframe.h"
#include "webrtc/base/common.h"
#include "webrtc/base/json.h"
#include "webrtc/base/logging.h"

//#pragma comment(lib, "opencv_world300d.lib")

#define DTLS_ON  true
#define DTLS_OFF false

// Names used for a IceCandidate JSON object.
const char kCandidateSdpMidName[] = "sdpMid";
const char kCandidateSdpMlineIndexName[] = "sdpMLineIndex";
const char kCandidateSdpName[] = "candidate";

// Names used for a SessionDescription JSON object.
const char kSessionDescriptionTypeName[] = "type";
const char kSessionDescriptionSdpName[] = "sdp";

const char kAudioLabel[] = "audio_label";
const char kVideoLabel[] = "video_label";
const char kStreamLabel[] = "stream_label";

// A little helper class to make sure we always to proper locking and
// unlocking when working with VideoRenderer buffers.
template <typename T>
class AutoLock {
public:
explicit AutoLock(T* obj) : obj_(obj) { obj_->Lock(); }
~AutoLock() { obj_->Unlock(); }
protected:
T* obj_;
};

class VideoRenderer : public webrtc::VideoRendererInterface {
public:
VideoRenderer(HWND wnd, int width, int height,
webrtc::VideoTrackInterface* track_to_render);
virtual ~VideoRenderer();

void Lock() {
::EnterCriticalSection(&buffer_lock_);
}

void Unlock() {
::LeaveCriticalSection(&buffer_lock_);
}

// VideoRendererInterface implementation
virtual void SetSize(int width, int height);
virtual void RenderFrame(const cricket::VideoFrame* frame);

const BITMAPINFO& bmi() const { return bmi_; }
const uint8* image() const { return image_.get(); }

protected:
enum {
SET_SIZE,
RENDER_FRAME,
};

HWND wnd_;
BITMAPINFO bmi_;
rtc::scoped_ptr<uint8[]> image_;
CRITICAL_SECTION buffer_lock_;
rtc::scoped_refptr<webrtc::VideoTrackInterface> rendered_track_;
};

//
// VideoRenderer
//
VideoRenderer::VideoRenderer(
HWND wnd, int width, int height,
webrtc::VideoTrackInterface* track_to_render)
: wnd_(wnd), rendered_track_(track_to_render) {
::InitializeCriticalSection(&buffer_lock_);
ZeroMemory(&bmi_, sizeof(bmi_));
bmi_.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi_.bmiHeader.biPlanes = 1;
bmi_.bmiHeader.biBitCount = 32;
bmi_.bmiHeader.biCompression = BI_RGB;
bmi_.bmiHeader.biWidth = width;
bmi_.bmiHeader.biHeight = -height;
bmi_.bmiHeader.biSizeImage = width * height *
(bmi_.bmiHeader.biBitCount >> 3);
rendered_track_->AddRenderer(this);
}

VideoRenderer::~VideoRenderer() {
rendered_track_->RemoveRenderer(this);
::DeleteCriticalSection(&buffer_lock_);
}

void VideoRenderer::SetSize(int width, int height) {
AutoLock<VideoRenderer> lock(this);

if (width == bmi_.bmiHeader.biWidth && height == bmi_.bmiHeader.biHeight) {
return;
}

bmi_.bmiHeader.biWidth = width;
bmi_.bmiHeader.biHeight = -height;
bmi_.bmiHeader.biSizeImage = width * height *
(bmi_.bmiHeader.biBitCount >> 3);
image_.reset(new uint8[bmi_.bmiHeader.biSizeImage]);
}
int ii = 0;
void VideoRenderer::RenderFrame(
const cricket::VideoFrame* video_frame) {
if (!video_frame)
return;

{
AutoLock<VideoRenderer> lock(this);

const cricket::VideoFrame* frame =
video_frame->GetCopyWithRotationApplied();

SetSize(static_cast<int>(frame->GetWidth()),
static_cast<int>(frame->GetHeight()));

ASSERT(image_.get() != NULL);
frame->ConvertToRgbBuffer(cricket::FOURCC_ARGB,
image_.get(),
bmi_.bmiHeader.biSizeImage,
bmi_.bmiHeader.biWidth *
bmi_.bmiHeader.biBitCount / 8);
}
InvalidateRect(wnd_, NULL, TRUE);
}

rtc::scoped_refptr<webrtc::PeerConnectionInterface> peer_connection_;
rtc::scoped_refptr<webrtc::PeerConnectionFactoryInterface> peer_connection_factory_;

rtc::scoped_ptr<VideoRenderer> local_renderer_;

HWND wnd = NULL;

cricket::VideoCapturer* OpenVideoCaptureDevice() {
rtc::scoped_ptr<cricket::DeviceManagerInterface> dev_manager(
cricket::DeviceManagerFactory::Create());
if (!dev_manager->Init()) {
LOG(LS_ERROR) << "Can't create device manager";
return NULL;
}
std::vector<cricket::Device> devs;
if (!dev_manager->GetVideoCaptureDevices(&devs)) {
LOG(LS_ERROR) << "Can't enumerate video devices";
return NULL;
}
std::vector<cricket::Device>::iterator dev_it = devs.begin();
cricket::VideoCapturer* capturer = NULL;
for (; dev_it != devs.end(); ++dev_it) {
capturer = dev_manager->CreateVideoCapturer(*dev_it);
if (capturer != NULL)
break;
}
return capturer;
}

void StartLocalRenderer(webrtc::VideoTrackInterface* local_video) {
local_renderer_.reset(new VideoRenderer(wnd, 1, 1, local_video));
}

void AddStreams() {

rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
peer_connection_factory_->CreateAudioTrack(
kAudioLabel, peer_connection_factory_->CreateAudioSource(NULL)));

rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
peer_connection_factory_->CreateVideoTrack(
kVideoLabel,
peer_connection_factory_->CreateVideoSource(OpenVideoCaptureDevice(),
NULL)));

StartLocalRenderer(video_track);
}

bool InitializePeerConnection() {
ASSERT(peer_connection_factory_.get() == NULL);
ASSERT(peer_connection_.get() == NULL);

peer_connection_factory_ = webrtc::CreatePeerConnectionFactory();

if (!peer_connection_factory_.get()) {
return false;
}

AddStreams();
return peer_connection_.get() != NULL;
}

void Show()
{
VideoRenderer* local_renderer = local_renderer_.get();
if (local_renderer)
{
AutoLock<VideoRenderer> local_lock(local_renderer);
const BITMAPINFO& bmi = local_renderer->bmi();
const uint8* image = local_renderer->image();
//printf("height=%d  width=%d  biSizeImage=%d \n", bmi.bmiHeader.biHeight, bmi.bmiHeader.biWidth, bmi.bmiHeader.biSizeImage);
//GetBitmapFromScreen("c:\\aa.bmp", (BITMAPINFO)bmi, (uint8*)image);
int rows = abs(bmi.bmiHeader.biHeight);;
int cols = bmi.bmiHeader.biWidth;
static int i = 0;
printf("%d\n", i++);
//cv::Mat img(rows, cols, CV_8UC4, (void*)image, 0U);
//cv::imshow("Video Capture", img);
//cvWaitKey(1);
}
}

void ThreadProc(LPVOID lpParam)
{
while (true)
{
Show();
Sleep(33);
}
}

int main()
{
getchar();

//wnd = FindWindow(L"ConsoleWindowClass", NULL);

if (!InitializePeerConnection())
printf("error\n");

DWORD dwThreadId;

CreateThread(
NULL,//defaultsecurityattributes
0,//usedefaultstacksize
(LPTHREAD_START_ROUTINE)ThreadProc,//threadfunction
NULL,//argumenttothreadfunction
0,//usedefaultcreationflags
&dwThreadId);//returnsthethreadidentifier

getchar();
return 0;
}