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

media/gpu/vaapi_video_encode_accelerator.h

 // Copyright 2014 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_VAAPI_VIDEO_ENCODE_ACCELERATOR_H_
 #define MEDIA_GPU_VAAPI_VIDEO_ENCODE_ACCELERATOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 10 matching lines @@
 #include "media/gpu/va_surface.h"
 #include "media/gpu/vaapi_wrapper.h"
 #include "media/video/video_encode_accelerator.h"
 
 namespace media {
 
 // A VideoEncodeAccelerator implementation that uses VA-API
 // (http://www.freedesktop.org/wiki/Software/vaapi) for HW-accelerated
 // video encode.
 class MEDIA_GPU_EXPORT VaapiVideoEncodeAccelerator
-    : public media::VideoEncodeAccelerator {
+    : public VideoEncodeAccelerator {
  public:
   VaapiVideoEncodeAccelerator();
   ~VaapiVideoEncodeAccelerator() override;
 
-  // media::VideoEncodeAccelerator implementation.
-  media::VideoEncodeAccelerator::SupportedProfiles GetSupportedProfiles()
-      override;
-  bool Initialize(media::VideoPixelFormat format,
+  // VideoEncodeAccelerator implementation.
+  VideoEncodeAccelerator::SupportedProfiles GetSupportedProfiles() override;
+  bool Initialize(VideoPixelFormat format,
                   const gfx::Size& input_visible_size,
-                  media::VideoCodecProfile output_profile,
+                  VideoCodecProfile output_profile,
                   uint32_t initial_bitrate,
                   Client* client) override;
-  void Encode(const scoped_refptr<media::VideoFrame>& frame,
+  void Encode(const scoped_refptr<VideoFrame>& frame,
               bool force_keyframe) override;
-  void UseOutputBitstreamBuffer(const media::BitstreamBuffer& buffer) override;
+  void UseOutputBitstreamBuffer(const BitstreamBuffer& buffer) override;
   void RequestEncodingParametersChange(uint32_t bitrate,
                                        uint32_t framerate) override;
   void Destroy() override;
 
  private:
   // Reference picture list.
   typedef std::list<scoped_refptr<VASurface>> RefPicList;
 
   // Encode job for one frame. Created when an input frame is awaiting and
   // enough resources are available to proceed. Once the job is prepared and
@@ skipping 31 matching lines @@
   };
 
   // Holds input frames coming from the client ready to be encoded.
   struct InputFrameRef;
   // Holds output buffers coming from the client ready to be filled.
   struct BitstreamBufferRef;
 
   // Tasks for each of the VEA interface calls to be executed on the
   // encoder thread.
   void InitializeTask();
-  void EncodeTask(const scoped_refptr<media::VideoFrame>& frame,
-                  bool force_keyframe);
+  void EncodeTask(const scoped_refptr<VideoFrame>& frame, bool force_keyframe);
   void UseOutputBitstreamBufferTask(
       std::unique_ptr<BitstreamBufferRef> buffer_ref);
   void RequestEncodingParametersChangeTask(uint32_t bitrate,
                                            uint32_t framerate);
   void DestroyTask();
 
   // Prepare and schedule an encode job if we have an input to encode
   // and enough resources to proceed.
   void EncodeFrameTask();
 
@@ skipping 19 matching lines @@
   // End current frame, updating reference picture lists and storing current
   // job in the jobs awaiting completion on submitted_encode_jobs_.
   void EndFrame();
 
   // Submit parameters for the current frame to the hardware.
   bool SubmitFrameParameters();
   // Submit keyframe headers to the hardware if the current frame is a keyframe.
   bool SubmitHeadersIfNeeded();
 
   // Upload image data from |frame| to the input surface for current job.
-  bool UploadFrame(const scoped_refptr<media::VideoFrame>& frame);
+  bool UploadFrame(const scoped_refptr<VideoFrame>& frame);
 
   // Execute encode in hardware. This does not block and will return before
   // the job is finished.
   bool ExecuteEncode();
 
   // Callback that returns a no longer used VASurfaceID to
   // available_va_surface_ids_ for reuse.
   void RecycleVASurfaceID(VASurfaceID va_surface_id);
 
   // Tries to return a bitstream buffer if both a submitted job awaits to
   // be completed and we have bitstream buffers from the client available
   // to download the encoded data to.
   void TryToReturnBitstreamBuffer();
 
   // Puts the encoder into en error state and notifies client about the error.
   void NotifyError(Error error);
 
   // Sets the encoder state on the correct thread.
   void SetState(State state);
 
   // VaapiWrapper is the owner of all HW resources (surfaces and buffers)
   // and will free them on destruction.
   scoped_refptr<VaapiWrapper> vaapi_wrapper_;
 
   // Input profile and sizes.
-  media::VideoCodecProfile profile_;
+  VideoCodecProfile profile_;
   gfx::Size visible_size_;
   gfx::Size coded_size_;  // Macroblock-aligned.
   // Width/height in macroblocks.
   unsigned int mb_width_;
   unsigned int mb_height_;
 
   // Maximum size of the reference list 0.
   unsigned int max_ref_idx_l0_size_;
 
   // Initial QP.
@@ skipping 30 matching lines @@
   // True if the parameters have changed and we need to submit a keyframe
   // with updated parameters.
   bool encoding_parameters_changed_;
 
   // Job currently being prepared for encode.
   std::unique_ptr<EncodeJob> current_encode_job_;
 
   // Current SPS, PPS and their packed versions. Packed versions are their NALUs
   // in AnnexB format *without* emulation prevention three-byte sequences
   // (those will be added by the driver).
-  media::H264SPS current_sps_;
-  media::H264BitstreamBuffer packed_sps_;
-  media::H264PPS current_pps_;
-  media::H264BitstreamBuffer packed_pps_;
+  H264SPS current_sps_;
+  H264BitstreamBuffer packed_sps_;
+  H264PPS current_pps_;
+  H264BitstreamBuffer packed_pps_;
 
   // Picture currently being prepared for encode.
   scoped_refptr<H264Picture> current_pic_;
 
   // VA surfaces available for reuse.
   std::vector<VASurfaceID> available_va_surface_ids_;
 
   // VA buffers for coded frames.
   std::vector<VABufferID> available_va_buffer_ids_;
 
@@ skipping 30 matching lines @@
   // thread (it's a member of this class).
   base::WeakPtr<VaapiVideoEncodeAccelerator> weak_this_;
   base::WeakPtrFactory<VaapiVideoEncodeAccelerator> weak_this_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiVideoEncodeAccelerator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_VAAPI_VIDEO_ENCODE_ACCELERATOR_H_