namespace {
+// Translate from webrtc::VideoCodecType and webrtc::VideoCodec to
+// media::VideoCodecProfile.
+media::VideoCodecProfile WebRTCVideoCodecToVideoCodecProfile(
+ webrtc::VideoCodecType type, const webrtc::VideoCodec* codec_settings) {
+ DCHECK_EQ(type, codec_settings->codecType);
+ switch (type) {
+ case webrtc::kVideoCodecVP8:
+ return media::VP8PROFILE_ANY;
+ case webrtc::kVideoCodecH264: {
+ switch (codec_settings->codecSpecific.H264.profile) {
+ case webrtc::kProfileBase:
+ return media::H264PROFILE_BASELINE;
+ case webrtc::kProfileMain:
+ return media::H264PROFILE_MAIN;
+ }
+ }
+ default:
+ NOTREACHED() << "Unrecognized video codec type";
+ return media::VIDEO_CODEC_PROFILE_UNKNOWN;
+ }
+}
+
// Populates struct webrtc::RTPFragmentationHeader for H264 codec.
// Each entry specifies the offset and length (excluding start code) of a NALU.
// Returns true if successful.
void Destroy();
// media::VideoEncodeAccelerator::Client implementation.
- virtual void RequireBitstreamBuffers(unsigned int input_count,
- const gfx::Size& input_coded_size,
- size_t output_buffer_size) OVERRIDE;
- virtual void BitstreamBufferReady(int32 bitstream_buffer_id,
- size_t payload_size,
- bool key_frame) OVERRIDE;
- virtual void NotifyError(media::VideoEncodeAccelerator::Error error) OVERRIDE;
+ void RequireBitstreamBuffers(unsigned int input_count,
+ const gfx::Size& input_coded_size,
+ size_t output_buffer_size) override;
+ void BitstreamBufferReady(int32 bitstream_buffer_id,
+ size_t payload_size,
+ bool key_frame) override;
+ void NotifyError(media::VideoEncodeAccelerator::Error error) override;
private:
friend class base::RefCountedThreadSafe<Impl>;
kOutputBufferCount = 3,
};
- virtual ~Impl();
+ ~Impl() override;
// Perform encoding on an input frame from the input queue.
void EncodeOneFrame();
RTCVideoEncoder::RTCVideoEncoder(
webrtc::VideoCodecType type,
- media::VideoCodecProfile profile,
const scoped_refptr<media::GpuVideoAcceleratorFactories>& gpu_factories)
: video_codec_type_(type),
- video_codec_profile_(profile),
gpu_factories_(gpu_factories),
encoded_image_callback_(NULL),
impl_status_(WEBRTC_VIDEO_CODEC_UNINITIALIZED),
weak_factory_(this) {
- DVLOG(1) << "RTCVideoEncoder(): profile=" << profile;
+ DVLOG(1) << "RTCVideoEncoder(): codec type=" << type;
}
RTCVideoEncoder::~RTCVideoEncoder() {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(!impl_.get());
+ media::VideoCodecProfile profile = WebRTCVideoCodecToVideoCodecProfile(
+ video_codec_type_, codec_settings);
+
weak_factory_.InvalidateWeakPtrs();
impl_ = new Impl(weak_factory_.GetWeakPtr(), gpu_factories_);
base::WaitableEvent initialization_waiter(true, false);
impl_,
gfx::Size(codec_settings->width, codec_settings->height),
codec_settings->startBitrate,
- video_codec_profile_,
+ profile,
&initialization_waiter,
&initialization_retval));
// webrtc::VideoEncoder expects this call to be synchronous.
initialization_waiter.Wait();
- RecordInitEncodeUMA(initialization_retval);
+ RecordInitEncodeUMA(initialization_retval, profile);
return initialization_retval;
}
memset(&header, 0, sizeof(header));
switch (video_codec_type_) {
case webrtc::kVideoCodecVP8:
- case webrtc::kVideoCodecGeneric:
// Generate a header describing a single fragment.
- // Note that webrtc treats the generic-type payload as an opaque buffer.
header.VerifyAndAllocateFragmentationHeader(1);
header.fragmentationOffset[0] = 0;
header.fragmentationLength[0] = image->_length;
impl_ = NULL;
}
-void RTCVideoEncoder::RecordInitEncodeUMA(int32_t init_retval) {
+void RTCVideoEncoder::RecordInitEncodeUMA(
+ int32_t init_retval, media::VideoCodecProfile profile) {
UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoEncoderInitEncodeSuccess",
init_retval == WEBRTC_VIDEO_CODEC_OK);
if (init_retval == WEBRTC_VIDEO_CODEC_OK) {
UMA_HISTOGRAM_ENUMERATION("Media.RTCVideoEncoderProfile",
- video_codec_profile_,
+ profile,
media::VIDEO_CODEC_PROFILE_MAX + 1);
}
}