Migrate content/common/gpu/media code to media/gpu

media/gpu/vaapi_wrapper.h

 // 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.
 //
 // This file contains an implementation of VaapiWrapper, used by
 // VaapiVideoDecodeAccelerator and VaapiH264Decoder for decode,
 // and VaapiVideoEncodeAccelerator for encode, to interface
 // with libva (VA-API library for hardware video codec).
 
-#ifndef CONTENT_COMMON_GPU_MEDIA_VAAPI_WRAPPER_H_
-#define CONTENT_COMMON_GPU_MEDIA_VAAPI_WRAPPER_H_
+#ifndef MEDIA_GPU_VAAPI_WRAPPER_H_
+#define MEDIA_GPU_VAAPI_WRAPPER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
-#include "content/common/content_export.h"
-#include "content/common/gpu/media/va_surface.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
+#include "media/gpu/media_gpu_export.h"
+#include "media/gpu/va_surface.h"
 #include "media/video/jpeg_decode_accelerator.h"
 #include "media/video/video_decode_accelerator.h"
 #include "media/video/video_encode_accelerator.h"
 #include "third_party/libva/va/va.h"
 #include "third_party/libva/va/va_vpp.h"
 #include "ui/gfx/geometry/size.h"
+
 #if defined(USE_X11)
 #include "third_party/libva/va/va_x11.h"
 #endif  // USE_X11
 
 #if defined(USE_OZONE)
 namespace ui {
 class NativePixmap;
 }
 #endif
 
-namespace content {
+namespace media {
 
 // This class handles VA-API calls and ensures proper locking of VA-API calls
 // to libva, the userspace shim to the HW codec driver. libva is not
 // thread-safe, so we have to perform locking ourselves. This class is fully
 // synchronous and its methods can be called from any thread and may wait on
 // the va_lock_ while other, concurrent calls run.
 //
 // This class is responsible for managing VAAPI connection, contexts and state.
 // It is also responsible for managing and freeing VABuffers (not VASurfaces),
 // which are used to queue parameters and slice data to the HW codec,
 // as well as underlying memory for VASurfaces themselves.
-class CONTENT_EXPORT VaapiWrapper
+class MEDIA_GPU_EXPORT VaapiWrapper
     : public base::RefCountedThreadSafe<VaapiWrapper> {
  public:
   enum CodecMode {
     kDecode,
     kEncode,
     kCodecModeMax,
   };
 
   // Return an instance of VaapiWrapper initialized for |va_profile| and
   // |mode|. |report_error_to_uma_cb| will be called independently from
   // reporting errors to clients via method return values.
   static scoped_refptr<VaapiWrapper> Create(
       CodecMode mode,
       VAProfile va_profile,
       const base::Closure& report_error_to_uma_cb);
 
   // Create VaapiWrapper for VideoCodecProfile. It maps VideoCodecProfile
   // |profile| to VAProfile.
   // |report_error_to_uma_cb| will be called independently from reporting
   // errors to clients via method return values.
   static scoped_refptr<VaapiWrapper> CreateForVideoCodec(
       CodecMode mode,
       media::VideoCodecProfile profile,
       const base::Closure& report_error_to_uma_cb);
 
   // Return the supported video encode profiles.
   static media::VideoEncodeAccelerator::SupportedProfiles
-      GetSupportedEncodeProfiles();
+  GetSupportedEncodeProfiles();
 
   // Return the supported video decode profiles.
   static media::VideoDecodeAccelerator::SupportedProfiles
-      GetSupportedDecodeProfiles();
+  GetSupportedDecodeProfiles();
 
   // Return true when JPEG decode is supported.
   static bool IsJpegDecodeSupported();
 
   // Create |num_surfaces| backing surfaces in driver for VASurfaces of
   // |va_format|, each of size |size|. Returns true when successful, with the
   // created IDs in |va_surfaces| to be managed and later wrapped in
   // VASurfaces.
   // The client must DestroySurfaces() each time before calling this method
   // again to free the allocated surfaces first, but is not required to do so
@@ skipping 203 matching lines @@
   // Return true if |va_profile| for |entrypoint| with |required_attribs| is
   // supported. |va_lock_| must be held on entry.
   bool AreAttribsSupported_Locked(
       VAProfile va_profile,
       VAEntrypoint entrypoint,
       const std::vector<VAConfigAttrib>& required_attribs);
 
   // Get maximum resolution for |va_profile| and |entrypoint| with
   // |required_attribs|. If return value is true, |resolution| is the maximum
   // resolution. |va_lock_| must be held on entry.
-  bool GetMaxResolution_Locked(
-      VAProfile va_profile,
-      VAEntrypoint entrypoint,
-      std::vector<VAConfigAttrib>& required_attribs,
-      gfx::Size* resolution);
+  bool GetMaxResolution_Locked(VAProfile va_profile,
+                               VAEntrypoint entrypoint,
+                               std::vector<VAConfigAttrib>& required_attribs,
+                               gfx::Size* resolution);
 
   // Destroys a |va_surface| created using CreateUnownedSurface.
   void DestroyUnownedSurface(VASurfaceID va_surface_id);
 
   // Initialize the video post processing context with the |size| of
   // the input pictures to be processed.
   bool InitializeVpp_Locked();
 
   // Deinitialize the video post processing context.
   void DeinitializeVpp();
@@ skipping 59 matching lines @@
   VAContextID va_vpp_context_id_;
   VABufferID va_vpp_buffer_id_;
 
   // Singleton variable to store supported profile information for encode and
   // decode.
   static base::LazyInstance<LazyProfileInfos> profile_infos_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiWrapper);
 };
 
-}  // namespace content
+}  // namespace media
 
-#endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_WRAPPER_H_
+#endif  // MEDIA_GPU_VAAPI_WRAPPER_H_