[M120 Migration][MM] Framerate calculation
[platform/framework/web/chromium-efl.git] / media / video / h265_parser.h
1 // Copyright 2015 The Chromium Authors
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 H265 Annex-B video stream parser.
6
7 #ifndef MEDIA_VIDEO_H265_PARSER_H_
8 #define MEDIA_VIDEO_H265_PARSER_H_
9
10 #include <stdint.h>
11 #include <sys/types.h>
12
13 #include <vector>
14
15 #include "base/containers/flat_map.h"
16 #include "media/base/media_export.h"
17 #include "media/base/ranges.h"
18 #include "media/base/video_color_space.h"
19 #include "media/base/video_types.h"
20 #include "media/video/h264_bit_reader.h"
21 #include "media/video/h264_parser.h"
22 #include "media/video/h265_nalu_parser.h"
23
24 namespace gfx {
25 struct HdrMetadataCta861_3;
26 struct HdrMetadataSmpteSt2086;
27 }  // namespace gfx
28
29 namespace media {
30
31 // For explanations of each struct and its members, see H.265 specification
32 // at http://www.itu.int/rec/T-REC-H.265.
33 enum {
34   kMaxLongTermRefPicSets = 32,   // 7.4.3.2.1
35   kMaxShortTermRefPicSets = 64,  // 7.4.3.2.1
36   kMaxSubLayers = 7,  // 7.4.3.1 & 7.4.3.2.1 [v|s]ps_max_sub_layers_minus1 + 1
37   kMaxDpbSize = 16,   // A.4.2
38   kMaxRefIdxActive = 15,  // 7.4.7.1 num_ref_idx_l{0,1}_active_minus1 + 1
39 };
40
41 struct MEDIA_EXPORT H265ProfileTierLevel {
42   H265ProfileTierLevel();
43
44   enum H265ProfileIdc {
45     kProfileIdcMain = 1,
46     kProfileIdcMain10 = 2,
47     kProfileIdcMainStill = 3,
48     kProfileIdcRangeExtensions = 4,
49     kProfileIdcHighThroughput = 5,
50     kProfileIdcMultiviewMain = 6,
51     kProfileIdcScalableMain = 7,
52     kProfileIdc3dMain = 8,
53     kProfileIdcScreenContentCoding = 9,
54     kProfileIdcScalableRangeExtensions = 10,
55     kProfileIdcHighThroughputScreenContentCoding = 11,
56   };
57
58   // Syntax elements.
59   int general_profile_idc;
60   int general_level_idc;  // 30x the actual level.
61   uint32_t general_profile_compatibility_flags;
62   bool general_progressive_source_flag;
63   bool general_interlaced_source_flag;
64   bool general_non_packed_constraint_flag;
65   bool general_frame_only_constraint_flag;
66   bool general_one_picture_only_constraint_flag;
67
68   // From Table A.8 - General tier and level limits.
69   int GetMaxLumaPs() const;
70   // From A.4.2 - Profile-specific level limits for the video profiles.
71   size_t GetDpbMaxPicBuf() const;
72 };
73
74 struct MEDIA_EXPORT H265ScalingListData {
75   H265ScalingListData();
76
77   enum {
78     kDefaultScalingListSize0Values = 16,  // Table 7-5, all values are 16
79     kScalingListSizeId0Count = 16,        // 7.4.5
80     kScalingListSizeId1To3Count = 64,     // 7.4.5
81     kNumScalingListMatrices = 6,
82   };
83
84   // TODO(jkardatzke): Optimize storage of the 32x32 since only indices 0 and 3
85   // are actually used. Also change it in the accelerator delegate if that is
86   // done.
87   // Syntax elements.
88   uint8_t scaling_list_dc_coef_16x16[kNumScalingListMatrices];
89   uint8_t scaling_list_dc_coef_32x32[kNumScalingListMatrices];
90   uint8_t scaling_list_4x4[kNumScalingListMatrices][kScalingListSizeId0Count];
91   uint8_t scaling_list_8x8[kNumScalingListMatrices]
92                           [kScalingListSizeId1To3Count];
93   uint8_t scaling_list_16x16[kNumScalingListMatrices]
94                             [kScalingListSizeId1To3Count];
95   uint8_t scaling_list_32x32[kNumScalingListMatrices]
96                             [kScalingListSizeId1To3Count];
97 };
98
99 struct MEDIA_EXPORT H265StRefPicSet {
100   H265StRefPicSet();
101
102   // Syntax elements.
103   int num_negative_pics;
104   int num_positive_pics;
105   int delta_poc_s0[kMaxShortTermRefPicSets];
106   int used_by_curr_pic_s0[kMaxShortTermRefPicSets];
107   int delta_poc_s1[kMaxShortTermRefPicSets];
108   int used_by_curr_pic_s1[kMaxShortTermRefPicSets];
109
110   // Calculated fields.
111   int num_delta_pocs;
112   int rps_idx_num_delta_pocs;
113 };
114
115 struct MEDIA_EXPORT H265VUIParameters {
116   H265VUIParameters();
117
118   // Syntax elements.
119   int sar_width;
120   int sar_height;
121   bool video_full_range_flag;
122   bool colour_description_present_flag;
123   int colour_primaries;
124   int transfer_characteristics;
125   int matrix_coeffs;
126   int def_disp_win_left_offset;
127   int def_disp_win_right_offset;
128   int def_disp_win_top_offset;
129   int def_disp_win_bottom_offset;
130
131   bool timing_info_present_flag = false;
132   // Not part of standard, used only for replacing timing_info data
133   int timing_info_bit_offset_from_nal_end = 0;
134
135   bool bitstream_restriction_flag;
136   int min_spatial_segmentation_idc;
137   int max_bytes_per_pic_denom;
138   int max_bits_per_min_cu_denom;
139   int log2_max_mv_length_horizontal;
140   int log2_max_mv_length_vertical;
141 };
142
143 struct MEDIA_EXPORT H265VPS {
144   H265VPS();
145
146   int vps_video_parameter_set_id;
147   bool vps_base_layer_internal_flag;
148   bool vps_base_layer_available_flag;
149   int vps_max_layers_minus1;
150   int vps_max_sub_layers_minus1;
151   bool vps_temporal_id_nesting_flag;
152   H265ProfileTierLevel profile_tier_level;
153   int vps_max_dec_pic_buffering_minus1[kMaxSubLayers];
154   int vps_max_num_reorder_pics[kMaxSubLayers];
155   int vps_max_latency_increase_plus1[kMaxSubLayers];
156   int vps_max_layer_id;
157   int vps_num_layer_sets_minus1;
158
159   // Computed from ScalabilityId
160   int aux_alpha_layer_id;
161
162   // skipped the rest
163 };
164
165 struct MEDIA_EXPORT H265SPS {
166   H265SPS();
167
168   // Syntax elements.
169   int sps_video_parameter_set_id;
170   int sps_max_sub_layers_minus1;
171   bool sps_temporal_id_nesting_flag;
172   H265ProfileTierLevel profile_tier_level;
173   int sps_seq_parameter_set_id;
174   int chroma_format_idc;
175   bool separate_colour_plane_flag;
176   int pic_width_in_luma_samples;
177   int pic_height_in_luma_samples;
178   int conf_win_left_offset;
179   int conf_win_right_offset;
180   int conf_win_top_offset;
181   int conf_win_bottom_offset;
182   int bit_depth_luma_minus8;
183   int bit_depth_chroma_minus8;
184   int log2_max_pic_order_cnt_lsb_minus4;
185   int sps_max_dec_pic_buffering_minus1[kMaxSubLayers];
186   int sps_max_num_reorder_pics[kMaxSubLayers];
187   uint32_t sps_max_latency_increase_plus1[kMaxSubLayers];
188   int log2_min_luma_coding_block_size_minus3;
189   int log2_diff_max_min_luma_coding_block_size;
190   int log2_min_luma_transform_block_size_minus2;
191   int log2_diff_max_min_luma_transform_block_size;
192   int max_transform_hierarchy_depth_inter;
193   int max_transform_hierarchy_depth_intra;
194   bool scaling_list_enabled_flag;
195   bool sps_scaling_list_data_present_flag;
196   H265ScalingListData scaling_list_data;
197   bool amp_enabled_flag;
198   bool sample_adaptive_offset_enabled_flag;
199   bool pcm_enabled_flag;
200   int pcm_sample_bit_depth_luma_minus1;
201   int pcm_sample_bit_depth_chroma_minus1;
202   int log2_min_pcm_luma_coding_block_size_minus3;
203   int log2_diff_max_min_pcm_luma_coding_block_size;
204   bool pcm_loop_filter_disabled_flag;
205   int num_short_term_ref_pic_sets;
206   H265StRefPicSet st_ref_pic_set[kMaxShortTermRefPicSets];
207   bool long_term_ref_pics_present_flag;
208   int num_long_term_ref_pics_sps;
209   int lt_ref_pic_poc_lsb_sps[kMaxLongTermRefPicSets];
210   bool used_by_curr_pic_lt_sps_flag[kMaxLongTermRefPicSets];
211   bool sps_temporal_mvp_enabled_flag;
212   bool strong_intra_smoothing_enabled_flag;
213   H265VUIParameters vui_parameters;
214
215   // Extension extra elements.
216   bool sps_extension_present_flag;
217   bool sps_range_extension_flag;
218   bool sps_multilayer_extension_flag;
219   bool sps_3d_extension_flag;
220   bool sps_scc_extension_flag;
221   bool transform_skip_rotation_enabled_flag;
222   bool transform_skip_context_enabled_flag;
223   bool implicit_rdpcm_enabled_flag;
224   bool explicit_rdpcm_enabled_flag;
225   bool extended_precision_processing_flag;
226   bool intra_smoothing_disabled_flag;
227   bool high_precision_offsets_enabled_flag;
228   bool persistent_rice_adaptation_enabled_flag;
229   bool cabac_bypass_alignment_enabled_flag;
230
231   // Calculated fields.
232   int chroma_array_type;
233   int sub_width_c;
234   int sub_height_c;
235   size_t max_dpb_size;
236   int bit_depth_y;
237   int bit_depth_c;
238   int max_pic_order_cnt_lsb;
239   int ctb_log2_size_y;
240   int pic_width_in_ctbs_y;
241   int pic_height_in_ctbs_y;
242   int pic_size_in_ctbs_y;
243   int wp_offset_half_range_y;
244   int wp_offset_half_range_c;
245   bool vui_parameters_present_flag = false;
246   uint32_t sps_max_latency_pictures[kMaxSubLayers];
247
248   // Helpers to compute frequently-used values. They do not verify that the
249   // results are in-spec for the given profile or level.
250   gfx::Size GetCodedSize() const;
251   gfx::Rect GetVisibleRect() const;
252   VideoColorSpace GetColorSpace() const;
253   VideoChromaSampling GetChromaSampling() const;
254 };
255
256 struct MEDIA_EXPORT H265PPS {
257   H265PPS();
258
259   enum {
260     kMaxNumTileColumnWidth = 19,  // From VAAPI.
261     kMaxNumTileRowHeight = 21,    // From VAAPI.
262   };
263
264   int temporal_id;  // calculated from NALU
265
266   // Syntax elements.
267   int pps_pic_parameter_set_id;
268   int pps_seq_parameter_set_id;
269   bool dependent_slice_segments_enabled_flag;
270   bool output_flag_present_flag;
271   int num_extra_slice_header_bits;
272   bool sign_data_hiding_enabled_flag;
273   bool cabac_init_present_flag;
274   int num_ref_idx_l0_default_active_minus1;
275   int num_ref_idx_l1_default_active_minus1;
276   int init_qp_minus26;
277   bool constrained_intra_pred_flag;
278   bool transform_skip_enabled_flag;
279   bool cu_qp_delta_enabled_flag;
280   int diff_cu_qp_delta_depth;
281   int pps_cb_qp_offset;
282   int pps_cr_qp_offset;
283   bool pps_slice_chroma_qp_offsets_present_flag;
284   bool weighted_pred_flag;
285   bool weighted_bipred_flag;
286   bool transquant_bypass_enabled_flag;
287   bool tiles_enabled_flag;
288   bool entropy_coding_sync_enabled_flag;
289   int num_tile_columns_minus1;
290   int num_tile_rows_minus1;
291   bool uniform_spacing_flag;
292   int column_width_minus1[kMaxNumTileColumnWidth];
293   int row_height_minus1[kMaxNumTileRowHeight];
294   bool loop_filter_across_tiles_enabled_flag;
295   bool pps_loop_filter_across_slices_enabled_flag;
296   bool deblocking_filter_control_present_flag;
297   bool deblocking_filter_override_enabled_flag;
298   bool pps_deblocking_filter_disabled_flag;
299   int pps_beta_offset_div2;
300   int pps_tc_offset_div2;
301   bool pps_scaling_list_data_present_flag;
302   H265ScalingListData scaling_list_data;
303   bool lists_modification_present_flag;
304   int log2_parallel_merge_level_minus2;
305   bool slice_segment_header_extension_present_flag;
306
307   // Extension extra elements.
308   bool pps_extension_present_flag;
309   bool pps_range_extension_flag;
310   bool pps_multilayer_extension_flag;
311   bool pps_3d_extension_flag;
312   bool pps_scc_extension_flag;
313   int log2_max_transform_skip_block_size_minus2;
314   bool cross_component_prediction_enabled_flag;
315   bool chroma_qp_offset_list_enabled_flag;
316   int diff_cu_chroma_qp_offset_depth;
317   int chroma_qp_offset_list_len_minus1;
318   int cb_qp_offset_list[6];
319   int cr_qp_offset_list[6];
320   int log2_sao_offset_scale_luma;
321   int log2_sao_offset_scale_chroma;
322
323   // Calculated fields.
324   int qp_bd_offset_y;
325 };
326
327 struct MEDIA_EXPORT H265RefPicListsModifications {
328   H265RefPicListsModifications();
329
330   // Syntax elements.
331   bool ref_pic_list_modification_flag_l0;
332   int list_entry_l0[kMaxRefIdxActive];
333   bool ref_pic_list_modification_flag_l1;
334   int list_entry_l1[kMaxRefIdxActive];
335 };
336
337 struct MEDIA_EXPORT H265PredWeightTable {
338   H265PredWeightTable();
339
340   // Syntax elements.
341   int luma_log2_weight_denom;
342   int delta_chroma_log2_weight_denom;
343   int chroma_log2_weight_denom;
344   int delta_luma_weight_l0[kMaxRefIdxActive];
345   int luma_offset_l0[kMaxRefIdxActive];
346   int delta_chroma_weight_l0[kMaxRefIdxActive][2];
347   int delta_chroma_offset_l0[kMaxRefIdxActive][2];
348   int delta_luma_weight_l1[kMaxRefIdxActive];
349   int luma_offset_l1[kMaxRefIdxActive];
350   int delta_chroma_weight_l1[kMaxRefIdxActive][2];
351   int delta_chroma_offset_l1[kMaxRefIdxActive][2];
352 };
353
354 struct MEDIA_EXPORT H265SliceHeader {
355   H265SliceHeader();
356
357   enum {
358     kSliceTypeB = 0,  // Table 7-7
359     kSliceTypeP = 1,  // Table 7-7
360     kSliceTypeI = 2,  // Table 7-7
361   };
362
363   int nal_unit_type;         // from NAL header
364   const uint8_t* nalu_data;  // from NAL header
365   size_t nalu_size;          // from NAL header
366   size_t header_size;  // calculated, not including emulation prevention bytes
367   size_t header_emulation_prevention_bytes;
368
369   // Calculated, but needs to be preserved when we copy slice dependent data
370   // so put it at the front.
371   bool irap_pic;
372
373   // Syntax elements.
374   bool first_slice_segment_in_pic_flag;
375   bool no_output_of_prior_pics_flag;
376   int slice_pic_parameter_set_id;
377   bool dependent_slice_segment_flag;
378   int slice_segment_address;
379   // Do not move any of the above fields below or vice-versa, everything after
380   // this is copied as a block.
381   int slice_type;
382   bool pic_output_flag;
383   int colour_plane_id;
384   int slice_pic_order_cnt_lsb;
385   bool short_term_ref_pic_set_sps_flag;
386   H265StRefPicSet st_ref_pic_set;
387   // Do not change the order of the following fields up through
388   // slice_sao_luma_flag. They are compared as a block.
389   int short_term_ref_pic_set_idx;
390   int num_long_term_sps;
391   int num_long_term_pics;
392   int poc_lsb_lt[kMaxLongTermRefPicSets];
393   bool used_by_curr_pic_lt[kMaxLongTermRefPicSets];
394   bool delta_poc_msb_present_flag[kMaxLongTermRefPicSets];
395   int delta_poc_msb_cycle_lt[kMaxLongTermRefPicSets];
396   bool slice_temporal_mvp_enabled_flag;
397   bool slice_sao_luma_flag;
398   bool slice_sao_chroma_flag;
399   bool num_ref_idx_active_override_flag;
400   int num_ref_idx_l0_active_minus1;
401   int num_ref_idx_l1_active_minus1;
402   H265RefPicListsModifications ref_pic_lists_modification;
403   bool mvd_l1_zero_flag;
404   bool cabac_init_flag;
405   bool collocated_from_l0_flag;
406   int collocated_ref_idx;
407   H265PredWeightTable pred_weight_table;
408   int five_minus_max_num_merge_cand;
409   int slice_qp_delta;
410   int slice_cb_qp_offset;
411   int slice_cr_qp_offset;
412   bool slice_deblocking_filter_disabled_flag;
413   int slice_beta_offset_div2;
414   int slice_tc_offset_div2;
415   bool slice_loop_filter_across_slices_enabled_flag;
416
417   // Calculated.
418   int curr_rps_idx;
419   int num_pic_total_curr;
420   // Number of bits st_ref_pic_set takes after removing emulation prevention
421   // bytes.
422   int st_rps_bits;
423   // Number of bits lt_ref_pic_set takes after removing emulation prevention
424   // bytes.
425   int lt_rps_bits;
426
427   bool IsISlice() const;
428   bool IsPSlice() const;
429   bool IsBSlice() const;
430
431   const H265StRefPicSet& GetStRefPicSet(const H265SPS* sps) const {
432     if (curr_rps_idx == sps->num_short_term_ref_pic_sets)
433       return st_ref_pic_set;
434
435     return sps->st_ref_pic_set[curr_rps_idx];
436   }
437 };
438
439 struct MEDIA_EXPORT H265SEIAlphaChannelInfo {
440   bool alpha_channel_cancel_flag;
441   int alpha_channel_use_idc;
442   int alpha_channel_bit_depth_minus8;
443   int alpha_transparent_value;
444   int alpha_opaque_value;
445   bool alpha_channel_incr_flag;
446   bool alpha_channel_clip_flag;
447   bool alpha_channel_clip_type_flag;
448 };
449
450 struct MEDIA_EXPORT H265SEIContentLightLevelInfo {
451   uint16_t max_content_light_level;
452   uint16_t max_picture_average_light_level;
453
454   gfx::HdrMetadataCta861_3 ToGfx() const;
455 };
456
457 struct MEDIA_EXPORT H265SEIMasteringDisplayInfo {
458   enum {
459     kNumDisplayPrimaries = 3,
460     kDisplayPrimaryComponents = 2,
461   };
462
463   uint16_t display_primaries[kNumDisplayPrimaries][kDisplayPrimaryComponents];
464   uint16_t white_points[2];
465   uint32_t max_luminance;
466   uint32_t min_luminance;
467
468   gfx::HdrMetadataSmpteSt2086 ToGfx() const;
469 };
470
471 struct MEDIA_EXPORT H265SEIMessage {
472   H265SEIMessage();
473
474   enum Type {
475     kSEIMasteringDisplayInfo = 137,
476     kSEIContentLightLevelInfo = 144,
477     kSEIAlphaChannelInfo = 165,
478   };
479
480   int type;
481   int payload_size;
482   union {
483     // Placeholder; in future more supported types will contribute to more
484     // union members here.
485     H265SEIAlphaChannelInfo alpha_channel_info;
486     H265SEIContentLightLevelInfo content_light_level_info;
487     H265SEIMasteringDisplayInfo mastering_display_info;
488   };
489 };
490
491 struct MEDIA_EXPORT H265SEI {
492   H265SEI();
493   ~H265SEI();
494
495   std::vector<H265SEIMessage> msgs;
496 };
497
498 // Class to parse an Annex-B H.265 stream.
499 class MEDIA_EXPORT H265Parser : public H265NaluParser {
500  public:
501   H265Parser();
502
503   H265Parser(const H265Parser&) = delete;
504   H265Parser& operator=(const H265Parser&) = delete;
505
506   ~H265Parser() override;
507
508   // NALU-specific parsing functions.
509   // These should be called after AdvanceToNextNALU().
510
511   // VPSes, SPSes and PPSes are owned by the parser class and the memory for
512   // their structures is managed here, not by the caller, as they are
513   // reused across NALUs.
514   //
515   // Parse an VPS/SPS/PPS NALU and save their data in the parser, returning id
516   // of the parsed structure in |*pps_id|/|*sps_id|/|*vps_id|. To get a pointer
517   // to a given VPS/SPS/PPS structure, use GetVPS()/GetSPS()/GetPPS(), passing
518   // the returned |*vps_id|/|*sps_id|/|*pps_id| as parameter.
519   Result ParseVPS(int* vps_id);
520   Result ParseSPS(int* sps_id);
521   Result ParsePPS(const H265NALU& nalu, int* pps_id);
522
523   // Return a pointer to VPS/SPS/PPS with given |*vps_id|/|sps_id|/|pps_id| or
524   // null if not present.
525   const H265VPS* GetVPS(int vps_id) const;
526   const H265SPS* GetSPS(int sps_id) const;
527   const H265PPS* GetPPS(int pps_id) const;
528
529   // Slice headers are not used across NALUs by the parser and can be discarded
530   // after current NALU, so the parser does not store them, nor does it manage
531   // their memory. The caller has to provide and manage it instead.
532
533   // Parse a slice header, returning it in |*shdr|. |*nalu| must be set to
534   // the NALU returned from AdvanceToNextNALU() and corresponding to |*shdr|.
535   // |prior_shdr| should be the last parsed header in decoding order for
536   // handling dependent slice segments. If |prior_shdr| is null and this is a
537   // dependent slice segment, an error will be returned.
538   Result ParseSliceHeader(const H265NALU& nalu,
539                           H265SliceHeader* shdr,
540                           H265SliceHeader* prior_shdr);
541
542   // Parse a slice header and return the associated picture parameter set ID.
543   Result ParseSliceHeaderForPictureParameterSets(const H265NALU& nalu,
544                                                  int* pps_id);
545
546   // Parse a SEI, returning it in |*sei|, provided and managed by the caller.
547   Result ParseSEI(H265SEI* sei);
548
549   static VideoCodecProfile ProfileIDCToVideoCodecProfile(int profile_idc);
550
551   void UpdateTimingInfoIfNeeded(std::vector<std::vector<uint8_t>>* spses_array,
552                                 int num_units_in_tick,
553                                 int time_scale);
554
555  private:
556   Result ParseProfileTierLevel(bool profile_present,
557                                int max_num_sub_layers_minus1,
558                                H265ProfileTierLevel* profile_tier_level);
559   Result ParseScalingListData(H265ScalingListData* scaling_list_data);
560   Result ParseStRefPicSet(int st_rps_idx,
561                           const H265SPS& sps,
562                           H265StRefPicSet* st_ref_pic_set,
563                           bool is_slice_hdr = false);
564   Result ParseVuiParameters(const H265SPS& sps, H265VUIParameters* vui);
565   Result ParseAndIgnoreHrdParameters(bool common_inf_present_flag,
566                                      int max_num_sub_layers_minus1);
567   Result ParseAndIgnoreSubLayerHrdParameters(
568       int cpb_cnt,
569       bool sub_pic_hrd_params_present_flag);
570   Result ParseRefPicListsModifications(const H265SliceHeader& shdr,
571                                        H265RefPicListsModifications* rpl_mod);
572   Result ParsePredWeightTable(const H265SPS& sps,
573                               const H265SliceHeader& shdr,
574                               H265PredWeightTable* pred_weight_table);
575   std::vector<uint8_t> PrepareSPSWithTimingInfo(
576       const std::vector<uint8_t>& old_sps,
577       int sps_id,
578       int num_units_in_tick,
579       int time_scale);
580
581   // VPSes, PPSes and SPSes stored for future reference.
582   base::flat_map<int, std::unique_ptr<H265VPS>> active_vps_;
583   base::flat_map<int, std::unique_ptr<H265SPS>> active_sps_;
584   base::flat_map<int, std::unique_ptr<H265PPS>> active_pps_;
585 };
586
587 }  // namespace media
588
589 #endif  // MEDIA_VIDEO_H265_PARSER_H_