• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "media/mp4/track_run_iterator.h"
6 
7 #include <algorithm>
8 
9 #include "media/base/buffers.h"
10 #include "media/base/stream_parser_buffer.h"
11 #include "media/mp4/rcheck.h"
12 
13 namespace {
14 static const uint32 kSampleIsDifferenceSampleFlagMask = 0x10000;
15 }
16 
17 namespace media {
18 namespace mp4 {
19 
20 struct SampleInfo {
21   int size;
22   int duration;
23   int cts_offset;
24   bool is_keyframe;
25 };
26 
27 struct TrackRunInfo {
28   uint32 track_id;
29   std::vector<SampleInfo> samples;
30   int64 timescale;
31   int64 start_dts;
32   int64 sample_start_offset;
33 
34   bool is_audio;
35   const AudioSampleEntry* audio_description;
36   const VideoSampleEntry* video_description;
37 
38   int64 aux_info_start_offset;  // Only valid if aux_info_total_size > 0.
39   int aux_info_default_size;
40   std::vector<uint8> aux_info_sizes;  // Populated if default_size == 0.
41   int aux_info_total_size;
42 
43   TrackRunInfo();
44   ~TrackRunInfo();
45 };
46 
TrackRunInfo()47 TrackRunInfo::TrackRunInfo()
48     : track_id(0),
49       timescale(-1),
50       start_dts(-1),
51       sample_start_offset(-1),
52       is_audio(false),
53       aux_info_start_offset(-1),
54       aux_info_default_size(-1),
55       aux_info_total_size(-1) {
56 }
~TrackRunInfo()57 TrackRunInfo::~TrackRunInfo() {}
58 
TimeDeltaFromRational(int64 numer,int64 denom)59 TimeDelta TimeDeltaFromRational(int64 numer, int64 denom) {
60   DCHECK_LT((numer > 0 ? numer : -numer),
61             kint64max / base::Time::kMicrosecondsPerSecond);
62   return TimeDelta::FromMicroseconds(
63         base::Time::kMicrosecondsPerSecond * numer / denom);
64 }
65 
TrackRunIterator(const Movie * moov,const LogCB & log_cb)66 TrackRunIterator::TrackRunIterator(const Movie* moov,
67                                    const LogCB& log_cb)
68     : moov_(moov), log_cb_(log_cb), sample_offset_(0) {
69   CHECK(moov);
70 }
71 
~TrackRunIterator()72 TrackRunIterator::~TrackRunIterator() {}
73 
PopulateSampleInfo(const TrackExtends & trex,const TrackFragmentHeader & tfhd,const TrackFragmentRun & trun,const int64 edit_list_offset,const uint32 i,SampleInfo * sample_info,const SampleDependsOn sample_depends_on)74 static void PopulateSampleInfo(const TrackExtends& trex,
75                                const TrackFragmentHeader& tfhd,
76                                const TrackFragmentRun& trun,
77                                const int64 edit_list_offset,
78                                const uint32 i,
79                                SampleInfo* sample_info,
80                                const SampleDependsOn sample_depends_on) {
81   if (i < trun.sample_sizes.size()) {
82     sample_info->size = trun.sample_sizes[i];
83   } else if (tfhd.default_sample_size > 0) {
84     sample_info->size = tfhd.default_sample_size;
85   } else {
86     sample_info->size = trex.default_sample_size;
87   }
88 
89   if (i < trun.sample_durations.size()) {
90     sample_info->duration = trun.sample_durations[i];
91   } else if (tfhd.default_sample_duration > 0) {
92     sample_info->duration = tfhd.default_sample_duration;
93   } else {
94     sample_info->duration = trex.default_sample_duration;
95   }
96 
97   if (i < trun.sample_composition_time_offsets.size()) {
98     sample_info->cts_offset = trun.sample_composition_time_offsets[i];
99   } else {
100     sample_info->cts_offset = 0;
101   }
102   sample_info->cts_offset += edit_list_offset;
103 
104   uint32 flags;
105   if (i < trun.sample_flags.size()) {
106     flags = trun.sample_flags[i];
107   } else if (tfhd.has_default_sample_flags) {
108     flags = tfhd.default_sample_flags;
109   } else {
110     flags = trex.default_sample_flags;
111   }
112 
113   switch (sample_depends_on) {
114     case kSampleDependsOnUnknown:
115       sample_info->is_keyframe = !(flags & kSampleIsDifferenceSampleFlagMask);
116       break;
117 
118     case kSampleDependsOnOthers:
119       sample_info->is_keyframe = false;
120       break;
121 
122     case kSampleDependsOnNoOther:
123       sample_info->is_keyframe = true;
124       break;
125 
126     case kSampleDependsOnReserved:
127       CHECK(false);
128   }
129 }
130 
131 // In well-structured encrypted media, each track run will be immediately
132 // preceded by its auxiliary information; this is the only optimal storage
133 // pattern in terms of minimum number of bytes from a serial stream needed to
134 // begin playback. It also allows us to optimize caching on memory-constrained
135 // architectures, because we can cache the relatively small auxiliary
136 // information for an entire run and then discard data from the input stream,
137 // instead of retaining the entire 'mdat' box.
138 //
139 // We optimize for this situation (with no loss of generality) by sorting track
140 // runs during iteration in order of their first data offset (either sample data
141 // or auxiliary data).
142 class CompareMinTrackRunDataOffset {
143  public:
operator ()(const TrackRunInfo & a,const TrackRunInfo & b)144   bool operator()(const TrackRunInfo& a, const TrackRunInfo& b) {
145     int64 a_aux = a.aux_info_total_size ? a.aux_info_start_offset : kint64max;
146     int64 b_aux = b.aux_info_total_size ? b.aux_info_start_offset : kint64max;
147 
148     int64 a_lesser = std::min(a_aux, a.sample_start_offset);
149     int64 a_greater = std::max(a_aux, a.sample_start_offset);
150     int64 b_lesser = std::min(b_aux, b.sample_start_offset);
151     int64 b_greater = std::max(b_aux, b.sample_start_offset);
152 
153     if (a_lesser == b_lesser) return a_greater < b_greater;
154     return a_lesser < b_lesser;
155   }
156 };
157 
Init(const MovieFragment & moof)158 bool TrackRunIterator::Init(const MovieFragment& moof) {
159   runs_.clear();
160 
161   for (size_t i = 0; i < moof.tracks.size(); i++) {
162     const TrackFragment& traf = moof.tracks[i];
163 
164     const Track* trak = NULL;
165     for (size_t t = 0; t < moov_->tracks.size(); t++) {
166       if (moov_->tracks[t].header.track_id == traf.header.track_id)
167         trak = &moov_->tracks[t];
168     }
169     RCHECK(trak);
170 
171     const TrackExtends* trex = NULL;
172     for (size_t t = 0; t < moov_->extends.tracks.size(); t++) {
173       if (moov_->extends.tracks[t].track_id == traf.header.track_id)
174         trex = &moov_->extends.tracks[t];
175     }
176     RCHECK(trex);
177 
178     const SampleDescription& stsd =
179         trak->media.information.sample_table.description;
180     if (stsd.type != kAudio && stsd.type != kVideo) {
181       DVLOG(1) << "Skipping unhandled track type";
182       continue;
183     }
184     size_t desc_idx = traf.header.sample_description_index;
185     if (!desc_idx) desc_idx = trex->default_sample_description_index;
186     RCHECK(desc_idx > 0);  // Descriptions are one-indexed in the file
187     desc_idx -= 1;
188 
189     // Process edit list to remove CTS offset introduced in the presence of
190     // B-frames (those that contain a single edit with a nonnegative media
191     // time). Other uses of edit lists are not supported, as they are
192     // both uncommon and better served by higher-level protocols.
193     int64 edit_list_offset = 0;
194     const std::vector<EditListEntry>& edits = trak->edit.list.edits;
195     if (!edits.empty()) {
196       if (edits.size() > 1)
197         DVLOG(1) << "Multi-entry edit box detected; some components ignored.";
198 
199       if (edits[0].media_time < 0) {
200         DVLOG(1) << "Empty edit list entry ignored.";
201       } else {
202         edit_list_offset = -edits[0].media_time;
203       }
204     }
205 
206     int64 run_start_dts = traf.decode_time.decode_time;
207     int sample_count_sum = 0;
208 
209     for (size_t j = 0; j < traf.runs.size(); j++) {
210       const TrackFragmentRun& trun = traf.runs[j];
211       TrackRunInfo tri;
212       tri.track_id = traf.header.track_id;
213       tri.timescale = trak->media.header.timescale;
214       tri.start_dts = run_start_dts;
215       tri.sample_start_offset = trun.data_offset;
216 
217       tri.is_audio = (stsd.type == kAudio);
218       if (tri.is_audio) {
219         RCHECK(!stsd.audio_entries.empty());
220         if (desc_idx > stsd.audio_entries.size())
221           desc_idx = 0;
222         tri.audio_description = &stsd.audio_entries[desc_idx];
223       } else {
224         RCHECK(!stsd.video_entries.empty());
225         if (desc_idx > stsd.video_entries.size())
226           desc_idx = 0;
227         tri.video_description = &stsd.video_entries[desc_idx];
228       }
229 
230       // Collect information from the auxiliary_offset entry with the same index
231       // in the 'saiz' container as the current run's index in the 'trun'
232       // container, if it is present.
233       if (traf.auxiliary_offset.offsets.size() > j) {
234         // There should be an auxiliary info entry corresponding to each sample
235         // in the auxiliary offset entry's corresponding track run.
236         RCHECK(traf.auxiliary_size.sample_count >=
237                sample_count_sum + trun.sample_count);
238         tri.aux_info_start_offset = traf.auxiliary_offset.offsets[j];
239         tri.aux_info_default_size =
240             traf.auxiliary_size.default_sample_info_size;
241         if (tri.aux_info_default_size == 0) {
242           const std::vector<uint8>& sizes =
243               traf.auxiliary_size.sample_info_sizes;
244           tri.aux_info_sizes.insert(tri.aux_info_sizes.begin(),
245               sizes.begin() + sample_count_sum,
246               sizes.begin() + sample_count_sum + trun.sample_count);
247         }
248 
249         // If the default info size is positive, find the total size of the aux
250         // info block from it, otherwise sum over the individual sizes of each
251         // aux info entry in the aux_offset entry.
252         if (tri.aux_info_default_size) {
253           tri.aux_info_total_size =
254               tri.aux_info_default_size * trun.sample_count;
255         } else {
256           tri.aux_info_total_size = 0;
257           for (size_t k = 0; k < trun.sample_count; k++) {
258             tri.aux_info_total_size += tri.aux_info_sizes[k];
259           }
260         }
261       } else {
262         tri.aux_info_start_offset = -1;
263         tri.aux_info_total_size = 0;
264       }
265 
266       tri.samples.resize(trun.sample_count);
267       for (size_t k = 0; k < trun.sample_count; k++) {
268         PopulateSampleInfo(*trex, traf.header, trun, edit_list_offset,
269                            k, &tri.samples[k], traf.sdtp.sample_depends_on(k));
270         run_start_dts += tri.samples[k].duration;
271       }
272       runs_.push_back(tri);
273       sample_count_sum += trun.sample_count;
274     }
275   }
276 
277   std::sort(runs_.begin(), runs_.end(), CompareMinTrackRunDataOffset());
278   run_itr_ = runs_.begin();
279   ResetRun();
280   return true;
281 }
282 
AdvanceRun()283 void TrackRunIterator::AdvanceRun() {
284   ++run_itr_;
285   ResetRun();
286 }
287 
ResetRun()288 void TrackRunIterator::ResetRun() {
289   if (!IsRunValid()) return;
290   sample_dts_ = run_itr_->start_dts;
291   sample_offset_ = run_itr_->sample_start_offset;
292   sample_itr_ = run_itr_->samples.begin();
293   cenc_info_.clear();
294 }
295 
AdvanceSample()296 void TrackRunIterator::AdvanceSample() {
297   DCHECK(IsSampleValid());
298   sample_dts_ += sample_itr_->duration;
299   sample_offset_ += sample_itr_->size;
300   ++sample_itr_;
301 }
302 
303 // This implementation only indicates a need for caching if CENC auxiliary
304 // info is available in the stream.
AuxInfoNeedsToBeCached()305 bool TrackRunIterator::AuxInfoNeedsToBeCached() {
306   DCHECK(IsRunValid());
307   return is_encrypted() && aux_info_size() > 0 && cenc_info_.size() == 0;
308 }
309 
310 // This implementation currently only caches CENC auxiliary info.
CacheAuxInfo(const uint8 * buf,int buf_size)311 bool TrackRunIterator::CacheAuxInfo(const uint8* buf, int buf_size) {
312   RCHECK(AuxInfoNeedsToBeCached() && buf_size >= aux_info_size());
313 
314   cenc_info_.resize(run_itr_->samples.size());
315   int64 pos = 0;
316   for (size_t i = 0; i < run_itr_->samples.size(); i++) {
317     int info_size = run_itr_->aux_info_default_size;
318     if (!info_size)
319       info_size = run_itr_->aux_info_sizes[i];
320 
321     BufferReader reader(buf + pos, info_size);
322     RCHECK(cenc_info_[i].Parse(track_encryption().default_iv_size, &reader));
323     pos += info_size;
324   }
325 
326   return true;
327 }
328 
IsRunValid() const329 bool TrackRunIterator::IsRunValid() const {
330   return run_itr_ != runs_.end();
331 }
332 
IsSampleValid() const333 bool TrackRunIterator::IsSampleValid() const {
334   return IsRunValid() && (sample_itr_ != run_itr_->samples.end());
335 }
336 
337 // Because tracks are in sorted order and auxiliary information is cached when
338 // returning samples, it is guaranteed that no data will be required before the
339 // lesser of the minimum data offset of this track and the next in sequence.
340 // (The stronger condition - that no data is required before the minimum data
341 // offset of this track alone - is not guaranteed, because the BMFF spec does
342 // not have any inter-run ordering restrictions.)
GetMaxClearOffset()343 int64 TrackRunIterator::GetMaxClearOffset() {
344   int64 offset = kint64max;
345 
346   if (IsSampleValid()) {
347     offset = std::min(offset, sample_offset_);
348     if (AuxInfoNeedsToBeCached())
349       offset = std::min(offset, aux_info_offset());
350   }
351   if (run_itr_ != runs_.end()) {
352     std::vector<TrackRunInfo>::const_iterator next_run = run_itr_ + 1;
353     if (next_run != runs_.end()) {
354       offset = std::min(offset, next_run->sample_start_offset);
355       if (next_run->aux_info_total_size)
356         offset = std::min(offset, next_run->aux_info_start_offset);
357     }
358   }
359   if (offset == kint64max) return 0;
360   return offset;
361 }
362 
track_id() const363 uint32 TrackRunIterator::track_id() const {
364   DCHECK(IsRunValid());
365   return run_itr_->track_id;
366 }
367 
is_encrypted() const368 bool TrackRunIterator::is_encrypted() const {
369   DCHECK(IsRunValid());
370   return track_encryption().is_encrypted;
371 }
372 
aux_info_offset() const373 int64 TrackRunIterator::aux_info_offset() const {
374   return run_itr_->aux_info_start_offset;
375 }
376 
aux_info_size() const377 int TrackRunIterator::aux_info_size() const {
378   return run_itr_->aux_info_total_size;
379 }
380 
is_audio() const381 bool TrackRunIterator::is_audio() const {
382   DCHECK(IsRunValid());
383   return run_itr_->is_audio;
384 }
385 
audio_description() const386 const AudioSampleEntry& TrackRunIterator::audio_description() const {
387   DCHECK(is_audio());
388   DCHECK(run_itr_->audio_description);
389   return *run_itr_->audio_description;
390 }
391 
video_description() const392 const VideoSampleEntry& TrackRunIterator::video_description() const {
393   DCHECK(!is_audio());
394   DCHECK(run_itr_->video_description);
395   return *run_itr_->video_description;
396 }
397 
sample_offset() const398 int64 TrackRunIterator::sample_offset() const {
399   DCHECK(IsSampleValid());
400   return sample_offset_;
401 }
402 
sample_size() const403 int TrackRunIterator::sample_size() const {
404   DCHECK(IsSampleValid());
405   return sample_itr_->size;
406 }
407 
dts() const408 TimeDelta TrackRunIterator::dts() const {
409   DCHECK(IsSampleValid());
410   return TimeDeltaFromRational(sample_dts_, run_itr_->timescale);
411 }
412 
cts() const413 TimeDelta TrackRunIterator::cts() const {
414   DCHECK(IsSampleValid());
415   return TimeDeltaFromRational(sample_dts_ + sample_itr_->cts_offset,
416                                run_itr_->timescale);
417 }
418 
duration() const419 TimeDelta TrackRunIterator::duration() const {
420   DCHECK(IsSampleValid());
421   return TimeDeltaFromRational(sample_itr_->duration, run_itr_->timescale);
422 }
423 
is_keyframe() const424 bool TrackRunIterator::is_keyframe() const {
425   DCHECK(IsSampleValid());
426   return sample_itr_->is_keyframe;
427 }
428 
track_encryption() const429 const TrackEncryption& TrackRunIterator::track_encryption() const {
430   if (is_audio())
431     return audio_description().sinf.info.track_encryption;
432   return video_description().sinf.info.track_encryption;
433 }
434 
GetDecryptConfig()435 scoped_ptr<DecryptConfig> TrackRunIterator::GetDecryptConfig() {
436   size_t sample_idx = sample_itr_ - run_itr_->samples.begin();
437   DCHECK(sample_idx < cenc_info_.size());
438   const FrameCENCInfo& cenc_info = cenc_info_[sample_idx];
439   DCHECK(is_encrypted() && !AuxInfoNeedsToBeCached());
440 
441   size_t total_size = 0;
442   if (!cenc_info.subsamples.empty() &&
443       (!cenc_info.GetTotalSizeOfSubsamples(&total_size) ||
444        total_size != static_cast<size_t>(sample_size()))) {
445     MEDIA_LOG(log_cb_) << "Incorrect CENC subsample size.";
446     return scoped_ptr<DecryptConfig>();
447   }
448 
449   const std::vector<uint8>& kid = track_encryption().default_kid;
450   return scoped_ptr<DecryptConfig>(new DecryptConfig(
451       std::string(reinterpret_cast<const char*>(&kid[0]), kid.size()),
452       std::string(reinterpret_cast<const char*>(cenc_info.iv),
453                   arraysize(cenc_info.iv)),
454       0,  // No offset to start of media data in MP4 using CENC.
455       cenc_info.subsamples));
456 }
457 
458 }  // namespace mp4
459 }  // namespace media
460