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