use VideoColorSpace in decoder configuration

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 433 matching lines @@
         config_changed_ = true;
       } else {
         pending_config_changed_ = true;
       }
     }
     last_pps_.swap(pps);
   }
   return true;
 }
 
-gfx::ColorSpace H264ConfigChangeDetector::current_color_space() const {
+VideoColorSpace H264ConfigChangeDetector::current_color_space() const {
   if (!parser_)
-    return gfx::ColorSpace();
+    return VideoColorSpace();
   // 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();
+  return VideoColorSpace();
 }
 
 DXVAVideoDecodeAccelerator::PendingSampleInfo::PendingSampleInfo(
     int32_t buffer_id,
     base::win::ScopedComPtr<IMFSample> sample,
     const gfx::ColorSpace& color_space)
     : input_buffer_id(buffer_id),
       picture_buffer_id(-1),
       color_space(color_space),
       output_sample(sample) {}
@@ skipping 1694 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.
-  gfx::ColorSpace color_space = config_change_detector_->current_color_space();
-  if (!color_space.IsValid())
+  VideoColorSpace color_space = config_change_detector_->current_color_space();
+  if (color_space == VideoColorSpace())
     color_space = config_.color_space;
-  DoDecode(color_space);
+  DoDecode(color_space.ToGfxColorSpace());
   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 (!color_space.IsValid())
+  VideoColorSpace color_space = config_change_detector_->current_color_space();
+  if (color_space == VideoColorSpace())
     color_space = config_.color_space;
 
   if (!inputs_before_decode_) {
     TRACE_EVENT_ASYNC_BEGIN0("gpu", "DXVAVideoDecodeAccelerator.Decoding",
                              this);
   }
   inputs_before_decode_++;
   {
     ScopedExceptionCatcher catcher(using_ms_vp9_mft_);
     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(color_space);
+    DoDecode(color_space.ToGfxColorSpace());
     // 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(color_space);
+  DoDecode(color_space.ToGfxColorSpace());
 
   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 659 matching lines @@
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 uint32_t DXVAVideoDecodeAccelerator::GetTextureTarget() const {
   bool provide_nv12_textures = share_nv12_textures_ || copy_nv12_textures_;
   return provide_nv12_textures ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
 }
 
 }  // namespace media