Attach color space information to hardware decoded NV12 video frames.

media/gpu/dxva_video_decode_accelerator_win.cc

 // Copyright (c) 2012 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/dxva_video_decode_accelerator_win.h"
 
 #include <memory>
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
@@ skipping 440 matching lines @@
         config_changed_ = true;
       } else {
         pending_config_changed_ = true;
       }
     }
     last_pps_.swap(pps);
   }
   return true;
 }
 
+gfx::ColorSpace H264ConfigChangeDetector::current_color_space() const {
+  if (!parser_)
+    return gfx::ColorSpace();
+  // TODO(hubbe): Is using last_sps_id_ correct here?
+  const H264SPS* sps = parser_->GetSPS(last_sps_id_);
+  if (sps)
+    return sps->GetColorSpace();
+  return gfx::ColorSpace();
+}
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     int32_t buffer_id,
-    IMFSample* sample)
-    : input_buffer_id(buffer_id), picture_buffer_id(-1) {
+    IMFSample* sample,
+    const gfx::ColorSpace& color_space)
+    : input_buffer_id(buffer_id),
+      picture_buffer_id(-1),
+      color_space(color_space) {
   output_sample.Attach(sample);
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     const PendingSampleInfo& other) = default;
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::~PendingSampleInfo() {}
 
 DXVAVideoDecodeAccelerator::DXVAVideoDecodeAccelerator(
     const GetGLContextCallback& get_gl_context_cb,
@@ skipping 1116 matching lines @@
   DVLOG(1) << "Flags: " << std::hex << std::showbase
            << output_stream_info_.dwFlags;
   if (codec_ == kCodecH264) {
     CHECK_EQ(output_stream_info_.dwFlags, 0x107u);
   }
   DVLOG(1) << "Min buffer size: " << output_stream_info_.cbSize;
   DVLOG(1) << "Alignment: " << output_stream_info_.cbAlignment;
   return true;
 }
 
-void DXVAVideoDecodeAccelerator::DoDecode() {
+void DXVAVideoDecodeAccelerator::DoDecode(const gfx::ColorSpace& color_space) {
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::DoDecode");
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   // This function is also called from FlushInternal in a loop which could
   // result in the state transitioning to kStopped due to no decoded output.
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE(
       (state == kNormal || state == kFlushing || state == kStopped),
       "DoDecode: not in normal/flushing/stopped state", ILLEGAL_STATE, );
 
   MFT_OUTPUT_DATA_BUFFER output_data_buffer = {0};
   DWORD status = 0;
-
   HRESULT hr = decoder_->ProcessOutput(0,  // No flags
                                        1,  // # of out streams to pull from
                                        &output_data_buffer, &status);
   IMFCollection* events = output_data_buffer.pEvents;
   if (events != NULL) {
     DVLOG(1) << "Got events from ProcessOuput, but discarding";
     events->Release();
   }
   if (FAILED(hr)) {
     // A stream change needs further ProcessInput calls to get back decoder
     // output which is why we need to set the state to stopped.
     if (hr == MF_E_TRANSFORM_STREAM_CHANGE) {
       if (!SetDecoderOutputMediaType(MFVideoFormat_NV12) &&
           !SetDecoderOutputMediaType(MFVideoFormat_P010)) {
         // Decoder didn't let us set NV12 output format. Not sure as to why
         // this can happen. Give up in disgust.
         NOTREACHED() << "Failed to set decoder output media type to NV12";
         SetState(kStopped);
       } else {
         DVLOG(1) << "Received output format change from the decoder."
                     " Recursively invoking DoDecode";
-        DoDecode();
+        DoDecode(color_space);
       }
       return;
     } else if (hr == MF_E_TRANSFORM_NEED_MORE_INPUT) {
       // No more output from the decoder. Stop playback.
       SetState(kStopped);
       return;
     } else {
       NOTREACHED() << "Unhandled error in DoDecode()";
       return;
     }
   }
   TRACE_EVENT_ASYNC_END0("gpu", "DXVAVideoDecodeAccelerator.Decoding", this);
 
   TRACE_COUNTER1("DXVA Decoding", "TotalPacketsBeforeDecode",
                  inputs_before_decode_);
 
   inputs_before_decode_ = 0;
 
-  RETURN_AND_NOTIFY_ON_FAILURE(ProcessOutputSample(output_data_buffer.pSample),
-                               "Failed to process output sample.",
-                               PLATFORM_FAILURE, );
+  RETURN_AND_NOTIFY_ON_FAILURE(
+      ProcessOutputSample(output_data_buffer.pSample, color_space),
+      "Failed to process output sample.", PLATFORM_FAILURE, );
 }
 
-bool DXVAVideoDecodeAccelerator::ProcessOutputSample(IMFSample* sample) {
+bool DXVAVideoDecodeAccelerator::ProcessOutputSample(
+    IMFSample* sample,
+    const gfx::ColorSpace& color_space) {
   RETURN_ON_FAILURE(sample, "Decode succeeded with NULL output sample", false);
 
   LONGLONG input_buffer_id = 0;
   RETURN_ON_HR_FAILURE(sample->GetSampleTime(&input_buffer_id),
                        "Failed to get input buffer id associated with sample",
                        false);
 
   {
     base::AutoLock lock(decoder_lock_);
     DCHECK(pending_output_samples_.empty());
     pending_output_samples_.push_back(
-        PendingSampleInfo(input_buffer_id, sample));
+        PendingSampleInfo(input_buffer_id, sample, color_space));
   }
 
   if (pictures_requested_) {
     DVLOG(1) << "Waiting for picture slots from the client.";
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::ProcessPendingSamples,
                    weak_ptr_));
     return true;
   }
@@ skipping 50 matching lines @@
       }
 
       if (width != index->second->size().width() ||
           height != index->second->size().height()) {
         HandleResolutionChanged(width, height);
         return;
       }
 
       pending_sample->picture_buffer_id = index->second->id();
       index->second->set_bound();
+      index->second->set_color_space(pending_sample->color_space);
       if (share_nv12_textures_) {
         main_thread_task_runner_->PostTask(
             FROM_HERE,
             base::Bind(&DXVAVideoDecodeAccelerator::BindPictureBufferToSample,
                        weak_ptr_, pending_sample->output_sample,
                        pending_sample->picture_buffer_id,
                        pending_sample->input_buffer_id));
         continue;
       }
 
@@ skipping 133 matching lines @@
     // they need to be GL_TEXTURE_EXTERNAL_OES.
     bool provide_nv12_textures = share_nv12_textures_ || copy_nv12_textures_;
     client_->ProvidePictureBuffers(
         kNumPictureBuffers,
         provide_nv12_textures ? PIXEL_FORMAT_NV12 : PIXEL_FORMAT_UNKNOWN,
         provide_nv12_textures ? 2 : 1, gfx::Size(width, height),
         provide_nv12_textures ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D);
   }
 }
 
-void DXVAVideoDecodeAccelerator::NotifyPictureReady(int picture_buffer_id,
-                                                    int input_buffer_id) {
+void DXVAVideoDecodeAccelerator::NotifyPictureReady(
+    int picture_buffer_id,
+    int input_buffer_id,
+    const gfx::ColorSpace& color_space) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   // This task could execute after the decoder has been torn down.
   if (GetState() != kUninitialized && client_) {
     // TODO(henryhsu): Use correct visible size instead of (0, 0). We can't use
     // coded size here so use (0, 0) intentionally to have the client choose.
-    Picture picture(picture_buffer_id, input_buffer_id, gfx::Rect(0, 0), false);
+    Picture picture(picture_buffer_id, input_buffer_id, gfx::Rect(0, 0),
+                    color_space, false);
     client_->PictureReady(picture);
   }
 }
 
 void DXVAVideoDecodeAccelerator::NotifyInputBuffersDropped() {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
   if (!client_)
     return;
 
   for (PendingInputs::iterator it = pending_input_buffers_.begin();
@@ skipping 58 matching lines @@
       RETURN_AND_NOTIFY_ON_FAILURE(SendMFTMessage(MFT_MESSAGE_COMMAND_DRAIN, 0),
                                    "Failed to send drain message",
                                    PLATFORM_FAILURE, );
       sent_drain_message_ = true;
     }
   }
 
   // Attempt to retrieve an output frame from the decoder. If we have one,
   // return and proceed when the output frame is processed. If we don't have a
   // frame then we are done.
-  DoDecode();
+  DoDecode(config_change_detector_->current_color_space());
   if (OutputSamplesPresent())
     return;
 
   if (!processing_config_changed_) {
     SetState(kFlushing);
 
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&DXVAVideoDecodeAccelerator::NotifyFlushDone, weak_ptr_));
   } else {
@@ skipping 28 matching lines @@
                                   PLATFORM_FAILURE, );
 
   processing_config_changed_ = config_changed;
 
   if (config_changed) {
     pending_input_buffers_.push_back(sample);
     FlushInternal();
     return;
   }
 
+  gfx::ColorSpace color_space = config_change_detector_->current_color_space();
+
   if (!inputs_before_decode_) {
     TRACE_EVENT_ASYNC_BEGIN0("gpu", "DXVAVideoDecodeAccelerator.Decoding",
                              this);
   }
   inputs_before_decode_++;
 
   hr = decoder_->ProcessInput(0, sample.get(), 0);
   // As per msdn if the decoder returns MF_E_NOTACCEPTING then it means that it
   // has enough data to produce one or more output samples. In this case the
   // recommended options are to
   // 1. Generate new output by calling IMFTransform::ProcessOutput until it
   //    returns MF_E_TRANSFORM_NEED_MORE_INPUT.
   // 2. Flush the input data
   // We implement the first option, i.e to retrieve the output sample and then
   // process the input again. Failure in either of these steps is treated as a
   // decoder failure.
   if (hr == MF_E_NOTACCEPTING) {
-    DoDecode();
+    DoDecode(color_space);
     // If the DoDecode call resulted in an output frame then we should not
     // process any more input until that frame is copied to the target surface.
     if (!OutputSamplesPresent()) {
       State state = GetState();
       RETURN_AND_NOTIFY_ON_FAILURE(
           (state == kStopped || state == kNormal || state == kFlushing),
           "Failed to process output. Unexpected decoder state: " << state,
           PLATFORM_FAILURE, );
       hr = decoder_->ProcessInput(0, sample.get(), 0);
     }
@@ skipping 11 matching lines @@
       decoder_thread_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                      base::Unretained(this)));
       return;
     }
   }
   RETURN_AND_NOTIFY_ON_HR_FAILURE(hr, "Failed to process input sample",
                                   PLATFORM_FAILURE, );
 
-  DoDecode();
+  DoDecode(color_space);
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE(
       (state == kStopped || state == kNormal || state == kFlushing),
       "Failed to process output. Unexpected decoder state: " << state,
       ILLEGAL_STATE, );
 
   LONGLONG input_buffer_id = 0;
   RETURN_ON_HR_FAILURE(
       sample->GetSampleTime(&input_buffer_id),
@@ skipping 159 matching lines @@
   RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_cb_.Run(),
                                "Failed to make context current",
                                PLATFORM_FAILURE, );
 
   DCHECK(!output_picture_buffers_.empty());
 
   bool result = picture_buffer->CopySurfaceComplete(src_surface, dest_surface);
   RETURN_AND_NOTIFY_ON_FAILURE(result, "Failed to complete copying surface",
                                PLATFORM_FAILURE, );
 
-  NotifyPictureReady(picture_buffer->id(), input_buffer_id);
+  NotifyPictureReady(picture_buffer->id(), input_buffer_id, gfx::ColorSpace());
 
   {
     base::AutoLock lock(decoder_lock_);
     if (!pending_output_samples_.empty())
       pending_output_samples_.pop_front();
   }
 
   if (pending_flush_ || processing_config_changed_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
@@ skipping 31 matching lines @@
   RETURN_AND_NOTIFY_ON_FAILURE(make_context_current_cb_.Run(),
                                "Failed to make context current",
                                PLATFORM_FAILURE, );
 
   DCHECK(!output_picture_buffers_.empty());
 
   bool result = picture_buffer->BindSampleToTexture(sample);
   RETURN_AND_NOTIFY_ON_FAILURE(result, "Failed to complete copying surface",
                                PLATFORM_FAILURE, );
 
-  NotifyPictureReady(picture_buffer->id(), input_buffer_id);
+  NotifyPictureReady(picture_buffer->id(), input_buffer_id,
+                     picture_buffer->color_space());
 
   {
     base::AutoLock lock(decoder_lock_);
     if (!pending_output_samples_.empty())
       pending_output_samples_.pop_front();
   }
 
   if (pending_flush_ || processing_config_changed_) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::FlushInternal,
@@ skipping 366 matching lines @@
   SetState(kConfigChange);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 }  // namespace media