Move H264Parser and H264BitReader to media/filters.

content/common/gpu/media/vaapi_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.
 //
 // This file contains an implementation of a class that provides H264 decode
 // support for use with VAAPI hardware video decode acceleration on Intel
 // systems.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_VAAPI_H264_DECODER_H_
 #define CONTENT_COMMON_GPU_MEDIA_VAAPI_H264_DECODER_H_
 
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "content/common/gpu/media/h264_dpb.h"
-#include "content/common/gpu/media/h264_parser.h"
 #include "content/common/gpu/media/vaapi_wrapper.h"
 #include "media/base/limits.h"
+#include "media/filters/h264_parser.h"
 
 namespace content {
 
 // An H264 decoder that utilizes VA-API. Provides features not supported by
 // the VA-API userspace library (libva), including stream parsing, reference
 // picture management and other operations not supported by the HW codec.
 //
 // Provides functionality to allow plugging VAAPI HW acceleration into the
 // VDA framework.
 //
@@ skipping 91 matching lines @@
   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);
   bool ProcessPPS(int pps_id);
-  bool ProcessSlice(H264SliceHeader* slice_hdr);
+  bool ProcessSlice(media::H264SliceHeader* slice_hdr);
 
   // Initialize the current picture according to data in |slice_hdr|.
-  bool InitCurrPicture(H264SliceHeader* slice_hdr);
+  bool InitCurrPicture(media::H264SliceHeader* slice_hdr);
 
   // Calculate picture order counts for the new picture
   // on initialization of a new frame (see spec).
-  bool CalculatePicOrderCounts(H264SliceHeader* slice_hdr);
+  bool CalculatePicOrderCounts(media::H264SliceHeader* slice_hdr);
 
   // Update PicNum values in pictures stored in DPB on creation of new
   // frame (see spec).
   void UpdatePicNums();
 
   // Prepare reference picture lists (ref_pic_list[01]_).
-  bool PrepareRefPicLists(H264SliceHeader* slice_hdr);
+  bool PrepareRefPicLists(media::H264SliceHeader* slice_hdr);
 
   // Construct initial reference picture lists for use in decoding of
   // P and B pictures (see 8.2.4 in spec).
-  void ConstructReferencePicListsP(H264SliceHeader* slice_hdr);
-  void ConstructReferencePicListsB(H264SliceHeader* slice_hdr);
+  void ConstructReferencePicListsP(media::H264SliceHeader* slice_hdr);
+  void ConstructReferencePicListsB(media::H264SliceHeader* slice_hdr);
 
   // Helper functions for reference list construction, per spec.
   int PicNumF(H264Picture *pic);
   int LongTermPicNumF(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(H264SliceHeader *slice_hdr, int list);
+  bool ModifyReferencePicList(media::H264SliceHeader* slice_hdr, int list);
 
   // 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();
   void ReferencePictureMarking();
 
   // Start processing a new frame.
-  bool StartNewFrame(H264SliceHeader* slice_hdr);
+  bool StartNewFrame(media::H264SliceHeader* slice_hdr);
 
   // All data for a frame received, process it and decode.
   bool FinishPrevFrameIfPresent();
 
   // Called after decoding, performs all operations to be done after decoding,
   // including DPB management, reference picture marking and memory management
   // operations.
   // This will also output a picture if one is ready for output.
   bool FinishPicture();
 
   // 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();
 
   // These queue up data for HW decoder to be committed on running HW decode.
   bool SendPPS();
   bool SendIQMatrix();
-  bool SendVASliceParam(H264SliceHeader* slice_hdr);
+  bool SendVASliceParam(media::H264SliceHeader* slice_hdr);
   bool SendSliceData(const uint8* ptr, size_t size);
-  bool QueueSlice(H264SliceHeader* slice_hdr);
+  bool QueueSlice(media::H264SliceHeader* slice_hdr);
 
   // Helper methods for filling HW structures.
   void FillVAPicture(VAPictureH264 *va_pic, H264Picture* pic);
   int FillVARefFramesFromDPB(VAPictureH264 *va_pics, int num_pics);
 
   // Commits all pending data for HW decoder and starts HW decoder.
   bool DecodePicture();
 
   // Notifies client that a picture is ready for output.
   bool OutputPic(H264Picture* pic);
@@ skipping 13 matching lines @@
   // Indicate that a surface is no longer needed by decoder.
   void UnassignSurfaceFromPoC(int poc);
 
   // Return DecodeSurface assigned to |poc|.
   DecodeSurface* DecodeSurfaceByPoC(int poc);
 
   // Decoder state.
   State state_;
 
   // Parser in use.
-  H264Parser parser_;
+  media::H264Parser parser_;
 
   // DPB in use.
   H264DPB dpb_;
 
   // Picture currently being processed/decoded.
   scoped_ptr<H264Picture> curr_pic_;
 
   // Reference picture lists, constructed for each picture before decoding.
   // Those lists are not owners of the pointers (DPB is).
   H264Picture::PtrVector ref_pic_list0_;
@@ skipping 46 matching lines @@
 
   // PicOrderCount of the previously outputted frame.
   int last_output_poc_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiH264Decoder);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_VAAPI_H264_DECODER_H_