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

media/gpu/v4l2_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_V4L2_VIDEO_ENCODE_ACCELERATOR_H_
 #define MEDIA_GPU_V4L2_VIDEO_ENCODE_ACCELERATOR_H_
 
 #include <linux/videodev2.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 23 matching lines @@
 namespace media {
 
 // This class handles video encode acceleration by interfacing with a V4L2
 // device exposed by the codec hardware driver. The threading model of this
 // class is the same as in the V4L2VideoDecodeAccelerator (from which class this
 // was designed).
 // This class may try to instantiate and use a V4L2ImageProcessor for input
 // format conversion, if the input format requested via Initialize() is not
 // accepted by the hardware codec.
 class MEDIA_GPU_EXPORT V4L2VideoEncodeAccelerator
-    : public media::VideoEncodeAccelerator {
+    : public VideoEncodeAccelerator {
  public:
   explicit V4L2VideoEncodeAccelerator(const scoped_refptr<V4L2Device>& device);
   ~V4L2VideoEncodeAccelerator() 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:
   // Auto-destroy reference for BitstreamBuffer, for tracking buffers passed to
   // this instance.
   struct BitstreamBufferRef;
 
   // Record for codec input buffers.
   struct InputRecord {
     InputRecord();
     ~InputRecord();
     bool at_device;
-    scoped_refptr<media::VideoFrame> frame;
+    scoped_refptr<VideoFrame> frame;
   };
 
   // Record for output buffers.
   struct OutputRecord {
     OutputRecord();
     ~OutputRecord();
     bool at_device;
     linked_ptr<BitstreamBufferRef> buffer_ref;
     void* address;
     size_t length;
   };
 
   struct ImageProcessorInputRecord {
     ImageProcessorInputRecord();
     ~ImageProcessorInputRecord();
-    scoped_refptr<media::VideoFrame> frame;
+    scoped_refptr<VideoFrame> frame;
     bool force_keyframe;
   };
 
   enum {
     kInitialFramerate = 30,
     // These are rather subjectively tuned.
     kInputBufferCount = 2,
     kOutputBufferCount = 2,
     kImageProcBufferCount = 2,
     kOutputBufferSize = (2 * 1024 * 1024),
@@ skipping 16 matching lines @@
                       base::TimeDelta timestamp,
                       int output_buffer_index);
 
   // Error callback for handling image processor errors.
   void ImageProcessorError();
 
   //
   // Encoding tasks, to be run on encode_thread_.
   //
 
-  void EncodeTask(const scoped_refptr<media::VideoFrame>& frame,
-                  bool force_keyframe);
+  void EncodeTask(const scoped_refptr<VideoFrame>& frame, bool force_keyframe);
 
   // Add a BitstreamBuffer to the queue of buffers ready to be used for encoder
   // output.
   void UseOutputBitstreamBufferTask(
       std::unique_ptr<BitstreamBufferRef> buffer_ref);
 
   // Device destruction task.
   void DestroyTask();
 
   // Service I/O on the V4L2 devices.  This task should only be scheduled from
@@ skipping 32 matching lines @@
   // Other utility functions.  Called on encoder_thread_, unless
   // encoder_thread_ is not yet started, in which case the child thread can call
   // these (e.g. in Initialize() or Destroy()).
   //
 
   // Change encoding parameters.
   void RequestEncodingParametersChangeTask(uint32_t bitrate,
                                            uint32_t framerate);
 
   // Set up formats and initialize the device for them.
-  bool SetFormats(media::VideoPixelFormat input_format,
-                  media::VideoCodecProfile output_profile);
+  bool SetFormats(VideoPixelFormat input_format,
+                  VideoCodecProfile output_profile);
 
   // Try to set up the device to the input format we were Initialized() with,
   // or if the device doesn't support it, use one it can support, so that we
   // can later instantiate a V4L2ImageProcessor to convert to it.
-  bool NegotiateInputFormat(media::VideoPixelFormat input_format);
+  bool NegotiateInputFormat(VideoPixelFormat input_format);
 
   // Set up the device to the output format requested in Initialize().
-  bool SetOutputFormat(media::VideoCodecProfile output_profile);
+  bool SetOutputFormat(VideoCodecProfile output_profile);
 
   // Initialize device controls with default values.
   bool InitControls();
 
   // Create the buffers we need.
   bool CreateInputBuffers();
   bool CreateOutputBuffers();
 
   // Destroy these buffers.
   void DestroyInputBuffers();
   void DestroyOutputBuffers();
 
   // Set controls in |ctrls| and return true if successful.
   bool SetExtCtrls(std::vector<struct v4l2_ext_control> ctrls);
 
   // Recycle output buffer of image processor with |output_buffer_index|.
   void ReuseImageProcessorOutputBuffer(int output_buffer_index);
 
   // Our original calling task runner for the child thread.
   const scoped_refptr<base::SingleThreadTaskRunner> child_task_runner_;
 
   gfx::Size visible_size_;
   // Input allocated size required by the device.
   gfx::Size input_allocated_size_;
   size_t output_buffer_byte_size_;
 
   // Formats for input frames and the output stream.
-  media::VideoPixelFormat device_input_format_;
+  VideoPixelFormat device_input_format_;
   size_t input_planes_count_;
   uint32_t output_format_fourcc_;
 
   //
   // Encoder state, owned and operated by encoder_thread_.
   // Before encoder_thread_ has started, the encoder state is managed by
   // the child (main) thread.  After encoder_thread_ has started, the encoder
   // thread should be the only one managing these.
   //
 
   // Encoder state.
   State encoder_state_;
 
   // We need to provide the stream header with every keyframe, to allow
   // midstream decoding restarts.  Store it here.
   std::unique_ptr<uint8_t[]> stream_header_;
   size_t stream_header_size_;
 
   // Video frames ready to be encoded.
-  std::queue<scoped_refptr<media::VideoFrame>> encoder_input_queue_;
+  std::queue<scoped_refptr<VideoFrame>> encoder_input_queue_;
 
   // Encoder device.
   scoped_refptr<V4L2Device> device_;
 
   // Input queue state.
   bool input_streamon_;
   // Input buffers enqueued to device.
   int input_buffer_queued_count_;
   // Input buffers ready to use; LIFO since we don't care about ordering.
   std::vector<int> free_input_buffers_;
@@ skipping 44 matching lines @@
   // as both threads will not outlive this object.
   base::WeakPtr<V4L2VideoEncodeAccelerator> weak_this_;
   base::WeakPtrFactory<V4L2VideoEncodeAccelerator> weak_this_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2VideoEncodeAccelerator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_V4L2_VIDEO_ENCODE_ACCELERATOR_H_