Home | History | Annotate | Download | only in filters 
      1 // Copyright 2014 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 an H264 Annex-B video stream parser.
      6 
      7 #ifndef MEDIA_FILTERS_H264_PARSER_H_
      8 #define MEDIA_FILTERS_H264_PARSER_H_
      9 
     10 #include <sys/types.h>
     11 
     12 #include <map>
     13 
     14 #include "base/basictypes.h"
     15 #include "media/base/media_export.h"
     16 #include "media/filters/h264_bit_reader.h"
     17 
     18 namespace media {
     19 
     20 // For explanations of each struct and its members, see H.264 specification
     21 // at http://www.itu.int/rec/T-REC-H.264.
     22 struct MEDIA_EXPORT H264NALU {
     23   H264NALU();
     24 
     25   enum Type {
     26     kUnspecified = 0,
     27     kNonIDRSlice = 1,
     28     kSliceDataA = 2,
     29     kSliceDataB = 3,
     30     kSliceDataC = 4,
     31     kIDRSlice = 5,
     32     kSEIMessage = 6,
     33     kSPS = 7,
     34     kPPS = 8,
     35     kAUD = 9,
     36     kEOSeq = 10,
     37     kEOStream = 11,
     38     kFiller = 12,
     39     kSPSExt = 13,
     40     kReserved14 = 14,
     41     kReserved15 = 15,
     42     kReserved16 = 16,
     43     kReserved17 = 17,
     44     kReserved18 = 18,
     45     kCodedSliceAux = 19,
     46     kCodedSliceExtension = 20,
     47   };
     48 
     49   // After (without) start code; we don't own the underlying memory
     50   // and a shallow copy should be made when copying this struct.
     51   const uint8* data;
     52   off_t size;  // From after start code to start code of next NALU (or EOS).
     53 
     54   int nal_ref_idc;
     55   int nal_unit_type;
     56 };
     57 
     58 enum {
     59   kH264ScalingList4x4Length = 16,
     60   kH264ScalingList8x8Length = 64,
     61 };
     62 
     63 struct MEDIA_EXPORT H264SPS {
     64   H264SPS();
     65 
     66   int profile_idc;
     67   bool constraint_set0_flag;
     68   bool constraint_set1_flag;
     69   bool constraint_set2_flag;
     70   bool constraint_set3_flag;
     71   bool constraint_set4_flag;
     72   bool constraint_set5_flag;
     73   int level_idc;
     74   int seq_parameter_set_id;
     75 
     76   int chroma_format_idc;
     77   bool separate_colour_plane_flag;
     78   int bit_depth_luma_minus8;
     79   int bit_depth_chroma_minus8;
     80   bool qpprime_y_zero_transform_bypass_flag;
     81 
     82   bool seq_scaling_matrix_present_flag;
     83   int scaling_list4x4[6][kH264ScalingList4x4Length];
     84   int scaling_list8x8[6][kH264ScalingList8x8Length];
     85 
     86   int log2_max_frame_num_minus4;
     87   int pic_order_cnt_type;
     88   int log2_max_pic_order_cnt_lsb_minus4;
     89   bool delta_pic_order_always_zero_flag;
     90   int offset_for_non_ref_pic;
     91   int offset_for_top_to_bottom_field;
     92   int num_ref_frames_in_pic_order_cnt_cycle;
     93   int expected_delta_per_pic_order_cnt_cycle;  // calculated
     94   int offset_for_ref_frame[255];
     95   int max_num_ref_frames;
     96   bool gaps_in_frame_num_value_allowed_flag;
     97   int pic_width_in_mbs_minus1;
     98   int pic_height_in_map_units_minus1;
     99   bool frame_mbs_only_flag;
    100   bool mb_adaptive_frame_field_flag;
    101   bool direct_8x8_inference_flag;
    102   bool frame_cropping_flag;
    103   int frame_crop_left_offset;
    104   int frame_crop_right_offset;
    105   int frame_crop_top_offset;
    106   int frame_crop_bottom_offset;
    107 
    108   bool vui_parameters_present_flag;
    109   int sar_width;    // Set to 0 when not specified.
    110   int sar_height;   // Set to 0 when not specified.
    111   bool bitstream_restriction_flag;
    112   int max_num_reorder_frames;
    113   int max_dec_frame_buffering;
    114 
    115   int chroma_array_type;
    116 };
    117 
    118 struct MEDIA_EXPORT H264PPS {
    119   H264PPS();
    120 
    121   int pic_parameter_set_id;
    122   int seq_parameter_set_id;
    123   bool entropy_coding_mode_flag;
    124   bool bottom_field_pic_order_in_frame_present_flag;
    125   int num_slice_groups_minus1;
    126   // TODO(posciak): Slice groups not implemented, could be added at some point.
    127   int num_ref_idx_l0_default_active_minus1;
    128   int num_ref_idx_l1_default_active_minus1;
    129   bool weighted_pred_flag;
    130   int weighted_bipred_idc;
    131   int pic_init_qp_minus26;
    132   int pic_init_qs_minus26;
    133   int chroma_qp_index_offset;
    134   bool deblocking_filter_control_present_flag;
    135   bool constrained_intra_pred_flag;
    136   bool redundant_pic_cnt_present_flag;
    137   bool transform_8x8_mode_flag;
    138 
    139   bool pic_scaling_matrix_present_flag;
    140   int scaling_list4x4[6][kH264ScalingList4x4Length];
    141   int scaling_list8x8[6][kH264ScalingList8x8Length];
    142 
    143   int second_chroma_qp_index_offset;
    144 };
    145 
    146 struct MEDIA_EXPORT H264ModificationOfPicNum {
    147   int modification_of_pic_nums_idc;
    148   union {
    149     int abs_diff_pic_num_minus1;
    150     int long_term_pic_num;
    151   };
    152 };
    153 
    154 struct MEDIA_EXPORT H264WeightingFactors {
    155   bool luma_weight_flag;
    156   bool chroma_weight_flag;
    157   int luma_weight[32];
    158   int luma_offset[32];
    159   int chroma_weight[32][2];
    160   int chroma_offset[32][2];
    161 };
    162 
    163 struct MEDIA_EXPORT H264DecRefPicMarking {
    164   int memory_mgmnt_control_operation;
    165   int difference_of_pic_nums_minus1;
    166   int long_term_pic_num;
    167   int long_term_frame_idx;
    168   int max_long_term_frame_idx_plus1;
    169 };
    170 
    171 struct MEDIA_EXPORT H264SliceHeader {
    172   H264SliceHeader();
    173 
    174   enum {
    175     kRefListSize = 32,
    176     kRefListModSize = kRefListSize
    177   };
    178 
    179   enum Type {
    180     kPSlice = 0,
    181     kBSlice = 1,
    182     kISlice = 2,
    183     kSPSlice = 3,
    184     kSISlice = 4,
    185   };
    186 
    187   bool IsPSlice() const;
    188   bool IsBSlice() const;
    189   bool IsISlice() const;
    190   bool IsSPSlice() const;
    191   bool IsSISlice() const;
    192 
    193   bool idr_pic_flag;       // from NAL header
    194   int nal_ref_idc;         // from NAL header
    195   const uint8* nalu_data;  // from NAL header
    196   off_t nalu_size;         // from NAL header
    197   off_t header_bit_size;   // calculated
    198 
    199   int first_mb_in_slice;
    200   int slice_type;
    201   int pic_parameter_set_id;
    202   int colour_plane_id;  // TODO(posciak): use this!  http://crbug.com/139878
    203   int frame_num;
    204   bool field_pic_flag;
    205   bool bottom_field_flag;
    206   int idr_pic_id;
    207   int pic_order_cnt_lsb;
    208   int delta_pic_order_cnt_bottom;
    209   int delta_pic_order_cnt[2];
    210   int redundant_pic_cnt;
    211   bool direct_spatial_mv_pred_flag;
    212 
    213   bool num_ref_idx_active_override_flag;
    214   int num_ref_idx_l0_active_minus1;
    215   int num_ref_idx_l1_active_minus1;
    216   bool ref_pic_list_modification_flag_l0;
    217   bool ref_pic_list_modification_flag_l1;
    218   H264ModificationOfPicNum ref_list_l0_modifications[kRefListModSize];
    219   H264ModificationOfPicNum ref_list_l1_modifications[kRefListModSize];
    220 
    221   int luma_log2_weight_denom;
    222   int chroma_log2_weight_denom;
    223 
    224   bool luma_weight_l0_flag;
    225   bool chroma_weight_l0_flag;
    226   H264WeightingFactors pred_weight_table_l0;
    227 
    228   bool luma_weight_l1_flag;
    229   bool chroma_weight_l1_flag;
    230   H264WeightingFactors pred_weight_table_l1;
    231 
    232   bool no_output_of_prior_pics_flag;
    233   bool long_term_reference_flag;
    234 
    235   bool adaptive_ref_pic_marking_mode_flag;
    236   H264DecRefPicMarking ref_pic_marking[kRefListSize];
    237 
    238   int cabac_init_idc;
    239   int slice_qp_delta;
    240   bool sp_for_switch_flag;
    241   int slice_qs_delta;
    242   int disable_deblocking_filter_idc;
    243   int slice_alpha_c0_offset_div2;
    244   int slice_beta_offset_div2;
    245 };
    246 
    247 struct H264SEIRecoveryPoint {
    248   int recovery_frame_cnt;
    249   bool exact_match_flag;
    250   bool broken_link_flag;
    251   int changing_slice_group_idc;
    252 };
    253 
    254 struct MEDIA_EXPORT H264SEIMessage {
    255   H264SEIMessage();
    256 
    257   enum Type {
    258     kSEIRecoveryPoint = 6,
    259   };
    260 
    261   int type;
    262   int payload_size;
    263   union {
    264     // Placeholder; in future more supported types will contribute to more
    265     // union members here.
    266     H264SEIRecoveryPoint recovery_point;
    267   };
    268 };
    269 
    270 // Class to parse an Annex-B H.264 stream,
    271 // as specified in chapters 7 and Annex B of the H.264 spec.
    272 class MEDIA_EXPORT H264Parser {
    273  public:
    274   enum Result {
    275     kOk,
    276     kInvalidStream,      // error in stream
    277     kUnsupportedStream,  // stream not supported by the parser
    278     kEOStream,           // end of stream
    279   };
    280 
    281   // Find offset from start of data to next NALU start code
    282   // and size of found start code (3 or 4 bytes).
    283   // If no start code is found, offset is pointing to the first unprocessed byte
    284   // (i.e. the first byte that was not considered as a possible start of a start
    285   // code) and |*start_code_size| is set to 0.
    286   // Preconditions:
    287   // - |data_size| >= 0
    288   // Postconditions:
    289   // - |*offset| is between 0 and |data_size| included.
    290   //   It is strictly less than |data_size| if |data_size| > 0.
    291   // - |*start_code_size| is either 0, 3 or 4.
    292   static bool FindStartCode(const uint8* data, off_t data_size,
    293                             off_t* offset, off_t* start_code_size);
    294 
    295   H264Parser();
    296   ~H264Parser();
    297 
    298   void Reset();
    299   // Set current stream pointer to |stream| of |stream_size| in bytes,
    300   // |stream| owned by caller.
    301   void SetStream(const uint8* stream, off_t stream_size);
    302 
    303   // Read the stream to find the next NALU, identify it and return
    304   // that information in |*nalu|. This advances the stream to the beginning
    305   // of this NALU, but not past it, so subsequent calls to NALU-specific
    306   // parsing functions (ParseSPS, etc.)  will parse this NALU.
    307   // If the caller wishes to skip the current NALU, it can call this function
    308   // again, instead of any NALU-type specific parse functions below.
    309   Result AdvanceToNextNALU(H264NALU* nalu);
    310 
    311   // NALU-specific parsing functions.
    312   // These should be called after AdvanceToNextNALU().
    313 
    314   // SPSes and PPSes are owned by the parser class and the memory for their
    315   // structures is managed here, not by the caller, as they are reused
    316   // across NALUs.
    317   //
    318   // Parse an SPS/PPS NALU and save their data in the parser, returning id
    319   // of the parsed structure in |*pps_id|/|*sps_id|.
    320   // To get a pointer to a given SPS/PPS structure, use GetSPS()/GetPPS(),
    321   // passing the returned |*sps_id|/|*pps_id| as parameter.
    322   // TODO(posciak,fischman): consider replacing returning Result from Parse*()
    323   // methods with a scoped_ptr and adding an AtEOS() function to check for EOS
    324   // if Parse*() return NULL.
    325   Result ParseSPS(int* sps_id);
    326   Result ParsePPS(int* pps_id);
    327 
    328   // Return a pointer to SPS/PPS with given |sps_id|/|pps_id| or NULL if not
    329   // present.
    330   const H264SPS* GetSPS(int sps_id);
    331   const H264PPS* GetPPS(int pps_id);
    332 
    333   // Slice headers and SEI messages are not used across NALUs by the parser
    334   // and can be discarded after current NALU, so the parser does not store
    335   // them, nor does it manage their memory.
    336   // The caller has to provide and manage it instead.
    337 
    338   // Parse a slice header, returning it in |*shdr|. |*nalu| must be set to
    339   // the NALU returned from AdvanceToNextNALU() and corresponding to |*shdr|.
    340   Result ParseSliceHeader(const H264NALU& nalu, H264SliceHeader* shdr);
    341 
    342   // Parse a SEI message, returning it in |*sei_msg|, provided and managed
    343   // by the caller.
    344   Result ParseSEI(H264SEIMessage* sei_msg);
    345 
    346  private:
    347   // Move the stream pointer to the beginning of the next NALU,
    348   // i.e. pointing at the next start code.
    349   // Return true if a NALU has been found.
    350   // If a NALU is found:
    351   // - its size in bytes is returned in |*nalu_size| and includes
    352   //   the start code as well as the trailing zero bits.
    353   // - the size in bytes of the start code is returned in |*start_code_size|.
    354   bool LocateNALU(off_t* nalu_size, off_t* start_code_size);
    355 
    356   // Exp-Golomb code parsing as specified in chapter 9.1 of the spec.
    357   // Read one unsigned exp-Golomb code from the stream and return in |*val|.
    358   Result ReadUE(int* val);
    359 
    360   // Read one signed exp-Golomb code from the stream and return in |*val|.
    361   Result ReadSE(int* val);
    362 
    363   // Parse scaling lists (see spec).
    364   Result ParseScalingList(int size, int* scaling_list, bool* use_default);
    365   Result ParseSPSScalingLists(H264SPS* sps);
    366   Result ParsePPSScalingLists(const H264SPS& sps, H264PPS* pps);
    367 
    368   // Parse optional VUI parameters in SPS (see spec).
    369   Result ParseVUIParameters(H264SPS* sps);
    370   // Set |hrd_parameters_present| to true only if they are present.
    371   Result ParseAndIgnoreHRDParameters(bool* hrd_parameters_present);
    372 
    373   // Parse reference picture lists' modifications (see spec).
    374   Result ParseRefPicListModifications(H264SliceHeader* shdr);
    375   Result ParseRefPicListModification(int num_ref_idx_active_minus1,
    376                                      H264ModificationOfPicNum* ref_list_mods);
    377 
    378   // Parse prediction weight table (see spec).
    379   Result ParsePredWeightTable(const H264SPS& sps, H264SliceHeader* shdr);
    380 
    381   // Parse weighting factors (see spec).
    382   Result ParseWeightingFactors(int num_ref_idx_active_minus1,
    383                                int chroma_array_type,
    384                                int luma_log2_weight_denom,
    385                                int chroma_log2_weight_denom,
    386                                H264WeightingFactors* w_facts);
    387 
    388   // Parse decoded reference picture marking information (see spec).
    389   Result ParseDecRefPicMarking(H264SliceHeader* shdr);
    390 
    391   // Pointer to the current NALU in the stream.
    392   const uint8* stream_;
    393 
    394   // Bytes left in the stream after the current NALU.
    395   off_t bytes_left_;
    396 
    397   H264BitReader br_;
    398 
    399   // PPSes and SPSes stored for future reference.
    400   typedef std::map<int, H264SPS*> SPSById;
    401   typedef std::map<int, H264PPS*> PPSById;
    402   SPSById active_SPSes_;
    403   PPSById active_PPSes_;
    404 
    405   DISALLOW_COPY_AND_ASSIGN(H264Parser);
    406 };
    407 
    408 }  // namespace media
    409 
    410 #endif  // MEDIA_FILTERS_H264_PARSER_H_
    411