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

media/gpu/h264_decoder.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_H264_DECODER_H_
 #define MEDIA_GPU_H264_DECODER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 35 matching lines @@
 
     // Submit metadata for the current frame, providing the current |sps| and
     // |pps| for it, |dpb| has to contain all the pictures in DPB for current
     // frame, and |ref_pic_p0/b0/b1| as specified in the H264 spec. Note that
     // depending on the frame type, either p0, or b0 and b1 are used. |pic|
     // contains information about the picture for the current frame.
     // Note that this does not run decode in the accelerator and the decoder
     // is expected to follow this call with one or more SubmitSlice() calls
     // before calling SubmitDecode().
     // Return true if successful.
-    virtual bool SubmitFrameMetadata(const media::H264SPS* sps,
-                                     const media::H264PPS* pps,
+    virtual bool SubmitFrameMetadata(const H264SPS* sps,
+                                     const H264PPS* pps,
                                      const H264DPB& dpb,
                                      const H264Picture::Vector& ref_pic_listp0,
                                      const H264Picture::Vector& ref_pic_listb0,
                                      const H264Picture::Vector& ref_pic_listb1,
                                      const scoped_refptr<H264Picture>& pic) = 0;
 
     // Submit one slice for the current frame, passing the current |pps| and
     // |pic| (same as in SubmitFrameMetadata()), the parsed header for the
     // current slice in |slice_hdr|, and the reordered |ref_pic_listX|,
     // as per H264 spec.
     // |data| pointing to the full slice (including the unparsed header| of
     // |size| in bytes.
     // This must be called one or more times per frame, before SubmitDecode().
     // Note that |data| does not have to remain valid after this call returns.
     // Return true if successful.
-    virtual bool SubmitSlice(const media::H264PPS* pps,
-                             const media::H264SliceHeader* slice_hdr,
+    virtual bool SubmitSlice(const H264PPS* pps,
+                             const H264SliceHeader* slice_hdr,
                              const H264Picture::Vector& ref_pic_list0,
                              const H264Picture::Vector& ref_pic_list1,
                              const scoped_refptr<H264Picture>& pic,
                              const uint8_t* data,
                              size_t size) = 0;
 
     // Execute the decode in hardware for |pic|, using all the slices and
     // metadata submitted via SubmitFrameMetadata() and SubmitSlice() since
     // the previous call to SubmitDecode().
     // Return true if successful.
@@ skipping 11 matching lines @@
     // any cached parameters/slices that have not been committed yet.
     virtual void Reset() = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(H264Accelerator);
   };
 
   H264Decoder(H264Accelerator* accelerator);
   ~H264Decoder() override;
 
-  // media::AcceleratedVideoDecoder implementation.
+  // AcceleratedVideoDecoder implementation.
   bool Flush() override WARN_UNUSED_RESULT;
   void Reset() override;
   void SetStream(const uint8_t* ptr, size_t size) override;
   DecodeResult Decode() override WARN_UNUSED_RESULT;
   gfx::Size GetPicSize() const override;
   size_t GetRequiredNumOfPictures() const override;
 
  private:
   // We need to keep at most kDPBMaxSize pictures in DPB for
   // reference/to display later and an additional one for the one currently
   // being decoded. We also ask for some additional ones since VDA needs
   // to accumulate a few ready-to-output pictures before it actually starts
   // displaying and giving them back. +2 instead of +1 because of subjective
   // smoothness improvement during testing.
   enum {
-    kPicsInPipeline = media::limits::kMaxVideoFrames + 2,
+    kPicsInPipeline = limits::kMaxVideoFrames + 2,
     kMaxNumReqPictures = H264DPB::kDPBMaxSize + kPicsInPipeline,
   };
 
   // Internal state of the decoder.
   enum State {
     kNeedStreamMetadata,  // After initialization, need an SPS.
     kDecoding,            // Ready to decode from any point.
     kAfterReset,          // After Reset(), need a resume point.
     kError,               // Error in decode, can't continue.
   };
 
   // Process H264 stream structures.
   bool ProcessSPS(int sps_id, bool* need_new_buffers);
   // Process current slice header to discover if we need to start a new picture,
   // finishing up the current one.
   bool PreprocessCurrentSlice();
   // Process current slice as a slice of the current picture.
   bool ProcessCurrentSlice();
 
   // Return true if we need to start a new picture.
-  bool IsNewPrimaryCodedPicture(const media::H264SliceHeader* slice_hdr) const;
+  bool IsNewPrimaryCodedPicture(const H264SliceHeader* slice_hdr) const;
 
   // Initialize the current picture according to data in |slice_hdr|.
-  bool InitCurrPicture(const media::H264SliceHeader* slice_hdr);
+  bool InitCurrPicture(const H264SliceHeader* slice_hdr);
 
   // Initialize |pic| as a "non-existing" picture (see spec) with |frame_num|,
   // to be used for frame gap concealment.
   bool InitNonexistingPicture(scoped_refptr<H264Picture> pic, int frame_num);
 
   // Calculate picture order counts for |pic| on initialization
   // of a new frame (see spec).
   bool CalculatePicOrderCounts(scoped_refptr<H264Picture> pic);
 
   // Update PicNum values in pictures stored in DPB on creation of
   // a picture with |frame_num|.
   void UpdatePicNums(int frame_num);
 
-  bool UpdateMaxNumReorderFrames(const media::H264SPS* sps);
+  bool UpdateMaxNumReorderFrames(const H264SPS* sps);
 
   // Prepare reference picture lists for the current frame.
-  void PrepareRefPicLists(const media::H264SliceHeader* slice_hdr);
+  void PrepareRefPicLists(const H264SliceHeader* slice_hdr);
   // Prepare reference picture lists for the given slice.
-  bool ModifyReferencePicLists(const media::H264SliceHeader* slice_hdr,
+  bool ModifyReferencePicLists(const H264SliceHeader* slice_hdr,
                                H264Picture::Vector* ref_pic_list0,
                                H264Picture::Vector* ref_pic_list1);
 
   // Construct initial reference picture lists for use in decoding of
   // P and B pictures (see 8.2.4 in spec).
-  void ConstructReferencePicListsP(const media::H264SliceHeader* slice_hdr);
-  void ConstructReferencePicListsB(const media::H264SliceHeader* slice_hdr);
+  void ConstructReferencePicListsP(const H264SliceHeader* slice_hdr);
+  void ConstructReferencePicListsB(const H264SliceHeader* slice_hdr);
 
   // Helper functions for reference list construction, per spec.
   int PicNumF(const scoped_refptr<H264Picture>& pic);
   int LongTermPicNumF(const scoped_refptr<H264Picture>& pic);
 
   // Perform the reference picture lists' modification (reordering), as
   // specified in spec (8.2.4).
   //
   // |list| indicates list number and should be either 0 or 1.
-  bool ModifyReferencePicList(const media::H264SliceHeader* slice_hdr,
+  bool ModifyReferencePicList(const H264SliceHeader* slice_hdr,
                               int list,
                               H264Picture::Vector* ref_pic_listx);
 
   // Perform reference picture memory management operations (marking/unmarking
   // of reference pictures, long term picture management, discarding, etc.).
   // See 8.2.5 in spec.
   bool HandleMemoryManagementOps(scoped_refptr<H264Picture> pic);
   bool ReferencePictureMarking(scoped_refptr<H264Picture> pic);
   bool SlidingWindowPictureMarking();
 
   // Handle a gap in frame_num in the stream up to |frame_num|, by creating
   // "non-existing" pictures (see spec).
   bool HandleFrameNumGap(int frame_num);
 
   // Start processing a new frame.
-  bool StartNewFrame(const media::H264SliceHeader* slice_hdr);
+  bool StartNewFrame(const H264SliceHeader* slice_hdr);
 
   // All data for a frame received, process it and decode.
   bool FinishPrevFrameIfPresent();
 
   // Called after we are done processing |pic|. Performs all operations to be
   // done after decoding, including DPB management, reference picture marking
   // and memory management operations.
   // This will also output pictures if any have become ready to be outputted
   // after processing |pic|.
   bool FinishPicture(scoped_refptr<H264Picture> pic);
 
   // Clear DPB contents and remove all surfaces in DPB from *in_use_ list.
   // Cleared pictures will be made available for decode, unless they are
   // at client waiting to be displayed.
   void ClearDPB();
 
   // Commits all pending data for HW decoder and starts HW decoder.
   bool DecodePicture();
 
   // Notifies client that a picture is ready for output.
   void OutputPic(scoped_refptr<H264Picture> pic);
 
   // Output all pictures in DPB that have not been outputted yet.
   bool OutputAllRemainingPics();
 
   // Decoder state.
   State state_;
 
   // Parser in use.
-  media::H264Parser parser_;
+  H264Parser parser_;
 
   // DPB in use.
   H264DPB dpb_;
 
   // Picture currently being processed/decoded.
   scoped_refptr<H264Picture> curr_pic_;
 
   // Reference picture lists, constructed for each frame.
   H264Picture::Vector ref_pic_list_p0_;
   H264Picture::Vector ref_pic_list_b0_;
@@ skipping 15 matching lines @@
   int prev_ref_top_field_order_cnt_;
   int prev_ref_pic_order_cnt_msb_;
   int prev_ref_pic_order_cnt_lsb_;
   H264Picture::Field prev_ref_field_;
 
   // Currently active SPS and PPS.
   int curr_sps_id_;
   int curr_pps_id_;
 
   // Current NALU and slice header being processed.
-  std::unique_ptr<media::H264NALU> curr_nalu_;
-  std::unique_ptr<media::H264SliceHeader> curr_slice_hdr_;
+  std::unique_ptr<H264NALU> curr_nalu_;
+  std::unique_ptr<H264SliceHeader> curr_slice_hdr_;
 
   // Output picture size.
   gfx::Size pic_size_;
 
   // PicOrderCount of the previously outputted frame.
   int last_output_poc_;
 
   H264Accelerator* accelerator_;
 
   DISALLOW_COPY_AND_ASSIGN(H264Decoder);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_H264_DECODER_H_