Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(767)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: media/gpu/media_foundation_video_encode_accelerator_win.cc

Issue 2172703002: Revert of H264 HW encode using MediaFoundation (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 4 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « media/gpu/media_foundation_video_encode_accelerator_win.h ('k') | media/gpu/video_encode_accelerator_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: media/gpu/media_foundation_video_encode_accelerator_win.cc
diff --git a/media/gpu/media_foundation_video_encode_accelerator_win.cc b/media/gpu/media_foundation_video_encode_accelerator_win.cc
deleted file mode 100644
index bd15bb2089421f59ac2c6c5294e855398c7c8414..0000000000000000000000000000000000000000
--- a/media/gpu/media_foundation_video_encode_accelerator_win.cc
+++ /dev/null
@@ -1,562 +0,0 @@
-// Copyright 2016 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.
-
-#include "media/gpu/media_foundation_video_encode_accelerator_win.h"
-
-#pragma warning(push)
-#pragma warning(disable : 4800) // Disable warning for added padding.
-
-#include <codecapi.h>
-#include <mferror.h>
-#include <mftransform.h>
-
-#include <utility>
-#include <vector>
-
-#include "base/threading/sequenced_task_runner_handle.h"
-#include "base/win/scoped_co_mem.h"
-#include "base/win/scoped_variant.h"
-#include "base/win/windows_version.h"
-#include "media/base/win/mf_helpers.h"
-#include "media/base/win/mf_initializer.h"
-#include "third_party/libyuv/include/libyuv.h"
-
-using base::win::ScopedComPtr;
-using media::mf::MediaBufferScopedPointer;
-
-namespace media {
-
-namespace {
-
-const size_t kMaxFrameRateNumerator = 30;
-const size_t kMaxFrameRateDenominator = 1;
-const size_t kMaxResolutionWidth = 4096;
-const size_t kMaxResolutionHeight = 2160;
-const size_t kNumInputBuffers = 3;
-const size_t kOneSecondInMicroseconds = 1000000;
-const size_t kOutputSampleBufferSizeRatio = 4;
-
-constexpr const wchar_t* const kMediaFoundationVideoEncoderDLLs[] = {
- L"mf.dll", L"mfplat.dll",
-};
-
-} // namespace
-
-class MediaFoundationVideoEncodeAccelerator::EncodeOutput {
- public:
- EncodeOutput(uint32_t size, bool key_frame, base::TimeDelta timestamp)
- : keyframe(key_frame), capture_timestamp(timestamp), data_(size) {}
-
- uint8_t* memory() { return data_.data(); }
-
- int size() const { return static_cast<int>(data_.size()); }
-
- const bool keyframe;
- const base::TimeDelta capture_timestamp;
-
- private:
- std::vector<uint8_t> data_;
-
- DISALLOW_COPY_AND_ASSIGN(EncodeOutput);
-};
-
-struct MediaFoundationVideoEncodeAccelerator::BitstreamBufferRef {
- BitstreamBufferRef(int32_t id,
- std::unique_ptr<base::SharedMemory> shm,
- size_t size)
- : id(id), shm(std::move(shm)), size(size) {}
- const int32_t id;
- const std::unique_ptr<base::SharedMemory> shm;
- const size_t size;
-
- private:
- DISALLOW_IMPLICIT_CONSTRUCTORS(BitstreamBufferRef);
-};
-
-MediaFoundationVideoEncodeAccelerator::MediaFoundationVideoEncodeAccelerator()
- : client_task_runner_(base::SequencedTaskRunnerHandle::Get()),
- encoder_thread_("MFEncoderThread"),
- encoder_task_weak_factory_(this) {}
-
-MediaFoundationVideoEncodeAccelerator::
- ~MediaFoundationVideoEncodeAccelerator() {
- DVLOG(3) << __FUNCTION__;
- DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-
- DCHECK(!encoder_thread_.IsRunning());
- DCHECK(!encoder_task_weak_factory_.HasWeakPtrs());
-}
-
-VideoEncodeAccelerator::SupportedProfiles
-MediaFoundationVideoEncodeAccelerator::GetSupportedProfiles() {
- DVLOG(3) << __FUNCTION__;
- DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-
- SupportedProfiles profiles;
- if (base::win::GetVersion() < base::win::VERSION_WIN8) {
- DLOG(ERROR) << "Windows versions earlier than 8 are not supported.";
- return profiles;
- }
-
- SupportedProfile profile;
- // More profiles can be supported here, but they should be available in SW
- // fallback as well.
- profile.profile = H264PROFILE_BASELINE;
- profile.max_framerate_numerator = kMaxFrameRateNumerator;
- profile.max_framerate_denominator = kMaxFrameRateDenominator;
- profile.max_resolution = gfx::Size(kMaxResolutionWidth, kMaxResolutionHeight);
- profiles.push_back(profile);
- return profiles;
-}
-
-bool MediaFoundationVideoEncodeAccelerator::Initialize(
- VideoPixelFormat format,
- const gfx::Size& input_visible_size,
- VideoCodecProfile output_profile,
- uint32_t initial_bitrate,
- Client* client) {
- DVLOG(3) << __FUNCTION__
- << ": input_format=" << VideoPixelFormatToString(format)
- << ", input_visible_size=" << input_visible_size.ToString()
- << ", output_profile=" << output_profile
- << ", initial_bitrate=" << initial_bitrate;
- DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-
- if (PIXEL_FORMAT_I420 != format) {
- DLOG(ERROR) << "Input format not supported= "
- << VideoPixelFormatToString(format);
- return false;
- }
-
- if (H264PROFILE_BASELINE != output_profile) {
- DLOG(ERROR) << "Output profile not supported= " << output_profile;
- return false;
- }
-
- for (const wchar_t* mfdll : kMediaFoundationVideoEncoderDLLs) {
- if (!::GetModuleHandle(mfdll)) {
- DLOG(ERROR) << mfdll << " is required for encoding";
- return false;
- }
- }
-
- encoder_thread_.init_com_with_mta(false);
- if (!encoder_thread_.Start()) {
- DLOG(ERROR) << "Failed spawning encoder thread.";
- return false;
- }
- encoder_thread_task_runner_ = encoder_thread_.task_runner();
-
- InitializeMediaFoundation();
-
- uint32_t flags = MFT_ENUM_FLAG_HARDWARE | MFT_ENUM_FLAG_SORTANDFILTER;
- MFT_REGISTER_TYPE_INFO input_info;
- input_info.guidMajorType = MFMediaType_Video;
- input_info.guidSubtype = MFVideoFormat_NV12;
- MFT_REGISTER_TYPE_INFO output_info;
- output_info.guidMajorType = MFMediaType_Video;
- output_info.guidSubtype = MFVideoFormat_H264;
-
- base::win::ScopedCoMem<CLSID> CLSIDs;
- uint32_t count = 0;
- HRESULT hr = MFTEnum(MFT_CATEGORY_VIDEO_ENCODER, flags, NULL, &output_info,
- NULL, &CLSIDs, &count);
- RETURN_ON_HR_FAILURE(hr, "Couldn't enumerate hardware encoder", false);
- RETURN_ON_FAILURE((count > 0), "No HW encoder found", false);
- DVLOG(3) << "HW encoder(s) found: " << count;
- hr = encoder_.CreateInstance(CLSIDs[0]);
- RETURN_ON_HR_FAILURE(hr, "Couldn't activate hardware encoder", false);
-
- client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
- client_ = client_ptr_factory_->GetWeakPtr();
- input_visible_size_ = input_visible_size;
- frame_rate_ = kMaxFrameRateNumerator / kMaxFrameRateDenominator;
- target_bitrate_ = initial_bitrate;
- bitstream_buffer_size_ = input_visible_size.GetArea();
-
- u_plane_offset_ =
- VideoFrame::PlaneSize(PIXEL_FORMAT_I420, VideoFrame::kYPlane,
- input_visible_size_)
- .GetArea();
- v_plane_offset_ =
- u_plane_offset_ +
- VideoFrame::PlaneSize(PIXEL_FORMAT_I420, VideoFrame::kUPlane,
- input_visible_size_)
- .GetArea();
-
- if (!InitializeInputOutputSamples()) {
- DLOG(ERROR) << "Failed initializing input-output samples.";
- return false;
- }
-
- if (!SetEncoderModes()) {
- DLOG(ERROR) << "Failed setting encoder parameters.";
- return false;
- }
-
- hr = encoder_->ProcessMessage(MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, NULL);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set ProcessMessage", false);
-
- client_task_runner_->PostTask(
- FROM_HERE,
- base::Bind(&Client::RequireBitstreamBuffers, client_, kNumInputBuffers,
- input_visible_size_, bitstream_buffer_size_));
- return SUCCEEDED(hr);
-}
-
-void MediaFoundationVideoEncodeAccelerator::Encode(
- const scoped_refptr<VideoFrame>& frame,
- bool force_keyframe) {
- DVLOG(3) << __FUNCTION__;
- DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-
- encoder_thread_task_runner_->PostTask(
- FROM_HERE, base::Bind(&MediaFoundationVideoEncodeAccelerator::EncodeTask,
- encoder_task_weak_factory_.GetWeakPtr(), frame,
- force_keyframe));
-}
-
-void MediaFoundationVideoEncodeAccelerator::UseOutputBitstreamBuffer(
- const BitstreamBuffer& buffer) {
- DVLOG(3) << __FUNCTION__ << ": buffer size=" << buffer.size();
- DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-
- if (buffer.size() < bitstream_buffer_size_) {
- DLOG(ERROR) << "Output BitstreamBuffer isn't big enough: " << buffer.size()
- << " vs. " << bitstream_buffer_size_;
- client_->NotifyError(kInvalidArgumentError);
- return;
- }
-
- std::unique_ptr<base::SharedMemory> shm(
- new base::SharedMemory(buffer.handle(), false));
- if (!shm->Map(buffer.size())) {
- DLOG(ERROR) << "Failed mapping shared memory.";
- client_->NotifyError(kPlatformFailureError);
- return;
- }
-
- std::unique_ptr<BitstreamBufferRef> buffer_ref(
- new BitstreamBufferRef(buffer.id(), std::move(shm), buffer.size()));
- encoder_thread_task_runner_->PostTask(
- FROM_HERE,
- base::Bind(
- &MediaFoundationVideoEncodeAccelerator::UseOutputBitstreamBufferTask,
- encoder_task_weak_factory_.GetWeakPtr(), base::Passed(&buffer_ref)));
-}
-
-void MediaFoundationVideoEncodeAccelerator::RequestEncodingParametersChange(
- uint32_t bitrate,
- uint32_t framerate) {
- DVLOG(3) << __FUNCTION__ << ": bitrate=" << bitrate
- << ": framerate=" << framerate;
- DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-
- encoder_thread_task_runner_->PostTask(
- FROM_HERE,
- base::Bind(&MediaFoundationVideoEncodeAccelerator::
- RequestEncodingParametersChangeTask,
- encoder_task_weak_factory_.GetWeakPtr(), bitrate, framerate));
-}
-
-void MediaFoundationVideoEncodeAccelerator::Destroy() {
- DVLOG(3) << __FUNCTION__;
- DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-
- // Cancel all callbacks.
- client_ptr_factory_.reset();
-
- if (encoder_thread_.IsRunning()) {
- encoder_thread_task_runner_->PostTask(
- FROM_HERE,
- base::Bind(&MediaFoundationVideoEncodeAccelerator::DestroyTask,
- encoder_task_weak_factory_.GetWeakPtr()));
- encoder_thread_.Stop();
- }
-
- delete this;
-}
-
-// static
-void MediaFoundationVideoEncodeAccelerator::PreSandboxInitialization() {
- for (const wchar_t* mfdll : kMediaFoundationVideoEncoderDLLs)
- ::LoadLibrary(mfdll);
-}
-
-bool MediaFoundationVideoEncodeAccelerator::InitializeInputOutputSamples() {
- DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-
- HRESULT hr = encoder_->GetStreamLimits(
- &input_stream_count_min_, &input_stream_count_max_,
- &output_stream_count_min_, &output_stream_count_max_);
- RETURN_ON_HR_FAILURE(hr, "Couldn't query stream limits", false);
- DVLOG(3) << "Stream limits: " << input_stream_count_min_ << ","
- << input_stream_count_max_ << "," << output_stream_count_min_ << ","
- << output_stream_count_max_;
-
- // Initialize output parameters.
- base::win::ScopedComPtr<IMFMediaType> imf_output_media_type;
- hr = MFCreateMediaType(imf_output_media_type.Receive());
- RETURN_ON_HR_FAILURE(hr, "Couldn't create media type", false);
- hr = imf_output_media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set media type", false);
- hr = imf_output_media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set video format", false);
- hr = imf_output_media_type->SetUINT32(MF_MT_AVG_BITRATE, target_bitrate_);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set bitrate", false);
- hr = MFSetAttributeRatio(imf_output_media_type.get(), MF_MT_FRAME_RATE,
- frame_rate_, kMaxFrameRateDenominator);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set frame rate", false);
- hr = MFSetAttributeSize(imf_output_media_type.get(), MF_MT_FRAME_SIZE,
- input_visible_size_.width(),
- input_visible_size_.height());
- RETURN_ON_HR_FAILURE(hr, "Couldn't set frame size", false);
- hr = imf_output_media_type->SetUINT32(MF_MT_INTERLACE_MODE,
- MFVideoInterlace_Progressive);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set interlace mode", false);
- hr = imf_output_media_type->SetUINT32(MF_MT_MPEG2_PROFILE,
- eAVEncH264VProfile_Base);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set codec profile", false);
- hr = encoder_->SetOutputType(0, imf_output_media_type.get(), 0);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set output media type", false);
-
- // Initialize input parameters.
- base::win::ScopedComPtr<IMFMediaType> imf_input_media_type;
- hr = MFCreateMediaType(imf_input_media_type.Receive());
- RETURN_ON_HR_FAILURE(hr, "Couldn't create media type", false);
- hr = imf_input_media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set media type", false);
- hr = imf_input_media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_YV12);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set video format", false);
- hr = MFSetAttributeRatio(imf_input_media_type.get(), MF_MT_FRAME_RATE,
- frame_rate_, kMaxFrameRateDenominator);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set frame rate", false);
- hr = MFSetAttributeSize(imf_input_media_type.get(), MF_MT_FRAME_SIZE,
- input_visible_size_.width(),
- input_visible_size_.height());
- RETURN_ON_HR_FAILURE(hr, "Couldn't set frame size", false);
- hr = imf_input_media_type->SetUINT32(MF_MT_INTERLACE_MODE,
- MFVideoInterlace_Progressive);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set interlace mode", false);
- hr = encoder_->SetInputType(0, imf_input_media_type.get(), 0);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set input media type", false);
-
- input_sample_.Attach(mf::CreateEmptySampleWithBuffer(
- VideoFrame::AllocationSize(PIXEL_FORMAT_I420, input_visible_size_), 2));
- output_sample_.Attach(mf::CreateEmptySampleWithBuffer(
- bitstream_buffer_size_ * kOutputSampleBufferSizeRatio, 2));
-
- return SUCCEEDED(hr);
-}
-
-bool MediaFoundationVideoEncodeAccelerator::SetEncoderModes() {
- DCHECK(sequence_checker_.CalledOnValidSequencedThread());
-
- HRESULT hr = encoder_.QueryInterface(IID_ICodecAPI, codec_api_.ReceiveVoid());
- RETURN_ON_HR_FAILURE(hr, "Couldn't get ICodecAPI", false);
- VARIANT var;
- var.vt = VT_UI4;
- var.ulVal = eAVEncCommonRateControlMode_CBR;
- hr = codec_api_->SetValue(&CODECAPI_AVEncCommonRateControlMode, &var);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set CommonRateControlMode", false);
- var.ulVal = target_bitrate_;
- hr = codec_api_->SetValue(&CODECAPI_AVEncCommonMeanBitRate, &var);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set bitrate", false);
- var.ulVal = eAVEncAdaptiveMode_FrameRate;
- hr = codec_api_->SetValue(&CODECAPI_AVEncAdaptiveMode, &var);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set FrameRate", false);
- var.vt = VT_BOOL;
- var.boolVal = VARIANT_TRUE;
- hr = codec_api_->SetValue(&CODECAPI_AVLowLatencyMode, &var);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set LowLatencyMode", false);
- return SUCCEEDED(hr);
-}
-
-void MediaFoundationVideoEncodeAccelerator::NotifyError(
- VideoEncodeAccelerator::Error error) {
- DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
- client_task_runner_->PostTask(
- FROM_HERE, base::Bind(&Client::NotifyError, client_, error));
-}
-
-void MediaFoundationVideoEncodeAccelerator::EncodeTask(
- const scoped_refptr<VideoFrame>& frame,
- bool force_keyframe) {
- DVLOG(3) << __FUNCTION__;
- DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
-
- base::win::ScopedComPtr<IMFMediaBuffer> input_buffer;
- input_sample_->GetBufferByIndex(0, input_buffer.Receive());
-
- {
- MediaBufferScopedPointer scoped_buffer(input_buffer.get());
- DCHECK(scoped_buffer.get());
- libyuv::I420Copy(frame->visible_data(VideoFrame::kYPlane),
- frame->stride(VideoFrame::kYPlane),
- frame->visible_data(VideoFrame::kVPlane),
- frame->stride(VideoFrame::kVPlane),
- frame->visible_data(VideoFrame::kUPlane),
- frame->stride(VideoFrame::kUPlane), scoped_buffer.get(),
- frame->stride(VideoFrame::kYPlane),
- scoped_buffer.get() + u_plane_offset_,
- frame->stride(VideoFrame::kUPlane),
- scoped_buffer.get() + v_plane_offset_,
- frame->stride(VideoFrame::kVPlane),
- input_visible_size_.width(), input_visible_size_.height());
- }
-
- input_sample_->SetSampleTime(frame->timestamp().InMicroseconds() * 10);
- input_sample_->SetSampleDuration(kOneSecondInMicroseconds / frame_rate_);
- HRESULT hr = encoder_->ProcessInput(0, input_sample_.get(), 0);
- // According to MSDN, if encoder returns MF_E_NOTACCEPTING, we need to try
- // processing the output. This error indicates that encoder does not accept
- // any more input data.
- if (hr == MF_E_NOTACCEPTING) {
- DVLOG(3) << "MF_E_NOTACCEPTING";
- ProcessOutput();
- hr = encoder_->ProcessInput(0, input_sample_.get(), 0);
- if (!SUCCEEDED(hr)) {
- NotifyError(kPlatformFailureError);
- RETURN_ON_HR_FAILURE(hr, "Couldn't encode", );
- }
- } else if (!SUCCEEDED(hr)) {
- NotifyError(kPlatformFailureError);
- RETURN_ON_HR_FAILURE(hr, "Couldn't encode", );
- }
- DVLOG(3) << "Sent for encode " << hr;
-
- ProcessOutput();
-}
-
-void MediaFoundationVideoEncodeAccelerator::ProcessOutput() {
- DVLOG(3) << __FUNCTION__;
- DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
-
- MFT_OUTPUT_DATA_BUFFER output_data_buffer = {0};
- output_data_buffer.dwStreamID = 0;
- output_data_buffer.dwStatus = 0;
- output_data_buffer.pEvents = NULL;
- output_data_buffer.pSample = output_sample_.get();
- DWORD status = 0;
- HRESULT hr = encoder_->ProcessOutput(0, 1, &output_data_buffer, &status);
- if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
- DVLOG(3) << "MF_E_TRANSFORM_NEED_MORE_INPUT";
- return;
- }
- RETURN_ON_HR_FAILURE(hr, "Couldn't get encoded data", );
- DVLOG(3) << "Got encoded data " << hr;
-
- base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
- hr = output_sample_->GetBufferByIndex(0, output_buffer.Receive());
- RETURN_ON_HR_FAILURE(hr, "Couldn't get buffer by index", );
- DWORD size = 0;
- hr = output_buffer->GetCurrentLength(&size);
- RETURN_ON_HR_FAILURE(hr, "Couldn't get buffer length", );
-
- const bool keyframe = MFGetAttributeUINT32(
- output_sample_.get(), MFSampleExtension_CleanPoint, false);
- DVLOG(3) << "We HAVE encoded data with size:" << size << " keyframe "
- << keyframe;
-
- if (bitstream_buffer_queue_.empty()) {
- DVLOG(3) << "No bitstream buffers.";
- // We need to copy the output so that encoding can continue.
- std::unique_ptr<EncodeOutput> encode_output(
- new EncodeOutput(size, keyframe, base::Time::Now() - base::Time()));
- {
- MediaBufferScopedPointer scoped_buffer(output_buffer.get());
- memcpy(encode_output->memory(), scoped_buffer.get(), size);
- }
- encoder_output_queue_.push_back(std::move(encode_output));
- return;
- }
-
- std::unique_ptr<MediaFoundationVideoEncodeAccelerator::BitstreamBufferRef>
- buffer_ref = std::move(bitstream_buffer_queue_.front());
- bitstream_buffer_queue_.pop_front();
-
- {
- MediaBufferScopedPointer scoped_buffer(output_buffer.get());
- memcpy(buffer_ref->shm->memory(), scoped_buffer.get(), size);
- }
-
- client_task_runner_->PostTask(
- FROM_HERE,
- base::Bind(&Client::BitstreamBufferReady, client_, buffer_ref->id, size,
- keyframe, base::Time::Now() - base::Time()));
-
- // Keep calling ProcessOutput recursively until MF_E_TRANSFORM_NEED_MORE_INPUT
- // is returned to flush out all the output.
- ProcessOutput();
-}
-
-void MediaFoundationVideoEncodeAccelerator::UseOutputBitstreamBufferTask(
- std::unique_ptr<BitstreamBufferRef> buffer_ref) {
- DVLOG(3) << __FUNCTION__;
- DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
-
- // If there is already EncodeOutput waiting, copy its output first.
- if (!encoder_output_queue_.empty()) {
- std::unique_ptr<MediaFoundationVideoEncodeAccelerator::EncodeOutput>
- encode_output = std::move(encoder_output_queue_.front());
- encoder_output_queue_.pop_front();
- ReturnBitstreamBuffer(std::move(encode_output), std::move(buffer_ref));
- return;
- }
-
- bitstream_buffer_queue_.push_back(std::move(buffer_ref));
-}
-
-void MediaFoundationVideoEncodeAccelerator::ReturnBitstreamBuffer(
- std::unique_ptr<EncodeOutput> encode_output,
- std::unique_ptr<MediaFoundationVideoEncodeAccelerator::BitstreamBufferRef>
- buffer_ref) {
- DVLOG(3) << __FUNCTION__;
- DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
-
- memcpy(buffer_ref->shm->memory(), encode_output->memory(),
- encode_output->size());
- client_task_runner_->PostTask(
- FROM_HERE,
- base::Bind(&Client::BitstreamBufferReady, client_, buffer_ref->id,
- encode_output->size(), encode_output->keyframe,
- encode_output->capture_timestamp));
-}
-
-void MediaFoundationVideoEncodeAccelerator::RequestEncodingParametersChangeTask(
- uint32_t bitrate,
- uint32_t framerate) {
- DVLOG(3) << __FUNCTION__;
- DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
-
- frame_rate_ = framerate ? framerate : 1;
- target_bitrate_ = bitrate ? bitrate : 1;
-
- VARIANT var;
- var.vt = VT_UI4;
- var.ulVal = target_bitrate_;
- HRESULT hr = codec_api_->SetValue(&CODECAPI_AVEncCommonMeanBitRate, &var);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set bitrate", );
-
- base::win::ScopedComPtr<IMFMediaType> imf_output_media_type;
- hr = MFCreateMediaType(imf_output_media_type.Receive());
- RETURN_ON_HR_FAILURE(hr, "Couldn't create output media type", );
- hr = imf_output_media_type->SetUINT32(MF_MT_AVG_BITRATE, target_bitrate_);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set bitrate", );
- hr = MFSetAttributeRatio(imf_output_media_type.get(), MF_MT_FRAME_RATE,
- frame_rate_, kMaxFrameRateDenominator);
- RETURN_ON_HR_FAILURE(hr, "Couldn't set output type params", );
-}
-
-void MediaFoundationVideoEncodeAccelerator::DestroyTask() {
- DVLOG(3) << __FUNCTION__;
- DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
-
- // Cancel all encoder thread callbacks.
- encoder_task_weak_factory_.InvalidateWeakPtrs();
-
- encoder_.Release();
-}
-
-} // namespace content
« no previous file with comments | « media/gpu/media_foundation_video_encode_accelerator_win.h ('k') | media/gpu/video_encode_accelerator_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698