// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif
#include "media/gpu/windows/d3d11_video_decoder_wrapper.h"
#include <d3d9.h>
#include "base/check_op.h"
#include "base/strings/string_number_conversions.h"
#include "media/gpu/windows/d3d11_picture_buffer.h"
#include "third_party/abseil-cpp/absl/container/inlined_vector.h"
namespace media {
namespace {
D3D11_VIDEO_DECODER_BUFFER_TYPE
BufferTypeToD3D11BufferType(D3DVideoDecoderWrapper::BufferType type) {
switch (type) {
case D3DVideoDecoderWrapper::BufferType::kPictureParameters:
return D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS;
case D3DVideoDecoderWrapper::BufferType::kInverseQuantizationMatrix:
return D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX;
case D3DVideoDecoderWrapper::BufferType::kSliceControl:
return D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL;
case D3DVideoDecoderWrapper::BufferType::kBitstream:
return D3D11_VIDEO_DECODER_BUFFER_BITSTREAM;
}
NOTREACHED();
}
template <typename D3D11VideoContext, typename D3D11VideoDecoderBufferDesc>
class ScopedD3D11DecoderBuffer;
template <typename D3D11VideoContext, typename D3D11VideoDecoderBufferDesc>
class D3D11VideoDecoderWrapperImpl : public D3D11VideoDecoderWrapper {
public:
D3D11VideoDecoderWrapperImpl(
MediaLog* media_log,
ComD3D11VideoDevice video_device,
Microsoft::WRL::ComPtr<D3D11VideoContext> video_context,
ComD3D11VideoDecoder video_decoder)
: D3D11VideoDecoderWrapper(media_log),
video_device_(std::move(video_device)),
video_context_(std::move(video_context)),
video_decoder_(std::move(video_decoder)) {}
~D3D11VideoDecoderWrapperImpl() override {
// Release the scoped buffer before video_context_ and video_decoder_
// destructs.
if (bitstream_buffer_) {
bitstream_buffer_.reset();
}
}
std::optional<bool> UseSingleTexture() const override {
D3D11_VIDEO_DECODER_DESC desc;
D3D11_VIDEO_DECODER_CONFIG config;
HRESULT hr = video_decoder_->GetCreationParameters(&desc, &config);
if (FAILED(hr)) {
MEDIA_PLOG(ERROR, hr, media_log_)
<< "D3D11VideoDecoder GetCreationParameters failed";
return std::nullopt;
}
// Prefer whatever the config tells us about whether to use one Texture2D
// with multiple array slices, or multiple Texture2Ds with one slice each.
// If bit 14 is clear, then it's the former, else it's the latter.
//
// Let the workaround override array texture mode, if enabled.
// TODO(crbug.com/41463736): Ignore |use_single_video_decoder_texture_|
// here, since it might be the case that it's not actually the right fix.
// Instead, We use this workaround to force a copy later. The workaround
// will be renamed if this turns out to fix the issue, but we might need to
// merge back and smaller changes are better.
//
// For more information, please see:
// https://download.microsoft.com/download/9/2/A/92A4E198-67E0-4ABD-9DB7-635D711C2752/DXVA_VPx.pdf
// https://download.microsoft.com/download/5/f/c/5fc4ec5c-bd8c-4624-8034-319c1bab7671/DXVA_H264.pdf
// TODO(crbug.com/dawn/1932): Use array textures if preferred with shared
// handles once Dawn supports importing those.
return config.ConfigDecoderSpecific & (1 << 14);
}
void Reset() override {
if (bitstream_buffer_) {
CHECK(bitstream_buffer_->Commit());
bitstream_buffer_.reset();
}
}
bool WaitForFrameBegins(D3D11PictureBuffer* output_picture) override {
auto result = output_picture->AcquireOutputView();
if (!result.has_value()) {
media_log_->NotifyError(std::move(result).error().AddHere());
return false;
}
ID3D11VideoDecoderOutputView* output_view = std::move(result).value();
HRESULT hr;
do {
hr = video_context_->DecoderBeginFrame(video_decoder_.Get(), output_view,
0, nullptr);
if (hr == E_PENDING || hr == D3DERR_WASSTILLDRAWING) {
// Hardware is busy. We should make the call again.
base::PlatformThread::YieldCurrentThread();
}
} while (hr == E_PENDING || hr == D3DERR_WASSTILLDRAWING);
if (FAILED(hr)) {
MEDIA_PLOG(ERROR, hr, media_log_) << "DecoderBeginFrame failed";
return false;
}
return true;
}
bool HasPendingBuffer(BufferType type) override {
D3D11_VIDEO_DECODER_BUFFER_TYPE d3d_buffer_type =
BufferTypeToD3D11BufferType(type);
for (auto video_buffer : video_buffers_) {
if (video_buffer.BufferType == d3d_buffer_type) {
return true;
}
}
return false;
}
bool SubmitSlice() override {
if (!slice_info_bytes_.empty()) {
auto buffer = GetSliceControlBuffer(slice_info_bytes_.size());
if (buffer.size() < slice_info_bytes_.size()) {
MEDIA_LOG(ERROR, media_log_) << "Insufficient slice info buffer size";
return false;
}
memcpy(buffer.data(), slice_info_bytes_.data(), slice_info_bytes_.size());
slice_info_bytes_.clear();
if (!buffer.Commit()) {
return false;
}
}
return SubmitBitstreamBuffer() && SubmitDecoderBuffers();
}
bool SubmitDecode() override {
HRESULT hr = video_context_->DecoderEndFrame(video_decoder_.Get());
if (FAILED(hr)) {
MEDIA_PLOG(ERROR, hr, media_log_) << "SubmitDecode failed";
return false;
}
return true;
}
private:
friend class ScopedD3D11DecoderBuffer<D3D11VideoContext,
D3D11VideoDecoderBufferDesc>;
std::unique_ptr<ScopedD3DBuffer> GetBuffer(BufferType type,
uint32_t desired_size) override {
return std::make_unique<ScopedD3D11DecoderBuffer<
D3D11VideoContext, D3D11VideoDecoderBufferDesc>>(
this, BufferTypeToD3D11BufferType(type), desired_size, media_log_);
}
bool SubmitBitstreamBuffer() {
DCHECK(bitstream_buffer_);
bool ok = bitstream_buffer_->Commit();
bitstream_buffer_.reset();
return ok;
}
bool SubmitDecoderBuffers();
ComD3D11VideoDevice video_device_;
Microsoft::WRL::ComPtr<D3D11VideoContext> video_context_;
ComD3D11VideoDecoder video_decoder_;
absl::InlinedVector<D3D11VideoDecoderBufferDesc, 4> video_buffers_;
};
template <>
bool D3D11VideoDecoderWrapperImpl<
ID3D11VideoContext,
D3D11_VIDEO_DECODER_BUFFER_DESC>::SubmitDecoderBuffers() {
DCHECK_LE(video_buffers_.size(), 4ull);
HRESULT hr = video_context_->SubmitDecoderBuffers(
video_decoder_.Get(), video_buffers_.size(), video_buffers_.data());
video_buffers_.clear();
if (FAILED(hr)) {
MEDIA_PLOG(ERROR, hr, media_log_) << "SubmitDecoderBuffers failed";
return false;
}
return true;
}
template <>
bool D3D11VideoDecoderWrapperImpl<
ID3D11VideoContext1,
D3D11_VIDEO_DECODER_BUFFER_DESC1>::SubmitDecoderBuffers() {
DCHECK_LE(video_buffers_.size(), 4ull);
HRESULT hr = video_context_->SubmitDecoderBuffers1(
video_decoder_.Get(), video_buffers_.size(), video_buffers_.data());
video_buffers_.clear();
if (FAILED(hr)) {
MEDIA_PLOG(ERROR, hr, media_log_) << "SubmitDecoderBuffers failed";
return false;
}
return true;
}
template <typename D3D11VideoContext, typename D3D11VideoDecoderBufferDesc>
class ScopedD3D11DecoderBuffer : public ScopedD3DBuffer {
public:
ScopedD3D11DecoderBuffer(
D3D11VideoDecoderWrapperImpl<D3D11VideoContext,
D3D11VideoDecoderBufferDesc>* decoder,
D3D11_VIDEO_DECODER_BUFFER_TYPE type,
uint32_t desired_size,
MediaLog* media_log)
: decoder_(decoder),
type_(type),
desired_size_(desired_size),
media_log_(media_log->Clone()) {
UINT size;
uint8_t* buffer;
HRESULT hr = decoder_->video_context_->GetDecoderBuffer(
decoder_->video_decoder_.Get(), type_, &size,
reinterpret_cast<void**>(&buffer));
if (FAILED(hr)) {
D3D11StatusCode status_code = D3D11StatusCode::kOk;
switch (type_) {
case D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS:
status_code = D3D11StatusCode::kGetPicParamBufferFailed;
break;
case D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX:
status_code = D3D11StatusCode::kGetQuantBufferFailed;
break;
case D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL:
status_code = D3D11StatusCode::kGetSliceControlBufferFailed;
break;
case D3D11_VIDEO_DECODER_BUFFER_BITSTREAM:
status_code = D3D11StatusCode::kGetBitstreamBufferFailed;
break;
default:
NOTREACHED();
}
media_log_->NotifyError(
D3D11Status{status_code, "D3D11 GetDecoderBuffer failed", hr});
return;
}
data_ = base::span<uint8_t>(buffer, size);
}
~ScopedD3D11DecoderBuffer() override { Commit(); }
ScopedD3D11DecoderBuffer(const ScopedD3D11DecoderBuffer&) = delete;
ScopedD3D11DecoderBuffer& operator=(const ScopedD3D11DecoderBuffer&) = delete;
bool Commit() override {
return Commit(std::min(static_cast<size_t>(desired_size_), data_.size()));
}
bool Commit(uint32_t written_size) override {
if (data_.empty()) {
return false;
}
HRESULT hr = decoder_->video_context_->ReleaseDecoderBuffer(
decoder_->video_decoder_.Get(), type_);
if (FAILED(hr)) {
D3D11StatusCode status_code = D3D11StatusCode::kOk;
switch (type_) {
case D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS:
status_code = D3D11StatusCode::kReleasePicParamBufferFailed;
break;
case D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX:
status_code = D3D11StatusCode::kReleaseQuantBufferFailed;
break;
case D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL:
status_code = D3D11StatusCode::kReleaseSliceControlBufferFailed;
break;
case D3D11_VIDEO_DECODER_BUFFER_BITSTREAM:
status_code = D3D11StatusCode::kReleaseBitstreamBufferFailed;
break;
default:
NOTREACHED();
}
media_log_->NotifyError(
D3D11Status{status_code, "D3D11 ReleaseDecoderBuffer failed", hr});
return false;
}
decoder_->video_buffers_.emplace_back(D3D11VideoDecoderBufferDesc{
.BufferType = type_,
.DataOffset = 0,
.DataSize = written_size,
});
data_ = base::span<uint8_t>();
return true;
}
private:
const raw_ptr<D3D11VideoDecoderWrapperImpl<D3D11VideoContext,
D3D11VideoDecoderBufferDesc>>
decoder_;
const D3D11_VIDEO_DECODER_BUFFER_TYPE type_;
const uint32_t desired_size_;
const std::unique_ptr<MediaLog> media_log_;
};
} // namespace
// static
std::unique_ptr<D3D11VideoDecoderWrapper> D3D11VideoDecoderWrapper::Create(
MediaLog* media_log,
ComD3D11VideoDevice video_device,
ComD3D11VideoContext video_context,
const D3D11DecoderConfigurator* decoder_configurator,
D3D_FEATURE_LEVEL supported_d3d11_version,
VideoDecoderConfig config) {
UINT config_count = 0;
HRESULT hr = video_device->GetVideoDecoderConfigCount(
decoder_configurator->DecoderDescriptor(), &config_count);
if (FAILED(hr) || config_count == 0) {
MEDIA_PLOG(ERROR, hr, media_log) << "GetVideoDecoderConfigCount failed";
return nullptr;
}
D3D11_VIDEO_DECODER_CONFIG dec_config{};
bool found = false;
for (UINT i = 0; i < config_count; i++) {
hr = video_device->GetVideoDecoderConfig(
decoder_configurator->DecoderDescriptor(), i, &dec_config);
if (FAILED(hr)) {
MEDIA_PLOG(ERROR, hr, media_log) << "GetVideoDecoderConfig failed";
return nullptr;
}
// DXVA HEVC, VP9, and AV1 specifications say ConfigBitstreamRaw
// "shall be 1".
if (dec_config.ConfigBitstreamRaw == 1 &&
(config.codec() == VideoCodec::kVP9 ||
config.codec() == VideoCodec::kAV1 ||
config.codec() == VideoCodec::kHEVC)) {
found = true;
break;
}
// ConfigBitstreamRaw == 2 means the decoder uses DXVA_Slice_H264_Short.
if (dec_config.ConfigBitstreamRaw == 2 &&
config.codec() == VideoCodec::kH264) {
found = true;
break;
}
}
if (!found) {
MEDIA_LOG(ERROR, media_log) << "VideoDecoderConfig is unsupported";
return nullptr;
}
ComD3D11VideoDecoder video_decoder;
hr = video_device->CreateVideoDecoder(
decoder_configurator->DecoderDescriptor(), &dec_config, &video_decoder);
if (FAILED(hr)) {
MEDIA_PLOG(ERROR, hr, media_log) << "CreateVideoDecoder failed";
return nullptr;
}
// If we got an 11.1 D3D11 Device, we can use a |ID3D11VideoContext1|,
// otherwise we have to make sure we only use a |ID3D11VideoContext|.
if (supported_d3d11_version == D3D_FEATURE_LEVEL_11_0) {
return std::make_unique<D3D11VideoDecoderWrapperImpl<
ID3D11VideoContext, D3D11_VIDEO_DECODER_BUFFER_DESC>>(
media_log, std::move(video_device), std::move(video_context),
std::move(video_decoder));
}
if (supported_d3d11_version == D3D_FEATURE_LEVEL_11_1) {
ComD3D11VideoContext1 video_context1;
hr = video_context.As(&video_context1);
CHECK_EQ(hr, S_OK);
return std::make_unique<D3D11VideoDecoderWrapperImpl<
ID3D11VideoContext1, D3D11_VIDEO_DECODER_BUFFER_DESC1>>(
media_log, std::move(video_device), std::move(video_context1),
std::move(video_decoder));
}
return nullptr;
}
D3D11VideoDecoderWrapper::~D3D11VideoDecoderWrapper() = default;
D3D11VideoDecoderWrapper::D3D11VideoDecoderWrapper(MediaLog* media_log)
: D3DVideoDecoderWrapper(media_log) {}
} // namespace media
Codebase Browser
chromium