OLD | NEW |
(Empty) | |
| 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_ |
OLD | NEW |