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

media/gpu/dxva_video_decode_accelerator_win.h

 // 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.
 
 #ifndef MEDIA_GPU_DXVA_VIDEO_DECODE_ACCELERATOR_WIN_H_
 #define MEDIA_GPU_DXVA_VIDEO_DECODE_ACCELERATOR_WIN_H_
 
 #include <d3d11.h>
 #include <d3d9.h>
 #include <initguid.h>
@@ skipping 67 matching lines @@
   std::vector<uint8_t> last_sps_;
   int last_pps_id_;
   std::vector<uint8_t> last_pps_;
   // Set to true if we detect a stream configuration change.
   bool config_changed_;
   // We want to indicate configuration changes only after we see IDR slices.
   // This flag tracks that we potentially have a configuration change which
   // we want to honor after we see an IDR slice.
   bool pending_config_changed_;
 
-  std::unique_ptr<media::H264Parser> parser_;
+  std::unique_ptr<H264Parser> parser_;
 
   DISALLOW_COPY_AND_ASSIGN(H264ConfigChangeDetector);
 };
 
 // Class to provide a DXVA 2.0 based accelerator using the Microsoft Media
 // foundation APIs via the VideoDecodeAccelerator interface.
 // This class lives on a single thread and DCHECKs that it is never accessed
 // from any other.
 class MEDIA_GPU_EXPORT DXVAVideoDecodeAccelerator
-    : public media::VideoDecodeAccelerator {
+    : public VideoDecodeAccelerator {
  public:
   enum State {
     kUninitialized,  // un-initialized.
     kNormal,         // normal playing state.
     kResetting,      // upon received Reset(), before ResetDone()
     kStopped,        // upon output EOS received.
     kFlushing,       // upon flush request received.
     kConfigChange,   // stream configuration change detected.
   };
 
   // Does not take ownership of |client| which must outlive |*this|.
   DXVAVideoDecodeAccelerator(
       const GetGLContextCallback& get_gl_context_cb,
       const MakeGLContextCurrentCallback& make_context_current_cb,
       const gpu::GpuPreferences& gpu_preferences);
   ~DXVAVideoDecodeAccelerator() override;
 
-  // media::VideoDecodeAccelerator implementation.
+  // VideoDecodeAccelerator implementation.
   bool Initialize(const Config& config, Client* client) override;
-  void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
-  void AssignPictureBuffers(
-      const std::vector<media::PictureBuffer>& buffers) override;
+  void Decode(const BitstreamBuffer& bitstream_buffer) override;
+  void AssignPictureBuffers(const std::vector<PictureBuffer>& buffers) override;
   void ReusePictureBuffer(int32_t picture_buffer_id) override;
   void Flush() override;
   void Reset() override;
   void Destroy() override;
   bool TryToSetupDecodeOnSeparateThread(
       const base::WeakPtr<Client>& decode_client,
       const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner)
       override;
   GLenum GetSurfaceInternalFormat() const override;
 
-  static media::VideoDecodeAccelerator::SupportedProfiles
-  GetSupportedProfiles();
+  static VideoDecodeAccelerator::SupportedProfiles GetSupportedProfiles();
 
   // Preload dlls required for decoding.
   static void PreSandboxInitialization();
 
  private:
   friend class DXVAPictureBuffer;
   friend class EGLStreamPictureBuffer;
   friend class PbufferPictureBuffer;
   typedef void* EGLConfig;
   typedef void* EGLSurface;
 
   // Returns the minimum resolution for the |profile| passed in.
-  static std::pair<int, int> GetMinResolution(
-      const media::VideoCodecProfile profile);
+  static std::pair<int, int> GetMinResolution(const VideoCodecProfile profile);
 
   // Returns the maximum resolution for the |profile| passed in.
-  static std::pair<int, int> GetMaxResolution(
-      const media::VideoCodecProfile profile);
+  static std::pair<int, int> GetMaxResolution(const VideoCodecProfile profile);
 
   // Returns the maximum resolution for H264 video.
   static std::pair<int, int> GetMaxH264Resolution();
 
   // Certain AMD GPU drivers like R600, R700, Evergreen and Cayman and
   // some second generation Intel GPU drivers crash if we create a video
   // device with a resolution higher then 1920 x 1088. This function
   // checks if the GPU is in this list and if yes returns true.
   static bool IsLegacyGPU(ID3D11Device* device);
 
   // Creates and initializes an instance of the D3D device and the
   // corresponding device manager. The device manager instance is eventually
   // passed to the IMFTransform interface implemented by the decoder.
   bool CreateD3DDevManager();
 
   // Creates and initializes an instance of the DX11 device and the
   // corresponding device manager. The device manager instance is eventually
   // passed to the IMFTransform interface implemented by the decoder.
   bool CreateDX11DevManager();
 
   // Creates, initializes and sets the media codec types for the decoder.
-  bool InitDecoder(media::VideoCodecProfile profile);
+  bool InitDecoder(VideoCodecProfile profile);
 
   // Validates whether the decoder supports hardware video acceleration.
   bool CheckDecoderDxvaSupport();
 
   // Returns information about the input and output streams. This includes
   // alignment information, decoder support flags, minimum sample size, etc.
   bool GetStreamsInfoAndBufferReqs();
 
   // Registers the input and output media types on the decoder. This includes
   // the expected input and output formats.
@@ skipping 16 matching lines @@
   // Invoked when we have a valid decoded output sample. Retrieves the D3D
   // surface and maintains a copy of it which is passed eventually to the
   // client when we have a picture buffer to copy the surface contents to.
   bool ProcessOutputSample(IMFSample* sample);
 
   // Processes pending output samples by copying them to available picture
   // slots.
   void ProcessPendingSamples();
 
   // Helper function to notify the accelerator client about the error.
-  void StopOnError(media::VideoDecodeAccelerator::Error error);
+  void StopOnError(VideoDecodeAccelerator::Error error);
 
   // Transitions the decoder to the uninitialized state. The decoder will stop
   // accepting requests in this state.
   void Invalidate();
 
   // Notifies the client that the input buffer identifed by input_buffer_id has
   // been processed.
   void NotifyInputBufferRead(int input_buffer_id);
 
   // Notifies the client that the decoder was flushed.
@@ skipping 118 matching lines @@
   // Returns S_OK or S_FALSE on succcess.
   // The |config_changed| parameter is set to true if we detect a change in the
   // stream.
   HRESULT CheckConfigChanged(IMFSample* sample, bool* config_changed);
 
   // Called when we detect a stream configuration change. We reinitialize the
   // decoder here.
   void ConfigChanged(const Config& config);
 
   // To expose client callbacks from VideoDecodeAccelerator.
-  media::VideoDecodeAccelerator::Client* client_;
+  VideoDecodeAccelerator::Client* client_;
 
   base::win::ScopedComPtr<IMFTransform> decoder_;
   base::win::ScopedComPtr<IMFTransform> video_format_converter_mft_;
 
   base::win::ScopedComPtr<IDirect3D9Ex> d3d9_;
   base::win::ScopedComPtr<IDirect3DDevice9Ex> d3d9_device_ex_;
   base::win::ScopedComPtr<IDirect3DDeviceManager9> device_manager_;
   base::win::ScopedComPtr<IDirect3DQuery9> query_;
 
   base::win::ScopedComPtr<ID3D11Device> d3d11_device_;
@@ skipping 68 matching lines @@
   // List of input samples waiting to be processed.
   typedef std::list<base::win::ScopedComPtr<IMFSample>> PendingInputs;
   PendingInputs pending_input_buffers_;
 
   // Callback to get current GLContext.
   GetGLContextCallback get_gl_context_cb_;
   // Callback to set the correct gl context.
   MakeGLContextCurrentCallback make_context_current_cb_;
 
   // Which codec we are decoding with hardware acceleration.
-  media::VideoCodec codec_;
+  VideoCodec codec_;
   // Thread on which the decoder operations like passing input frames,
   // getting output frames are performed. One instance of this thread
   // is created per decoder instance.
   base::Thread decoder_thread_;
 
   // Task runner to be used for posting tasks to the decoder thread.
   scoped_refptr<base::SingleThreadTaskRunner> decoder_thread_task_runner_;
 
   // Task runner to be used for posting tasks to the main thread.
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
@@ skipping 46 matching lines @@
 
   // Function pointer for the MFCreateDXGIDeviceManager API.
   static CreateDXGIDeviceManager create_dxgi_device_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(DXVAVideoDecodeAccelerator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_DXVA_VIDEO_DECODE_ACCELERATOR_WIN_H_