421 lines
14 KiB
C++
421 lines
14 KiB
C++
|
/*
|
||
|
* Copyright (c) 2011 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/media/engine/webrtcvideocapturer.h"
|
||
|
|
||
|
#include "webrtc/base/arraysize.h"
|
||
|
#include "webrtc/base/bind.h"
|
||
|
#include "webrtc/base/checks.h"
|
||
|
#include "webrtc/base/criticalsection.h"
|
||
|
#include "webrtc/base/logging.h"
|
||
|
#include "webrtc/base/safe_conversions.h"
|
||
|
#include "webrtc/base/thread.h"
|
||
|
#include "webrtc/base/timeutils.h"
|
||
|
#include "webrtc/media/engine/webrtcvideoframe.h"
|
||
|
#include "webrtc/media/engine/webrtcvideoframefactory.h"
|
||
|
|
||
|
#include "webrtc/base/win32.h" // Need this to #include the impl files.
|
||
|
#include "webrtc/modules/video_capture/video_capture_factory.h"
|
||
|
#include "webrtc/system_wrappers/include/field_trial.h"
|
||
|
|
||
|
namespace cricket {
|
||
|
|
||
|
struct kVideoFourCCEntry {
|
||
|
uint32_t fourcc;
|
||
|
webrtc::RawVideoType webrtc_type;
|
||
|
};
|
||
|
|
||
|
// This indicates our format preferences and defines a mapping between
|
||
|
// webrtc::RawVideoType (from video_capture_defines.h) to our FOURCCs.
|
||
|
static kVideoFourCCEntry kSupportedFourCCs[] = {
|
||
|
{ FOURCC_I420, webrtc::kVideoI420 }, // 12 bpp, no conversion.
|
||
|
{ FOURCC_YV12, webrtc::kVideoYV12 }, // 12 bpp, no conversion.
|
||
|
{ FOURCC_YUY2, webrtc::kVideoYUY2 }, // 16 bpp, fast conversion.
|
||
|
{ FOURCC_UYVY, webrtc::kVideoUYVY }, // 16 bpp, fast conversion.
|
||
|
{ FOURCC_NV12, webrtc::kVideoNV12 }, // 12 bpp, fast conversion.
|
||
|
{ FOURCC_NV21, webrtc::kVideoNV21 }, // 12 bpp, fast conversion.
|
||
|
{ FOURCC_MJPG, webrtc::kVideoMJPEG }, // compressed, slow conversion.
|
||
|
{ FOURCC_ARGB, webrtc::kVideoARGB }, // 32 bpp, slow conversion.
|
||
|
{ FOURCC_24BG, webrtc::kVideoRGB24 }, // 24 bpp, slow conversion.
|
||
|
};
|
||
|
|
||
|
class WebRtcVcmFactory : public WebRtcVcmFactoryInterface {
|
||
|
public:
|
||
|
virtual rtc::scoped_refptr<webrtc::VideoCaptureModule> Create(
|
||
|
int id,
|
||
|
const char* device) {
|
||
|
return webrtc::VideoCaptureFactory::Create(id, device);
|
||
|
}
|
||
|
virtual webrtc::VideoCaptureModule::DeviceInfo* CreateDeviceInfo(int id) {
|
||
|
return webrtc::VideoCaptureFactory::CreateDeviceInfo(id);
|
||
|
}
|
||
|
virtual void DestroyDeviceInfo(webrtc::VideoCaptureModule::DeviceInfo* info) {
|
||
|
delete info;
|
||
|
}
|
||
|
};
|
||
|
|
||
|
static bool CapabilityToFormat(const webrtc::VideoCaptureCapability& cap,
|
||
|
VideoFormat* format) {
|
||
|
uint32_t fourcc = 0;
|
||
|
for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
|
||
|
if (kSupportedFourCCs[i].webrtc_type == cap.rawType) {
|
||
|
fourcc = kSupportedFourCCs[i].fourcc;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
if (fourcc == 0) {
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
format->fourcc = fourcc;
|
||
|
format->width = cap.width;
|
||
|
format->height = cap.height;
|
||
|
format->interval = VideoFormat::FpsToInterval(cap.maxFPS);
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
static bool FormatToCapability(const VideoFormat& format,
|
||
|
webrtc::VideoCaptureCapability* cap) {
|
||
|
webrtc::RawVideoType webrtc_type = webrtc::kVideoUnknown;
|
||
|
for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
|
||
|
if (kSupportedFourCCs[i].fourcc == format.fourcc) {
|
||
|
webrtc_type = kSupportedFourCCs[i].webrtc_type;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
if (webrtc_type == webrtc::kVideoUnknown) {
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
cap->width = format.width;
|
||
|
cap->height = format.height;
|
||
|
cap->maxFPS = VideoFormat::IntervalToFps(format.interval);
|
||
|
cap->expectedCaptureDelay = 0;
|
||
|
cap->rawType = webrtc_type;
|
||
|
cap->codecType = webrtc::kVideoCodecUnknown;
|
||
|
cap->interlaced = false;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
///////////////////////////////////////////////////////////////////////////
|
||
|
// Implementation of class WebRtcVideoCapturer
|
||
|
///////////////////////////////////////////////////////////////////////////
|
||
|
|
||
|
WebRtcVideoCapturer::WebRtcVideoCapturer()
|
||
|
: factory_(new WebRtcVcmFactory),
|
||
|
module_(nullptr),
|
||
|
captured_frames_(0),
|
||
|
start_thread_(nullptr),
|
||
|
async_invoker_(nullptr) {
|
||
|
set_frame_factory(new WebRtcVideoFrameFactory());
|
||
|
}
|
||
|
|
||
|
WebRtcVideoCapturer::WebRtcVideoCapturer(WebRtcVcmFactoryInterface* factory)
|
||
|
: factory_(factory),
|
||
|
module_(nullptr),
|
||
|
captured_frames_(0),
|
||
|
start_thread_(nullptr),
|
||
|
async_invoker_(nullptr) {
|
||
|
set_frame_factory(new WebRtcVideoFrameFactory());
|
||
|
}
|
||
|
|
||
|
WebRtcVideoCapturer::~WebRtcVideoCapturer() {}
|
||
|
|
||
|
bool WebRtcVideoCapturer::Init(const Device& device) {
|
||
|
RTC_DCHECK(!start_thread_);
|
||
|
if (module_) {
|
||
|
LOG(LS_ERROR) << "The capturer is already initialized";
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
webrtc::VideoCaptureModule::DeviceInfo* info = factory_->CreateDeviceInfo(0);
|
||
|
if (!info) {
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// Find the desired camera, by name.
|
||
|
// In the future, comparing IDs will be more robust.
|
||
|
// TODO(juberti): Figure what's needed to allow this.
|
||
|
int num_cams = info->NumberOfDevices();
|
||
|
char vcm_id[256] = "";
|
||
|
bool found = false;
|
||
|
for (int index = 0; index < num_cams; ++index) {
|
||
|
char vcm_name[256];
|
||
|
if (info->GetDeviceName(index, vcm_name, arraysize(vcm_name), vcm_id,
|
||
|
arraysize(vcm_id)) != -1) {
|
||
|
if (device.name == reinterpret_cast<char*>(vcm_name)) {
|
||
|
found = true;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (!found) {
|
||
|
LOG(LS_WARNING) << "Failed to find capturer for id: " << device.id;
|
||
|
factory_->DestroyDeviceInfo(info);
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// Enumerate the supported formats.
|
||
|
// TODO(juberti): Find out why this starts/stops the camera...
|
||
|
std::vector<VideoFormat> supported;
|
||
|
int32_t num_caps = info->NumberOfCapabilities(vcm_id);
|
||
|
for (int32_t i = 0; i < num_caps; ++i) {
|
||
|
webrtc::VideoCaptureCapability cap;
|
||
|
if (info->GetCapability(vcm_id, i, cap) != -1) {
|
||
|
VideoFormat format;
|
||
|
if (CapabilityToFormat(cap, &format)) {
|
||
|
supported.push_back(format);
|
||
|
} else {
|
||
|
LOG(LS_WARNING) << "Ignoring unsupported WebRTC capture format "
|
||
|
<< cap.rawType;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
factory_->DestroyDeviceInfo(info);
|
||
|
|
||
|
if (supported.empty()) {
|
||
|
LOG(LS_ERROR) << "Failed to find usable formats for id: " << device.id;
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
module_ = factory_->Create(0, vcm_id);
|
||
|
if (!module_) {
|
||
|
LOG(LS_ERROR) << "Failed to create capturer for id: " << device.id;
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
// It is safe to change member attributes now.
|
||
|
SetId(device.id);
|
||
|
SetSupportedFormats(supported);
|
||
|
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool WebRtcVideoCapturer::Init(
|
||
|
const rtc::scoped_refptr<webrtc::VideoCaptureModule>& module) {
|
||
|
RTC_DCHECK(!start_thread_);
|
||
|
if (module_) {
|
||
|
LOG(LS_ERROR) << "The capturer is already initialized";
|
||
|
return false;
|
||
|
}
|
||
|
if (!module) {
|
||
|
LOG(LS_ERROR) << "Invalid VCM supplied";
|
||
|
return false;
|
||
|
}
|
||
|
// TODO(juberti): Set id and formats.
|
||
|
module_ = module;
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
bool WebRtcVideoCapturer::GetBestCaptureFormat(const VideoFormat& desired,
|
||
|
VideoFormat* best_format) {
|
||
|
if (!best_format) {
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
if (!VideoCapturer::GetBestCaptureFormat(desired, best_format)) {
|
||
|
// We maybe using a manually injected VCM which doesn't support enum.
|
||
|
// Use the desired format as the best format.
|
||
|
best_format->width = desired.width;
|
||
|
best_format->height = desired.height;
|
||
|
best_format->fourcc = FOURCC_I420;
|
||
|
best_format->interval = desired.interval;
|
||
|
LOG(LS_INFO) << "Failed to find best capture format,"
|
||
|
<< " fall back to the requested format "
|
||
|
<< best_format->ToString();
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
void WebRtcVideoCapturer::OnSinkWantsChanged(const rtc::VideoSinkWants& wants) {
|
||
|
// Can't take lock here as this will cause deadlock with
|
||
|
// OnIncomingCapturedFrame. In fact, the whole method, including methods it
|
||
|
// calls, can't take lock.
|
||
|
RTC_DCHECK(module_);
|
||
|
|
||
|
const std::string group_name =
|
||
|
webrtc::field_trial::FindFullName("WebRTC-CVO");
|
||
|
|
||
|
if (group_name == "Disabled") {
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
VideoCapturer::OnSinkWantsChanged(wants);
|
||
|
bool result = module_->SetApplyRotation(wants.rotation_applied);
|
||
|
RTC_CHECK(result);
|
||
|
|
||
|
return;
|
||
|
}
|
||
|
|
||
|
CaptureState WebRtcVideoCapturer::Start(const VideoFormat& capture_format) {
|
||
|
if (!module_) {
|
||
|
LOG(LS_ERROR) << "The capturer has not been initialized";
|
||
|
return CS_FAILED;
|
||
|
}
|
||
|
if (start_thread_) {
|
||
|
LOG(LS_ERROR) << "The capturer is already running";
|
||
|
RTC_DCHECK(start_thread_->IsCurrent())
|
||
|
<< "Trying to start capturer on different threads";
|
||
|
return CS_FAILED;
|
||
|
}
|
||
|
|
||
|
start_thread_ = rtc::Thread::Current();
|
||
|
RTC_DCHECK(!async_invoker_);
|
||
|
async_invoker_.reset(new rtc::AsyncInvoker());
|
||
|
captured_frames_ = 0;
|
||
|
|
||
|
SetCaptureFormat(&capture_format);
|
||
|
|
||
|
webrtc::VideoCaptureCapability cap;
|
||
|
if (!FormatToCapability(capture_format, &cap)) {
|
||
|
LOG(LS_ERROR) << "Invalid capture format specified";
|
||
|
return CS_FAILED;
|
||
|
}
|
||
|
|
||
|
int64_t start = rtc::TimeMillis();
|
||
|
module_->RegisterCaptureDataCallback(*this);
|
||
|
if (module_->StartCapture(cap) != 0) {
|
||
|
LOG(LS_ERROR) << "Camera '" << GetId() << "' failed to start";
|
||
|
module_->DeRegisterCaptureDataCallback();
|
||
|
async_invoker_.reset();
|
||
|
SetCaptureFormat(nullptr);
|
||
|
start_thread_ = nullptr;
|
||
|
return CS_FAILED;
|
||
|
}
|
||
|
|
||
|
LOG(LS_INFO) << "Camera '" << GetId() << "' started with format "
|
||
|
<< capture_format.ToString() << ", elapsed time "
|
||
|
<< rtc::TimeSince(start) << " ms";
|
||
|
|
||
|
SetCaptureState(CS_RUNNING);
|
||
|
return CS_STARTING;
|
||
|
}
|
||
|
|
||
|
void WebRtcVideoCapturer::Stop() {
|
||
|
if (!start_thread_) {
|
||
|
LOG(LS_ERROR) << "The capturer is already stopped";
|
||
|
return;
|
||
|
}
|
||
|
RTC_DCHECK(start_thread_);
|
||
|
RTC_DCHECK(start_thread_->IsCurrent());
|
||
|
RTC_DCHECK(async_invoker_);
|
||
|
if (IsRunning()) {
|
||
|
// The module is responsible for OnIncomingCapturedFrame being called, if
|
||
|
// we stop it we will get no further callbacks.
|
||
|
module_->StopCapture();
|
||
|
}
|
||
|
module_->DeRegisterCaptureDataCallback();
|
||
|
|
||
|
// TODO(juberti): Determine if the VCM exposes any drop stats we can use.
|
||
|
double drop_ratio = 0.0;
|
||
|
LOG(LS_INFO) << "Camera '" << GetId() << "' stopped after capturing "
|
||
|
<< captured_frames_ << " frames and dropping "
|
||
|
<< drop_ratio << "%";
|
||
|
|
||
|
// Clear any pending async invokes (that OnIncomingCapturedFrame may have
|
||
|
// caused).
|
||
|
async_invoker_.reset();
|
||
|
|
||
|
SetCaptureFormat(NULL);
|
||
|
start_thread_ = nullptr;
|
||
|
SetCaptureState(CS_STOPPED);
|
||
|
}
|
||
|
|
||
|
bool WebRtcVideoCapturer::IsRunning() {
|
||
|
return (module_ != NULL && module_->CaptureStarted());
|
||
|
}
|
||
|
|
||
|
bool WebRtcVideoCapturer::GetPreferredFourccs(std::vector<uint32_t>* fourccs) {
|
||
|
if (!fourccs) {
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
fourccs->clear();
|
||
|
for (size_t i = 0; i < arraysize(kSupportedFourCCs); ++i) {
|
||
|
fourccs->push_back(kSupportedFourCCs[i].fourcc);
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
void WebRtcVideoCapturer::OnIncomingCapturedFrame(
|
||
|
const int32_t id,
|
||
|
const webrtc::VideoFrame& sample) {
|
||
|
// This can only happen between Start() and Stop().
|
||
|
RTC_DCHECK(start_thread_);
|
||
|
RTC_DCHECK(async_invoker_);
|
||
|
if (start_thread_->IsCurrent()) {
|
||
|
SignalFrameCapturedOnStartThread(sample);
|
||
|
} else {
|
||
|
// This currently happens on with at least VideoCaptureModuleV4L2 and
|
||
|
// possibly other implementations of WebRTC's VideoCaptureModule.
|
||
|
// In order to maintain the threading contract with the upper layers and
|
||
|
// consistency with other capturers such as in Chrome, we need to do a
|
||
|
// thread hop.
|
||
|
// Note that Stop() can cause the async invoke call to be cancelled.
|
||
|
async_invoker_->AsyncInvoke<void>(
|
||
|
RTC_FROM_HERE, start_thread_,
|
||
|
// Note that Bind captures by value, so there's an intermediate copy
|
||
|
// of sample.
|
||
|
rtc::Bind(&WebRtcVideoCapturer::SignalFrameCapturedOnStartThread, this,
|
||
|
sample));
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void WebRtcVideoCapturer::OnCaptureDelayChanged(const int32_t id,
|
||
|
const int32_t delay) {
|
||
|
LOG(LS_INFO) << "Capture delay changed to " << delay << " ms";
|
||
|
}
|
||
|
|
||
|
void WebRtcVideoCapturer::SignalFrameCapturedOnStartThread(
|
||
|
const webrtc::VideoFrame& frame) {
|
||
|
// This can only happen between Start() and Stop().
|
||
|
RTC_DCHECK(start_thread_);
|
||
|
RTC_DCHECK(start_thread_->IsCurrent());
|
||
|
RTC_DCHECK(async_invoker_);
|
||
|
|
||
|
++captured_frames_;
|
||
|
// Log the size and pixel aspect ratio of the first captured frame.
|
||
|
if (1 == captured_frames_) {
|
||
|
LOG(LS_INFO) << "Captured frame size "
|
||
|
<< frame.width() << "x" << frame.height()
|
||
|
<< ". Expected format " << GetCaptureFormat()->ToString();
|
||
|
}
|
||
|
|
||
|
// Signal down stream components on captured frame.
|
||
|
// The CapturedFrame class doesn't support planes. We have to ExtractBuffer
|
||
|
// to one block for it.
|
||
|
size_t length =
|
||
|
webrtc::CalcBufferSize(webrtc::kI420, frame.width(), frame.height());
|
||
|
capture_buffer_.resize(length);
|
||
|
// TODO(magjed): Refactor the WebRtcCapturedFrame to avoid memory copy or
|
||
|
// take over ownership of the buffer held by |frame| if that's possible.
|
||
|
webrtc::ExtractBuffer(frame, length, &capture_buffer_[0]);
|
||
|
WebRtcCapturedFrame webrtc_frame(frame, &capture_buffer_[0], length);
|
||
|
SignalFrameCaptured(this, &webrtc_frame);
|
||
|
}
|
||
|
|
||
|
// WebRtcCapturedFrame
|
||
|
WebRtcCapturedFrame::WebRtcCapturedFrame(const webrtc::VideoFrame& sample,
|
||
|
void* buffer,
|
||
|
size_t length) {
|
||
|
width = sample.width();
|
||
|
height = sample.height();
|
||
|
fourcc = FOURCC_I420;
|
||
|
// TODO(hellner): Support pixel aspect ratio (for OSX).
|
||
|
pixel_width = 1;
|
||
|
pixel_height = 1;
|
||
|
// Convert units from VideoFrame RenderTimeMs to CapturedFrame (nanoseconds).
|
||
|
time_stamp = sample.render_time_ms() * rtc::kNumNanosecsPerMillisec;
|
||
|
data_size = rtc::checked_cast<uint32_t>(length);
|
||
|
data = buffer;
|
||
|
rotation = sample.rotation();
|
||
|
}
|
||
|
|
||
|
} // namespace cricket
|