Skip to content

GitLab

T
tangled
Commit 20b35ac0 authored by liberato@chromium.org's avatar liberato@chromium.org Committed by Commit Bot
Browse files
Options

Remove D3D11 VDA. 

This CL removes the WIP D3D11 VDA in favor of the D3D11 Mojo Video
Decoder WIP.

Bug: 775577
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: Ie84276b35e274dff5e271be7ecad25e59ea4e7c3
Reviewed-on: https://chromium-review.googlesource.com/806237
Commit-Queue: Frank Liberato <liberato@chromium.org>
Reviewed-by: default avatarDan Sanders <sandersd@chromium.org>
Cr-Commit-Position: refs/heads/master@{#522092}
parent a30846fd
Hide whitespace changes
Inline Side-by-side
Showing with 4 additions and 356 deletions
media/gpu/BUILD.gn
View file @ 20b35ac0
...@@ -360,18 +360,12 @@ component("gpu") { ...@@ -360,18 +360,12 @@ component("gpu") {
if (is_win) { if (is_win) {
sources += [ sources += [
"d3d11_video_decode_accelerator_win.cc",
"d3d11_video_decode_accelerator_win.h",
"dxva_picture_buffer_win.cc", "dxva_picture_buffer_win.cc",
"dxva_picture_buffer_win.h", "dxva_picture_buffer_win.h",
"dxva_video_decode_accelerator_win.cc", "dxva_video_decode_accelerator_win.cc",
"dxva_video_decode_accelerator_win.h", "dxva_video_decode_accelerator_win.h",
"media_foundation_video_encode_accelerator_win.cc", "media_foundation_video_encode_accelerator_win.cc",
"media_foundation_video_encode_accelerator_win.h", "media_foundation_video_encode_accelerator_win.h",
"windows/d3d11_h264_accelerator.cc",
"windows/d3d11_h264_accelerator.h",
"windows/d3d11_picture_buffer.cc",
"windows/d3d11_picture_buffer.h",
"windows/init_guid.cc", "windows/init_guid.cc",
] ]
configs += [ configs += [
...@@ -403,6 +397,10 @@ component("gpu") { ...@@ -403,6 +397,10 @@ component("gpu") {
] ]
if (enable_d3d11_video_decoder) { if (enable_d3d11_video_decoder) {
sources += [ sources += [
"windows/d3d11_h264_accelerator.cc",
"windows/d3d11_h264_accelerator.h",
"windows/d3d11_picture_buffer.cc",
"windows/d3d11_picture_buffer.h",
"windows/d3d11_video_decoder.cc", "windows/d3d11_video_decoder.cc",
"windows/d3d11_video_decoder.h", "windows/d3d11_video_decoder.h",
"windows/d3d11_video_decoder_impl.cc", "windows/d3d11_video_decoder_impl.cc",
......
media/gpu/d3d11_video_decode_accelerator_win.cc deleted 100644 → 0
View file @ a30846fd
// 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/d3d11_video_decode_accelerator_win.h"
#include "base/bits.h"
#include "base/memory/ptr_util.h"
#include "base/memory/shared_memory.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/trace_event/trace_event.h"
#include "media/gpu/h264_decoder.h"
#include "media/gpu/h264_dpb.h"
#include "media/gpu/windows/d3d11_h264_accelerator.h"
#include "media/gpu/windows/d3d11_picture_buffer.h"
#include "ui/gfx/color_space.h"
#include "ui/gl/gl_angle_util_win.h"
#include "ui/gl/gl_bindings.h"
namespace media {
#define RETURN_ON_FAILURE(result, log, ret) \
do { \
if (!(result)) { \
DLOG(ERROR) << log; \
return ret; \
} \
} while (0)
D3D11VideoDecodeAccelerator::D3D11VideoDecodeAccelerator(
const GetGLContextCallback& get_gl_context_cb,
const MakeGLContextCurrentCallback& make_context_current_cb,
const BindGLImageCallback& bind_image_cb)
: get_gl_context_cb_(get_gl_context_cb),
make_context_current_cb_(make_context_current_cb),
bind_image_cb_(bind_image_cb) {}
D3D11VideoDecodeAccelerator::~D3D11VideoDecodeAccelerator() {}
bool D3D11VideoDecodeAccelerator::Initialize(const Config& config,
Client* client) {
client_ = client;
make_context_current_cb_.Run();
device_ = gl::QueryD3D11DeviceObjectFromANGLE();
device_->GetImmediateContext(device_context_.GetAddressOf());
HRESULT hr = device_context_.CopyTo(video_context_.GetAddressOf());
CHECK(SUCCEEDED(hr));
hr = device_.CopyTo(video_device_.GetAddressOf());
CHECK(SUCCEEDED(hr));
bool is_h264 =
config.profile >= H264PROFILE_MIN && config.profile <= H264PROFILE_MAX;
if (!is_h264)
return false;
GUID needed_guid;
memcpy(&needed_guid, &D3D11_DECODER_PROFILE_H264_VLD_NOFGT,
sizeof(needed_guid));
GUID decoder_guid = {};
{
// Enumerate supported video profiles and look for the H264 profile.
bool found = false;
UINT profile_count = video_device_->GetVideoDecoderProfileCount();
for (UINT profile_idx = 0; profile_idx < profile_count; profile_idx++) {
GUID profile_id = {};
hr = video_device_->GetVideoDecoderProfile(profile_idx, &profile_id);
if (SUCCEEDED(hr) && (profile_id == needed_guid)) {
decoder_guid = profile_id;
found = true;
break;
}
}
CHECK(found);
}
D3D11_VIDEO_DECODER_DESC desc = {};
desc.Guid = decoder_guid;
desc.SampleWidth = 1920;
desc.SampleHeight = 1088;
desc.OutputFormat = DXGI_FORMAT_NV12;
UINT config_count = 0;
hr = video_device_->GetVideoDecoderConfigCount(&desc, &config_count);
if (FAILED(hr) || config_count == 0)
CHECK(false);
D3D11_VIDEO_DECODER_CONFIG dec_config = {};
for (UINT i = 0; i < config_count; i++) {
hr = video_device_->GetVideoDecoderConfig(&desc, i, &dec_config);
if (FAILED(hr))
CHECK(false);
if (dec_config.ConfigBitstreamRaw == 2)
break;
}
memcpy(&decoder_guid_, &decoder_guid, sizeof decoder_guid_);
Microsoft::WRL::ComPtr<ID3D11VideoDecoder> video_decoder;
hr = video_device_->CreateVideoDecoder(&desc, &dec_config,
video_decoder.GetAddressOf());
CHECK(video_decoder.Get());
h264_accelerator_.reset(new D3D11H264Accelerator(
this, video_decoder, video_device_, video_context_));
decoder_.reset(new media::H264Decoder(h264_accelerator_.get()));
return true;
}
void D3D11VideoDecodeAccelerator::Decode(
const BitstreamBuffer& bitstream_buffer) {
input_buffer_queue_.push_back(bitstream_buffer);
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&D3D11VideoDecodeAccelerator::DoDecode,
base::Unretained(this)));
}
void D3D11VideoDecodeAccelerator::DoDecode() {
if (!bitstream_buffer_) {
if (input_buffer_queue_.empty())
return;
BitstreamBuffer buffer = input_buffer_queue_.front();
bitstream_buffer_ =
base::MakeUnique<base::SharedMemory>(buffer.handle(), true);
bitstream_buffer_->Map(buffer.size());
bitstream_buffer_size_ = buffer.size();
input_buffer_id_ = buffer.id();
input_buffer_queue_.pop_front();
decoder_->SetStream((const uint8_t*)bitstream_buffer_->memory(),
bitstream_buffer_size_);
}
while (true) {
media::AcceleratedVideoDecoder::DecodeResult result = decoder_->Decode();
if (result == media::AcceleratedVideoDecoder::kRanOutOfStreamData) {
client_->NotifyEndOfBitstreamBuffer(input_buffer_id_);
bitstream_buffer_.reset();
break;
}
if (result == media::AcceleratedVideoDecoder::kRanOutOfSurfaces) {
return;
}
if (result == media::AcceleratedVideoDecoder::kAllocateNewSurfaces) {
client_->ProvidePictureBuffers(20, PIXEL_FORMAT_NV12, 2,
decoder_->GetPicSize(),
GL_TEXTURE_EXTERNAL_OES);
return;
} else {
LOG(ERROR) << "VDA Error " << result;
CHECK(false);
}
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&D3D11VideoDecodeAccelerator::DoDecode,
base::Unretained(this)));
}
void D3D11VideoDecodeAccelerator::AssignPictureBuffers(
const std::vector<PictureBuffer>& buffers) {
D3D11_TEXTURE2D_DESC texture_desc = {};
texture_desc.Width = decoder_->GetPicSize().width();
texture_desc.Height = decoder_->GetPicSize().height();
texture_desc.MipLevels = 1;
texture_desc.ArraySize = buffers.size();
texture_desc.Format = DXGI_FORMAT_NV12;
texture_desc.SampleDesc.Count = 1;
texture_desc.Usage = D3D11_USAGE_DEFAULT;
texture_desc.BindFlags = D3D11_BIND_DECODER | D3D11_BIND_SHADER_RESOURCE;
texture_desc.MiscFlags = D3D11_RESOURCE_MISC_SHARED;
Microsoft::WRL::ComPtr<ID3D11Texture2D> out_texture;
HRESULT hr = device_->CreateTexture2D(&texture_desc, nullptr,
out_texture.GetAddressOf());
CHECK(SUCCEEDED(hr));
make_context_current_cb_.Run();
picture_buffers_.clear();
for (size_t i = 0; i < buffers.size(); i++) {
picture_buffers_.push_back(
base::MakeUnique<D3D11PictureBuffer>(buffers[i], i));
picture_buffers_[i]->Init(video_device_, out_texture, decoder_guid_);
for (uint32_t client_id : buffers[i].client_texture_ids()) {
// The picture buffer handles the actual binding of its contents to
// texture ids. This call just causes the texture manager to hold a
// reference to the GLImage as long as either texture exists.
bind_image_cb_.Run(client_id, GL_TEXTURE_EXTERNAL_OES,
picture_buffers_[i]->gl_image(), true);
}
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&D3D11VideoDecodeAccelerator::DoDecode,
base::Unretained(this)));
}
void D3D11VideoDecodeAccelerator::ReusePictureBuffer(
int32_t picture_buffer_id) {
make_context_current_cb_.Run();
for (auto& buffer : picture_buffers_) {
if (buffer->picture_buffer().id() == picture_buffer_id) {
buffer->set_in_client_use(false);
break;
}
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&D3D11VideoDecodeAccelerator::DoDecode,
base::Unretained(this)));
}
D3D11PictureBuffer* D3D11VideoDecodeAccelerator::GetPicture() {
for (auto& buffer : picture_buffers_)
if (!buffer->in_client_use() && !buffer->in_picture_use()) {
return buffer.get();
}
return nullptr;
}
void D3D11VideoDecodeAccelerator::Flush() {
client_->NotifyFlushDone();
}
void D3D11VideoDecodeAccelerator::Reset() {
client_->NotifyResetDone();
}
void D3D11VideoDecodeAccelerator::Destroy() {}
bool D3D11VideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
const base::WeakPtr<Client>& decode_client,
const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
return false;
}
GLenum D3D11VideoDecodeAccelerator::GetSurfaceInternalFormat() const {
return GL_BGRA_EXT;
}
size_t D3D11VideoDecodeAccelerator::input_buffer_id() const {
return input_buffer_id_;
}
void D3D11VideoDecodeAccelerator::OutputResult(D3D11PictureBuffer* buffer,
size_t input_buffer_id) {
buffer->set_in_client_use(true);
Picture picture(buffer->picture_buffer().id(), input_buffer_id,
gfx::Rect(0, 0), gfx::ColorSpace(), true);
client_->PictureReady(picture);
}
} // namespace media
media/gpu/d3d11_video_decode_accelerator_win.h deleted 100644 → 0
View file @ a30846fd
// 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.
#ifndef MEDIA_GPU_D3D11_VIDEO_DECODE_ACCELERATOR_WIN_H_
#define MEDIA_GPU_D3D11_VIDEO_DECODE_ACCELERATOR_WIN_H_
#include <d3d11.h>
#include <wrl/client.h>
#include <list>
#include <memory>
#include "media/gpu/accelerated_video_decoder.h"
#include "media/gpu/gpu_video_decode_accelerator_helpers.h"
#include "media/gpu/media_gpu_export.h"
#include "media/gpu/windows/d3d11_h264_accelerator.h"
#include "media/video/video_decode_accelerator.h"
namespace media {
class MEDIA_GPU_EXPORT D3D11VideoDecodeAccelerator
: public VideoDecodeAccelerator,
public D3D11VideoDecoderClient {
public:
D3D11VideoDecodeAccelerator(
const GetGLContextCallback& get_gl_context_cb,
const MakeGLContextCurrentCallback& make_context_current_cb,
const BindGLImageCallback& bind_image_cb);
~D3D11VideoDecodeAccelerator() override;
// VideoDecodeAccelerator implementation.
bool Initialize(const Config& config, Client* client) override;
void Decode(const BitstreamBuffer& bitstream_buffer) override;
void DoDecode();
void AssignPictureBuffers(const std::vector<PictureBuffer>& buffers) override;
void ReusePictureBuffer(int32_t picture_buffer_id) override;
void Flush() override;
void Reset() override;
void Destroy() override;
bool TryToSetupDecodeOnSeparateThread(
const base::WeakPtr<Client>& decode_client,
const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner)
override;
GLenum GetSurfaceInternalFormat() const override;
// D3D11VideoDecoderClient implementation.
D3D11PictureBuffer* GetPicture() override;
void OutputResult(D3D11PictureBuffer* buffer,
size_t input_buffer_id) override;
size_t input_buffer_id() const override;
private:
Client* client_;
GetGLContextCallback get_gl_context_cb_;
MakeGLContextCurrentCallback make_context_current_cb_;
BindGLImageCallback bind_image_cb_;
Microsoft::WRL::ComPtr<ID3D11Device> device_;
Microsoft::WRL::ComPtr<ID3D11DeviceContext> device_context_;
Microsoft::WRL::ComPtr<ID3D11VideoDevice> video_device_;
Microsoft::WRL::ComPtr<ID3D11VideoContext> video_context_;
std::unique_ptr<AcceleratedVideoDecoder> decoder_;
std::unique_ptr<D3D11H264Accelerator> h264_accelerator_;
GUID decoder_guid_;
std::list<BitstreamBuffer> input_buffer_queue_;
uint32_t input_buffer_id_;
std::unique_ptr<base::SharedMemory> bitstream_buffer_;
size_t bitstream_buffer_size_;
std::vector<std::unique_ptr<D3D11PictureBuffer>> picture_buffers_;
DISALLOW_COPY_AND_ASSIGN(D3D11VideoDecodeAccelerator);
};
} // namespace media
#endif // MEDIA_GPU_D3D11_VIDEO_DECODE_ACCELERATOR_WIN_H_
media/gpu/gpu_video_decode_accelerator_factory.cc
View file @ 20b35ac0
...@@ -15,7 +15,6 @@ ...@@ -15,7 +15,6 @@
#if defined(OS_WIN) #if defined(OS_WIN)
#include "base/win/windows_version.h" #include "base/win/windows_version.h"
#include "media/gpu/d3d11_video_decode_accelerator_win.h"
#include "media/gpu/dxva_video_decode_accelerator_win.h" #include "media/gpu/dxva_video_decode_accelerator_win.h"
#endif #endif
#if defined(OS_MACOSX) #if defined(OS_MACOSX)
...@@ -137,7 +136,6 @@ GpuVideoDecodeAcceleratorFactory::CreateVDA( ...@@ -137,7 +136,6 @@ GpuVideoDecodeAcceleratorFactory::CreateVDA(
const gpu::GpuPreferences&) const; const gpu::GpuPreferences&) const;
const CreateVDAFp create_vda_fps[] = { const CreateVDAFp create_vda_fps[] = {
#if defined(OS_WIN) #if defined(OS_WIN)
&GpuVideoDecodeAcceleratorFactory::CreateD3D11VDA,
&GpuVideoDecodeAcceleratorFactory::CreateDXVAVDA, &GpuVideoDecodeAcceleratorFactory::CreateDXVAVDA,
#endif #endif
#if BUILDFLAG(USE_V4L2_CODEC) #if BUILDFLAG(USE_V4L2_CODEC)
...@@ -167,21 +165,6 @@ GpuVideoDecodeAcceleratorFactory::CreateVDA( ...@@ -167,21 +165,6 @@ GpuVideoDecodeAcceleratorFactory::CreateVDA(
} }
#if defined(OS_WIN) #if defined(OS_WIN)
std::unique_ptr<VideoDecodeAccelerator>
GpuVideoDecodeAcceleratorFactory::CreateD3D11VDA(
const gpu::GpuDriverBugWorkarounds& workarounds,
const gpu::GpuPreferences& gpu_preferences) const {
std::unique_ptr<VideoDecodeAccelerator> decoder;
if (!base::FeatureList::IsEnabled(kD3D11VideoDecoding))
return decoder;
if (base::win::GetVersion() >= base::win::VERSION_WIN8) {
DVLOG(0) << "Initializing D3D11 HW decoder for windows.";
decoder.reset(new D3D11VideoDecodeAccelerator(
get_gl_context_cb_, make_context_current_cb_, bind_image_cb_));
}
return decoder;
}
std::unique_ptr<VideoDecodeAccelerator> std::unique_ptr<VideoDecodeAccelerator>
GpuVideoDecodeAcceleratorFactory::CreateDXVAVDA( GpuVideoDecodeAcceleratorFactory::CreateDXVAVDA(
const gpu::GpuDriverBugWorkarounds& workarounds, const gpu::GpuDriverBugWorkarounds& workarounds,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment