| // 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. |
| |
| // This is defined here to ensure the D3D11, D3D9, and DXVA includes through |
| // this header have their GUIDs intialized. |
| #define INITGUID |
| #include "media/gpu/d3d11_video_decode_accelerator_win.h" |
| #undef INITGUID |
| |
| #include <d3d11.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 "base/win/scoped_comptr.h" |
| #include "media/gpu/d3d11_h264_accelerator.h" |
| #include "media/gpu/h264_decoder.h" |
| #include "media/gpu/h264_dpb.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) |
| : get_gl_context_cb_(get_gl_context_cb), |
| make_context_current_cb_(make_context_current_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_.Receive()); |
| |
| HRESULT hr = device_context_.QueryInterface(video_context_.Receive()); |
| CHECK(SUCCEEDED(hr)); |
| |
| hr = device_.QueryInterface(video_device_.Receive()); |
| 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_); |
| |
| base::win::ScopedComPtr<ID3D11VideoDecoder> video_decoder; |
| hr = video_device_->CreateVideoDecoder(&desc, &dec_config, |
| video_decoder.Receive()); |
| 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; |
| |
| base::win::ScopedComPtr<ID3D11Texture2D> out_texture; |
| HRESULT hr = |
| device_->CreateTexture2D(&texture_desc, nullptr, out_texture.Receive()); |
| 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_); |
| } |
| 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(), false); |
| client_->PictureReady(picture); |
| } |
| } // namespace media |