Log media::StatusCode for D3D11VideoDecoder

To help track down the cause of excess dxva usage from D3D11, this CL
adds a sparse histogram of media::StatusCodes that are returned from
D3D11VideoDecoder and the H264 / VP9 accelerators.

Bug: 1168304
Change-Id: If2c3c1990cf50776c69958048b7b9c2969095c3d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2638247
Commit-Queue: Frank Liberato <liberato@chromium.org>
Reviewed-by: Ted Meyer <tmathmeyer@chromium.org>
Reviewed-by: Ilya Sherman <isherman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#845387}

media/base/status_codes.h

@@ -80,6 +80,20 @@ enum class StatusCode : StatusCodeType {
   kQueryVideoContextFailed = 0x00000314,
   kAcceleratorFlushFailed = 0x00000315,
   kTryAgainNotSupported = 0x00000316,
+  kCryptoConfigFailed = 0x00000317,
+  kDecoderBeginFrameFailed = 0x00000318,
+  kReleaseDecoderBufferFailed = 0x00000319,
+  kGetPicParamBufferFailed = 0x00000320,
+  kReleasePicParamBufferFailed = 0x00000321,
+  kGetBitstreamBufferFailed = 0x00000322,
+  kReleaseBitstreamBufferFailed = 0x00000323,
+  kGetSliceControlBufferFailed = 0x00000324,
+  kReleaseSliceControlBufferFailed = 0x00000325,
+  kDecoderEndFrameFailed = 0x00000326,
+  kSubmitDecoderBuffersFailed = 0x00000327,
+  kGetQuantBufferFailed = 0x00000328,
+  kReleaseQuantBufferFailed = 0x00000329,
+  kBitstreamBufferSliceTooBig = 0x00000330,
 
   // MojoDecoder Errors: 0x04
   kMojoDecoderNoWrappedDecoder = 0x00000401,

media/gpu/windows/d3d11_h264_accelerator.cc

@@ -7,6 +7,8 @@
 #include <windows.h>
 
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_functions.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "media/base/media_log.h"
 #include "media/base/win/mf_helpers.h"
@@ -95,7 +97,8 @@ DecoderStatus D3D11H264Accelerator::SubmitFrameMetadata(
     scoped_refptr<H264Picture> pic) {
   const bool is_encrypted = pic->decrypt_config();
   if (is_encrypted) {
-    RecordFailure("Cannot find decrypt context for the frame.");
+    RecordFailure("Cannot find decrypt context for the frame.",
+                  StatusCode::kCryptoConfigFailed);
     return DecoderStatus::kFail;
   }
 
@@ -111,7 +114,8 @@ DecoderStatus D3D11H264Accelerator::SubmitFrameMetadata(
       // TODO(liberato): For now, just busy wait.
       ;
     } else if (!SUCCEEDED(hr)) {
-      RecordFailure("DecoderBeginFrame failed", hr);
+      RecordFailure("DecoderBeginFrame failed",
+                    StatusCode::kDecoderBeginFrameFailed, hr);
       return DecoderStatus::kFail;
     } else {
       break;
@@ -161,7 +165,8 @@ bool D3D11H264Accelerator::RetrieveBitstreamBuffer() {
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_BITSTREAM, &buffer_size,
       &buffer);
   if (!SUCCEEDED(hr)) {
-    RecordFailure("GetDecoderBuffer (Bitstream) failed", hr);
+    RecordFailure("GetDecoderBuffer (Bitstream) failed",
+                  StatusCode::kGetBitstreamBufferFailed, hr);
     return false;
   }
   bitstream_buffer_bytes_ = (uint8_t*)buffer;
@@ -333,7 +338,8 @@ DecoderStatus D3D11H264Accelerator::SubmitSlice(
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS,
       &buffer_size, &buffer);
   if (!SUCCEEDED(hr)) {
-    RecordFailure("ReleaseDecoderBuffer (PictureParams) failed", hr);
+    RecordFailure("GetDecoderBuffer (PictureParams) failed",
+                  StatusCode::kGetPicParamBufferFailed, hr);
     return DecoderStatus::kFail;
   }
 
@@ -341,7 +347,8 @@ DecoderStatus D3D11H264Accelerator::SubmitSlice(
   hr = video_context_->ReleaseDecoderBuffer(
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS);
   if (!SUCCEEDED(hr)) {
-    RecordFailure("ReleaseDecoderBuffer (PictureParams) failed", hr);
+    RecordFailure("ReleaseDecoderBuffer (PictureParams) failed",
+                  StatusCode::kReleasePicParamBufferFailed, hr);
     return DecoderStatus::kFail;
   }
 
@@ -373,7 +380,8 @@ DecoderStatus D3D11H264Accelerator::SubmitSlice(
       D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX, &buffer_size,
       &buffer);
   if (!SUCCEEDED(hr)) {
-    RecordFailure("GetDecoderBuffer (QuantMatrix) failed", hr);
+    RecordFailure("GetDecoderBuffer (QuantMatrix) failed",
+                  StatusCode::kGetQuantBufferFailed, hr);
     return DecoderStatus::kFail;
   }
   memcpy(buffer, &iq_matrix_buf, sizeof(iq_matrix_buf));
@@ -381,7 +389,8 @@ DecoderStatus D3D11H264Accelerator::SubmitSlice(
       video_decoder_.Get(),
       D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX);
   if (!SUCCEEDED(hr)) {
-    RecordFailure("ReleaseDecoderBuffer (QuantMatrix) failed", hr);
+    RecordFailure("ReleaseDecoderBuffer (QuantMatrix) failed",
+                  StatusCode::kReleaseQuantBufferFailed, hr);
     return DecoderStatus::kFail;
   }
 
@@ -399,8 +408,9 @@ DecoderStatus D3D11H264Accelerator::SubmitSlice(
     // the subsample ClearSize adjustment below should work.
     if (bitstream_buffer_size_ < remaining_bitstream) {
       RecordFailure("Input slice NALU (" + std::to_string(remaining_bitstream) +
-                    ") too big to fit in the bistream buffer (" +
-                    std::to_string(bitstream_buffer_size_) + ").");
+                        ") too big to fit in the bistream buffer (" +
+                        base::NumberToString(bitstream_buffer_size_) + ").",
+                    StatusCode::kBitstreamBufferSliceTooBig);
       return DecoderStatus::kFail;
     }
 
@@ -420,15 +430,11 @@ DecoderStatus D3D11H264Accelerator::SubmitSlice(
   while (remaining_bitstream > 0) {
     if (bitstream_buffer_size_ < remaining_bitstream &&
         slice_info_.size() > 0) {
-      if (!SubmitSliceData()) {
-        RecordFailure("SubmitSliceData failed");
+      if (!SubmitSliceData())
         return DecoderStatus::kFail;
-      }
 
-      if (!RetrieveBitstreamBuffer()) {
-        RecordFailure("RetrieveBitstreamBuffer failed");
+      if (!RetrieveBitstreamBuffer())
         return DecoderStatus::kFail;
-      }
     }
 
     size_t bytes_to_copy = remaining_bitstream;
@@ -482,7 +488,8 @@ bool D3D11H264Accelerator::SubmitSliceData() {
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL,
       &buffer_size, &buffer);
   if (!SUCCEEDED(hr)) {
-    RecordFailure("GetDecoderBuffer (SliceControl) failed", hr);
+    RecordFailure("GetDecoderBuffer (SliceControl) failed",
+                  StatusCode::kGetSliceControlBufferFailed, hr);
     return false;
   }
 
@@ -491,14 +498,16 @@ bool D3D11H264Accelerator::SubmitSliceData() {
   hr = video_context_->ReleaseDecoderBuffer(
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL);
   if (!SUCCEEDED(hr)) {
-    RecordFailure("ReleaseDecoderBuffer (SliceControl) failed", hr);
+    RecordFailure("ReleaseDecoderBuffer (SliceControl) failed",
+                  StatusCode::kReleaseSliceControlBufferFailed, hr);
     return false;
   }
 
   hr = video_context_->ReleaseDecoderBuffer(
       video_decoder_.Get(), D3D11_VIDEO_DECODER_BUFFER_BITSTREAM);
   if (!SUCCEEDED(hr)) {
-    RecordFailure("ReleaseDecoderBuffer (BitStream) failed", hr);
+    RecordFailure("ReleaseDecoderBuffer (BitStream) failed",
+                  StatusCode::kReleaseBitstreamBufferFailed, hr);
     return false;
   }
 
@@ -536,7 +545,8 @@ bool D3D11H264Accelerator::SubmitSliceData() {
   frame_iv_.clear();
   subsamples_.clear();
   if (!SUCCEEDED(hr)) {
-    RecordFailure("SubmitDecoderBuffers failed", hr);
+    RecordFailure("SubmitDecoderBuffers failed",
+                  StatusCode::kSubmitDecoderBuffersFailed, hr);
     return false;
   }
 
@@ -545,14 +555,13 @@ bool D3D11H264Accelerator::SubmitSliceData() {
 
 DecoderStatus D3D11H264Accelerator::SubmitDecode(
     scoped_refptr<H264Picture> pic) {
-  if (!SubmitSliceData()) {
-    RecordFailure("SubmitSliceData failed");
+  if (!SubmitSliceData())
     return DecoderStatus::kFail;
-  }
 
   HRESULT hr = video_context_->DecoderEndFrame(video_decoder_.Get());
   if (!SUCCEEDED(hr)) {
-    RecordFailure("DecoderEndFrame failed", hr);
+    RecordFailure("DecoderEndFrame failed", StatusCode::kDecoderEndFrameFailed,
+                  hr);
     return DecoderStatus::kFail;
   }
 
@@ -579,6 +588,7 @@ bool D3D11H264Accelerator::OutputPicture(scoped_refptr<H264Picture> pic) {
 }
 
 void D3D11H264Accelerator::RecordFailure(const std::string& reason,
+                                         StatusCode code,
                                          HRESULT hr) const {
   std::string hr_string;
   if (!SUCCEEDED(hr))
@@ -586,6 +596,7 @@ void D3D11H264Accelerator::RecordFailure(const std::string& reason,
 
   DLOG(ERROR) << reason << hr_string;
   MEDIA_LOG(ERROR, media_log_) << hr_string << ": " << reason;
+  base::UmaHistogramSparse("Media.D3D11.H264Status", static_cast<int>(code));
 }
 
 void D3D11H264Accelerator::SetVideoDecoder(ComD3D11VideoDecoder video_decoder) {

media/gpu/windows/d3d11_h264_accelerator.h

@@ -13,6 +13,7 @@
 #include <vector>
 
 #include "gpu/command_buffer/service/texture_manager.h"
+#include "media/base/status_codes.h"
 #include "media/base/video_frame.h"
 #include "media/base/win/mf_helpers.h"
 #include "media/gpu/h264_decoder.h"
@@ -84,7 +85,9 @@ class D3D11H264Accelerator : public H264Decoder::H264Accelerator {
   bool RetrieveBitstreamBuffer();
 
   // Record a failure to DVLOG and |media_log_|.
-  void RecordFailure(const std::string& reason, HRESULT hr = S_OK) const;
+  void RecordFailure(const std::string& reason,
+                     StatusCode code,
+                     HRESULT hr = S_OK) const;
 
   D3D11VideoDecoderClient* client_;
   MediaLog* media_log_ = nullptr;

media/gpu/windows/d3d11_video_decoder.cc

@@ -899,6 +899,10 @@ void D3D11VideoDecoder::NotifyError(const Status& reason) {
   TRACE_EVENT0("gpu", "D3D11VideoDecoder::NotifyError");
   state_ = State::kError;
 
+  // Log why this failed.
+  base::UmaHistogramSparse("Media.D3D11.NotifyErrorStatus",
+                           static_cast<int>(reason.code()));
+
   if (init_cb_) {
     std::move(init_cb_).Run(reason);
   } else {

media/gpu/windows/d3d11_vp9_accelerator.cc

@@ -9,19 +9,21 @@
 #include <utility>
 
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_functions.h"
 #include "media/gpu/windows/d3d11_vp9_picture.h"
 
 namespace media {
 
 using DecodeStatus = VP9Decoder::VP9Accelerator::Status;
 
-#define RETURN_ON_HR_FAILURE(expr_name, expr)                                  \
-  do {                                                                         \
-    HRESULT expr_value = (expr);                                               \
-    if (FAILED(expr_value)) {                                                  \
-      RecordFailure(#expr_name, logging::SystemErrorCodeToString(expr_value)); \
-      return false;                                                            \
-    }                                                                          \
+#define RETURN_ON_HR_FAILURE(expr_name, expr, code)                           \
+  do {                                                                        \
+    HRESULT expr_value = (expr);                                              \
+    if (FAILED(expr_value)) {                                                 \
+      RecordFailure(#expr_name, logging::SystemErrorCodeToString(expr_value), \
+                    code);                                                    \
+      return false;                                                           \
+    }                                                                         \
   } while (0)
 
 std::vector<D3D11_VIDEO_DECODER_SUB_SAMPLE_MAPPING_BLOCK>
@@ -54,9 +56,11 @@ D3D11VP9Accelerator::D3D11VP9Accelerator(
 D3D11VP9Accelerator::~D3D11VP9Accelerator() {}
 
 void D3D11VP9Accelerator::RecordFailure(const std::string& fail_type,
-                                        const std::string& reason) {
+                                        const std::string& reason,
+                                        StatusCode code) {
   MEDIA_LOG(ERROR, media_log_)
       << "DX11VP9Failure(" << fail_type << ")=" << reason;
+  base::UmaHistogramSparse("Media.D3D11.VP9Status", static_cast<int>(code));
 }
 
 scoped_refptr<VP9Picture> D3D11VP9Accelerator::CreateVP9Picture() {
@@ -70,7 +74,8 @@ bool D3D11VP9Accelerator::BeginFrame(const D3D11VP9Picture& pic) {
   const bool is_encrypted = pic.decrypt_config();
   if (is_encrypted) {
     RecordFailure("crypto_config",
-                  "Cannot find the decrypt context for the frame.");
+                  "Cannot find the decrypt context for the frame.",
+                  StatusCode::kCryptoConfigFailed);
     return false;
   }
 
@@ -82,7 +87,8 @@ bool D3D11VP9Accelerator::BeginFrame(const D3D11VP9Picture& pic) {
   } while (hr == E_PENDING || hr == D3DERR_WASSTILLDRAWING);
 
   if (FAILED(hr)) {
-    RecordFailure("DecoderBeginFrame", logging::SystemErrorCodeToString(hr));
+    RecordFailure("DecoderBeginFrame", logging::SystemErrorCodeToString(hr),
+                  StatusCode::kDecoderBeginFrameFailed);
     return false;
   }
 
@@ -253,25 +259,29 @@ void D3D11VP9Accelerator::CopyHeaderSizeAndID(DXVA_PicParams_VP9* pic_params,
 bool D3D11VP9Accelerator::SubmitDecoderBuffer(
     const DXVA_PicParams_VP9& pic_params,
     const D3D11VP9Picture& pic) {
-#define GET_BUFFER(type)                                 \
-  RETURN_ON_HR_FAILURE(GetDecoderBuffer,                 \
-                       video_context_->GetDecoderBuffer( \
-                           video_decoder_.Get(), type, &buffer_size, &buffer))
-#define RELEASE_BUFFER(type) \
-  RETURN_ON_HR_FAILURE(      \
-      ReleaseDecoderBuffer,  \
-      video_context_->ReleaseDecoderBuffer(video_decoder_.Get(), type))
+#define GET_BUFFER(type, code)                                                 \
+  RETURN_ON_HR_FAILURE(GetDecoderBuffer,                                       \
+                       video_context_->GetDecoderBuffer(                       \
+                           video_decoder_.Get(), type, &buffer_size, &buffer), \
+                       code)
+#define RELEASE_BUFFER(type, code) \
+  RETURN_ON_HR_FAILURE(            \
+      ReleaseDecoderBuffer,        \
+      video_context_->ReleaseDecoderBuffer(video_decoder_.Get(), type), code)
 
   UINT buffer_size;
   void* buffer;
 
-  GET_BUFFER(D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS);
+  GET_BUFFER(D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS,
+             StatusCode::kGetPicParamBufferFailed);
   memcpy(buffer, &pic_params, sizeof(pic_params));
-  RELEASE_BUFFER(D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS);
+  RELEASE_BUFFER(D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS,
+                 StatusCode::kReleasePicParamBufferFailed);
 
   size_t buffer_offset = 0;
   while (buffer_offset < pic.frame_hdr->frame_size) {
-    GET_BUFFER(D3D11_VIDEO_DECODER_BUFFER_BITSTREAM);
+    GET_BUFFER(D3D11_VIDEO_DECODER_BUFFER_BITSTREAM,
+               StatusCode::kGetBitstreamBufferFailed);
     size_t copy_size = pic.frame_hdr->frame_size - buffer_offset;
     bool contains_end = true;
     if (copy_size > buffer_size) {
@@ -279,11 +289,13 @@ bool D3D11VP9Accelerator::SubmitDecoderBuffer(
       contains_end = false;
     }
     memcpy(buffer, pic.frame_hdr->data + buffer_offset, copy_size);
-    RELEASE_BUFFER(D3D11_VIDEO_DECODER_BUFFER_BITSTREAM);
+    RELEASE_BUFFER(D3D11_VIDEO_DECODER_BUFFER_BITSTREAM,
+                   StatusCode::kReleaseBitstreamBufferFailed);
 
     DXVA_Slice_VPx_Short slice_info;
 
-    GET_BUFFER(D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL);
+    GET_BUFFER(D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL,
+               StatusCode::kGetSliceControlBufferFailed);
     slice_info.BSNALunitDataLocation = 0;
     slice_info.SliceBytesInBuffer = (UINT)copy_size;
 
@@ -299,7 +311,8 @@ bool D3D11VP9Accelerator::SubmitDecoderBuffer(
       slice_info.wBadSliceChopping = 3;
 
     memcpy(buffer, &slice_info, sizeof(slice_info));
-    RELEASE_BUFFER(D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL);
+    RELEASE_BUFFER(D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL,
+                   StatusCode::kReleaseSliceControlBufferFailed);
 
     constexpr int buffers_count = 3;
     VideoContextWrapper::VideoBufferWrapper buffers[buffers_count] = {};
@@ -327,7 +340,8 @@ bool D3D11VP9Accelerator::SubmitDecoderBuffer(
 
     RETURN_ON_HR_FAILURE(SubmitDecoderBuffers,
                          video_context_->SubmitDecoderBuffers(
-                             video_decoder_.Get(), buffers_count, buffers));
+                             video_decoder_.Get(), buffers_count, buffers),
+                         StatusCode::kSubmitDecoderBuffersFailed);
     buffer_offset += copy_size;
   }
 
@@ -361,7 +375,8 @@ DecodeStatus D3D11VP9Accelerator::SubmitDecode(
 
   HRESULT hr = video_context_->DecoderEndFrame(video_decoder_.Get());
   if (FAILED(hr)) {
-    RecordFailure("DecoderEndFrame", logging::SystemErrorCodeToString(hr));
+    RecordFailure("DecoderEndFrame", logging::SystemErrorCodeToString(hr),
+                  StatusCode::kDecoderEndFrameFailed);
     return DecodeStatus::kFail;
   }
 

media/gpu/windows/d3d11_vp9_accelerator.h

@@ -12,6 +12,7 @@
 #include <wrl/client.h>
 
 #include "media/base/media_log.h"
+#include "media/base/status_codes.h"
 #include "media/gpu/vp9_decoder.h"
 #include "media/gpu/windows/d3d11_com_defs.h"
 #include "media/gpu/windows/d3d11_video_context_wrapper.h"
@@ -66,7 +67,9 @@ class D3D11VP9Accelerator : public VP9Decoder::VP9Accelerator {
   bool SubmitDecoderBuffer(const DXVA_PicParams_VP9& pic_params,
                            const D3D11VP9Picture& pic);
 
-  void RecordFailure(const std::string& fail_type, const std::string& reason);
+  void RecordFailure(const std::string& fail_type,
+                     const std::string& reason,
+                     StatusCode code);
 
   void SetVideoDecoder(ComD3D11VideoDecoder video_decoder);
 

tools/metrics/histograms/enums.xml

@@ -49399,6 +49399,121 @@ Called by update_use_counter_css.py.-->
   <int value="0" label="AMEDIA_OK"/>
 </enum>
 
+<enum name="MediaStatusCode">
+  <int value="0" label="Ok"/>
+  <int value="1" label="Aborted"/>
+  <int value="2" label="InvalidArgument"/>
+  <int value="257" label="DecoderInitializeNeverCompleted"/>
+  <int value="258" label="DecoderFailedDecode"/>
+  <int value="259" label="DecoderUnsupportedProfile"/>
+  <int value="260" label="DecoderUnsupportedCodec"/>
+  <int value="261" label="DecoderUnsupportedConfig"/>
+  <int value="262" label="EncryptedContentUnsupported"/>
+  <int value="263" label="ClearContentUnsupported"/>
+  <int value="264" label="DecoderMissingCdmForEncryptedContent"/>
+  <int value="266" label="DecoderCantChangeCodec"/>
+  <int value="268" label="InitializationUnspecifiedFailure"/>
+  <int value="269" label="DecoderVideoFrameConstructionFailed"/>
+  <int value="270" label="MakeContextCurrentFailed"/>
+  <int value="271" label="DecodeErrorDoNotUse"/>
+  <int value="513" label="WindowsWrappedHresult"/>
+  <int value="514" label="WindowsApiNotAvailible"/>
+  <int value="515" label="WindowsD3D11Error"/>
+  <int value="769" label="PostTextureFailed"/>
+  <int value="770" label="PostAcquireStreamFailed"/>
+  <int value="771" label="CreateEglStreamFailed"/>
+  <int value="772" label="CreateEglStreamConsumerFailed"/>
+  <int value="773" label="CreateEglStreamProducerFailed"/>
+  <int value="774" label="CreateTextureSelectorFailed"/>
+  <int value="775" label="QueryID3D11MultithreadFailed"/>
+  <int value="776" label="GetDecoderConfigCountFailed"/>
+  <int value="777" label="GetDecoderConfigFailed"/>
+  <int value="778" label="ProcessTextureFailed"/>
+  <int value="779" label="UnsupportedTextureFormatForBind"/>
+  <int value="780" label="CreateDecoderOutputViewFailed"/>
+  <int value="781" label="AllocateTextureForCopyingWrapperFailed"/>
+  <int value="782" label="CreateDecoderOutputTextureFailed"/>
+  <int value="783" label="CreateVideoProcessorInputViewFailed"/>
+  <int value="784" label="VideoProcessorBltFailed"/>
+  <int value="785" label="CreateVideoProcessorOutputViewFailed"/>
+  <int value="786" label="CreateVideoProcessorEnumeratorFailed"/>
+  <int value="787" label="CreateVideoProcessorFailed"/>
+  <int value="788" label="QueryVideoContextFailed"/>
+  <int value="789" label="AcceleratorFlushFailed"/>
+  <int value="790" label="TryAgainNotSupported"/>
+  <int value="791" label="CryptoConfigFailed"/>
+  <int value="792" label="DecoderBeginFrameFailed"/>
+  <int value="793" label="ReleaseDecoderBufferFailed"/>
+  <int value="800" label="GetPicParamBufferFailed"/>
+  <int value="801" label="ReleasePicParamBufferFailed"/>
+  <int value="802" label="GetBitstreamBufferFailed"/>
+  <int value="803" label="ReleaseBitstreamBufferFailed"/>
+  <int value="804" label="GetSliceControlBufferFailed"/>
+  <int value="805" label="ReleaseSliceControlBufferFailed"/>
+  <int value="806" label="DecoderEndFrameFailed"/>
+  <int value="807" label="SubmitDecoderBuffersFailed"/>
+  <int value="808" label="GetQuantBufferFailed"/>
+  <int value="809" label="ReleaseQuantBufferFailed"/>
+  <int value="816" label="SliceTooBigForBitstreamBuffer"/>
+  <int value="1025" label="MojoDecoderNoWrappedDecoder"/>
+  <int value="1026" label="MojoDecoderStoppedBeforeInitDone"/>
+  <int value="1027" label="MojoDecoderUnsupported"/>
+  <int value="1028" label="MojoDecoderNoConnection"/>
+  <int value="1029" label="MojoDecoderDeletedWithoutInitialization"/>
+  <int value="1281" label="ChromeOSVideoDecoderNoDecoders"/>
+  <int value="1282" label="V4l2NoDevice"/>
+  <int value="1283" label="V4l2FailedToStopStreamQueue"/>
+  <int value="1284" label="V4l2NoDecoder"/>
+  <int value="1285" label="V4l2FailedFileCapabilitiesCheck"/>
+  <int value="1286" label="V4l2FailedResourceAllocation"/>
+  <int value="1287" label="V4l2BadFormat"/>
+  <int value="1288" label="V4L2FailedToStartStreamQueue"/>
+  <int value="1289" label="VaapiReinitializedDuringDecode"/>
+  <int value="1296" label="VaapiFailedAcceleratorCreation"/>
+  <int value="1537" label="EncoderInitializeNeverCompleted"/>
+  <int value="1538" label="EncoderInitializeTwice"/>
+  <int value="1539" label="EncoderFailedEncode"/>
+  <int value="1540" label="EncoderUnsupportedProfile"/>
+  <int value="1541" label="EncoderUnsupportedCodec"/>
+  <int value="1542" label="EncoderUnsupportedConfig"/>
+  <int value="1543" label="EncoderInitializationError"/>
+  <int value="1544" label="EncoderFailedFlush"/>
+  <int value="1793" label="VaapiBadContext"/>
+  <int value="1794" label="VaapiNoBuffer"/>
+  <int value="1795" label="VaapiNoBufferHandle"/>
+  <int value="1796" label="VaapiNoPixmap"/>
+  <int value="1797" label="VaapiNoImage"/>
+  <int value="1798" label="VaapiNoSurface"/>
+  <int value="1799" label="VaapiFailedToInitializeImage"/>
+  <int value="1800" label="VaapiFailedToBindTexture"/>
+  <int value="1801" label="VaapiFailedToBindImage"/>
+  <int value="1802" label="VaapiUnsupportedFormat"/>
+  <int value="1803" label="VaapiFailedToExportImage"/>
+  <int value="1804" label="VaapiBadImageSize"/>
+  <int value="1805" label="VaapiNoTexture"/>
+  <int value="2049" label="H264ParsingError"/>
+  <int value="2050" label="H264BufferTooSmall"/>
+  <int value="2306" label="PipelineErrorNetwork"/>
+  <int value="2307" label="PipelineErrorDecode"/>
+  <int value="2309" label="PipelineErrorAbort"/>
+  <int value="2310" label="PipelineErrorInitializationFailed"/>
+  <int value="2312" label="PipelineErrorCouldNotRender"/>
+  <int value="2313" label="PipelineErrorRead"/>
+  <int value="2315" label="PipelineErrorInvalidState"/>
+  <int value="2316" label="PipelineErrorDemuxerErrorCouldNotOpen"/>
+  <int value="2317" label="PipelineErrorDemuxerErrorCouldNotParse"/>
+  <int value="2318" label="PipelineErrorDemuxerErrorNoSupportedStreams"/>
+  <int value="2319" label="PipelineErrorDecoderErrorNotSupported"/>
+  <int value="2320" label="PipelineErrorChuckDemuxerErrorAppendFailed"/>
+  <int value="2321" label="PipelineErrorChunkDemuxerErrorEosStatusDecodeError"/>
+  <int value="2322"
+      label="PipelineErrorChunkDemuxerErrorEosStatusNetworkError"/>
+  <int value="2323" label="PipelineErrorAudioRendererError"/>
+  <int value="2325" label="PipelineErrorExternalRendererFailed"/>
+  <int value="2326" label="PipelineErrorDemuxerErrorDetectedHLS"/>
+  <int value="2561" label="UnsupportedFrameFormatError"/>
+</enum>
+
 <enum name="MediaStreamRequestResult">
   <int value="0" label="OK"/>
   <int value="1" label="Permission Denied"/>

tools/metrics/histograms/histograms_xml/media/histograms.xml

@@ -1304,6 +1304,38 @@ reviews. Googlers can read more about this at go/gwsq-gerrit.
   </summary>
 </histogram>
 
+<histogram name="Media.D3D11.H264Status" enum="MediaStatusCode"
+    expires_after="2021-06-13">
+  <owner>liberato@chromium.org</owner>
+  <owner>tmathmeyer@chromium.org</owner>
+  <summary>
+    This records the media::StatusCode from the H264 accelerator. It is emitted
+    when the accelerator encounters an error during decoding.
+  </summary>
+</histogram>
+
+<histogram name="Media.D3D11.NotifyErrorStatus" enum="MediaStatusCode"
+    expires_after="2021-06-13">
+  <owner>liberato@chromium.org</owner>
+  <owner>tmathmeyer@chromium.org</owner>
+  <summary>
+    This records the media::StatusCode that was sent to NotifyError. kOk is not
+    recorded here. It is recorded when D3D11VideoDecoder reports an error to the
+    client. For decoder failures, an additional status code may be logged by the
+    accelerator -- see Media.D3D11{H264,VP9}Status for that.
+  </summary>
+</histogram>
+
+<histogram name="Media.D3D11.VP9Status" enum="MediaStatusCode"
+    expires_after="2021-06-13">
+  <owner>liberato@chromium.org</owner>
+  <owner>tmathmeyer@chromium.org</owner>
+  <summary>
+    This records the media::StatusCode from the VP9 accelerator. It is emitted
+    when the accelerator encounters an error during decoding.
+  </summary>
+</histogram>
+
 <histogram name="Media.D3D11.WasVideoSupported"
     enum="D3D11VideoNotSupportedReason" expires_after="2021-06-13">
   <owner>liberato@chromium.org</owner>