media/filters/vp9_parser.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // This file contains an implementation of a VP9 bitstream parser. The main
   6 // purpose of this parser is to support hardware decode acceleration. Some
   7 // accelerators, e.g. libva which implements VA-API, require the caller
   8 // (chrome) to feed them parsed VP9 frame header.
   9 //
  10 // Example usage:
  11 //   {
  12 //     Vp9Parser parser;
  13 //     uint8_t* frame_stream;
  14 //     size_t frame_size;
  15 //
  16 //     // Get frames from, say, WebM parser or IVF parser.
  17 //     while (GetVp9Frame(&frame_stream, &frame_size)) {
  18 //       Vp9FrameHeader header;
  19 //       if (!parser.ParseFrame(frame_stream, frame_size, &header)) {
  20 //         // Parse failed.
  21 //         return false;
  22 //       }
  23 //       // Got a frame parsed successfully.
  24 //     }
  25 //  }
  26
  27 #ifndef MEDIA_FILTERS_VP9_PARSER_H_
  28 #define MEDIA_FILTERS_VP9_PARSER_H_
  29
  30 #include <stddef.h>
  31 #include <stdint.h>
  32
  33 #include "base/macros.h"
  34 #include "media/base/media_export.h"
  35 #include "media/filters/vp9_raw_bits_reader.h"
  36
  37 namespace media {
  38
  39 const int kVp9MaxProfile = 4;
  40 const int kVp9NumRefFramesLog2 = 3;
  41 const int kVp9NumRefFrames = 1 << kVp9NumRefFramesLog2;
  42 const uint8_t kVp9MaxProb = 255;
  43 const int kVp9NumRefsPerFrame = 3;
  44
  45 enum class Vp9ColorSpace {
  46   UNKNOWN = 0,
  47   BT_601 = 1,
  48   BT_709 = 2,
  49   SMPTE_170 = 3,
  50   SMPTE_240 = 4,
  51   BT_2020 = 5,
  52   RESERVED = 6,
  53   SRGB = 7,
  54 };
  55
  56 enum class Vp9InterpFilter {
  57   INTERP_FILTER_SELECT = 0,
  58   EIGHTTAP_SMOOTH = 1,
  59   EIGHTTAP = 2,
  60   EIGHTTAP_SHARP = 3,
  61   BILINEAR = 4,
  62 };
  63
  64 // Members of Vp9FrameHeader will be 0-initialized by Vp9Parser::ParseFrame.
  65 struct MEDIA_EXPORT Vp9Segmentation {
  66   static const int kNumSegments = 8;
  67   static const int kNumTreeProbs = kNumSegments - 1;
  68   static const int kNumPredictionProbs = 3;
  69   static const int kNumFeatures = 4;
  70
  71   bool enabled;
  72
  73   bool update_map;
  74   uint8_t tree_probs[kNumTreeProbs];
  75   bool temporal_update;
  76   uint8_t pred_probs[kNumPredictionProbs];
  77
  78   bool update_data;
  79   bool abs_delta;
  80   bool feature_enabled[kNumSegments][kNumFeatures];
  81   int8_t feature_data[kNumSegments][kNumFeatures];
  82 };
  83
  84 // Members of Vp9FrameHeader will be 0-initialized by Vp9Parser::ParseFrame.
  85 struct MEDIA_EXPORT Vp9LoopFilter {
  86   static const int kNumRefDeltas = 4;
  87   static const int kNumModeDeltas = 2;
  88
  89   uint8_t filter_level;
  90   uint8_t sharpness_level;
  91
  92   bool mode_ref_delta_enabled;
  93   bool mode_ref_delta_update;
  94   bool update_ref_deltas[kNumRefDeltas];
  95   int8_t ref_deltas[kNumRefDeltas];
  96   bool update_mode_deltas[kNumModeDeltas];
  97   int8_t mode_deltas[kNumModeDeltas];
  98 };
  99
 100 // Members of Vp9FrameHeader will be 0-initialized by Vp9Parser::ParseFrame.
 101 struct MEDIA_EXPORT Vp9QuantizationParams {
 102   bool IsLossless() const {
 103     return base_qindex == 0 && y_dc_delta == 0 && uv_dc_delta == 0 &&
 104            uv_ac_delta == 0;
 105   }
 106
 107   uint8_t base_qindex;
 108   int8_t y_dc_delta;
 109   int8_t uv_dc_delta;
 110   int8_t uv_ac_delta;
 111 };
 112
 113 // VP9 frame header.
 114 struct MEDIA_EXPORT Vp9FrameHeader {
 115   enum FrameType {
 116     KEYFRAME = 0,
 117     INTERFRAME = 1,
 118   };
 119
 120   bool IsKeyframe() const { return frame_type == KEYFRAME; }
 121
 122   uint8_t profile;
 123
 124   bool show_existing_frame;
 125   uint8_t frame_to_show;
 126
 127   FrameType frame_type;
 128
 129   bool show_frame;
 130   bool error_resilient_mode;
 131
 132   uint8_t bit_depth;
 133   Vp9ColorSpace color_space;
 134   bool yuv_range;
 135   uint8_t subsampling_x;
 136   uint8_t subsampling_y;
 137
 138   // The range of width and height is 1..2^16.
 139   uint32_t width;
 140   uint32_t height;
 141   uint32_t display_width;
 142   uint32_t display_height;
 143
 144   bool intra_only;
 145   uint8_t reset_context;
 146   bool refresh_flag[kVp9NumRefFrames];
 147   uint8_t frame_refs[kVp9NumRefsPerFrame];
 148   bool ref_sign_biases[kVp9NumRefsPerFrame];
 149   bool allow_high_precision_mv;
 150   Vp9InterpFilter interp_filter;
 151
 152   bool refresh_frame_context;
 153   bool frame_parallel_decoding_mode;
 154   uint8_t frame_context_idx;
 155
 156   Vp9LoopFilter loop_filter;
 157   Vp9QuantizationParams quant_params;
 158   Vp9Segmentation segment;
 159
 160   uint8_t log2_tile_cols;
 161   uint8_t log2_tile_rows;
 162
 163   // Size of compressed header in bytes.
 164   size_t first_partition_size;
 165
 166   // Size of uncompressed header in bytes.
 167   size_t uncompressed_header_size;
 168 };
 169
 170 // A parser for VP9 bitstream.
 171 class MEDIA_EXPORT Vp9Parser {
 172  public:
 173   Vp9Parser();
 174
 175   // Parses one frame and fills parsing result to |fhdr|. Returns true on
 176   // success, false otherwise.
 177   // |stream| is the address of VP9 bitstream with |size|.
 178   bool ParseFrame(const uint8_t* stream, size_t size, Vp9FrameHeader* fhdr);
 179
 180  private:
 181   // The parsing context to keep track of references.
 182   struct ReferenceSlot {
 183     uint32_t width;
 184     uint32_t height;
 185   };
 186
 187   uint8_t ReadProfile();
 188   bool VerifySyncCode();
 189   bool ReadBitDepthColorSpaceSampling(Vp9FrameHeader* fhdr);
 190   void ReadFrameSize(Vp9FrameHeader* fhdr);
 191   bool ReadFrameSizeFromRefs(Vp9FrameHeader* fhdr);
 192   void ReadDisplayFrameSize(Vp9FrameHeader* fhdr);
 193   Vp9InterpFilter ReadInterpFilter();
 194   void ReadLoopFilter(Vp9LoopFilter* loop_filter);
 195   void ReadQuantization(Vp9QuantizationParams* quants);
 196   void ReadSegmentationMap(Vp9Segmentation* segment);
 197   void ReadSegmentationData(Vp9Segmentation* segment);
 198   void ReadSegmentation(Vp9Segmentation* segment);
 199   void ReadTiles(Vp9FrameHeader* fhdr);
 200   bool ParseUncompressedHeader(Vp9FrameHeader* fhdr);
 201   void UpdateSlots(const Vp9FrameHeader* fhdr);
 202
 203   // Start address of VP9 bitstream buffer.
 204   const uint8_t* stream_;
 205
 206   // Size of |stream_| in bytes.
 207   size_t size_;
 208
 209   // Raw bits decoder for uncompressed frame header.
 210   Vp9RawBitsReader reader_;
 211
 212   // The parsing context to keep track of references.
 213   ReferenceSlot ref_slots_[kVp9NumRefFrames];
 214
 215   DISALLOW_COPY_AND_ASSIGN(Vp9Parser);
 216 };
 217
 218 }  // namespace media
 219
 220 #endif  // MEDIA_FILTERS_VP9_PARSER_H_