Log codec IDs for MediaSource content.

media/formats/mp4/box_definitions.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/formats/mp4/box_definitions.h"
 
 #include "base/logging.h"
 #include "media/formats/mp4/es_descriptor.h"
 #include "media/formats/mp4/rcheck.h"
 
@@ skipping 331 matching lines @@
     : version(0),
       profile_indication(0),
       profile_compatibility(0),
       avc_level(0),
       length_size(0) {}
 
 AVCDecoderConfigurationRecord::~AVCDecoderConfigurationRecord() {}
 FourCC AVCDecoderConfigurationRecord::BoxType() const { return FOURCC_AVCC; }
 
 bool AVCDecoderConfigurationRecord::Parse(BoxReader* reader) {
-  return ParseInternal(reader);
+  return ParseInternal(reader, reader->log_cb());
 }
 
 bool AVCDecoderConfigurationRecord::Parse(const uint8* data, int data_size) {
   BufferReader reader(data, data_size);
-  return ParseInternal(&reader);
+  return ParseInternal(&reader, LogCB());
 }
 
-bool AVCDecoderConfigurationRecord::ParseInternal(BufferReader* reader) {
+bool AVCDecoderConfigurationRecord::ParseInternal(BufferReader* reader,
+                                                  const LogCB& log_cb) {
   RCHECK(reader->Read1(&version) && version == 1 &&
          reader->Read1(&profile_indication) &&
          reader->Read1(&profile_compatibility) &&
          reader->Read1(&avc_level));
 
   uint8 length_size_minus_one;
   RCHECK(reader->Read1(&length_size_minus_one) &&
          (length_size_minus_one & 0xfc) == 0xfc);
   length_size = (length_size_minus_one & 0x3) + 1;
 
   RCHECK(length_size != 3); // Only values of 1, 2, and 4 are valid.
 
   uint8 num_sps;
   RCHECK(reader->Read1(&num_sps) && (num_sps & 0xe0) == 0xe0);
   num_sps &= 0x1f;
 
   sps_list.resize(num_sps);
   for (int i = 0; i < num_sps; i++) {
     uint16 sps_length;
     RCHECK(reader->Read2(&sps_length) &&
            reader->ReadVec(&sps_list[i], sps_length));
+    RCHECK(sps_list[i].size() > 4);
+
+    if (!log_cb.is_null()) {
+      MEDIA_LOG(log_cb) << "Video codec: avc1." << std::hex
+                        << static_cast<int>(sps_list[i][1])
+                        << static_cast<int>(sps_list[i][2])
+                        << static_cast<int>(sps_list[i][3]);
+    }
   }
 
   uint8 num_pps;
   RCHECK(reader->Read1(&num_pps));
 
   pps_list.resize(num_pps);
   for (int i = 0; i < num_pps; i++) {
     uint16 pps_length;
     RCHECK(reader->Read2(&pps_length) &&
            reader->ReadVec(&pps_list[i], pps_length));
@@ skipping 70 matching lines @@
 bool ElementaryStreamDescriptor::Parse(BoxReader* reader) {
   std::vector<uint8> data;
   ESDescriptor es_desc;
 
   RCHECK(reader->ReadFullBoxHeader());
   RCHECK(reader->ReadVec(&data, reader->size() - reader->pos()));
   RCHECK(es_desc.Parse(data));
 
   object_type = es_desc.object_type();
 
-  RCHECK(aac.Parse(es_desc.decoder_specific_info()));
+  if (object_type != 0x40) {
+    MEDIA_LOG(reader->log_cb()) << "Audio codec: mp4a."
+                                << std::hex << static_cast<int>(object_type);
+  }
+
+  if (es_desc.IsAAC(object_type))
+    RCHECK(aac.Parse(es_desc.decoder_specific_info(), reader->log_cb()));
 
   return true;
 }
 
 AudioSampleEntry::AudioSampleEntry()
     : format(FOURCC_NULL),
       data_reference_index(0),
       channelcount(0),
       samplesize(0),
       samplerate(0) {}
@@ skipping 342 matching lines @@
 SampleDependsOn IndependentAndDisposableSamples::sample_depends_on(
     size_t i) const {
   if (i >= sample_depends_on_.size())
     return kSampleDependsOnUnknown;
 
   return sample_depends_on_[i];
 }
 
 }  // namespace mp4
 }  // namespace media