| // 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 "base/macros.h" |
| #include "media/base/media_export.h" |
| #include "media/filters/vp9_raw_bits_reader.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; |
| |
| enum class Vp9ColorSpace { |
| UNKNOWN = 0, |
| BT_601 = 1, |
| BT_709 = 2, |
| SMPTE_170 = 3, |
| SMPTE_240 = 4, |
| BT_2020 = 5, |
| RESERVED = 6, |
| SRGB = 7, |
| }; |
| |
| enum Vp9InterpFilter { |
| EIGHTTAP = 0, |
| EIGHTTAP_SMOOTH = 1, |
| EIGHTTAP_SHARP = 2, |
| BILINEAR = 3, |
| SWICHABLE = 4, |
| }; |
| |
| struct MEDIA_EXPORT Vp9Segmentation { |
| static const size_t kNumSegments = 8; |
| static const size_t kNumTreeProbs = kNumSegments - 1; |
| static const size_t kNumPredictionProbs = 3; |
| enum SegmentLevelFeature { |
| SEG_LVL_ALT_Q = 0, |
| SEG_LVL_ALT_LF = 1, |
| SEG_LVL_REF_FRAME = 2, |
| SEG_LVL_SKIP = 3, |
| SEG_LVL_MAX |
| }; |
| |
| bool enabled; |
| |
| bool update_map; |
| uint8_t tree_probs[kNumTreeProbs]; |
| bool temporal_update; |
| uint8_t pred_probs[kNumPredictionProbs]; |
| |
| bool update_data; |
| bool abs_delta; |
| bool feature_enabled[kNumSegments][SEG_LVL_MAX]; |
| int16_t feature_data[kNumSegments][SEG_LVL_MAX]; |
| |
| int16_t y_dequant[kNumSegments][2]; |
| int16_t uv_dequant[kNumSegments][2]; |
| |
| bool FeatureEnabled(size_t seg_id, SegmentLevelFeature feature) const { |
| return feature_enabled[seg_id][feature]; |
| } |
| |
| int16_t FeatureData(size_t seg_id, SegmentLevelFeature feature) const { |
| return feature_data[seg_id][feature]; |
| } |
| }; |
| |
| struct MEDIA_EXPORT Vp9LoopFilter { |
| enum Vp9FrameType { |
| VP9_FRAME_INTRA = 0, |
| VP9_FRAME_LAST = 1, |
| VP9_FRAME_GOLDEN = 2, |
| VP9_FRAME_ALTREF = 3, |
| VP9_FRAME_MAX = 4, |
| }; |
| |
| static const size_t kNumModeDeltas = 2; |
| |
| uint8_t filter_level; |
| uint8_t sharpness_level; |
| |
| bool mode_ref_delta_enabled; |
| bool mode_ref_delta_update; |
| bool update_ref_deltas[VP9_FRAME_MAX]; |
| int8_t ref_deltas[VP9_FRAME_MAX]; |
| bool update_mode_deltas[kNumModeDeltas]; |
| int8_t mode_deltas[kNumModeDeltas]; |
| |
| uint8_t lvl[Vp9Segmentation::kNumSegments][VP9_FRAME_MAX][kNumModeDeltas]; |
| }; |
| |
| // Members of Vp9FrameHeader will be 0-initialized by Vp9Parser::ParseNextFrame. |
| struct MEDIA_EXPORT Vp9QuantizationParams { |
| bool IsLossless() const { |
| return base_qindex == 0 && y_dc_delta == 0 && uv_dc_delta == 0 && |
| uv_ac_delta == 0; |
| } |
| |
| uint8_t base_qindex; |
| int8_t y_dc_delta; |
| int8_t uv_dc_delta; |
| int8_t uv_ac_delta; |
| }; |
| |
| // VP9 frame header. |
| struct MEDIA_EXPORT Vp9FrameHeader { |
| enum FrameType { |
| KEYFRAME = 0, |
| INTERFRAME = 1, |
| }; |
| |
| bool IsKeyframe() const; |
| bool RefreshFlag(size_t i) const { return !!(refresh_flags & (1u << i)); } |
| |
| uint8_t profile; |
| |
| bool show_existing_frame; |
| uint8_t frame_to_show; |
| |
| FrameType frame_type; |
| |
| bool show_frame; |
| bool error_resilient_mode; |
| |
| uint8_t bit_depth; |
| Vp9ColorSpace color_space; |
| bool yuv_range; |
| uint8_t subsampling_x; |
| uint8_t subsampling_y; |
| |
| // The range of width and height is 1..2^16. |
| uint32_t width; |
| uint32_t height; |
| uint32_t display_width; |
| uint32_t display_height; |
| |
| bool intra_only; |
| uint8_t reset_context; |
| uint8_t refresh_flags; |
| uint8_t frame_refs[kVp9NumRefsPerFrame]; |
| bool ref_sign_biases[kVp9NumRefsPerFrame]; |
| bool allow_high_precision_mv; |
| Vp9InterpFilter interp_filter; |
| |
| bool refresh_frame_context; |
| bool frame_parallel_decoding_mode; |
| uint8_t frame_context_idx; |
| |
| Vp9QuantizationParams quant_params; |
| |
| uint8_t log2_tile_cols; |
| uint8_t log2_tile_rows; |
| |
| // Pointer to the beginning of frame data. It is a responsibility of the |
| // client of the Vp9Parser to maintain validity of this data while it is |
| // being used outside of that class. |
| const uint8_t* data; |
| |
| // Size of |data| in bytes. |
| size_t frame_size; |
| |
| // Size of compressed header in bytes. |
| size_t first_partition_size; |
| |
| // Size of uncompressed header in bytes. |
| size_t uncompressed_header_size; |
| }; |
| |
| // A parser for VP9 bitstream. |
| class MEDIA_EXPORT Vp9Parser { |
| public: |
| // ParseNextFrame() return values. See documentation for ParseNextFrame(). |
| enum Result { |
| kOk, |
| kInvalidStream, |
| kEOStream, |
| }; |
| |
| Vp9Parser(); |
| ~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. Return kOk if a frame has successfully been parsed, kEOStream if |
| // there is no more data in the current stream buffer, or kInvalidStream |
| // on error. |
| Result ParseNextFrame(Vp9FrameHeader* fhdr); |
| |
| // Return current segmentation state. |
| const Vp9Segmentation& GetSegmentation() const { return segmentation_; } |
| |
| // Return current loop filter state. |
| const Vp9LoopFilter& GetLoopFilter() const { return loop_filter_; } |
| |
| // Clear parser state and return to an initialized state. |
| void Reset(); |
| |
| private: |
| // The parsing context to keep track of references. |
| struct ReferenceSlot { |
| uint32_t width; |
| uint32_t height; |
| }; |
| |
| bool ParseSuperframe(); |
| uint8_t ReadProfile(); |
| bool VerifySyncCode(); |
| bool ReadBitDepthColorSpaceSampling(Vp9FrameHeader* fhdr); |
| void ReadFrameSize(Vp9FrameHeader* fhdr); |
| bool ReadFrameSizeFromRefs(Vp9FrameHeader* fhdr); |
| void ReadDisplayFrameSize(Vp9FrameHeader* fhdr); |
| Vp9InterpFilter ReadInterpFilter(); |
| void ReadLoopFilter(); |
| void ReadQuantization(Vp9QuantizationParams* quants); |
| void ReadSegmentationMap(); |
| void ReadSegmentationData(); |
| void ReadSegmentation(); |
| void ReadTiles(Vp9FrameHeader* fhdr); |
| bool ParseUncompressedHeader(const uint8_t* stream, |
| off_t frame_size, |
| Vp9FrameHeader* fhdr); |
| void UpdateSlots(const Vp9FrameHeader* fhdr); |
| |
| void ResetLoopfilter(); |
| void SetupPastIndependence(); |
| size_t GetQIndex(const Vp9QuantizationParams& quant, size_t segid) const; |
| void SetupSegmentationDequant(const Vp9QuantizationParams& quant); |
| void SetupLoopFilter(); |
| |
| // Current address in the bitstream buffer. |
| const uint8_t* stream_; |
| |
| // Remaining bytes in stream_. |
| off_t bytes_left_; |
| |
| // Stores start pointer and size of each frame within the current superframe. |
| struct FrameInfo { |
| FrameInfo(const uint8_t* ptr, off_t size); |
| |
| // Starting address of the frame. |
| const uint8_t* ptr; |
| |
| // Size of the frame in bytes. |
| off_t size; |
| }; |
| |
| // FrameInfo for the remaining frames in the current superframe to be parsed. |
| std::deque<FrameInfo> frames_; |
| |
| // Raw bits decoder for uncompressed frame header. |
| Vp9RawBitsReader reader_; |
| |
| // Segmentation and loop filter state that persists across frames. |
| Vp9Segmentation segmentation_; |
| Vp9LoopFilter loop_filter_; |
| |
| // The parsing context to keep track of references. |
| ReferenceSlot ref_slots_[kVp9NumRefFrames]; |
| |
| DISALLOW_COPY_AND_ASSIGN(Vp9Parser); |
| }; |
| |
| } // namespace media |
| |
| #endif // MEDIA_FILTERS_VP9_PARSER_H_ |