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

media/gpu/vaapi_wrapper.cc

 // Copyright 2013 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/vaapi_wrapper.h"
 
 #include <dlfcn.h>
 #include <string.h>
 
 #include "base/bind.h"
@@ skipping 100 matching lines @@
 };
 
 // Attributes required for encode.
 static const VAConfigAttrib kEncodeVAConfigAttribs[] = {
     {VAConfigAttribRateControl, VA_RC_CBR},
     {VAConfigAttribEncPackedHeaders,
      VA_ENC_PACKED_HEADER_SEQUENCE | VA_ENC_PACKED_HEADER_PICTURE},
 };
 
 struct ProfileMap {
-  media::VideoCodecProfile profile;
+  VideoCodecProfile profile;
   VAProfile va_profile;
 };
 
 // A map between VideoCodecProfile and VAProfile.
 static const ProfileMap kProfileMap[] = {
-    {media::H264PROFILE_BASELINE, VAProfileH264Baseline},
-    {media::H264PROFILE_MAIN, VAProfileH264Main},
+    {H264PROFILE_BASELINE, VAProfileH264Baseline},
+    {H264PROFILE_MAIN, VAProfileH264Main},
     // TODO(posciak): See if we can/want support other variants of
-    // media::H264PROFILE_HIGH*.
-    {media::H264PROFILE_HIGH, VAProfileH264High},
-    {media::VP8PROFILE_ANY, VAProfileVP8Version0_3},
+    // H264PROFILE_HIGH*.
+    {H264PROFILE_HIGH, VAProfileH264High},
+    {VP8PROFILE_ANY, VAProfileVP8Version0_3},
     // TODO(servolk): Need to add VP9 profiles 1,2,3 here after rolling
     // third_party/libva to 1.7. crbug.com/598118
-    {media::VP9PROFILE_PROFILE0, VAProfileVP9Profile0},
+    {VP9PROFILE_PROFILE0, VAProfileVP9Profile0},
 };
 
 static std::vector<VAConfigAttrib> GetRequiredAttribs(
     VaapiWrapper::CodecMode mode) {
   std::vector<VAConfigAttrib> required_attribs;
   required_attribs.insert(
       required_attribs.end(), kCommonVAConfigAttribs,
       kCommonVAConfigAttribs + arraysize(kCommonVAConfigAttribs));
   if (mode == VaapiWrapper::kEncode) {
     required_attribs.insert(
@@ skipping 52 matching lines @@
     if (vaapi_wrapper->Initialize(mode, va_profile))
       return vaapi_wrapper;
   }
   LOG(ERROR) << "Failed to create VaapiWrapper for va_profile: " << va_profile;
   return nullptr;
 }
 
 // static
 scoped_refptr<VaapiWrapper> VaapiWrapper::CreateForVideoCodec(
     CodecMode mode,
-    media::VideoCodecProfile profile,
+    VideoCodecProfile profile,
     const base::Closure& report_error_to_uma_cb) {
   VAProfile va_profile = ProfileToVAProfile(profile, mode);
   scoped_refptr<VaapiWrapper> vaapi_wrapper =
       Create(mode, va_profile, report_error_to_uma_cb);
   return vaapi_wrapper;
 }
 
 // static
-media::VideoEncodeAccelerator::SupportedProfiles
+VideoEncodeAccelerator::SupportedProfiles
 VaapiWrapper::GetSupportedEncodeProfiles() {
-  media::VideoEncodeAccelerator::SupportedProfiles profiles;
+  VideoEncodeAccelerator::SupportedProfiles profiles;
   std::vector<ProfileInfo> encode_profile_infos =
       profile_infos_.Get().GetSupportedProfileInfosForCodecMode(kEncode);
 
   for (size_t i = 0; i < arraysize(kProfileMap); ++i) {
     VAProfile va_profile = ProfileToVAProfile(kProfileMap[i].profile, kEncode);
     if (va_profile == VAProfileNone)
       continue;
     for (const auto& profile_info : encode_profile_infos) {
       if (profile_info.va_profile == va_profile) {
-        media::VideoEncodeAccelerator::SupportedProfile profile;
+        VideoEncodeAccelerator::SupportedProfile profile;
         profile.profile = kProfileMap[i].profile;
         profile.max_resolution = profile_info.max_resolution;
         profile.max_framerate_numerator = kMaxEncoderFramerate;
         profile.max_framerate_denominator = 1;
         profiles.push_back(profile);
         break;
       }
     }
   }
   return profiles;
 }
 
 // static
-media::VideoDecodeAccelerator::SupportedProfiles
+VideoDecodeAccelerator::SupportedProfiles
 VaapiWrapper::GetSupportedDecodeProfiles() {
-  media::VideoDecodeAccelerator::SupportedProfiles profiles;
+  VideoDecodeAccelerator::SupportedProfiles profiles;
   std::vector<ProfileInfo> decode_profile_infos =
       profile_infos_.Get().GetSupportedProfileInfosForCodecMode(kDecode);
 
   for (size_t i = 0; i < arraysize(kProfileMap); ++i) {
     VAProfile va_profile = ProfileToVAProfile(kProfileMap[i].profile, kDecode);
     if (va_profile == VAProfileNone)
       continue;
     for (const auto& profile_info : decode_profile_infos) {
       if (profile_info.va_profile == va_profile) {
-        media::VideoDecodeAccelerator::SupportedProfile profile;
+        VideoDecodeAccelerator::SupportedProfile profile;
         profile.profile = kProfileMap[i].profile;
         profile.max_resolution = profile_info.max_resolution;
         profile.min_resolution.SetSize(16, 16);
         profiles.push_back(profile);
         break;
       }
     }
   }
   return profiles;
 }
@@ skipping 11 matching lines @@
                              -1,  // The maximum possible support 'ALL'.
                              VA_RENDER_MODE_LOCAL_GPU,
                              VA_DISPLAY_ATTRIB_SETTABLE};
 
   VAStatus va_res = vaSetDisplayAttributes(va_display_, &item, 1);
   if (va_res != VA_STATUS_SUCCESS)
     DVLOG(2) << "vaSetDisplayAttributes unsupported, ignoring by default.";
 }
 
 // static
-VAProfile VaapiWrapper::ProfileToVAProfile(media::VideoCodecProfile profile,
+VAProfile VaapiWrapper::ProfileToVAProfile(VideoCodecProfile profile,
                                            CodecMode mode) {
   VAProfile va_profile = VAProfileNone;
   for (size_t i = 0; i < arraysize(kProfileMap); ++i) {
     if (kProfileMap[i].profile == profile) {
       va_profile = kProfileMap[i].va_profile;
       break;
     }
   }
   if (!profile_infos_.Get().IsProfileSupported(mode, va_profile) &&
       va_profile == VAProfileH264Baseline) {
-    // crbug.com/345569: media::ProfileIDToVideoCodecProfile() currently strips
+    // crbug.com/345569: ProfileIDToVideoCodecProfile() currently strips
     // the information whether the profile is constrained or not, so we have no
     // way to know here. Try for baseline first, but if it is not supported,
     // try constrained baseline and hope this is what it actually is
     // (which in practice is true for a great majority of cases).
     if (profile_infos_.Get().IsProfileSupported(
             mode, VAProfileH264ConstrainedBaseline)) {
       va_profile = VAProfileH264ConstrainedBaseline;
       DVLOG(1) << "Fall back to constrained baseline profile.";
     }
   }
@@ skipping 614 matching lines @@
   va_res = vaDestroyImage(va_display_, image->image_id);
   VA_LOG_ON_ERROR(va_res, "vaDestroyImage failed");
 }
 
 static void DestroyVAImage(VADisplay va_display, VAImage image) {
   if (image.image_id != VA_INVALID_ID)
     vaDestroyImage(va_display, image.image_id);
 }
 
 bool VaapiWrapper::UploadVideoFrameToSurface(
-    const scoped_refptr<media::VideoFrame>& frame,
+    const scoped_refptr<VideoFrame>& frame,
     VASurfaceID va_surface_id) {
   base::AutoLock auto_lock(*va_lock_);
 
   VAImage image;
   VAStatus va_res = vaDeriveImage(va_display_, va_surface_id, &image);
   VA_SUCCESS_OR_RETURN(va_res, "vaDeriveImage failed", false);
   base::ScopedClosureRunner vaimage_deleter(
       base::Bind(&DestroyVAImage, va_display_, image));
 
   if (image.format.fourcc != VA_FOURCC_NV12) {
     LOG(ERROR) << "Unsupported image format: " << image.format.fourcc;
     return false;
   }
 
   if (gfx::Rect(image.width, image.height) < gfx::Rect(frame->coded_size())) {
     LOG(ERROR) << "Buffer too small to fit the frame.";
     return false;
   }
 
   void* image_ptr = NULL;
   va_res = vaMapBuffer(va_display_, image.buf, &image_ptr);
   VA_SUCCESS_OR_RETURN(va_res, "vaMapBuffer failed", false);
   DCHECK(image_ptr);
 
   int ret = 0;
   {
     base::AutoUnlock auto_unlock(*va_lock_);
     ret = libyuv::I420ToNV12(
-        frame->data(media::VideoFrame::kYPlane),
-        frame->stride(media::VideoFrame::kYPlane),
-        frame->data(media::VideoFrame::kUPlane),
-        frame->stride(media::VideoFrame::kUPlane),
-        frame->data(media::VideoFrame::kVPlane),
-        frame->stride(media::VideoFrame::kVPlane),
+        frame->data(VideoFrame::kYPlane), frame->stride(VideoFrame::kYPlane),
+        frame->data(VideoFrame::kUPlane), frame->stride(VideoFrame::kUPlane),
+        frame->data(VideoFrame::kVPlane), frame->stride(VideoFrame::kVPlane),
         static_cast<uint8_t*>(image_ptr) + image.offsets[0], image.pitches[0],
         static_cast<uint8_t*>(image_ptr) + image.offsets[1], image.pitches[1],
         image.width, image.height);
   }
 
   va_res = vaUnmapBuffer(va_display_, image.buf);
   VA_LOG_ON_ERROR(va_res, "vaUnmapBuffer failed");
 
   return ret == 0;
 }
@@ skipping 263 matching lines @@
   drm_fd_.reset(HANDLE_EINTR(dup(fd)));
 }
 #endif  // USE_OZONE
 
 bool VaapiWrapper::VADisplayState::VAAPIVersionLessThan(int major, int minor) {
   return (major_version_ < major) ||
          (major_version_ == major && minor_version_ < minor);
 }
 
 }  // namespace media