Add accelerated video decoder interface, VP8 and H.264 implementations and hook up to V4L2SVDA

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/vaapi_h264_dpb.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.
 //
@@ skipping 80 matching lines @@
 
  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,
-    kMaxNumReqPictures = H264DPB::kDPBMaxSize + kPicsInPipeline,
+    kMaxNumReqPictures = VaapiH264DPB::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.
   };
 
@@ skipping 17 matching lines @@
 
   // Prepare reference picture lists (ref_pic_list[01]_).
   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(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);
+  int PicNumF(VaapiH264Picture *pic);
+  int LongTermPicNumF(VaapiH264Picture *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(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.
@@ skipping 18 matching lines @@
   void ClearDPB();
 
   // These queue up data for HW decoder to be committed on running HW decode.
   bool SendPPS();
   bool SendIQMatrix();
   bool SendVASliceParam(media::H264SliceHeader* slice_hdr);
   bool SendSliceData(const uint8* ptr, size_t size);
   bool QueueSlice(media::H264SliceHeader* slice_hdr);
 
   // Helper methods for filling HW structures.
-  void FillVAPicture(VAPictureH264 *va_pic, H264Picture* pic);
+  void FillVAPicture(VAPictureH264 *va_pic, VaapiH264Picture* 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);
+  bool OutputPic(VaapiH264Picture* pic);
 
   // Output all pictures in DPB that have not been outputted yet.
   bool OutputAllRemainingPics();
 
   // Represents a frame being decoded. Will always have a VASurface
   // assigned to it, which will eventually contain decoded picture data.
   class DecodeSurface;
 
   // Assign an available surface to the given PicOrderCnt |poc|,
   // removing it from the available surfaces pool. Return true if a surface
   // has been found, false otherwise.
   bool AssignSurfaceToPoC(int32 input_id, int poc);
 
   // 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.
   media::H264Parser parser_;
 
   // DPB in use.
-  H264DPB dpb_;
+  VaapiH264DPB dpb_;
 
   // Picture currently being processed/decoded.
-  scoped_ptr<H264Picture> curr_pic_;
+  scoped_ptr<VaapiH264Picture> 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_;
-  H264Picture::PtrVector ref_pic_list1_;
+  VaapiH264Picture::PtrVector ref_pic_list0_;
+  VaapiH264Picture::PtrVector ref_pic_list1_;
 
   // Global state values, needed in decoding. See spec.
   int max_pic_order_cnt_lsb_;
   int max_frame_num_;
   int max_pic_num_;
   int max_long_term_frame_idx_;
   size_t max_num_reorder_frames_;
 
   int frame_num_;
   int prev_frame_num_;
   int prev_frame_num_offset_;
   bool prev_has_memmgmnt5_;
 
   // Values related to previously decoded reference picture.
   bool prev_ref_has_memmgmnt5_;
   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_;
+  VaapiH264Picture::Field prev_ref_field_;
 
   // Currently active SPS and PPS.
   int curr_sps_id_;
   int curr_pps_id_;
 
   // Output picture size.
   gfx::Size pic_size_;
 
   // Maps H.264 PicOrderCount to currently used DecodeSurfaces;
   typedef std::map<int, linked_ptr<DecodeSurface> > DecSurfacesInUse;
@@ skipping 17 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_