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

media/gpu/v4l2_video_decode_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.
 //
 // This file contains an implementation of VideoDecodeAccelerator
 // that utilizes hardware video decoders, which expose Video4Linux 2 API
 // (http://linuxtv.org/downloads/v4l-dvb-apis/).
 
 #ifndef MEDIA_GPU_V4L2_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_GPU_V4L2_VIDEO_DECODE_ACCELERATOR_H_
@@ skipping 28 matching lines @@
 
 // This class handles video accelerators directly through a V4L2 device exported
 // by the hardware blocks.
 //
 // The threading model of this class is driven by the fact that it needs to
 // interface two fundamentally different event queues -- the one Chromium
 // provides through MessageLoop, and the one driven by the V4L2 devices which
 // is waited on with epoll().  There are three threads involved in this class:
 //
 // * The child thread, which is the main GPU process thread which calls the
-//   media::VideoDecodeAccelerator entry points.  Calls from this thread
+//   VideoDecodeAccelerator entry points.  Calls from this thread
 //   generally do not block (with the exception of Initialize() and Destroy()).
 //   They post tasks to the decoder_thread_, which actually services the task
 //   and calls back when complete through the
-//   media::VideoDecodeAccelerator::Client interface.
+//   VideoDecodeAccelerator::Client interface.
 // * The decoder_thread_, owned by this class.  It services API tasks, through
 //   the *Task() routines, as well as V4L2 device events, through
 //   ServiceDeviceTask().  Almost all state modification is done on this thread
 //   (this doesn't include buffer (re)allocation sequence, see below).
 // * The device_poll_thread_, owned by this class.  All it does is epoll() on
 //   the V4L2 in DevicePollTask() and schedule a ServiceDeviceTask() on the
 //   decoder_thread_ when something interesting happens.
 //   TODO(sheu): replace this thread with an TYPE_IO decoder_thread_.
 //
 // Note that this class has (almost) no locks, apart from the pictures_assigned_
@@ skipping 14 matching lines @@
 // V4L2VideoDecodeAccelerator may use image processor to convert the output.
 // There are three cases:
 // Flush: V4L2VDA should wait until image processor returns all processed
 //   frames.
 // Reset: V4L2VDA doesn't need to wait for image processor. When image processor
 //   returns an old frame, drop it.
 // Resolution change: V4L2VDA destroy image processor when destroying output
 //   buffrers. We cannot drop any frame during resolution change. So V4L2VDA
 //   should destroy output buffers after image processor returns all the frames.
 class MEDIA_GPU_EXPORT V4L2VideoDecodeAccelerator
-    : public media::VideoDecodeAccelerator {
+    : public VideoDecodeAccelerator {
  public:
   V4L2VideoDecodeAccelerator(
       EGLDisplay egl_display,
       const GetGLContextCallback& get_gl_context_cb,
       const MakeGLContextCurrentCallback& make_context_current_cb,
       const scoped_refptr<V4L2Device>& device);
   ~V4L2VideoDecodeAccelerator() override;
 
-  // media::VideoDecodeAccelerator implementation.
+  // VideoDecodeAccelerator implementation.
   // Note: Initialize() and Destroy() are synchronous.
   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;
 
-  static media::VideoDecodeAccelerator::SupportedProfiles
-  GetSupportedProfiles();
+  static VideoDecodeAccelerator::SupportedProfiles GetSupportedProfiles();
 
  private:
   // These are rather subjectively tuned.
   enum {
     kInputBufferCount = 8,
     // TODO(posciak): determine input buffer size based on level limits.
     // See http://crbug.com/255116.
     // Input bitstream buffer size for up to 1080p streams.
     kInputBufferMaxSizeFor1080p = 1024 * 1024,
     // Input bitstream buffer size for up to 4k streams.
     kInputBufferMaxSizeFor4k = 4 * kInputBufferMaxSizeFor1080p,
     // Number of output buffers to use for each VDA stage above what's required
     // by the decoder (e.g. DPB size, in H264).  We need
-    // media::limits::kMaxVideoFrames to fill up the GpuVideoDecode pipeline,
+    // limits::kMaxVideoFrames to fill up the GpuVideoDecode pipeline,
     // and +1 for a frame in transit.
-    kDpbOutputBufferExtraCount = media::limits::kMaxVideoFrames + 1,
+    kDpbOutputBufferExtraCount = limits::kMaxVideoFrames + 1,
   };
 
   // Internal state of the decoder.
   enum State {
     kUninitialized,  // Initialize() not yet called.
     kInitialized,    // Initialize() returned true; ready to start decoding.
     kDecoding,       // DecodeBufferInitial() successful; decoding frames.
     kResetting,      // Presently resetting.
     kAfterReset,     // After Reset(), ready to start decoding again.
     kChangingResolution,  // Performing resolution change, all remaining
@@ skipping 48 matching lines @@
     std::vector<base::ScopedFD> fds;
   };
 
   //
   // Decoding tasks, to be run on decode_thread_.
   //
 
   // Enqueue a BitstreamBuffer to decode.  This will enqueue a buffer to the
   // decoder_input_queue_, then queue a DecodeBufferTask() to actually decode
   // the buffer.
-  void DecodeTask(const media::BitstreamBuffer& bitstream_buffer);
+  void DecodeTask(const BitstreamBuffer& bitstream_buffer);
 
   // Decode from the buffers queued in decoder_input_queue_.  Calls
   // DecodeBufferInitial() or DecodeBufferContinue() as appropriate.
   void DecodeBufferTask();
   // Advance to the next fragment that begins a frame.
   bool AdvanceFrameFragment(const uint8_t* data, size_t size, size_t* endpos);
   // Schedule another DecodeBufferTask() if we're behind.
   void ScheduleDecodeBufferTaskIfNeeded();
 
   // Return true if we should continue to schedule DecodeBufferTask()s after
@@ skipping 187 matching lines @@
   // Picture buffers held by the client.
   int decoder_frames_at_client_;
   // Are we flushing?
   bool decoder_flushing_;
   // Got a reset request while we were performing resolution change.
   bool resolution_change_reset_pending_;
   // Input queue for decoder_thread_: BitstreamBuffers in.
   std::queue<linked_ptr<BitstreamBufferRef>> decoder_input_queue_;
   // For H264 decode, hardware requires that we send it frame-sized chunks.
   // We'll need to parse the stream.
-  std::unique_ptr<media::H264Parser> decoder_h264_parser_;
+  std::unique_ptr<H264Parser> decoder_h264_parser_;
   // Set if the decoder has a pending incomplete frame in an input buffer.
   bool decoder_partial_frame_pending_;
 
   //
   // Hardware state and associated queues.  Since decoder_thread_ services
   // the hardware, decoder_thread_ owns these too.
   // output_buffer_map_, free_output_buffers_ and output_planes_count_ are an
   // exception during the buffer (re)allocation sequence, when the
   // decoder_thread_ is blocked briefly while the Child thread manipulates
   // them.
@@ skipping 55 matching lines @@
 
   // EGL state
   EGLDisplay egl_display_;
 
   // Callback to get current GLContext.
   GetGLContextCallback get_gl_context_cb_;
   // Callback to set the correct gl context.
   MakeGLContextCurrentCallback make_context_current_cb_;
 
   // The codec we'll be decoding for.
-  media::VideoCodecProfile video_profile_;
+  VideoCodecProfile video_profile_;
   // Chosen output format.
   uint32_t output_format_fourcc_;
 
   // Image processor device, if one is in use.
   scoped_refptr<V4L2Device> image_processor_device_;
   // Image processor. Created and destroyed on child thread.
   std::unique_ptr<V4L2ImageProcessor> image_processor_;
 
   // The V4L2Device EGLImage is created from.
   scoped_refptr<V4L2Device> egl_image_device_;
@@ skipping 14 matching lines @@
 
   // The WeakPtrFactory for |weak_this_|.
   base::WeakPtrFactory<V4L2VideoDecodeAccelerator> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2VideoDecodeAccelerator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_V4L2_VIDEO_DECODE_ACCELERATOR_H_