V4L2SVDA: Add a VP9Accelerator implementation utilizing the V4L2 VP9 frame API.

media/filters/vp9_parser.h

 // Copyright 2015 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 VP9 bitstream parser. The main
 // purpose of this parser is to support hardware decode acceleration. Some
 // accelerators, e.g. libva which implements VA-API, require the caller
 // (chrome) to feed them parsed VP9 frame header.
 //
 // See media::VP9Decoder for example usage.
 //
 #ifndef MEDIA_FILTERS_VP9_PARSER_H_
 #define MEDIA_FILTERS_VP9_PARSER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/types.h>
 
 #include <deque>
+#include <memory>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "media/base/media_export.h"
 
 namespace media {
 
 const int kVp9MaxProfile = 4;
 const int kVp9NumRefFramesLog2 = 3;
 const size_t kVp9NumRefFrames = 1 << kVp9NumRefFramesLog2;
 const uint8_t kVp9MaxProb = 255;
 const size_t kVp9NumRefsPerFrame = 3;
-const size_t kVp9NumFrameContexts = 4;
+const size_t kVp9NumFrameContextsLog2 = 2;
+const size_t kVp9NumFrameContexts = 1 << kVp9NumFrameContextsLog2;
 
 using Vp9Prob = uint8_t;
 
 enum class Vp9ColorSpace {
   UNKNOWN = 0,
   BT_601 = 1,
   BT_709 = 2,
   SMPTE_170 = 3,
   SMPTE_240 = 4,
   BT_2020 = 5,
@@ skipping 85 matching lines @@
   }
 
   uint8_t base_q_idx;
   int8_t delta_q_y_dc;
   int8_t delta_q_uv_dc;
   int8_t delta_q_uv_ac;
 };
 
 // Entropy context for frame parsing
 struct MEDIA_EXPORT Vp9FrameContext {
+  bool IsValid() const;
+
   Vp9Prob tx_probs_8x8[2][1];
   Vp9Prob tx_probs_16x16[2][2];
   Vp9Prob tx_probs_32x32[2][3];
 
   Vp9Prob coef_probs[4][2][2][6][6][3];
   Vp9Prob skip_prob[3];
   Vp9Prob inter_mode_probs[7][3];
   Vp9Prob interp_filter_probs[4][2];
   Vp9Prob is_inter_prob[4];
 
@@ skipping 99 matching lines @@
   // Size of uncompressed header in bytes.
   size_t uncompressed_header_size;
 
   Vp9CompressedHeader compressed_header;
   // Initial frame entropy context after load_probs2(frame_context_idx).
   Vp9FrameContext initial_frame_context;
   // Current frame entropy context after header parsing.
   Vp9FrameContext frame_context;
 };
 
-class Vp9FrameContextManager {
+// A parser for VP9 bitstream.
+class MEDIA_EXPORT Vp9Parser {
  public:
   // If context update is needed after decoding a frame, the client must
   // execute this callback, passing the updated context state.
   using ContextRefreshCallback = base::Callback<void(const Vp9FrameContext&)>;
 
-  static bool IsValidFrameContext(const Vp9FrameContext& context);
-
-  Vp9FrameContextManager();
-  ~Vp9FrameContextManager();
-  bool initialized() const { return initialized_; }
-  bool needs_client_update() const { return needs_client_update_; }
-  const Vp9FrameContext& frame_context() const;
-
-  // Resets to uninitialized state.
-  void Reset();
-
-  // Sets this context need update from parser's client. Returns a callback for
-  // update.
-  ContextRefreshCallback SetNeedsClientUpdate();
-
-  // Updates frame context.
-  void Update(const Vp9FrameContext& frame_context);
-
- private:
-  // Updates frame context from parser's client.
-  void UpdateFromClient(const Vp9FrameContext& frame_context);
-
-  bool initialized_ = false;
-  bool needs_client_update_ = false;
-  Vp9FrameContext frame_context_;
-
-  base::WeakPtrFactory<Vp9FrameContextManager> weak_ptr_factory_;
-};
-
-// A parser for VP9 bitstream.
-class MEDIA_EXPORT Vp9Parser {
- public:
   // ParseNextFrame() return values. See documentation for ParseNextFrame().
   enum Result {
     kOk,
     kInvalidStream,
     kEOStream,
     kAwaitingRefresh,
   };
 
   // The parsing context to keep track of references.
   struct ReferenceSlot {
     bool initialized;
     uint32_t frame_width;
     uint32_t frame_height;
     uint8_t subsampling_x;
     uint8_t subsampling_y;
     uint8_t bit_depth;
 
     // More fields for consistency checking.
     uint8_t profile;
     Vp9ColorSpace color_space;
   };
 
   // The parsing context that persists across frames.
-  struct Context {
+  class Context {
+   public:
+    class Vp9FrameContextManager {
+     public:
+      Vp9FrameContextManager();
+      ~Vp9FrameContextManager();
+      bool initialized() const { return initialized_; }
+      bool needs_client_update() const { return needs_client_update_; }
+      const Vp9FrameContext& frame_context() const;
+
+      // Resets to uninitialized state.
+      void Reset();
+
+      // Marks this context as requiring an update from parser's client.
+      void SetNeedsClientUpdate();
+
+      // Updates frame context.
+      void Update(const Vp9FrameContext& frame_context);
+
+      // Return a callback to update frame context at a later time with.

[kcwu, 2016/08/17 04:06:09]

s/Return/Returns/

[Pawel Osciak, 2016/08/19 08:22:43]

Done.

+      ContextRefreshCallback GetUpdateCb();
+
+     private:
+      // Updates frame context from parser's client.
+      void UpdateFromClient(const Vp9FrameContext& frame_context);
+
+      bool initialized_ = false;
+      bool needs_client_update_ = false;
+      Vp9FrameContext frame_context_;
+
+      base::WeakPtrFactory<Vp9FrameContextManager> weak_ptr_factory_;
+    };
+
     void Reset();
 
+    // Mark |frame_context_idx| as requiring update from the client.
+    void MarkFrameContextForUpdate(size_t frame_context_idx);
+
+    // Update frame context at |frame_context_idx| with the contents of
+    // |frame_context|.
+    void UpdateFrameContext(size_t frame_context_idx,
+                            const Vp9FrameContext& frame_context);
+
+    // Return ReferenceSlot for frame of |ref_type|.
+    const ReferenceSlot& GetRefSlot(size_t ref_type) const;

[kcwu, 2016/08/17 04:06:09]

ref_idx or ref_frame_idx?

"size_t ref_type" looks confusing.

[Pawel Osciak, 2016/08/19 08:22:43]

Done.

+
+    // Update contents of ReferenceSlot for |ref_type| with the contents of
+    // |ref_slot|.
+    void UpdateRefSlot(size_t ref_type, const ReferenceSlot& ref_slot);
+
+    const Vp9SegmentationParams& segmentation() const { return segmentation_; }
+
+    const Vp9LoopFilterParams& loop_filter() const { return loop_filter_; }
+
+   private:
+    friend class Vp9UncompressedHeaderParser;
+    friend class Vp9Parser;
+
     // Segmentation and loop filter state.
-    Vp9SegmentationParams segmentation;
-    Vp9LoopFilterParams loop_filter;
+    Vp9SegmentationParams segmentation_;
+    Vp9LoopFilterParams loop_filter_;
 
     // Frame references.
-    ReferenceSlot ref_slots[kVp9NumRefFrames];
+    ReferenceSlot ref_slots_[kVp9NumRefFrames];
 
-    Vp9FrameContextManager frame_context_managers[kVp9NumFrameContexts];
+    Vp9FrameContextManager frame_context_managers_[kVp9NumFrameContexts];
   };
 
   // The constructor. See ParseNextFrame() for comments for
   // |parsing_compressed_header|.
   explicit Vp9Parser(bool parsing_compressed_header);
   ~Vp9Parser();
 
   // Set a new stream buffer to read from, starting at |stream| and of size
   // |stream_size| in bytes. |stream| must point to the beginning of a single
   // frame or a single superframe, is owned by caller and must remain valid
   // until the next call to SetStream().
   void SetStream(const uint8_t* stream, off_t stream_size);
 
   // Parse the next frame in the current stream buffer, filling |fhdr| with
   // the parsed frame header and updating current segmentation and loop filter
-  // state. If |parsing_compressed_header_|, this function also fills
-  // |context_refresh_cb|, which is used to update frame context. If
-  // |*context_refresh_cb| is null, no callback is necessary.
+  // state.
   // Return kOk if a frame has successfully been parsed,
   //        kEOStream if there is no more data in the current stream buffer,
   //        kAwaitingRefresh if this frame awaiting frame context update, or
   //        kInvalidStream on error.
-  Result ParseNextFrame(
-      Vp9FrameHeader* fhdr,
-      Vp9FrameContextManager::ContextRefreshCallback* context_refresh_cb);
+  Result ParseNextFrame(Vp9FrameHeader* fhdr);
 
-  // Return current segmentation state.
-  const Vp9SegmentationParams& GetSegmentation() const {
-    return context_.segmentation;
-  }
+  // Return current parsing context.
+  const Context& context() const { return context_; }
 
-  // Return current loop filter state.
-  const Vp9LoopFilterParams& GetLoopFilter() const {
-    return context_.loop_filter;
-  }
+  // Return a ContextRefreshCallback, which, if not null, has to be called with
+  // the new context state after the frame associated with |frame_context_idx|
+  // is decoded.
+  ContextRefreshCallback GetContextRefreshCb(size_t frame_context_idx);
 
   // Clear parser state and return to an initialized state.
   void Reset();
 
  private:
-  class UncompressedHeaderParser;
-  class CompressedHeaderParser;
-
   // Stores start pointer and size of each frame within the current superframe.
   struct FrameInfo {
     FrameInfo() = default;
     FrameInfo(const uint8_t* ptr, off_t size);
     bool IsValid() const { return ptr != nullptr; }
     void Reset() { ptr = nullptr; }
 
     // Starting address of the frame.
     const uint8_t* ptr = nullptr;
 
@@ skipping 23 matching lines @@
 
   FrameInfo curr_frame_info_;
   Vp9FrameHeader curr_frame_header_;
 
   DISALLOW_COPY_AND_ASSIGN(Vp9Parser);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_VP9_PARSER_H_