media: Drop "media::" in media/gpu

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 200 matching lines @@
   DWORD max_length_;
   DWORD current_length_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaBufferScopedPointer);
 };
 
 }  // namespace
 
 namespace media {
 
-static const media::VideoCodecProfile kSupportedProfiles[] = {
-    media::H264PROFILE_BASELINE, media::H264PROFILE_MAIN,
-    media::H264PROFILE_HIGH,     media::VP8PROFILE_ANY,
-    media::VP9PROFILE_PROFILE0,  media::VP9PROFILE_PROFILE1,
-    media::VP9PROFILE_PROFILE2,  media::VP9PROFILE_PROFILE3};
+static const VideoCodecProfile kSupportedProfiles[] = {
+    H264PROFILE_BASELINE, H264PROFILE_MAIN,    H264PROFILE_HIGH,
+    VP8PROFILE_ANY,       VP9PROFILE_PROFILE0, VP9PROFILE_PROFILE1,
+    VP9PROFILE_PROFILE2,  VP9PROFILE_PROFILE3};
 
 CreateDXGIDeviceManager
     DXVAVideoDecodeAccelerator::create_dxgi_device_manager_ = NULL;
 
 #define RETURN_ON_FAILURE(result, log, ret) \
   do {                                      \
     if (!(result)) {                        \
       DLOG(ERROR) << log;                   \
       return ret;                           \
     }                                       \
@@ skipping 217 matching lines @@
       last_pps_id_(0),
       config_changed_(false),
       pending_config_changed_(false) {}
 
 H264ConfigChangeDetector::~H264ConfigChangeDetector() {}
 
 bool H264ConfigChangeDetector::DetectConfig(const uint8_t* stream,
                                             unsigned int size) {
   std::vector<uint8_t> sps;
   std::vector<uint8_t> pps;
-  media::H264NALU nalu;
+  H264NALU nalu;
   bool idr_seen = false;
 
   if (!parser_.get())
-    parser_.reset(new media::H264Parser);
+    parser_.reset(new H264Parser);
 
   parser_->SetStream(stream, size);
   config_changed_ = false;
 
   while (true) {
-    media::H264Parser::Result result = parser_->AdvanceToNextNALU(&nalu);
+    H264Parser::Result result = parser_->AdvanceToNextNALU(&nalu);
 
-    if (result == media::H264Parser::kEOStream)
+    if (result == H264Parser::kEOStream)
       break;
 
-    if (result == media::H264Parser::kUnsupportedStream) {
+    if (result == H264Parser::kUnsupportedStream) {
       DLOG(ERROR) << "Unsupported H.264 stream";
       return false;
     }
 
-    if (result != media::H264Parser::kOk) {
+    if (result != H264Parser::kOk) {
       DLOG(ERROR) << "Failed to parse H.264 stream";
       return false;
     }
 
     switch (nalu.nal_unit_type) {
-      case media::H264NALU::kSPS:
+      case H264NALU::kSPS:
         result = parser_->ParseSPS(&last_sps_id_);
-        if (result == media::H264Parser::kUnsupportedStream) {
+        if (result == H264Parser::kUnsupportedStream) {
           DLOG(ERROR) << "Unsupported SPS";
           return false;
         }
 
-        if (result != media::H264Parser::kOk) {
+        if (result != H264Parser::kOk) {
           DLOG(ERROR) << "Could not parse SPS";
           return false;
         }
 
         sps.assign(nalu.data, nalu.data + nalu.size);
         break;
 
-      case media::H264NALU::kPPS:
+      case H264NALU::kPPS:
         result = parser_->ParsePPS(&last_pps_id_);
-        if (result == media::H264Parser::kUnsupportedStream) {
+        if (result == H264Parser::kUnsupportedStream) {
           DLOG(ERROR) << "Unsupported PPS";
           return false;
         }
-        if (result != media::H264Parser::kOk) {
+        if (result != H264Parser::kOk) {
           DLOG(ERROR) << "Could not parse PPS";
           return false;
         }
         pps.assign(nalu.data, nalu.data + nalu.size);
         break;
 
-      case media::H264NALU::kIDRSlice:
+      case H264NALU::kIDRSlice:
         idr_seen = true;
         // If we previously detected a configuration change, and see an IDR
         // slice next time around, we need to flag a configuration change.
         if (pending_config_changed_) {
           config_changed_ = true;
           pending_config_changed_ = false;
         }
         break;
 
       default:
@@ skipping 47 matching lines @@
     : client_(NULL),
       dev_manager_reset_token_(0),
       dx11_dev_manager_reset_token_(0),
       egl_config_(NULL),
       state_(kUninitialized),
       pictures_requested_(false),
       inputs_before_decode_(0),
       sent_drain_message_(false),
       get_gl_context_cb_(get_gl_context_cb),
       make_context_current_cb_(make_context_current_cb),
-      codec_(media::kUnknownVideoCodec),
+      codec_(kUnknownVideoCodec),
       decoder_thread_("DXVAVideoDecoderThread"),
       pending_flush_(false),
       share_nv12_textures_(gpu_preferences.enable_zero_copy_dxgi_video),
       use_dx11_(false),
       use_keyed_mutex_(false),
       dx11_video_format_converter_media_type_needs_init_(true),
       using_angle_device_(false),
       enable_accelerated_vpx_decode_(
           gpu_preferences.enable_accelerated_vpx_decode),
       weak_this_factory_(this) {
@@ skipping 77 matching lines @@
 
   RETURN_AND_NOTIFY_ON_FAILURE(gl::GLFence::IsSupported(),
                                "GL fences are unsupported", PLATFORM_FAILURE,
                                false);
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state == kUninitialized),
                                "Initialize: invalid state: " << state,
                                ILLEGAL_STATE, false);
 
-  media::InitializeMediaFoundation();
+  InitializeMediaFoundation();
 
   RETURN_AND_NOTIFY_ON_FAILURE(InitDecoder(config.profile),
                                "Failed to initialize decoder", PLATFORM_FAILURE,
                                false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(GetStreamsInfoAndBufferReqs(),
                                "Failed to get input/output stream info.",
                                PLATFORM_FAILURE, false);
 
   RETURN_AND_NOTIFY_ON_FAILURE(
@@ skipping 154 matching lines @@
   RETURN_ON_HR_FAILURE(
       hr, "Failed to set MF_XVP_PLAYBACK_MODE attribute on converter", false);
 
   hr = converter_attributes->SetUINT32(MF_LOW_LATENCY, FALSE);
   RETURN_ON_HR_FAILURE(
       hr, "Failed to set MF_LOW_LATENCY attribute on converter", false);
   return true;
 }
 
 void DXVAVideoDecodeAccelerator::Decode(
-    const media::BitstreamBuffer& bitstream_buffer) {
+    const BitstreamBuffer& bitstream_buffer) {
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::Decode");
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   // SharedMemory will take over the ownership of handle.
   base::SharedMemory shm(bitstream_buffer.handle(), true);
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE(
       (state == kNormal || state == kStopped || state == kFlushing),
       "Invalid state: " << state, ILLEGAL_STATE, );
@@ skipping 18 matching lines @@
   RETURN_AND_NOTIFY_ON_HR_FAILURE(
       sample->SetSampleTime(bitstream_buffer.id()),
       "Failed to associate input buffer id with sample", PLATFORM_FAILURE, );
 
   decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::DecodeInternal,
                             base::Unretained(this), sample));
 }
 
 void DXVAVideoDecodeAccelerator::AssignPictureBuffers(
-    const std::vector<media::PictureBuffer>& buffers) {
+    const std::vector<PictureBuffer>& buffers) {
   DCHECK(main_thread_task_runner_->BelongsToCurrentThread());
 
   State state = GetState();
   RETURN_AND_NOTIFY_ON_FAILURE((state != kUninitialized),
                                "Invalid state: " << state, ILLEGAL_STATE, );
   RETURN_AND_NOTIFY_ON_FAILURE(
       (kNumPictureBuffers >= buffers.size()),
       "Failed to provide requested picture buffers. (Got "
           << buffers.size() << ", requested " << kNumPictureBuffers << ")",
       INVALID_ARGUMENT, );
@@ skipping 193 matching lines @@
     const base::WeakPtr<Client>& decode_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
 GLenum DXVAVideoDecodeAccelerator::GetSurfaceInternalFormat() const {
   return GL_BGRA_EXT;
 }
 
 // static
-media::VideoDecodeAccelerator::SupportedProfiles
+VideoDecodeAccelerator::SupportedProfiles
 DXVAVideoDecodeAccelerator::GetSupportedProfiles() {
   TRACE_EVENT0("gpu,startup",
                "DXVAVideoDecodeAccelerator::GetSupportedProfiles");
 
   // TODO(henryhsu): Need to ensure the profiles are actually supported.
   SupportedProfiles profiles;
   for (const auto& supported_profile : kSupportedProfiles) {
     std::pair<int, int> min_resolution = GetMinResolution(supported_profile);
     std::pair<int, int> max_resolution = GetMaxResolution(supported_profile);
 
@@ skipping 17 matching lines @@
     LoadLibrary(L"msvproc.dll");
   } else {
 #if defined(ENABLE_DX11_FOR_WIN7)
     LoadLibrary(L"mshtmlmedia.dll");
 #endif
   }
 }
 
 // static
 std::pair<int, int> DXVAVideoDecodeAccelerator::GetMinResolution(
-    media::VideoCodecProfile profile) {
+    VideoCodecProfile profile) {
   TRACE_EVENT0("gpu,startup", "DXVAVideoDecodeAccelerator::GetMinResolution");
   std::pair<int, int> min_resolution;
-  if (profile >= media::H264PROFILE_BASELINE &&
-      profile <= media::H264PROFILE_HIGH) {
+  if (profile >= H264PROFILE_BASELINE && profile <= H264PROFILE_HIGH) {
     // Windows Media Foundation H.264 decoding does not support decoding videos
     // with any dimension smaller than 48 pixels:
     // http://msdn.microsoft.com/en-us/library/windows/desktop/dd797815
     min_resolution = std::make_pair(48, 48);
   } else {
     // TODO(ananta)
     // Detect this properly for VP8/VP9 profiles.
     min_resolution = std::make_pair(16, 16);
   }
   return min_resolution;
 }
 
 // static
 std::pair<int, int> DXVAVideoDecodeAccelerator::GetMaxResolution(
-    const media::VideoCodecProfile profile) {
+    const VideoCodecProfile profile) {
   TRACE_EVENT0("gpu,startup", "DXVAVideoDecodeAccelerator::GetMaxResolution");
   std::pair<int, int> max_resolution;
-  if (profile >= media::H264PROFILE_BASELINE &&
-      profile <= media::H264PROFILE_HIGH) {
+  if (profile >= H264PROFILE_BASELINE && profile <= H264PROFILE_HIGH) {
     max_resolution = GetMaxH264Resolution();
   } else {
     // TODO(ananta)
     // Detect this properly for VP8/VP9 profiles.
     max_resolution = std::make_pair(4096, 2160);
   }
   return max_resolution;
 }
 
 std::pair<int, int> DXVAVideoDecodeAccelerator::GetMaxH264Resolution() {
@@ skipping 154 matching lines @@
       for (size_t i = 0; i < arraysize(g_IntelLegacyGPUList); i++) {
         if (adapter_desc.DeviceId == g_IntelLegacyGPUList[i])
           return legacy_gpu;
       }
     }
   }
   legacy_gpu = false;
   return legacy_gpu;
 }
 
-bool DXVAVideoDecodeAccelerator::InitDecoder(media::VideoCodecProfile profile) {
+bool DXVAVideoDecodeAccelerator::InitDecoder(VideoCodecProfile profile) {
   HMODULE decoder_dll = NULL;
 
   CLSID clsid = {};
 
   // Profile must fall within the valid range for one of the supported codecs.
-  if (profile >= media::H264PROFILE_MIN && profile <= media::H264PROFILE_MAX) {
+  if (profile >= H264PROFILE_MIN && profile <= H264PROFILE_MAX) {
     // We mimic the steps CoCreateInstance uses to instantiate the object. This
     // was previously done because it failed inside the sandbox, and now is done
     // as a more minimal approach to avoid other side-effects CCI might have (as
     // we are still in a reduced sandbox).
     decoder_dll = ::GetModuleHandle(L"msmpeg2vdec.dll");
     RETURN_ON_FAILURE(decoder_dll,
                       "msmpeg2vdec.dll required for decoding is not loaded",
                       false);
 
     // Check version of DLL, version 6.1.7140 is blacklisted due to high crash
     // rates in browsers loading that DLL. If that is the version installed we
     // fall back to software decoding. See crbug/403440.
     std::unique_ptr<FileVersionInfo> version_info(
         FileVersionInfo::CreateFileVersionInfoForModule(decoder_dll));
     RETURN_ON_FAILURE(version_info, "unable to get version of msmpeg2vdec.dll",
                       false);
     base::string16 file_version = version_info->file_version();
     RETURN_ON_FAILURE(file_version.find(L"6.1.7140") == base::string16::npos,
                       "blacklisted version of msmpeg2vdec.dll 6.1.7140", false);
-    codec_ = media::kCodecH264;
+    codec_ = kCodecH264;
     clsid = __uuidof(CMSH264DecoderMFT);
   } else if (enable_accelerated_vpx_decode_ &&
-             (profile == media::VP8PROFILE_ANY ||
-              profile == media::VP9PROFILE_PROFILE0 ||
-              profile == media::VP9PROFILE_PROFILE1 ||
-              profile == media::VP9PROFILE_PROFILE2 ||
-              profile == media::VP9PROFILE_PROFILE3)) {
+             (profile == VP8PROFILE_ANY || profile == VP9PROFILE_PROFILE0 ||
+              profile == VP9PROFILE_PROFILE1 ||
+              profile == VP9PROFILE_PROFILE2 ||
+              profile == VP9PROFILE_PROFILE3)) {
     int program_files_key = base::DIR_PROGRAM_FILES;
     if (base::win::OSInfo::GetInstance()->wow64_status() ==
         base::win::OSInfo::WOW64_ENABLED) {
       program_files_key = base::DIR_PROGRAM_FILES6432;
     }
 
     base::FilePath dll_path;
     RETURN_ON_FAILURE(PathService::Get(program_files_key, &dll_path),
                       "failed to get path for Program Files", false);
 
     dll_path = dll_path.Append(kVPXDecoderDLLPath);
-    if (profile == media::VP8PROFILE_ANY) {
-      codec_ = media::kCodecVP8;
+    if (profile == VP8PROFILE_ANY) {
+      codec_ = kCodecVP8;
       dll_path = dll_path.Append(kVP8DecoderDLLName);
       clsid = CLSID_WebmMfVp8Dec;
     } else {
-      codec_ = media::kCodecVP9;
+      codec_ = kCodecVP9;
       dll_path = dll_path.Append(kVP9DecoderDLLName);
       clsid = CLSID_WebmMfVp9Dec;
     }
     decoder_dll = ::LoadLibraryEx(dll_path.value().data(), NULL,
                                   LOAD_WITH_ALTERED_SEARCH_PATH);
     RETURN_ON_FAILURE(decoder_dll, "vpx decoder dll is not loaded", false);
   } else {
     RETURN_ON_FAILURE(false, "Unsupported codec.", false);
   }
 
@@ skipping 48 matching lines @@
 
 bool DXVAVideoDecodeAccelerator::CheckDecoderDxvaSupport() {
   base::win::ScopedComPtr<IMFAttributes> attributes;
   HRESULT hr = decoder_->GetAttributes(attributes.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get decoder attributes", false);
 
   UINT32 dxva = 0;
   hr = attributes->GetUINT32(MF_SA_D3D_AWARE, &dxva);
   RETURN_ON_HR_FAILURE(hr, "Failed to check if decoder supports DXVA", false);
 
-  if (codec_ == media::kCodecH264) {
+  if (codec_ == kCodecH264) {
     hr = attributes->SetUINT32(CODECAPI_AVDecVideoAcceleration_H264, TRUE);
     RETURN_ON_HR_FAILURE(hr, "Failed to enable DXVA H/W decoding", false);
   }
 
   hr = attributes->SetUINT32(CODECAPI_AVLowLatencyMode, TRUE);
   if (SUCCEEDED(hr)) {
     DVLOG(1) << "Successfully set Low latency mode on decoder.";
   } else {
     DVLOG(1) << "Failed to set Low latency mode on decoder. Error: " << hr;
   }
@@ skipping 34 matching lines @@
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderInputMediaType() {
   base::win::ScopedComPtr<IMFMediaType> media_type;
   HRESULT hr = MFCreateMediaType(media_type.Receive());
   RETURN_ON_HR_FAILURE(hr, "MFCreateMediaType failed", false);
 
   hr = media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Video);
   RETURN_ON_HR_FAILURE(hr, "Failed to set major input type", false);
 
-  if (codec_ == media::kCodecH264) {
+  if (codec_ == kCodecH264) {
     hr = media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264);
-  } else if (codec_ == media::kCodecVP8) {
+  } else if (codec_ == kCodecVP8) {
     hr = media_type->SetGUID(MF_MT_SUBTYPE, MEDIASUBTYPE_VP80);
-  } else if (codec_ == media::kCodecVP9) {
+  } else if (codec_ == kCodecVP9) {
     hr = media_type->SetGUID(MF_MT_SUBTYPE, MEDIASUBTYPE_VP90);
   } else {
     NOTREACHED();
     RETURN_ON_FAILURE(false, "Unsupported codec on input media type.", false);
   }
   RETURN_ON_HR_FAILURE(hr, "Failed to set subtype", false);
 
   // Not sure about this. msdn recommends setting this value on the input
   // media type.
   hr = media_type->SetUINT32(MF_MT_INTERLACE_MODE,
@@ skipping 32 matching lines @@
 // sure they're the correct size. We only provide decoding if DXVA is enabled.
 bool DXVAVideoDecodeAccelerator::GetStreamsInfoAndBufferReqs() {
   HRESULT hr = decoder_->GetInputStreamInfo(0, &input_stream_info_);
   RETURN_ON_HR_FAILURE(hr, "Failed to get input stream info", false);
 
   hr = decoder_->GetOutputStreamInfo(0, &output_stream_info_);
   RETURN_ON_HR_FAILURE(hr, "Failed to get decoder output stream info", false);
 
   DVLOG(1) << "Input stream info: ";
   DVLOG(1) << "Max latency: " << input_stream_info_.hnsMaxLatency;
-  if (codec_ == media::kCodecH264) {
+  if (codec_ == kCodecH264) {
     // There should be three flags, one for requiring a whole frame be in a
     // single sample, one for requiring there be one buffer only in a single
     // sample, and one that specifies a fixed sample size. (as in cbSize)
     CHECK_EQ(input_stream_info_.dwFlags, 0x7u);
   }
 
   DVLOG(1) << "Min buffer size: " << input_stream_info_.cbSize;
   DVLOG(1) << "Max lookahead: " << input_stream_info_.cbMaxLookahead;
   DVLOG(1) << "Alignment: " << input_stream_info_.cbAlignment;
 
   DVLOG(1) << "Output stream info: ";
   // The flags here should be the same and mean the same thing, except when
   // DXVA is enabled, there is an extra 0x100 flag meaning decoder will
   // allocate its own sample.
   DVLOG(1) << "Flags: " << std::hex << std::showbase
            << output_stream_info_.dwFlags;
-  if (codec_ == media::kCodecH264) {
+  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() {
   TRACE_EVENT0("media", "DXVAVideoDecodeAccelerator::DoDecode");
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
@@ skipping 174 matching lines @@
           index->second->CopyOutputSampleDataToPictureBuffer(
               this, surface.get(), d3d11_texture.get(),
               pending_sample->input_buffer_id),
           "Failed to copy output sample", PLATFORM_FAILURE, );
 
     }
   }
 }
 
 void DXVAVideoDecodeAccelerator::StopOnError(
-    media::VideoDecodeAccelerator::Error error) {
+    VideoDecodeAccelerator::Error error) {
   if (!main_thread_task_runner_->BelongsToCurrentThread()) {
     main_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DXVAVideoDecodeAccelerator::StopOnError,
                               weak_this_factory_.GetWeakPtr(), error));
     return;
   }
 
   if (client_)
     client_->NotifyError(error);
   client_ = NULL;
@@ skipping 92 matching lines @@
   }
 }
 
 void DXVAVideoDecodeAccelerator::NotifyPictureReady(int picture_buffer_id,
                                                     int input_buffer_id) {
   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.
-    media::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), 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 712 matching lines @@
       RETURN_ON_HR_FAILURE(hr, "Failed to set output type", false);
       return true;
     }
     media_type.Release();
   }
   return false;
 }
 
 HRESULT DXVAVideoDecodeAccelerator::CheckConfigChanged(IMFSample* sample,
                                                        bool* config_changed) {
-  if (codec_ != media::kCodecH264)
+  if (codec_ != kCodecH264)
     return S_FALSE;
 
   base::win::ScopedComPtr<IMFMediaBuffer> buffer;
   HRESULT hr = sample->GetBufferByIndex(0, buffer.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from input sample", hr);
 
   MediaBufferScopedPointer scoped_media_buffer(buffer.get());
 
   if (!config_change_detector_->DetectConfig(
           scoped_media_buffer.get(), scoped_media_buffer.current_length())) {
@@ skipping 10 matching lines @@
   SetState(kConfigChange);
   Invalidate();
   Initialize(config_, client_);
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DXVAVideoDecodeAccelerator::DecodePendingInputBuffers,
                  base::Unretained(this)));
 }
 
 }  // namespace media