DASH Media Packaging SDK
 All Classes Namespaces Functions Variables Typedefs Enumerator
box_definitions_comparison.h
1 // Copyright 2014 Google Inc. All rights reserved.
2 //
3 // Use of this source code is governed by a BSD-style
4 // license that can be found in the LICENSE file or at
5 // https://developers.google.com/open-source/licenses/bsd
6 //
7 // Overloads operator== for mp4 boxes, mainly used for testing.
8 
9 #ifndef MEDIA_FORMATS_MP4_BOX_DEFINITIONS_COMPARISON_H_
10 #define MEDIA_FORMATS_MP4_BOX_DEFINITIONS_COMPARISON_H_
11 
12 #include "packager/media/formats/mp4/box_definitions.h"
13 
14 namespace edash_packager {
15 namespace media {
16 
17 inline bool operator==(const SubsampleEntry& lhs, const SubsampleEntry& rhs) {
18  return lhs.clear_bytes == rhs.clear_bytes &&
19  lhs.cipher_bytes == rhs.cipher_bytes;
20 }
21 
22 namespace mp4 {
23 
24 inline bool operator==(const FileType& lhs, const FileType& rhs) {
25  return lhs.major_brand == rhs.major_brand &&
26  lhs.minor_version == rhs.minor_version &&
27  lhs.compatible_brands == rhs.compatible_brands;
28 }
29 
30 inline bool operator==(const ProtectionSystemSpecificHeader& lhs,
31  const ProtectionSystemSpecificHeader& rhs) {
32  return lhs.system_id == rhs.system_id && lhs.data == rhs.data;
33 }
34 
35 inline bool operator==(const SampleAuxiliaryInformationOffset& lhs,
36  const SampleAuxiliaryInformationOffset& rhs) {
37  return lhs.offsets == rhs.offsets;
38 }
39 
40 inline bool operator==(const SampleAuxiliaryInformationSize& lhs,
41  const SampleAuxiliaryInformationSize& rhs) {
42  return lhs.default_sample_info_size == rhs.default_sample_info_size &&
43  lhs.sample_count == rhs.sample_count &&
44  lhs.sample_info_sizes == rhs.sample_info_sizes;
45 }
46 
47 inline bool operator==(const SampleEncryptionEntry& lhs,
48  const SampleEncryptionEntry& rhs) {
49  return lhs.initialization_vector == rhs.initialization_vector &&
50  lhs.subsamples == rhs.subsamples;
51 }
52 
53 inline bool operator==(const SampleEncryption& lhs,
54  const SampleEncryption& rhs) {
55  return lhs.iv_size == rhs.iv_size &&
56  lhs.sample_encryption_entries == rhs.sample_encryption_entries;
57 }
58 
59 inline bool operator==(const OriginalFormat& lhs, const OriginalFormat& rhs) {
60  return lhs.format == rhs.format;
61 }
62 
63 inline bool operator==(const SchemeType& lhs, const SchemeType& rhs) {
64  return lhs.type == rhs.type && lhs.version == rhs.version;
65 }
66 
67 inline bool operator==(const TrackEncryption& lhs, const TrackEncryption& rhs) {
68  return lhs.is_encrypted == rhs.is_encrypted &&
69  lhs.default_iv_size == rhs.default_iv_size &&
70  lhs.default_kid == rhs.default_kid;
71 }
72 
73 inline bool operator==(const SchemeInfo& lhs, const SchemeInfo& rhs) {
74  return lhs.track_encryption == rhs.track_encryption;
75 }
76 
77 inline bool operator==(const ProtectionSchemeInfo& lhs,
78  const ProtectionSchemeInfo& rhs) {
79  return lhs.format == rhs.format && lhs.type == rhs.type &&
80  lhs.info == rhs.info;
81 }
82 
83 inline bool operator==(const MovieHeader& lhs, const MovieHeader& rhs) {
84  return lhs.creation_time == rhs.creation_time &&
85  lhs.modification_time == rhs.modification_time &&
86  lhs.timescale == rhs.timescale && lhs.duration == rhs.duration &&
87  lhs.rate == rhs.rate && lhs.volume == rhs.volume &&
88  lhs.next_track_id == rhs.next_track_id;
89 }
90 
91 inline bool operator==(const TrackHeader& lhs, const TrackHeader& rhs) {
92  return lhs.creation_time == rhs.creation_time &&
93  lhs.modification_time == rhs.modification_time &&
94  lhs.track_id == rhs.track_id && lhs.duration == rhs.duration &&
95  lhs.layer == rhs.layer && lhs.alternate_group == rhs.alternate_group &&
96  lhs.volume == rhs.volume && lhs.width == rhs.width &&
97  lhs.height == rhs.height;
98 }
99 
100 inline bool operator==(const SampleDescription& lhs,
101  const SampleDescription& rhs) {
102  return lhs.type == rhs.type && lhs.video_entries == rhs.video_entries &&
103  lhs.audio_entries == rhs.audio_entries;
104 }
105 
106 inline bool operator==(const DecodingTime& lhs, const DecodingTime& rhs) {
107  return lhs.sample_count == rhs.sample_count &&
108  lhs.sample_delta == rhs.sample_delta;
109 }
110 
111 inline bool operator==(const DecodingTimeToSample& lhs,
112  const DecodingTimeToSample& rhs) {
113  return lhs.decoding_time == rhs.decoding_time;
114 }
115 
116 inline bool operator==(const CompositionOffset& lhs,
117  const CompositionOffset& rhs) {
118  return lhs.sample_count == rhs.sample_count &&
119  lhs.sample_offset == rhs.sample_offset;
120 }
121 
122 inline bool operator==(const CompositionTimeToSample& lhs,
123  const CompositionTimeToSample& rhs) {
124  return lhs.composition_offset == rhs.composition_offset;
125 }
126 
127 inline bool operator==(const ChunkInfo& lhs, const ChunkInfo& rhs) {
128  return lhs.first_chunk == rhs.first_chunk &&
129  lhs.samples_per_chunk == rhs.samples_per_chunk &&
130  lhs.sample_description_index == rhs.sample_description_index;
131 }
132 
133 inline bool operator==(const SampleToChunk& lhs, const SampleToChunk& rhs) {
134  return lhs.chunk_info == rhs.chunk_info;
135 }
136 
137 inline bool operator==(const SampleSize& lhs, const SampleSize& rhs) {
138  return lhs.sample_size == rhs.sample_size &&
139  lhs.sample_count == rhs.sample_count && lhs.sizes == rhs.sizes;
140 }
141 
142 inline bool operator==(const CompactSampleSize& lhs,
143  const CompactSampleSize& rhs) {
144  return lhs.field_size == rhs.field_size && lhs.sizes == rhs.sizes;
145 }
146 
147 inline bool operator==(const ChunkLargeOffset& lhs,
148  const ChunkLargeOffset& rhs) {
149  return lhs.offsets == rhs.offsets;
150 }
151 
152 inline bool operator==(const SyncSample& lhs, const SyncSample& rhs) {
153  return lhs.sample_number == rhs.sample_number;
154 }
155 
156 inline bool operator==(const SampleTable& lhs, const SampleTable& rhs) {
157  return lhs.description == rhs.description &&
158  lhs.decoding_time_to_sample == rhs.decoding_time_to_sample &&
159  lhs.composition_time_to_sample == rhs.composition_time_to_sample &&
160  lhs.sample_to_chunk == rhs.sample_to_chunk &&
161  lhs.sample_size == rhs.sample_size &&
162  lhs.chunk_large_offset == rhs.chunk_large_offset &&
163  lhs.sync_sample == rhs.sync_sample;
164 }
165 
166 inline bool operator==(const EditListEntry& lhs, const EditListEntry& rhs) {
167  return lhs.segment_duration == rhs.segment_duration &&
168  lhs.media_time == rhs.media_time &&
169  lhs.media_rate_integer == rhs.media_rate_integer &&
170  lhs.media_rate_fraction == rhs.media_rate_fraction;
171 }
172 
173 inline bool operator==(const EditList& lhs, const EditList& rhs) {
174  return lhs.edits == rhs.edits;
175 }
176 
177 inline bool operator==(const Edit& lhs, const Edit& rhs) {
178  return lhs.list == rhs.list;
179 }
180 
181 inline bool operator==(const HandlerReference& lhs,
182  const HandlerReference& rhs) {
183  return lhs.type == rhs.type;
184 }
185 
186 inline bool operator==(const CodecConfigurationRecord& lhs,
187  const CodecConfigurationRecord& rhs) {
188  return lhs.data == rhs.data;
189 }
190 
191 inline bool operator==(const PixelAspectRatio& lhs,
192  const PixelAspectRatio& rhs) {
193  return lhs.h_spacing == rhs.h_spacing && lhs.v_spacing == rhs.v_spacing;
194 }
195 
196 inline bool operator==(const VideoSampleEntry& lhs,
197  const VideoSampleEntry& rhs) {
198  return lhs.format == rhs.format &&
199  lhs.data_reference_index == rhs.data_reference_index &&
200  lhs.width == rhs.width && lhs.height == rhs.height &&
201  lhs.pixel_aspect == rhs.pixel_aspect && lhs.sinf == rhs.sinf &&
202  lhs.codec_config_record == rhs.codec_config_record;
203 }
204 
205 inline bool operator==(const ESDescriptor& lhs, const ESDescriptor& rhs) {
206  return lhs.esid() == rhs.esid() && lhs.object_type() == rhs.object_type() &&
207  lhs.decoder_specific_info() == rhs.decoder_specific_info();
208 }
209 
210 inline bool operator==(const ElementaryStreamDescriptor& lhs,
211  const ElementaryStreamDescriptor& rhs) {
212  return lhs.es_descriptor == rhs.es_descriptor;
213 }
214 
215 inline bool operator==(const DTSSpecific& lhs,
216  const DTSSpecific& rhs) {
217  return lhs.data == rhs.data;
218 }
219 
220 inline bool operator==(const AudioSampleEntry& lhs,
221  const AudioSampleEntry& rhs) {
222  return lhs.format == rhs.format &&
223  lhs.data_reference_index == rhs.data_reference_index &&
224  lhs.channelcount == rhs.channelcount &&
225  lhs.samplesize == rhs.samplesize && lhs.samplerate == rhs.samplerate &&
226  lhs.sinf == rhs.sinf && lhs.esds == rhs.esds &&
227  lhs.ddts == rhs.ddts;
228 }
229 
230 inline bool operator==(const WebVTTConfigurationBox& lhs,
231  const WebVTTConfigurationBox& rhs) {
232  return lhs.config == rhs.config;
233 }
234 
235 inline bool operator==(const WebVTTSourceLabelBox& lhs,
236  const WebVTTSourceLabelBox& rhs) {
237  return lhs.source_label == rhs.source_label;
238 }
239 
240 inline bool operator==(const WVTTSampleEntry& lhs,
241  const WVTTSampleEntry& rhs) {
242  return lhs.config == rhs.config && lhs.label == rhs.label;
243 }
244 
245 inline bool operator==(const MediaHeader& lhs, const MediaHeader& rhs) {
246  return lhs.creation_time == rhs.creation_time &&
247  lhs.modification_time == rhs.modification_time &&
248  lhs.timescale == rhs.timescale && lhs.duration == rhs.duration &&
249  strcmp(lhs.language, rhs.language) == 0;
250 }
251 
252 inline bool operator==(const VideoMediaHeader& lhs,
253  const VideoMediaHeader& rhs) {
254  return lhs.graphicsmode == rhs.graphicsmode &&
255  lhs.opcolor_red == rhs.opcolor_red &&
256  lhs.opcolor_green == rhs.opcolor_green &&
257  lhs.opcolor_blue == rhs.opcolor_blue;
258 }
259 
260 inline bool operator==(const SoundMediaHeader& lhs,
261  const SoundMediaHeader& rhs) {
262  return lhs.balance == rhs.balance;
263 }
264 
265 inline bool operator==(const SubtitleMediaHeader& lhs,
266  const SubtitleMediaHeader& rhs) {
267  return true;
268 }
269 
270 inline bool operator==(const DataEntryUrl& lhs, const DataEntryUrl& rhs) {
271  return lhs.flags == rhs.flags && lhs.location == rhs.location;
272 }
273 
274 inline bool operator==(const DataReference& lhs, const DataReference& rhs) {
275  return lhs.data_entry == rhs.data_entry;
276 }
277 
278 inline bool operator==(const DataInformation& lhs, const DataInformation& rhs) {
279  return lhs.dref == rhs.dref;
280 }
281 
282 inline bool operator==(const MediaInformation& lhs,
283  const MediaInformation& rhs) {
284  return lhs.dinf == rhs.dinf && lhs.sample_table == rhs.sample_table &&
285  lhs.vmhd == rhs.vmhd && lhs.smhd == rhs.smhd;
286 }
287 
288 inline bool operator==(const Media& lhs, const Media& rhs) {
289  return lhs.header == rhs.header && lhs.handler == rhs.handler &&
290  lhs.information == rhs.information;
291 }
292 
293 inline bool operator==(const Track& lhs, const Track& rhs) {
294  return lhs.header == rhs.header && lhs.media == rhs.media &&
295  lhs.edit == rhs.edit && lhs.sample_encryption == rhs.sample_encryption;
296 }
297 
298 inline bool operator==(const MovieExtendsHeader& lhs,
299  const MovieExtendsHeader& rhs) {
300  return lhs.fragment_duration == rhs.fragment_duration;
301 }
302 
303 inline bool operator==(const TrackExtends& lhs, const TrackExtends& rhs) {
304  return lhs.track_id == rhs.track_id &&
305  lhs.default_sample_description_index ==
306  rhs.default_sample_description_index &&
307  lhs.default_sample_duration == rhs.default_sample_duration &&
308  lhs.default_sample_size == rhs.default_sample_size &&
309  lhs.default_sample_flags == rhs.default_sample_flags;
310 }
311 
312 inline bool operator==(const MovieExtends& lhs, const MovieExtends& rhs) {
313  return lhs.header == rhs.header && lhs.tracks == rhs.tracks;
314 }
315 
316 inline bool operator==(const Movie& lhs, const Movie& rhs) {
317  return lhs.header == rhs.header && lhs.extends == rhs.extends &&
318  lhs.tracks == rhs.tracks && lhs.pssh == rhs.pssh;
319 }
320 
321 inline bool operator==(const TrackFragmentDecodeTime& lhs,
322  const TrackFragmentDecodeTime& rhs) {
323  return lhs.decode_time == rhs.decode_time;
324 }
325 
326 inline bool operator==(const MovieFragmentHeader& lhs,
327  const MovieFragmentHeader& rhs) {
328  return lhs.sequence_number == rhs.sequence_number;
329 }
330 
331 inline bool operator==(const TrackFragmentHeader& lhs,
332  const TrackFragmentHeader& rhs) {
333  return lhs.flags == rhs.flags && lhs.track_id == rhs.track_id &&
334  lhs.sample_description_index == rhs.sample_description_index &&
335  lhs.default_sample_duration == rhs.default_sample_duration &&
336  lhs.default_sample_size == rhs.default_sample_size &&
337  lhs.default_sample_flags == rhs.default_sample_flags;
338 }
339 
340 inline bool operator==(const TrackFragmentRun& lhs,
341  const TrackFragmentRun& rhs) {
342  return lhs.flags == rhs.flags && lhs.sample_count == rhs.sample_count &&
343  lhs.data_offset == rhs.data_offset &&
344  lhs.sample_flags == rhs.sample_flags &&
345  lhs.sample_sizes == rhs.sample_sizes &&
346  lhs.sample_durations == rhs.sample_durations &&
347  lhs.sample_composition_time_offsets ==
348  rhs.sample_composition_time_offsets;
349 }
350 
351 inline bool operator==(const SampleToGroupEntry& lhs,
352  const SampleToGroupEntry& rhs) {
353  return lhs.sample_count == rhs.sample_count &&
354  lhs.group_description_index == rhs.group_description_index;
355 }
356 
357 inline bool operator==(const SampleToGroup& lhs,
358  const SampleToGroup& rhs) {
359  return lhs.grouping_type == rhs.grouping_type &&
360  lhs.grouping_type_parameter == rhs.grouping_type_parameter &&
361  lhs.entries == rhs.entries;
362 }
363 
364 inline bool operator==(const CencSampleEncryptionInfoEntry& lhs,
365  const CencSampleEncryptionInfoEntry& rhs) {
366  return lhs.is_encrypted == rhs.is_encrypted &&
367  lhs.iv_size == rhs.iv_size &&
368  lhs.key_id == rhs.key_id;
369 }
370 
371 inline bool operator==(const SampleGroupDescription& lhs,
372  const SampleGroupDescription& rhs) {
373  return lhs.grouping_type == rhs.grouping_type &&
374  lhs.entries == rhs.entries;
375 }
376 
377 inline bool operator==(const TrackFragment& lhs, const TrackFragment& rhs) {
378  return lhs.header == rhs.header && lhs.runs == rhs.runs &&
379  lhs.decode_time == rhs.decode_time &&
380  lhs.auxiliary_offset == rhs.auxiliary_offset &&
381  lhs.auxiliary_size == rhs.auxiliary_size &&
382  lhs.sample_encryption == rhs.sample_encryption;
383 }
384 
385 inline bool operator==(const MovieFragment& lhs, const MovieFragment& rhs) {
386  return lhs.header == rhs.header && lhs.tracks == rhs.tracks &&
387  lhs.pssh == rhs.pssh;
388 }
389 
390 inline bool operator==(const SegmentReference& lhs,
391  const SegmentReference& rhs) {
392  return lhs.reference_type == rhs.reference_type &&
393  lhs.referenced_size == rhs.referenced_size &&
394  lhs.subsegment_duration == rhs.subsegment_duration &&
395  lhs.starts_with_sap == rhs.starts_with_sap &&
396  lhs.sap_type == rhs.sap_type &&
397  lhs.sap_delta_time == rhs.sap_delta_time;
398 }
399 
400 inline bool operator==(const SegmentIndex& lhs, const SegmentIndex& rhs) {
401  return lhs.reference_id == rhs.reference_id &&
402  lhs.timescale == rhs.timescale &&
403  lhs.earliest_presentation_time == rhs.earliest_presentation_time &&
404  lhs.first_offset == rhs.first_offset &&
405  lhs.references == rhs.references;
406 }
407 
408 inline bool operator==(const CueSourceIDBox& lhs,
409  const CueSourceIDBox& rhs) {
410  return lhs.source_id == rhs.source_id;
411 }
412 
413 inline bool operator==(const CueTimeBox& lhs,
414  const CueTimeBox& rhs) {
415  return lhs.cue_current_time == rhs.cue_current_time;
416 }
417 
418 inline bool operator==(const CueIDBox& lhs,
419  const CueIDBox& rhs) {
420  return lhs.cue_id == rhs.cue_id;
421 }
422 
423 inline bool operator==(const CueSettingsBox& lhs,
424  const CueSettingsBox& rhs) {
425  return lhs.settings == rhs.settings;
426 }
427 
428 inline bool operator==(const CuePayloadBox& lhs,
429  const CuePayloadBox& rhs) {
430  return lhs.cue_text == rhs.cue_text;
431 }
432 
433 inline bool operator==(const VTTEmptyCueBox& lhs, const VTTEmptyCueBox& rhs) {
434  return true;
435 }
436 
437 inline bool operator==(const VTTAdditionalTextBox& lhs,
438  const VTTAdditionalTextBox& rhs) {
439  return lhs.cue_additional_text == rhs.cue_additional_text;
440 }
441 
442 inline bool operator==(const VTTCueBox& lhs,
443  const VTTCueBox& rhs) {
444  return lhs.cue_source_id == rhs.cue_source_id && lhs.cue_id == rhs.cue_id &&
445  lhs.cue_time == rhs.cue_time && lhs.cue_settings == rhs.cue_settings &&
446  lhs.cue_payload == rhs.cue_payload;
447 }
448 
449 } // namespace mp4
450 } // namespace media
451 } // namespace edash_packager
452 
453 #endif // MEDIA_FORMATS_MP4_BOX_DEFINITIONS_COMPARISON_H_