Create MP4MediaParser and its dependents.

Create new classes: StreamInfo, AudioStreamInfo, VideoStreamInfo,
MediaParser, MediaSample, MP4MediaParser.

Change-Id: I19c2fc73964d9f8fc90acaddd1783f4e6ff87d07

media/base/audio_stream_info.cc

@@ -0,0 +1,53 @@
+// Copyright (c) 2013 Google Inc. 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/base/audio_stream_info.h"
+
+#include <sstream>
+
+#include "media/base/limits.h"
+
+namespace media {
+
+AudioStreamInfo::AudioStreamInfo(int track_id,
+                                 int time_scale,
+                                 AudioCodec codec,
+                                 int bytes_per_channel,
+                                 int num_channels,
+                                 int samples_per_second,
+                                 const uint8* extra_data,
+                                 size_t extra_data_size,
+                                 bool is_encrypted)
+    : StreamInfo(kStreamAudio,
+                 track_id,
+                 time_scale,
+                 extra_data,
+                 extra_data_size,
+                 is_encrypted),
+      codec_(codec),
+      bytes_per_channel_(bytes_per_channel),
+      num_channels_(num_channels),
+      samples_per_second_(samples_per_second) {}
+
+AudioStreamInfo::~AudioStreamInfo() {}
+
+bool AudioStreamInfo::IsValidConfig() const {
+  return codec_ != kUnknownAudioCodec && num_channels_ != 0 &&
+         num_channels_ <= limits::kMaxChannels && bytes_per_channel_ > 0 &&
+         bytes_per_channel_ <= limits::kMaxBytesPerSample &&
+         samples_per_second_ > 0 &&
+         samples_per_second_ <= limits::kMaxSampleRate;
+}
+
+std::string AudioStreamInfo::ToString() {
+  std::ostringstream s;
+  s << "codec: " << codec_
+    << " bytes_per_channel: " << bytes_per_channel_
+    << " num_channels: " << num_channels_
+    << " samples_per_second: " << samples_per_second_
+    << " " << StreamInfo::ToString();
+  return s.str();
+}
+
+}  // namespace media

media/base/audio_stream_info.h

@@ -0,0 +1,76 @@
+// Copyright (c) 2013 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MEDIA_BASE_AUDIO_STREAM_INFO_H_
+#define MEDIA_BASE_AUDIO_STREAM_INFO_H_
+
+#include <vector>
+
+#include "media/base/stream_info.h"
+
+namespace media {
+
+enum AudioCodec {
+  kUnknownAudioCodec = 0,
+  kCodecAAC,
+  kCodecMP3,
+  kCodecPCM,
+  kCodecVorbis,
+  kCodecFLAC,
+  kCodecAMR_NB,
+  kCodecAMR_WB,
+  kCodecPCM_MULAW,
+  kCodecGSM_MS,
+  kCodecPCM_S16BE,
+  kCodecPCM_S24BE,
+  kCodecOpus,
+  kCodecEAC3,
+
+  kNumAudioCodec
+};
+
+class AudioStreamInfo : public StreamInfo {
+ public:
+  // Constructs an initialized object. It is acceptable to pass in NULL for
+  // |extra_data|, otherwise the memory is copied.
+  AudioStreamInfo(int track_id,
+                  int time_scale,
+                  AudioCodec codec,
+                  int bytes_per_channel,
+                  int num_channels,
+                  int samples_per_second,
+                  const uint8* extra_data,
+                  size_t extra_data_size,
+                  bool is_encrypted);
+
+  virtual ~AudioStreamInfo();
+
+  // Returns true if this object has appropriate configuration values, false
+  // otherwise.
+  virtual bool IsValidConfig() const;
+
+  // Returns a human-readable string describing |*this|.
+  virtual std::string ToString();
+
+  AudioCodec codec() const { return codec_; }
+  int bits_per_channel() const { return bytes_per_channel_ * 8; }
+  int bytes_per_channel() const { return bytes_per_channel_; }
+  int num_channels() const { return num_channels_; }
+  int samples_per_second() const { return samples_per_second_; }
+  int bytes_per_frame() const { return num_channels_ * bytes_per_channel_; }
+
+ private:
+  AudioCodec codec_;
+  int bytes_per_channel_;
+  int num_channels_;
+  int samples_per_second_;
+
+  // Not using DISALLOW_COPY_AND_ASSIGN here intentionally to allow the compiler
+  // generated copy constructor and assignment operator. Since the extra data is
+  // typically small, the performance impact is minimal.
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_AUDIO_STREAM_INFO_H_

media/base/bit_reader.h

@@ -9,12 +9,11 @@
 
 #include "base/basictypes.h"
 #include "base/logging.h"
-#include "media/base/media_export.h"
 
 namespace media {
 
 // A class to read bit streams.
-class MEDIA_EXPORT BitReader {
+class BitReader {
  public:
   // Initialize the reader to start reading at |data|, |size| being size
   // of |data| in bytes.

media/base/buffers.h

@@ -22,21 +22,19 @@
 #define MEDIA_BASE_BUFFERS_H_
 
 #include "base/basictypes.h"
-#include "base/memory/ref_counted.h"
 #include "base/time/time.h"
-#include "media/base/media_export.h"
 
 namespace media {
 
 // TODO(scherkus): Move the contents of this file elsewhere.
 
 // Indicates an invalid or missing timestamp.
-MEDIA_EXPORT extern inline base::TimeDelta kNoTimestamp() {
+extern inline base::TimeDelta kNoTimestamp() {
   return base::TimeDelta::FromMicroseconds(kint64min);
 }
 
 // Represents an infinite stream duration.
-MEDIA_EXPORT extern inline base::TimeDelta kInfiniteDuration() {
+extern inline base::TimeDelta kInfiniteDuration() {
   return base::TimeDelta::FromMicroseconds(kint64max);
 }
 

media/base/byte_queue.h

@@ -7,7 +7,6 @@
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
-#include "media/base/media_export.h"
 
 namespace media {
 
@@ -16,7 +15,7 @@ namespace media {
 // Pop(). The contents of the queue can be observed via the Peek() method.
 // This class manages the underlying storage of the queue and tries to minimize
 // the number of buffer copies when data is appended and removed.
-class MEDIA_EXPORT ByteQueue {
+class ByteQueue {
  public:
   ByteQueue();
   ~ByteQueue();

media/base/container_names.cc

@@ -13,8 +13,6 @@
 
 namespace media {
 
-namespace container_names {
-
 #define TAG(a, b, c, d) \
     ((static_cast<uint8>(a) << 24) | (static_cast<uint8>(b) << 16) | \
      (static_cast<uint8>(c) << 8) | (static_cast<uint8>(d)))
@@ -1666,6 +1664,4 @@ MediaContainerName DetermineContainer(const uint8* buffer, int buffer_size) {
   return CONTAINER_UNKNOWN;
 }
 
-}  // namespace container_names
-
 }  // namespace media

media/base/container_names.h

@@ -6,12 +6,9 @@
 #define MEDIA_BASE_CONTAINER_NAMES_H_
 
 #include "base/basictypes.h"
-#include "media/base/media_export.h"
 
 namespace media {
 
-namespace container_names {
-
 // This is the set of input container formats detected for logging purposes. Not
 // all of these are enabled (and it varies by product). Any additions need to be
 // done at the end of the list (before CONTAINER_MAX). This list must be kept in
@@ -60,10 +57,7 @@ enum MediaContainerName {
 };
 
 // Determine the container type.
-MEDIA_EXPORT MediaContainerName DetermineContainer(const uint8* buffer,
+MediaContainerName DetermineContainer(const uint8* buffer, int buffer_size);
-                                                   int buffer_size);
-
-}  // namespace container_names
 
 }  // namespace media
 

media/base/container_names_unittest.cc

@@ -9,8 +9,6 @@
 
 namespace media {
 
-namespace container_names {
-
 // Using a macros to simplify tests. Since EXPECT_EQ outputs the second argument
 // as a string when it fails, this lets the output identify what item actually
 // failed.
@@ -215,6 +213,4 @@ TEST(ContainerNamesTest, FileCheckUNKNOWN) {
   TestFile(CONTAINER_UNKNOWN, GetTestDataFilePath("webm_vp8_track_entry"));
 }
 
-}  // namespace container_names
-
 }  // namespace media

media/base/decrypt_config.h

@@ -10,7 +10,6 @@
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
-#include "media/base/media_export.h"
 
 namespace media {
 
@@ -29,7 +28,7 @@ struct SubsampleEntry {
 };
 
 // Contains all information that a decryptor needs to decrypt a media sample.
-class MEDIA_EXPORT DecryptConfig {
+class DecryptConfig {
  public:
   // Keys are always 128 bits.
   static const int kDecryptionKeySize = 16;

media/base/media_parser.h

@@ -0,0 +1,70 @@
+// Copyright (c) 2013 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MEDIA_BASE_MEDIA_PARSER_H_
+#define MEDIA_BASE_MEDIA_PARSER_H_
+
+#include <string>
+#include <vector>
+
+#include "base/callback.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "media/base/container_names.h"
+
+namespace media {
+
+class MediaSample;
+class StreamInfo;
+
+class MediaParser {
+ public:
+  MediaParser() {}
+  virtual ~MediaParser() {}
+
+  // Indicates completion of parser initialization.
+  // First parameter - Indicates initialization success. Set to true if
+  //                   initialization was successful. False if an error
+  //                   occurred.
+  // Second parameter - A vector of all the elementary streams within this file.
+  typedef base::Callback<void(bool, std::vector<scoped_refptr<StreamInfo> >&)>
+      InitCB;
+
+  // New stream sample have been parsed.
+  // First parameter - The track id of the new sample.
+  // Second parameter - The new media sample;
+  // Return value - True indicates that the sample is accepted.
+  //                False if something was wrong with the sample and a parsing
+  //                error should be signaled.
+  typedef base::Callback<
+      bool(uint32 track_id, const scoped_refptr<MediaSample>&)>
+      NewSampleCB;
+
+  // A new potentially encrypted stream has been parsed.
+  // First Parameter - Container name.
+  // Second parameter - The initialization data associated with the stream.
+  // Third parameter - Number of bytes of the initialization data.
+  typedef base::Callback<void(MediaContainerName, scoped_ptr<uint8[]>, int)>
+      NeedKeyCB;
+
+  // Initialize the parser with necessary callbacks. Must be called before any
+  // data is passed to Parse(). |init_cb| will be called once enough data has
+  // been parsed to determine the initial stream configurations.
+  virtual void Init(const InitCB& init_cb,
+                    const NewSampleCB& new_sample_cb,
+                    const NeedKeyCB& need_key_cb) = 0;
+
+  // Called when there is new data to parse.
+  //
+  // Returns true if the parse succeeds.
+  // TODO(kqyang): change to return Status.
+  virtual bool Parse(const uint8* buf, int size) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MediaParser);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_MEDIA_PARSER_H_

media/base/media_sample.cc

@@ -0,0 +1,74 @@
+// Copyright (c) 2013 Google Inc. 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/base/media_sample.h"
+
+#include "base/logging.h"
+#include "media/base/decrypt_config.h"
+
+namespace media {
+
+MediaSample::MediaSample(const uint8* data,
+                         int size,
+                         const uint8* side_data,
+                         int side_data_size,
+                         bool is_key_frame)
+    : dts_(0), pts_(0), duration_(0), is_key_frame_(is_key_frame) {
+  if (!data) {
+    CHECK_EQ(size, 0);
+    CHECK(!side_data);
+    return;
+  }
+
+  data_.assign(data, data + size);
+  if (side_data)
+    side_data_.assign(side_data, side_data + side_data_size);
+}
+
+MediaSample::~MediaSample() {}
+
+// static
+scoped_refptr<MediaSample> MediaSample::CopyFrom(const uint8* data,
+                                                 int data_size,
+                                                 bool is_key_frame) {
+  // If you hit this CHECK you likely have a bug in a demuxer. Go fix it.
+  CHECK(data);
+  return make_scoped_refptr(
+      new MediaSample(data, data_size, NULL, 0, is_key_frame));
+}
+
+// static
+scoped_refptr<MediaSample> MediaSample::CopyFrom(const uint8* data,
+                                                 int data_size,
+                                                 const uint8* side_data,
+                                                 int side_data_size,
+                                                 bool is_key_frame) {
+  // If you hit this CHECK you likely have a bug in a demuxer. Go fix it.
+  CHECK(data);
+  return make_scoped_refptr(new MediaSample(
+      data, data_size, side_data, side_data_size, is_key_frame));
+}
+
+// static
+scoped_refptr<MediaSample> MediaSample::CreateEOSBuffer() {
+  return make_scoped_refptr(new MediaSample(NULL, 0, NULL, 0, false));
+}
+
+std::string MediaSample::ToString() {
+  if (end_of_stream()) {
+    return "end of stream";
+  }
+
+  std::ostringstream s;
+  s << "dts: " << dts_
+    << " pts: " << pts_
+    << " duration: " << duration_
+    << " is_key_frame: " << is_key_frame_
+    << " size: " << data_.size()
+    << " side_data_size: " << side_data_.size()
+    << " encrypted: " << (decrypt_config_ != NULL);
+  return s.str();
+}
+
+}  // namespace media

media/base/media_sample.h

@@ -0,0 +1,162 @@
+// Copyright (c) 2013 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MEDIA_BASE_MEDIA_SAMPLE_H_
+#define MEDIA_BASE_MEDIA_SAMPLE_H_
+
+#include <deque>
+#include <string>
+#include <vector>
+
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "media/base/decrypt_config.h"
+
+namespace media {
+
+class DecryptConfig;
+
+// Holds media sample. Also includes decoder specific functionality for
+// decryption.
+class MediaSample
+    : public base::RefCountedThreadSafe<MediaSample> {
+ public:
+  // Create a MediaSample whose |data_| is copied from |data|.
+  // |data| must not be NULL and |size| >= 0.
+  static scoped_refptr<MediaSample> CopyFrom(const uint8* data,
+                                             int size,
+                                             bool is_key_frame);
+
+  // Create a MediaSample whose |data_| is copied from |data| and |side_data_|
+  // is copied from |side_data|. Data pointers must not be NULL and sizes
+  // must be >= 0.
+  static scoped_refptr<MediaSample> CopyFrom(const uint8* data,
+                                             int size,
+                                             const uint8* side_data,
+                                             int side_data_size,
+                                             bool is_key_frame);
+
+  // Create a MediaSample indicating we've reached end of stream.
+  //
+  // Calling any method other than end_of_stream() on the resulting buffer
+  // is disallowed.
+  // TODO(kqyang): do we need it?
+  static scoped_refptr<MediaSample> CreateEOSBuffer();
+
+  int64 dts() const {
+    DCHECK(!end_of_stream());
+    return dts_;
+  }
+
+  void set_dts(int64 dts) {
+    DCHECK(!end_of_stream());
+    dts_ = dts;
+  }
+
+  int64 pts() const {
+    DCHECK(!end_of_stream());
+    return pts_;
+  }
+
+  void set_pts(int64 pts) {
+    DCHECK(!end_of_stream());
+    pts_ = pts;
+  }
+
+  int64 duration() const {
+    DCHECK(!end_of_stream());
+    return duration_;
+  }
+
+  void set_duration(int64 duration) {
+    DCHECK(!end_of_stream());
+    duration_ = duration;
+  }
+
+  bool is_key_frame() const {
+    DCHECK(!end_of_stream());
+    return is_key_frame_;
+  }
+
+  const uint8* data() const {
+    DCHECK(!end_of_stream());
+    return data_.data();
+  }
+
+  uint8* writable_data() {
+    DCHECK(!end_of_stream());
+    return data_.data();
+  }
+
+  int data_size() const {
+    DCHECK(!end_of_stream());
+    return data_.size();
+  }
+
+  const uint8* side_data() const {
+    DCHECK(!end_of_stream());
+    return side_data_.data();
+  }
+
+  int side_data_size() const {
+    DCHECK(!end_of_stream());
+    return side_data_.size();
+  }
+
+  const DecryptConfig* decrypt_config() const {
+    DCHECK(!end_of_stream());
+    return decrypt_config_.get();
+  }
+
+  void set_decrypt_config(scoped_ptr<DecryptConfig> decrypt_config) {
+    DCHECK(!end_of_stream());
+    decrypt_config_ = decrypt_config.Pass();
+  }
+
+  // If there's no data in this buffer, it represents end of stream.
+  bool end_of_stream() const {
+    return data_.size() == 0;
+  }
+
+  // Returns a human-readable string describing |*this|.
+  std::string ToString();
+
+ protected:
+  friend class base::RefCountedThreadSafe<MediaSample>;
+
+  // Allocates a buffer of size |size| >= 0 and copies |data| into it.  Buffer
+  // will be padded and aligned as necessary.  If |data| is NULL then |data_| is
+  // set to NULL and |buffer_size_| to 0.
+  MediaSample(const uint8* data,
+              int size,
+              const uint8* side_data,
+              int side_data_size,
+              bool is_key_frame);
+  virtual ~MediaSample();
+
+ private:
+  // Decoding time stamp.
+  int64 dts_;
+  // Presentation time stamp.
+  int64 pts_;
+  int64 duration_;
+  bool is_key_frame_;
+
+  // Main buffer data.
+  std::vector<uint8> data_;
+  // Contain additional buffers to complete the main one. Needed by WebM
+  // http://www.matroska.org/technical/specs/index.html BlockAdditional[A5].
+  // Not used by mp4 and other containers.
+  std::vector<uint8> side_data_;
+  scoped_ptr<DecryptConfig> decrypt_config_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaSample);
+};
+
+typedef std::deque<scoped_refptr<MediaSample> > BufferQueue;
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_MEDIA_SAMPLE_H_

media/base/run_tests_with_atexit_manager.cc

@@ -0,0 +1,12 @@
+// Copyright (c) 2013 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license tha can be
+// found in the LICENSE file.
+
+#include "base/at_exit.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  base::AtExitManager exit;
+  return RUN_ALL_TESTS();
+}

media/base/stream_info.cc

@@ -0,0 +1,37 @@
+// Copyright (c) 2013 Google Inc. 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/base/stream_info.h"
+
+#include "base/logging.h"
+
+namespace media {
+
+StreamInfo::StreamInfo(StreamType stream_type,
+                       int track_id,
+                       int time_scale,
+                       const uint8* extra_data,
+                       size_t extra_data_size,
+                       bool is_encrypted)
+    : stream_type_(stream_type),
+      track_id_(track_id),
+      time_scale_(time_scale),
+      is_encrypted_(is_encrypted) {
+
+  CHECK((extra_data_size != 0) == (extra_data != NULL));
+  extra_data_.assign(extra_data, extra_data + extra_data_size);
+}
+
+StreamInfo::~StreamInfo() {}
+
+std::string StreamInfo::ToString() {
+  std::ostringstream s;
+  s << "type: " << (stream_type_ == kStreamAudio ? "Audio" : "Video")
+    << " track_id: " << track_id_
+    << " time_scale: " << time_scale_
+    << " is_encrypted: " << is_encrypted_;
+  return s.str();
+}
+
+}  // namespace media

media/base/stream_info.h

@@ -0,0 +1,70 @@
+// Copyright (c) 2013 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MEDIA_BASE_STREAM_INFO_H_
+#define MEDIA_BASE_STREAM_INFO_H_
+
+#include <string>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+
+namespace media {
+
+enum StreamType {
+  kStreamAudio,
+  kStreamVideo,
+};
+
+class StreamInfo : public base::RefCountedThreadSafe<StreamInfo>  {
+ public:
+  StreamInfo(StreamType stream_type,
+             int track_id,
+             int time_scale,
+             const uint8* extra_data,
+             size_t extra_data_size,
+             bool is_encrypted);
+  virtual ~StreamInfo();
+
+  // Returns true if this object has appropriate configuration values, false
+  // otherwise.
+  virtual bool IsValidConfig() const = 0;
+
+  // Returns a human-readable string describing |*this|.
+  virtual std::string ToString();
+
+  StreamType stream_type() const { return stream_type_; }
+  int track_id() const { return track_id_; }
+  int time_scale() const { return time_scale_; }
+
+  bool is_encrypted() const { return is_encrypted_; }
+
+  const uint8* extra_data() const {
+    return extra_data_.empty() ? NULL : &extra_data_[0];
+  }
+  size_t extra_data_size() const {
+    return extra_data_.size();
+  }
+
+ private:
+  // Whether the stream is Audio or Video.
+  StreamType stream_type_;
+  int track_id_;
+  int time_scale_;
+  // Whether the stream is potentially encrypted.
+  // Note that in a potentially encrypted stream, individual buffers
+  // can be encrypted or not encrypted.
+  bool is_encrypted_;
+  // Optional byte data required for some audio/video decoders such as Vorbis
+  // codebooks.
+  std::vector<uint8> extra_data_;
+
+  // Not using DISALLOW_COPY_AND_ASSIGN here intentionally to allow the compiler
+  // generated copy constructor and assignment operator. Since the extra data is
+  // typically small, the performance impact is minimal.
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_STREAM_INFO_H_

media/base/test_data_util.cc

@@ -7,7 +7,6 @@
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
-#include "media/base/decoder_buffer.h"
 
 namespace media {
 
@@ -21,7 +20,7 @@ base::FilePath GetTestDataFilePath(const std::string& name) {
   return file_path;
 }
 
-scoped_refptr<DecoderBuffer> ReadTestDataFile(const std::string& name) {
+std::vector<uint8> ReadTestDataFile(const std::string& name) {
   base::FilePath file_path;
   CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &file_path));
 
@@ -34,11 +33,11 @@ scoped_refptr<DecoderBuffer> ReadTestDataFile(const std::string& name) {
       << "Failed to get file size for '" << name << "'";
 
   int file_size = static_cast<int>(tmp);
+  std::vector<uint8> buffer(file_size);
 
-  scoped_refptr<DecoderBuffer> buffer(new DecoderBuffer(file_size));
   CHECK_EQ(file_size,
            file_util::ReadFile(
-               file_path, reinterpret_cast<char*>(buffer->writable_data()),
+               file_path, reinterpret_cast<char*>(buffer.data()),
                file_size)) << "Failed to read '" << name << "'";
 
   return buffer;

media/base/test_data_util.h

@@ -9,13 +9,9 @@
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 
 namespace media {
 
-class DecoderBuffer;
-
 // Returns a file path for a file in the media/test/data directory.
 base::FilePath GetTestDataFilePath(const std::string& name);
 
@@ -25,7 +21,7 @@ base::FilePath GetTestDataFilePath(const std::string& name);
 //
 //  |name| - The name of the file.
 //  |buffer| - The contents of the file.
-scoped_refptr<DecoderBuffer> ReadTestDataFile(const std::string& name);
+std::vector<uint8> ReadTestDataFile(const std::string& name);
 
 }  // namespace media
 

media/base/video_stream_info.cc

@@ -0,0 +1,48 @@
+// Copyright (c) 2013 Google Inc. 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/base/video_stream_info.h"
+
+#include <sstream>
+
+#include "media/base/limits.h"
+
+namespace media {
+
+VideoStreamInfo::VideoStreamInfo(int track_id,
+                                 int time_scale,
+                                 VideoCodec codec,
+                                 int width,
+                                 int height,
+                                 const uint8* extra_data,
+                                 size_t extra_data_size,
+                                 bool is_encrypted)
+    : StreamInfo(kStreamVideo,
+                 track_id,
+                 time_scale,
+                 extra_data,
+                 extra_data_size,
+                 is_encrypted),
+      codec_(codec),
+      width_(width),
+      height_(height) {}
+
+VideoStreamInfo::~VideoStreamInfo() {}
+
+bool VideoStreamInfo::IsValidConfig() const {
+  return codec_ != kUnknownVideoCodec &&
+         width_ > 0 && width_ <= limits::kMaxDimension &&
+         height_ > 0 && height_ <= limits::kMaxDimension;
+}
+
+std::string VideoStreamInfo::ToString() {
+  std::ostringstream s;
+  s << "codec: " << codec_
+    << " width: " << width_
+    << " height: " << height_
+    << " " << StreamInfo::ToString();
+  return s.str();
+}
+
+}  // namespace media

media/base/video_stream_info.h

@@ -0,0 +1,63 @@
+// Copyright (c) 2013 Google Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef MEDIA_BASE_VIDEO_STREAM_INFO_H_
+#define MEDIA_BASE_VIDEO_STREAM_INFO_H_
+
+#include "media/base/stream_info.h"
+
+namespace media {
+
+enum VideoCodec {
+  kUnknownVideoCodec = 0,
+  kCodecH264,
+  kCodecVC1,
+  kCodecMPEG2,
+  kCodecMPEG4,
+  kCodecTheora,
+  kCodecVP8,
+  kCodecVP9,
+
+  kNumVideoCodec
+};
+
+class VideoStreamInfo : public StreamInfo {
+ public:
+  // Constructs an initialized object. It is acceptable to pass in NULL for
+  // |extra_data|, otherwise the memory is copied.
+  VideoStreamInfo(int track_id,
+                  int time_scale,
+                  VideoCodec codec,
+                  int width,
+                  int height,
+                  const uint8* extra_data,
+                  size_t extra_data_size,
+                  bool is_encrypted);
+
+  virtual ~VideoStreamInfo();
+
+  // Returns true if this object has appropriate configuration values, false
+  // otherwise.
+  virtual bool IsValidConfig() const;
+
+  // Returns a human-readable string describing |*this|.
+  virtual std::string ToString();
+
+  VideoCodec codec() const { return codec_; }
+  int width() const { return width_; }
+  int height() const { return height_; }
+
+ private:
+  VideoCodec codec_;
+  int width_;
+  int height_;
+
+  // Not using DISALLOW_COPY_AND_ASSIGN here intentionally to allow the compiler
+  // generated copy constructor and assignment operator. Since the extra data is
+  // typically small, the performance impact is minimal.
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_VIDEO_STREAM_INFO_H_

media/mp4/aac.cc

@@ -10,43 +10,26 @@
 #include "media/base/bit_reader.h"
 #include "media/mp4/rcheck.h"
 
-// The following conversion table is extracted from ISO 14496 Part 3 -
+namespace {
-// Table 1.16 - Sampling Frequency Index.
+
-static const int kFrequencyMap[] = {
+// Sampling Frequency Index table, from ISO 14496-3 Table 1.16
+static const int kSampleRates[] = {
   96000, 88200, 64000, 48000, 44100, 32000, 24000,
   22050, 16000, 12000, 11025, 8000, 7350
 };
 
+// Channel Configuration table, from ISO 14496-3 Table 1.17
+const uint32 kChannelConfigs[] = {0, 1, 2, 3, 4, 5, 6, 8};
+
+}  // namespace
+
 namespace media {
 
-static ChannelLayout ConvertChannelConfigToLayout(uint8 channel_config) {
-  switch (channel_config) {
-    case 1:
-      return CHANNEL_LAYOUT_MONO;
-    case 2:
-      return CHANNEL_LAYOUT_STEREO;
-    case 3:
-      return CHANNEL_LAYOUT_SURROUND;
-    case 4:
-      return CHANNEL_LAYOUT_4_0;
-    case 5:
-      return CHANNEL_LAYOUT_5_0;
-    case 6:
-      return CHANNEL_LAYOUT_5_1;
-    case 8:
-      return CHANNEL_LAYOUT_7_1;
-    default:
-      break;
-  }
-
-  return CHANNEL_LAYOUT_UNSUPPORTED;
-}
-
 namespace mp4 {
 
 AAC::AAC()
     : profile_(0), frequency_index_(0), channel_config_(0), frequency_(0),
-      extension_frequency_(0), channel_layout_(CHANNEL_LAYOUT_UNSUPPORTED) {
+      extension_frequency_(0), num_channels_(0) {
 }
 
 AAC::~AAC() {
@@ -122,24 +105,26 @@ bool AAC::Parse(const std::vector<uint8>& data) {
   }
 
   if (frequency_ == 0) {
-    RCHECK(frequency_index_ < arraysize(kFrequencyMap));
+    RCHECK(frequency_index_ < arraysize(kSampleRates));
-    frequency_ = kFrequencyMap[frequency_index_];
+    frequency_ = kSampleRates[frequency_index_];
   }
 
   if (extension_frequency_ == 0 && extension_frequency_index != 0xff) {
-    RCHECK(extension_frequency_index < arraysize(kFrequencyMap));
+    RCHECK(extension_frequency_index < arraysize(kSampleRates));
-    extension_frequency_ = kFrequencyMap[extension_frequency_index];
+    extension_frequency_ = kSampleRates[extension_frequency_index];
   }
 
+  // TODO(kqyang): should we care about whether Parametric Stereo is on?
   // When Parametric Stereo is on, mono will be played as stereo.
   if (ps_present && channel_config_ == 1)
-    channel_layout_ = CHANNEL_LAYOUT_STEREO;
+    num_channels_ = 2;  // CHANNEL_LAYOUT_STEREO
-  else
+  else {
-    channel_layout_ = ConvertChannelConfigToLayout(channel_config_);
+    RCHECK(channel_config_ < arraysize(kChannelConfigs));
+    num_channels_ = kChannelConfigs[channel_config_];
+  }
 
-  return frequency_ != 0 && channel_layout_ != CHANNEL_LAYOUT_UNSUPPORTED &&
+  return frequency_ != 0 && num_channels_ != 0 && profile_ >= 1 &&
-      profile_ >= 1 && profile_ <= 4 && frequency_index_ != 0xf &&
+         profile_ <= 4 && frequency_index_ != 0xf && channel_config_ <= 7;
-      channel_config_ <= 7;
 }
 
 int AAC::GetOutputSamplesPerSecond(bool sbr_in_mimetype) const {
@@ -157,17 +142,17 @@ int AAC::GetOutputSamplesPerSecond(bool sbr_in_mimetype) const {
   return std::min(2 * frequency_, 48000);
 }
 
-ChannelLayout AAC::GetChannelLayout(bool sbr_in_mimetype) const {
+int AAC::GetNumChannels(bool sbr_in_mimetype) const {
   // Check for implicit signalling of HE-AAC and indicate stereo output
   // if the mono channel configuration is signalled.
   // See ISO-14496-3 Section 1.6.6.1.2 for details about this special casing.
   if (sbr_in_mimetype && channel_config_ == 1)
-    return CHANNEL_LAYOUT_STEREO;
+    return 2;  // CHANNEL_LAYOUT_STEREO
 
-  return channel_layout_;
+  return num_channels_;
 }
 
-bool AAC::ConvertEsdsToADTS(std::vector<uint8>* buffer) const {
+bool AAC::ConvertToADTS(std::vector<uint8>* buffer) const {
   size_t size = buffer->size() + kADTSHeaderSize;
 
   DCHECK(profile_ >= 1 && profile_ <= 4 && frequency_index_ != 0xf &&

media/mp4/aac.h

@@ -8,8 +8,6 @@
 #include <vector>
 
 #include "base/basictypes.h"
-#include "media/base/channel_layout.h"
-#include "media/base/media_export.h"
 
 namespace media {
 
@@ -21,7 +19,9 @@ namespace mp4 {
 // embedded in the esds box in an ISO BMFF file.
 // Please refer to ISO 14496 Part 3 Table 1.13 - Syntax of AudioSpecificConfig
 // for more details.
-class MEDIA_EXPORT AAC {
+// TODO(kqyang): the class name is not appropriate, it should be
+// AACAudioSpecificConfig instead.
+class AAC {
  public:
   AAC();
   ~AAC();
@@ -35,22 +35,18 @@ class MEDIA_EXPORT AAC {
   // Gets the output sample rate for the AAC stream.
   // |sbr_in_mimetype| should be set to true if the SBR mode is
   // signalled in the mimetype. (ie mp4a.40.5 in the codecs parameter).
-  // Returns the samples_per_second value that should used in an
-  // AudioDecoderConfig.
   int GetOutputSamplesPerSecond(bool sbr_in_mimetype) const;
 
-  // Gets the channel layout for the AAC stream.
+  // Gets number of channels for the AAC stream.
   // |sbr_in_mimetype| should be set to true if the SBR mode is
   // signalled in the mimetype. (ie mp4a.40.5 in the codecs parameter).
-  // Returns the channel_layout value that should used in an
+  int GetNumChannels(bool sbr_in_mimetype) const;
-  // AudioDecoderConfig.
-  ChannelLayout GetChannelLayout(bool sbr_in_mimetype) const;
 
   // This function converts a raw AAC frame into an AAC frame with an ADTS
   // header. On success, the function returns true and stores the converted data
   // in the buffer. The function returns false on failure and leaves the buffer
   // unchanged.
-  bool ConvertEsdsToADTS(std::vector<uint8>* buffer) const;
+  bool ConvertToADTS(std::vector<uint8>* buffer) const;
 
 #if defined(OS_ANDROID)
   // Returns the codec specific data needed by android MediaCodec.
@@ -78,13 +74,12 @@ class MEDIA_EXPORT AAC {
   std::vector<uint8> codec_specific_data_;
 #endif
 
-  // The following variables store audio configuration information that
+  // The following variables store audio configuration information.
-  // can be used by Chromium. They are based on the AAC specific
+  // They are based on the AAC specific configuration but can be overridden
-  // configuration but can be overridden by extensions in elementary
+  // by extensions in elementary stream descriptor.
-  // stream descriptor.
   int frequency_;
   int extension_frequency_;
-  ChannelLayout channel_layout_;
+  int num_channels_;
 };
 
 }  // namespace mp4

media/mp4/aac_unittest.cc

@@ -19,7 +19,7 @@ TEST(AACTest, BasicProfileTest) {
 
   EXPECT_TRUE(aac.Parse(data));
   EXPECT_EQ(aac.GetOutputSamplesPerSecond(false), 44100);
-  EXPECT_EQ(aac.GetChannelLayout(false), CHANNEL_LAYOUT_STEREO);
+  EXPECT_EQ(aac.GetNumChannels(false), 2);
 }
 
 TEST(AACTest, ExtensionTest) {
@@ -32,7 +32,7 @@ TEST(AACTest, ExtensionTest) {
   EXPECT_TRUE(aac.Parse(data));
   EXPECT_EQ(aac.GetOutputSamplesPerSecond(false), 48000);
   EXPECT_EQ(aac.GetOutputSamplesPerSecond(true), 48000);
-  EXPECT_EQ(aac.GetChannelLayout(false), CHANNEL_LAYOUT_STEREO);
+  EXPECT_EQ(aac.GetNumChannels(false), 2);
 }
 
 // Test implicit SBR with mono channel config.
@@ -50,11 +50,11 @@ TEST(AACTest, ImplicitSBR_ChannelConfig0) {
 
   // Test w/o implict SBR.
   EXPECT_EQ(aac.GetOutputSamplesPerSecond(false), 24000);
-  EXPECT_EQ(aac.GetChannelLayout(false), CHANNEL_LAYOUT_MONO);
+  EXPECT_EQ(aac.GetNumChannels(false), 1);
 
   // Test implicit SBR.
   EXPECT_EQ(aac.GetOutputSamplesPerSecond(true), 48000);
-  EXPECT_EQ(aac.GetChannelLayout(true), CHANNEL_LAYOUT_STEREO);
+  EXPECT_EQ(aac.GetNumChannels(true), 2);
 }
 
 // Tests implicit SBR with a stereo channel config.
@@ -69,11 +69,11 @@ TEST(AACTest, ImplicitSBR_ChannelConfig1) {
 
   // Test w/o implict SBR.
   EXPECT_EQ(aac.GetOutputSamplesPerSecond(false), 24000);
-  EXPECT_EQ(aac.GetChannelLayout(false), CHANNEL_LAYOUT_STEREO);
+  EXPECT_EQ(aac.GetNumChannels(false), 2);
 
   // Test implicit SBR.
   EXPECT_EQ(aac.GetOutputSamplesPerSecond(true), 48000);
-  EXPECT_EQ(aac.GetChannelLayout(true), CHANNEL_LAYOUT_STEREO);
+  EXPECT_EQ(aac.GetNumChannels(true), 2);
 }
 
 TEST(AACTest, SixChannelTest) {
@@ -85,7 +85,7 @@ TEST(AACTest, SixChannelTest) {
 
   EXPECT_TRUE(aac.Parse(data));
   EXPECT_EQ(aac.GetOutputSamplesPerSecond(false), 48000);
-  EXPECT_EQ(aac.GetChannelLayout(false), CHANNEL_LAYOUT_5_1);
+  EXPECT_EQ(aac.GetNumChannels(false), 6);
 }
 
 TEST(AACTest, DataTooShortTest) {

media/mp4/avc.cc

@@ -1,91 +0,0 @@
-// Copyright (c) 2012 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/mp4/avc.h"
-
-#include <algorithm>
-#include <vector>
-
-#include "media/mp4/box_definitions.h"
-#include "media/mp4/box_reader.h"
-
-namespace media {
-namespace mp4 {
-
-static const uint8 kAnnexBStartCode[] = {0, 0, 0, 1};
-static const int kAnnexBStartCodeSize = 4;
-
-static bool ConvertAVCToAnnexBInPlaceForLengthSize4(std::vector<uint8>* buf) {
-  const int kLengthSize = 4;
-  size_t pos = 0;
-  while (pos + kLengthSize < buf->size()) {
-    int nal_size = (*buf)[pos];
-    nal_size = (nal_size << 8) + (*buf)[pos+1];
-    nal_size = (nal_size << 8) + (*buf)[pos+2];
-    nal_size = (nal_size << 8) + (*buf)[pos+3];
-    std::copy(kAnnexBStartCode, kAnnexBStartCode + kAnnexBStartCodeSize,
-              buf->begin() + pos);
-    pos += kLengthSize + nal_size;
-  }
-  return pos == buf->size();
-}
-
-// static
-bool AVC::ConvertFrameToAnnexB(int length_size, std::vector<uint8>* buffer) {
-  RCHECK(length_size == 1 || length_size == 2 || length_size == 4);
-
-  if (length_size == 4)
-    return ConvertAVCToAnnexBInPlaceForLengthSize4(buffer);
-
-  std::vector<uint8> temp;
-  temp.swap(*buffer);
-  buffer->reserve(temp.size() + 32);
-
-  size_t pos = 0;
-  while (pos + length_size < temp.size()) {
-    int nal_size = temp[pos];
-    if (length_size == 2) nal_size = (nal_size << 8) + temp[pos+1];
-    pos += length_size;
-
-    RCHECK(pos + nal_size <= temp.size());
-    buffer->insert(buffer->end(), kAnnexBStartCode,
-                   kAnnexBStartCode + kAnnexBStartCodeSize);
-    buffer->insert(buffer->end(), temp.begin() + pos,
-                   temp.begin() + pos + nal_size);
-    pos += nal_size;
-  }
-  return pos == temp.size();
-}
-
-// static
-bool AVC::ConvertConfigToAnnexB(
-    const AVCDecoderConfigurationRecord& avc_config,
-    std::vector<uint8>* buffer) {
-  DCHECK(buffer->empty());
-  buffer->clear();
-  int total_size = 0;
-  for (size_t i = 0; i < avc_config.sps_list.size(); i++)
-    total_size += avc_config.sps_list[i].size() + kAnnexBStartCodeSize;
-  for (size_t i = 0; i < avc_config.pps_list.size(); i++)
-    total_size += avc_config.pps_list[i].size() + kAnnexBStartCodeSize;
-  buffer->reserve(total_size);
-
-  for (size_t i = 0; i < avc_config.sps_list.size(); i++) {
-    buffer->insert(buffer->end(), kAnnexBStartCode,
-                kAnnexBStartCode + kAnnexBStartCodeSize);
-    buffer->insert(buffer->end(), avc_config.sps_list[i].begin(),
-                avc_config.sps_list[i].end());
-  }
-
-  for (size_t i = 0; i < avc_config.pps_list.size(); i++) {
-    buffer->insert(buffer->end(), kAnnexBStartCode,
-                   kAnnexBStartCode + kAnnexBStartCodeSize);
-    buffer->insert(buffer->end(), avc_config.pps_list[i].begin(),
-                   avc_config.pps_list[i].end());
-  }
-  return true;
-}
-
-}  // namespace mp4
-}  // namespace media

media/mp4/avc.h

@@ -1,30 +0,0 @@
-// Copyright (c) 2012 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.
-
-#ifndef MEDIA_MP4_AVC_H_
-#define MEDIA_MP4_AVC_H_
-
-#include <vector>
-
-#include "base/basictypes.h"
-#include "media/base/media_export.h"
-
-namespace media {
-namespace mp4 {
-
-struct AVCDecoderConfigurationRecord;
-
-class MEDIA_EXPORT AVC {
- public:
-  static bool ConvertFrameToAnnexB(int length_size, std::vector<uint8>* buffer);
-
-  static bool ConvertConfigToAnnexB(
-      const AVCDecoderConfigurationRecord& avc_config,
-      std::vector<uint8>* buffer);
-};
-
-}  // namespace mp4
-}  // namespace media
-
-#endif  // MEDIA_MP4_AVC_H_

media/mp4/avc_unittest.cc

@@ -1,95 +0,0 @@
-// Copyright (c) 2012 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 <string.h>
-
-#include "base/basictypes.h"
-#include "media/base/stream_parser_buffer.h"
-#include "media/mp4/avc.h"
-#include "media/mp4/box_definitions.h"
-#include "testing/gtest/include/gtest/gtest.h"
-#include "testing/gtest/include/gtest/gtest-param-test.h"
-
-namespace media {
-namespace mp4 {
-
-static const uint8 kNALU1[] = { 0x01, 0x02, 0x03 };
-static const uint8 kNALU2[] = { 0x04, 0x05, 0x06, 0x07 };
-static const uint8 kExpected[] = {
-  0x00, 0x00, 0x00, 0x01, 0x01, 0x02, 0x03,
-  0x00, 0x00, 0x00, 0x01, 0x04, 0x05, 0x06, 0x07 };
-
-static const uint8 kExpectedParamSets[] = {
-  0x00, 0x00, 0x00, 0x01, 0x67, 0x12,
-  0x00, 0x00, 0x00, 0x01, 0x67, 0x34,
-  0x00, 0x00, 0x00, 0x01, 0x68, 0x56, 0x78};
-
-class AVCConversionTest : public testing::TestWithParam<int> {
- protected:
-  void MakeInputForLength(int length_size, std::vector<uint8>* buf) {
-    buf->clear();
-    for (int i = 1; i < length_size; i++)
-      buf->push_back(0);
-    buf->push_back(sizeof(kNALU1));
-    buf->insert(buf->end(), kNALU1, kNALU1 + sizeof(kNALU1));
-
-    for (int i = 1; i < length_size; i++)
-      buf->push_back(0);
-    buf->push_back(sizeof(kNALU2));
-    buf->insert(buf->end(), kNALU2, kNALU2 + sizeof(kNALU2));
-  }
-};
-
-TEST_P(AVCConversionTest, ParseCorrectly) {
-  std::vector<uint8> buf;
-  MakeInputForLength(GetParam(), &buf);
-  EXPECT_TRUE(AVC::ConvertFrameToAnnexB(GetParam(), &buf));
-  EXPECT_EQ(buf.size(), sizeof(kExpected));
-  EXPECT_EQ(0, memcmp(kExpected, &buf[0], sizeof(kExpected)));
-}
-
-TEST_P(AVCConversionTest, ParsePartial) {
-  std::vector<uint8> buf;
-  MakeInputForLength(GetParam(), &buf);
-  buf.pop_back();
-  EXPECT_FALSE(AVC::ConvertFrameToAnnexB(GetParam(), &buf));
-  // This tests a buffer ending in the middle of a NAL length. For length size
-  // of one, this can't happen, so we skip that case.
-  if (GetParam() != 1) {
-    MakeInputForLength(GetParam(), &buf);
-    buf.erase(buf.end() - (sizeof(kNALU2) + 1), buf.end());
-    EXPECT_FALSE(AVC::ConvertFrameToAnnexB(GetParam(), &buf));
-  }
-}
-
-TEST_P(AVCConversionTest, ParseEmpty) {
-  std::vector<uint8> buf;
-  EXPECT_TRUE(AVC::ConvertFrameToAnnexB(GetParam(), &buf));
-  EXPECT_EQ(0u, buf.size());
-}
-
-INSTANTIATE_TEST_CASE_P(AVCConversionTestValues,
-                        AVCConversionTest,
-                        ::testing::Values(1, 2, 4));
-
-TEST_F(AVCConversionTest, ConvertConfigToAnnexB) {
-  AVCDecoderConfigurationRecord avc_config;
-  avc_config.sps_list.resize(2);
-  avc_config.sps_list[0].push_back(0x67);
-  avc_config.sps_list[0].push_back(0x12);
-  avc_config.sps_list[1].push_back(0x67);
-  avc_config.sps_list[1].push_back(0x34);
-  avc_config.pps_list.resize(1);
-  avc_config.pps_list[0].push_back(0x68);
-  avc_config.pps_list[0].push_back(0x56);
-  avc_config.pps_list[0].push_back(0x78);
-
-  std::vector<uint8> buf;
-  EXPECT_TRUE(AVC::ConvertConfigToAnnexB(avc_config, &buf));
-  EXPECT_EQ(0, memcmp(kExpectedParamSets, &buf[0],
-                      sizeof(kExpectedParamSets)));
-}
-
-}  // namespace mp4
-}  // namespace media

media/mp4/box_definitions.h

@@ -8,11 +8,7 @@
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
-#include "media/base/media_export.h"
 #include "media/mp4/aac.h"
-#include "media/mp4/avc.h"
 #include "media/mp4/box_reader.h"
 #include "media/mp4/fourccs.h"
 
@@ -32,27 +28,27 @@ enum TrackType {
   virtual bool Parse(BoxReader* reader) OVERRIDE; \
   virtual FourCC BoxType() const OVERRIDE; \
 
-struct MEDIA_EXPORT FileType : Box {
+struct FileType : Box {
   DECLARE_BOX_METHODS(FileType);
 
   FourCC major_brand;
   uint32 minor_version;
 };
 
-struct MEDIA_EXPORT ProtectionSystemSpecificHeader : Box {
+struct ProtectionSystemSpecificHeader : Box {
   DECLARE_BOX_METHODS(ProtectionSystemSpecificHeader);
 
   std::vector<uint8> system_id;
   std::vector<uint8> raw_box;
 };
 
-struct MEDIA_EXPORT SampleAuxiliaryInformationOffset : Box {
+struct SampleAuxiliaryInformationOffset : Box {
   DECLARE_BOX_METHODS(SampleAuxiliaryInformationOffset);
 
   std::vector<uint64> offsets;
 };
 
-struct MEDIA_EXPORT SampleAuxiliaryInformationSize : Box {
+struct SampleAuxiliaryInformationSize : Box {
   DECLARE_BOX_METHODS(SampleAuxiliaryInformationSize);
 
   uint8 default_sample_info_size;
@@ -60,20 +56,20 @@ struct MEDIA_EXPORT SampleAuxiliaryInformationSize : Box {
   std::vector<uint8> sample_info_sizes;
 };
 
-struct MEDIA_EXPORT OriginalFormat : Box {
+struct OriginalFormat : Box {
   DECLARE_BOX_METHODS(OriginalFormat);
 
   FourCC format;
 };
 
-struct MEDIA_EXPORT SchemeType : Box {
+struct SchemeType : Box {
   DECLARE_BOX_METHODS(SchemeType);
 
   FourCC type;
   uint32 version;
 };
 
-struct MEDIA_EXPORT TrackEncryption : Box {
+struct TrackEncryption : Box {
   DECLARE_BOX_METHODS(TrackEncryption);
 
   // Note: this definition is specific to the CENC protection type.
@@ -82,13 +78,13 @@ struct MEDIA_EXPORT TrackEncryption : Box {
   std::vector<uint8> default_kid;
 };
 
-struct MEDIA_EXPORT SchemeInfo : Box {
+struct SchemeInfo : Box {
   DECLARE_BOX_METHODS(SchemeInfo);
 
   TrackEncryption track_encryption;
 };
 
-struct MEDIA_EXPORT ProtectionSchemeInfo : Box {
+struct ProtectionSchemeInfo : Box {
   DECLARE_BOX_METHODS(ProtectionSchemeInfo);
 
   OriginalFormat format;
@@ -96,7 +92,7 @@ struct MEDIA_EXPORT ProtectionSchemeInfo : Box {
   SchemeInfo info;
 };
 
-struct MEDIA_EXPORT MovieHeader : Box {
+struct MovieHeader : Box {
   DECLARE_BOX_METHODS(MovieHeader);
 
   uint64 creation_time;
@@ -108,7 +104,7 @@ struct MEDIA_EXPORT MovieHeader : Box {
   uint32 next_track_id;
 };
 
-struct MEDIA_EXPORT TrackHeader : Box {
+struct TrackHeader : Box {
   DECLARE_BOX_METHODS(TrackHeader);
 
   uint64 creation_time;
@@ -122,32 +118,32 @@ struct MEDIA_EXPORT TrackHeader : Box {
   uint32 height;
 };
 
-struct MEDIA_EXPORT EditListEntry {
+struct EditListEntry {
   uint64 segment_duration;
   int64 media_time;
   int16 media_rate_integer;
   int16 media_rate_fraction;
 };
 
-struct MEDIA_EXPORT EditList : Box {
+struct EditList : Box {
   DECLARE_BOX_METHODS(EditList);
 
   std::vector<EditListEntry> edits;
 };
 
-struct MEDIA_EXPORT Edit : Box {
+struct Edit : Box {
   DECLARE_BOX_METHODS(Edit);
 
   EditList list;
 };
 
-struct MEDIA_EXPORT HandlerReference : Box {
+struct HandlerReference : Box {
   DECLARE_BOX_METHODS(HandlerReference);
 
   TrackType type;
 };
 
-struct MEDIA_EXPORT AVCDecoderConfigurationRecord : Box {
+struct AVCDecoderConfigurationRecord : Box {
   DECLARE_BOX_METHODS(AVCDecoderConfigurationRecord);
 
   uint8 version;
@@ -163,14 +159,14 @@ struct MEDIA_EXPORT AVCDecoderConfigurationRecord : Box {
   std::vector<PPS> pps_list;
 };
 
-struct MEDIA_EXPORT PixelAspectRatioBox : Box {
+struct PixelAspectRatioBox : Box {
   DECLARE_BOX_METHODS(PixelAspectRatioBox);
 
   uint32 h_spacing;
   uint32 v_spacing;
 };
 
-struct MEDIA_EXPORT VideoSampleEntry : Box {
+struct VideoSampleEntry : Box {
   DECLARE_BOX_METHODS(VideoSampleEntry);
 
   FourCC format;
@@ -185,14 +181,14 @@ struct MEDIA_EXPORT VideoSampleEntry : Box {
   AVCDecoderConfigurationRecord avcc;
 };
 
-struct MEDIA_EXPORT ElementaryStreamDescriptor : Box {
+struct ElementaryStreamDescriptor : Box {
   DECLARE_BOX_METHODS(ElementaryStreamDescriptor);
 
   uint8 object_type;
   AAC aac;
 };
 
-struct MEDIA_EXPORT AudioSampleEntry : Box {
+struct AudioSampleEntry : Box {
   DECLARE_BOX_METHODS(AudioSampleEntry);
 
   FourCC format;
@@ -205,7 +201,7 @@ struct MEDIA_EXPORT AudioSampleEntry : Box {
   ElementaryStreamDescriptor esds;
 };
 
-struct MEDIA_EXPORT SampleDescription : Box {
+struct SampleDescription : Box {
   DECLARE_BOX_METHODS(SampleDescription);
 
   TrackType type;
@@ -213,7 +209,7 @@ struct MEDIA_EXPORT SampleDescription : Box {
   std::vector<AudioSampleEntry> audio_entries;
 };
 
-struct MEDIA_EXPORT SampleTable : Box {
+struct SampleTable : Box {
   DECLARE_BOX_METHODS(SampleTable);
 
   // Media Source specific: we ignore many of the sub-boxes in this box,
@@ -223,7 +219,7 @@ struct MEDIA_EXPORT SampleTable : Box {
   SampleDescription description;
 };
 
-struct MEDIA_EXPORT MediaHeader : Box {
+struct MediaHeader : Box {
   DECLARE_BOX_METHODS(MediaHeader);
 
   uint64 creation_time;
@@ -232,13 +228,13 @@ struct MEDIA_EXPORT MediaHeader : Box {
   uint64 duration;
 };
 
-struct MEDIA_EXPORT MediaInformation : Box {
+struct MediaInformation : Box {
   DECLARE_BOX_METHODS(MediaInformation);
 
   SampleTable sample_table;
 };
 
-struct MEDIA_EXPORT Media : Box {
+struct Media : Box {
   DECLARE_BOX_METHODS(Media);
 
   MediaHeader header;
@@ -246,7 +242,7 @@ struct MEDIA_EXPORT Media : Box {
   MediaInformation information;
 };
 
-struct MEDIA_EXPORT Track : Box {
+struct Track : Box {
   DECLARE_BOX_METHODS(Track);
 
   TrackHeader header;
@@ -254,13 +250,13 @@ struct MEDIA_EXPORT Track : Box {
   Edit edit;
 };
 
-struct MEDIA_EXPORT MovieExtendsHeader : Box {
+struct MovieExtendsHeader : Box {
   DECLARE_BOX_METHODS(MovieExtendsHeader);
 
   uint64 fragment_duration;
 };
 
-struct MEDIA_EXPORT TrackExtends : Box {
+struct TrackExtends : Box {
   DECLARE_BOX_METHODS(TrackExtends);
 
   uint32 track_id;
@@ -270,14 +266,14 @@ struct MEDIA_EXPORT TrackExtends : Box {
   uint32 default_sample_flags;
 };
 
-struct MEDIA_EXPORT MovieExtends : Box {
+struct MovieExtends : Box {
   DECLARE_BOX_METHODS(MovieExtends);
 
   MovieExtendsHeader header;
   std::vector<TrackExtends> tracks;
 };
 
-struct MEDIA_EXPORT Movie : Box {
+struct Movie : Box {
   DECLARE_BOX_METHODS(Movie);
 
   bool fragmented;
@@ -287,19 +283,19 @@ struct MEDIA_EXPORT Movie : Box {
   std::vector<ProtectionSystemSpecificHeader> pssh;
 };
 
-struct MEDIA_EXPORT TrackFragmentDecodeTime : Box {
+struct TrackFragmentDecodeTime : Box {
   DECLARE_BOX_METHODS(TrackFragmentDecodeTime);
 
   uint64 decode_time;
 };
 
-struct MEDIA_EXPORT MovieFragmentHeader : Box {
+struct MovieFragmentHeader : Box {
   DECLARE_BOX_METHODS(MovieFragmentHeader);
 
   uint32 sequence_number;
 };
 
-struct MEDIA_EXPORT TrackFragmentHeader : Box {
+struct TrackFragmentHeader : Box {
   DECLARE_BOX_METHODS(TrackFragmentHeader);
 
   uint32 track_id;
@@ -314,7 +310,7 @@ struct MEDIA_EXPORT TrackFragmentHeader : Box {
   bool has_default_sample_flags;
 };
 
-struct MEDIA_EXPORT TrackFragmentRun : Box {
+struct TrackFragmentRun : Box {
   DECLARE_BOX_METHODS(TrackFragmentRun);
 
   uint32 sample_count;
@@ -325,7 +321,7 @@ struct MEDIA_EXPORT TrackFragmentRun : Box {
   std::vector<int32> sample_composition_time_offsets;
 };
 
-struct MEDIA_EXPORT TrackFragment : Box {
+struct TrackFragment : Box {
   DECLARE_BOX_METHODS(TrackFragment);
 
   TrackFragmentHeader header;
@@ -335,7 +331,7 @@ struct MEDIA_EXPORT TrackFragment : Box {
   SampleAuxiliaryInformationSize auxiliary_size;
 };
 
-struct MEDIA_EXPORT MovieFragment : Box {
+struct MovieFragment : Box {
   DECLARE_BOX_METHODS(MovieFragment);
 
   MovieFragmentHeader header;

media/mp4/box_reader.cc

@@ -79,10 +79,8 @@ bool BufferReader::Read4sInto8s(int64* v) {
 }
 
 
-BoxReader::BoxReader(const uint8* buf, const int size,
+BoxReader::BoxReader(const uint8* buf, const int size)
-                     const LogCB& log_cb)
     : BufferReader(buf, size),
-      log_cb_(log_cb),
       type_(FOURCC_NULL),
       version_(0),
       flags_(0),
@@ -101,13 +99,12 @@ BoxReader::~BoxReader() {
 // static
 BoxReader* BoxReader::ReadTopLevelBox(const uint8* buf,
                                       const int buf_size,
-                                      const LogCB& log_cb,
                                       bool* err) {
-  scoped_ptr<BoxReader> reader(new BoxReader(buf, buf_size, log_cb));
+  scoped_ptr<BoxReader> reader(new BoxReader(buf, buf_size));
   if (!reader->ReadHeader(err))
     return NULL;
 
-  if (!IsValidTopLevelBox(reader->type(), log_cb)) {
+  if (!IsValidTopLevelBox(reader->type())) {
     *err = true;
     return NULL;
   }
@@ -121,13 +118,12 @@ BoxReader* BoxReader::ReadTopLevelBox(const uint8* buf,
 // static
 bool BoxReader::StartTopLevelBox(const uint8* buf,
                                  const int buf_size,
-                                 const LogCB& log_cb,
                                  FourCC* type,
                                  int* box_size,
                                  bool* err) {
-  BoxReader reader(buf, buf_size, log_cb);
+  BoxReader reader(buf, buf_size);
   if (!reader.ReadHeader(err)) return false;
-  if (!IsValidTopLevelBox(reader.type(), log_cb)) {
+  if (!IsValidTopLevelBox(reader.type())) {
     *err = true;
     return false;
   }
@@ -137,8 +133,7 @@ bool BoxReader::StartTopLevelBox(const uint8* buf,
 }
 
 // static
-bool BoxReader::IsValidTopLevelBox(const FourCC& type,
+bool BoxReader::IsValidTopLevelBox(const FourCC& type) {
-                                   const LogCB& log_cb) {
   switch (type) {
     case FOURCC_FTYP:
     case FOURCC_PDIN:
@@ -158,8 +153,7 @@ bool BoxReader::IsValidTopLevelBox(const FourCC& type,
       return true;
     default:
       // Hex is used to show nonprintable characters and aid in debugging
-      MEDIA_LOG(log_cb) << "Unrecognized top-level box type 0x"
+      LOG(ERROR) << "Unrecognized top-level box type 0x" << std::hex << type;
-                        << std::hex << type;
       return false;
   }
 }
@@ -170,7 +164,7 @@ bool BoxReader::ScanChildren() {
 
   bool err = false;
   while (pos() < size()) {
-    BoxReader child(&buf_[pos_], size_ - pos_, log_cb_);
+    BoxReader child(&buf_[pos_], size_ - pos_);
     if (!child.ReadHeader(&err)) break;
 
     children_.insert(std::pair<FourCC, BoxReader>(child.type(), child));

media/mp4/box_reader.h

@@ -10,8 +10,6 @@
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
-#include "media/base/media_export.h"
-#include "media/base/media_log.h"
 #include "media/mp4/fourccs.h"
 #include "media/mp4/rcheck.h"
 
@@ -20,13 +18,13 @@ namespace mp4 {
 
 class BoxReader;
 
-struct MEDIA_EXPORT Box {
+struct Box {
   virtual ~Box();
   virtual bool Parse(BoxReader* reader) = 0;
   virtual FourCC BoxType() const = 0;
 };
 
-class MEDIA_EXPORT BufferReader {
+class BufferReader {
  public:
   BufferReader(const uint8* buf, const int size)
     : buf_(buf), size_(size), pos_(0) {}
@@ -67,7 +65,7 @@ class MEDIA_EXPORT BufferReader {
   template<typename T> bool Read(T* t) WARN_UNUSED_RESULT;
 };
 
-class MEDIA_EXPORT BoxReader : public BufferReader {
+class BoxReader : public BufferReader {
  public:
   ~BoxReader();
 
@@ -79,7 +77,6 @@ class MEDIA_EXPORT BoxReader : public BufferReader {
   // |buf| is retained but not owned, and must outlive the BoxReader instance.
   static BoxReader* ReadTopLevelBox(const uint8* buf,
                                     const int buf_size,
-                                    const LogCB& log_cb,
                                     bool* err);
 
   // Read the box header from the current buffer. This function returns true if
@@ -90,7 +87,6 @@ class MEDIA_EXPORT BoxReader : public BufferReader {
   // |buf| is not retained.
   static bool StartTopLevelBox(const uint8* buf,
                                const int buf_size,
-                               const LogCB& log_cb,
                                FourCC* type,
                                int* box_size,
                                bool* err) WARN_UNUSED_RESULT;
@@ -98,8 +94,7 @@ class MEDIA_EXPORT BoxReader : public BufferReader {
   // Returns true if |type| is recognized to be a top-level box, false
   // otherwise. This returns true for some boxes which we do not parse.
   // Helpful in debugging misaligned appends.
-  static bool IsValidTopLevelBox(const FourCC& type,
+  static bool IsValidTopLevelBox(const FourCC& type);
-                                 const LogCB& log_cb);
 
   // Scan through all boxes within the current box, starting at the current
   // buffer position. Must be called before any of the *Child functions work.
@@ -137,7 +132,7 @@ class MEDIA_EXPORT BoxReader : public BufferReader {
   uint32 flags() const  { return flags_; }
 
  private:
-  BoxReader(const uint8* buf, const int size, const LogCB& log_cb);
+  BoxReader(const uint8* buf, const int size);
 
   // Must be called immediately after init. If the return is false, this
   // indicates that the box header and its contents were not available in the
@@ -148,7 +143,6 @@ class MEDIA_EXPORT BoxReader : public BufferReader {
   // true, the error is unrecoverable and the stream should be aborted.
   bool ReadHeader(bool* err);
 
-  LogCB log_cb_;
   FourCC type_;
   uint8 version_;
   uint32 flags_;
@@ -197,7 +191,7 @@ bool BoxReader::ReadAllChildren(std::vector<T>* children) {
 
   bool err = false;
   while (pos() < size()) {
-    BoxReader child_reader(&buf_[pos_], size_ - pos_, log_cb_);
+    BoxReader child_reader(&buf_[pos_], size_ - pos_);
     if (!child_reader.ReadHeader(&err)) break;
     T child;
     RCHECK(child.Parse(&child_reader));

media/mp4/box_reader_unittest.cc

@@ -86,7 +86,7 @@ TEST_F(BoxReaderTest, ExpectedOperationTest) {
   std::vector<uint8> buf = GetBuf();
   bool err;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &err));
   EXPECT_FALSE(err);
   EXPECT_TRUE(reader.get());
 
@@ -114,7 +114,7 @@ TEST_F(BoxReaderTest, OuterTooShortTest) {
 
   // Create a soft failure by truncating the outer box.
   scoped_ptr<BoxReader> r(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size() - 2, LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size() - 2, &err));
 
   EXPECT_FALSE(err);
   EXPECT_FALSE(r.get());
@@ -127,7 +127,7 @@ TEST_F(BoxReaderTest, InnerTooLongTest) {
   // Make an inner box too big for its outer box.
   buf[25] = 1;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &err));
 
   SkipBox box;
   EXPECT_FALSE(box.Parse(reader.get()));
@@ -140,7 +140,7 @@ TEST_F(BoxReaderTest, WrongFourCCTest) {
   // Set an unrecognized top-level FourCC.
   buf[5] = 1;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &err));
   EXPECT_FALSE(reader.get());
   EXPECT_TRUE(err);
 }
@@ -149,7 +149,7 @@ TEST_F(BoxReaderTest, ScanChildrenTest) {
   std::vector<uint8> buf = GetBuf();
   bool err;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &err));
 
   EXPECT_TRUE(reader->SkipBytes(16) && reader->ScanChildren());
 
@@ -173,7 +173,7 @@ TEST_F(BoxReaderTest, ReadAllChildrenTest) {
   buf[3] = 0x38;
   bool err;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &err));
 
   std::vector<PsshBox> kids;
   EXPECT_TRUE(reader->SkipBytes(16) && reader->ReadAllChildren(&kids));
@@ -190,7 +190,7 @@ TEST_F(BoxReaderTest, SkippingBloc) {
 
   bool err;
   scoped_ptr<BoxReader> reader(
-      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), LogCB(), &err));
+      BoxReader::ReadTopLevelBox(&buf[0], buf.size(), &err));
 
   EXPECT_FALSE(err);
   EXPECT_TRUE(reader);

media/mp4/es_descriptor.cc

@@ -32,7 +32,7 @@ namespace media {
 namespace mp4 {
 
 // static
-bool ESDescriptor::IsAAC(uint8 object_type) {
+bool ESDescriptor::IsAAC(ObjectType object_type) {
   return object_type == kISO_14496_3 || object_type == kISO_13818_7_AAC_LC;
 }
 
@@ -72,7 +72,7 @@ bool ESDescriptor::Parse(const std::vector<uint8>& data) {
   return true;
 }
 
-uint8 ESDescriptor::object_type() const {
+ObjectType ESDescriptor::object_type() const {
   return object_type_;
 }
 

media/mp4/es_descriptor.h

@@ -8,7 +8,6 @@
 #include <vector>
 
 #include "base/basictypes.h"
-#include "media/base/media_export.h"
 
 namespace media {
 
@@ -28,17 +27,17 @@ enum ObjectType {
 // This class parse object type and decoder specific information from an
 // elementary stream descriptor, which is usually contained in an esds box.
 // Please refer to ISO 14496 Part 1 7.2.6.5 for more details.
-class MEDIA_EXPORT ESDescriptor {
+class ESDescriptor {
  public:
   // Utility function to check if the given object type is AAC.
-  static bool IsAAC(uint8 object_type);
+  static bool IsAAC(ObjectType object_type);
 
   ESDescriptor();
   ~ESDescriptor();
 
   bool Parse(const std::vector<uint8>& data);
 
-  uint8 object_type() const;
+  ObjectType object_type() const;
   const std::vector<uint8>& decoder_specific_info() const;
 
  private:
@@ -51,7 +50,7 @@ class MEDIA_EXPORT ESDescriptor {
   bool ParseDecoderConfigDescriptor(BitReader* reader);
   bool ParseDecoderSpecificInfo(BitReader* reader);
 
-  uint8 object_type_;
+  ObjectType object_type_;
   std::vector<uint8> decoder_specific_info_;
 };
 

media/mp4/mp4_media_parser.cc

@@ -2,29 +2,38 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "media/mp4/mp4_stream_parser.h"
+#include "media/mp4/mp4_media_parser.h"
 
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
 #include "base/time/time.h"
-#include "media/base/audio_decoder_config.h"
+#include "media/base/audio_stream_info.h"
-#include "media/base/stream_parser_buffer.h"
+#include "media/base/buffers.h"
-#include "media/base/video_decoder_config.h"
+#include "media/base/media_sample.h"
-#include "media/base/video_util.h"
+#include "media/base/video_stream_info.h"
 #include "media/mp4/box_definitions.h"
 #include "media/mp4/box_reader.h"
 #include "media/mp4/es_descriptor.h"
 #include "media/mp4/rcheck.h"
+#include "media/mp4/track_run_iterator.h"
+
+namespace {
+
+base::TimeDelta TimeDeltaFromRational(int64 numer, int64 denom) {
+  DCHECK_LT((numer > 0 ? numer : -numer),
+            kint64max / base::Time::kMicrosecondsPerSecond);
+  return base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond *
+                                           numer / denom);
+}
+
+}  // namespace
 
 namespace media {
 namespace mp4 {
 
-// TODO(xhwang): Figure out the init data type appropriately once it's spec'ed.
+MP4MediaParser::MP4MediaParser()
-static const char kMp4InitDataType[] = "video/mp4";
-
-MP4StreamParser::MP4StreamParser(const std::set<int>& audio_object_types,
-                                 bool has_sbr)
     : state_(kWaitingForInit),
       moof_head_(0),
       mdat_tail_(0),
@@ -32,55 +41,37 @@ MP4StreamParser::MP4StreamParser(const std::set<int>& audio_object_types,
       has_video_(false),
       audio_track_id_(0),
       video_track_id_(0),
-      audio_object_types_(audio_object_types),
+      // TODO(kqyang): do we need to care about it??
-      has_sbr_(has_sbr),
+      has_sbr_(false),
       is_audio_track_encrypted_(false),
       is_video_track_encrypted_(false) {
 }
 
-MP4StreamParser::~MP4StreamParser() {}
+MP4MediaParser::~MP4MediaParser() {}
 
-void MP4StreamParser::Init(const InitCB& init_cb,
+void MP4MediaParser::Init(const InitCB& init_cb,
-                           const NewConfigCB& config_cb,
+                          const NewSampleCB& new_sample_cb,
-                           const NewBuffersCB& new_buffers_cb,
+                          const NeedKeyCB& need_key_cb) {
-                           const NewTextBuffersCB& /* text_cb */ ,
-                           const NeedKeyCB& need_key_cb,
-                           const AddTextTrackCB& /* add_text_track_cb */ ,
-                           const NewMediaSegmentCB& new_segment_cb,
-                           const base::Closure& end_of_segment_cb,
-                           const LogCB& log_cb) {
   DCHECK_EQ(state_, kWaitingForInit);
   DCHECK(init_cb_.is_null());
   DCHECK(!init_cb.is_null());
-  DCHECK(!config_cb.is_null());
+  DCHECK(!new_sample_cb.is_null());
-  DCHECK(!new_buffers_cb.is_null());
   DCHECK(!need_key_cb.is_null());
-  DCHECK(!end_of_segment_cb.is_null());
 
   ChangeState(kParsingBoxes);
   init_cb_ = init_cb;
-  config_cb_ = config_cb;
+  new_sample_cb_ = new_sample_cb;
-  new_buffers_cb_ = new_buffers_cb;
   need_key_cb_ = need_key_cb;
-  new_segment_cb_ = new_segment_cb;
-  end_of_segment_cb_ = end_of_segment_cb;
-  log_cb_ = log_cb;
 }
 
-void MP4StreamParser::Reset() {
+void MP4MediaParser::Reset() {
   queue_.Reset();
   runs_.reset();
   moof_head_ = 0;
   mdat_tail_ = 0;
 }
 
-void MP4StreamParser::Flush() {
+bool MP4MediaParser::Parse(const uint8* buf, int size) {
-  DCHECK_NE(state_, kWaitingForInit);
-  Reset();
-  ChangeState(kParsingBoxes);
-}
-
-bool MP4StreamParser::Parse(const uint8* buf, int size) {
   DCHECK_NE(state_, kWaitingForInit);
 
   if (state_ == kError)
@@ -88,9 +79,6 @@ bool MP4StreamParser::Parse(const uint8* buf, int size) {
 
   queue_.Push(buf, size);
 
-  BufferQueue audio_buffers;
-  BufferQueue video_buffers;
-
   bool result, err = false;
 
   do {
@@ -98,7 +86,7 @@ bool MP4StreamParser::Parse(const uint8* buf, int size) {
       result = ParseBox(&err);
     } else {
       DCHECK_EQ(kEmittingSamples, state_);
-      result = EnqueueSample(&audio_buffers, &video_buffers, &err);
+      result = EnqueueSample(&err);
       if (result) {
         int64 max_clear = runs_->GetMaxClearOffset() + moof_head_;
         err = !ReadAndDiscardMDATsUntil(max_clear);
@@ -106,9 +94,6 @@ bool MP4StreamParser::Parse(const uint8* buf, int size) {
     }
   } while (result && !err);
 
-  if (!err)
-    err = !SendAndFlushSamples(&audio_buffers, &video_buffers);
-
   if (err) {
     DLOG(ERROR) << "Error while parsing MP4";
     moov_.reset();
@@ -120,14 +105,13 @@ bool MP4StreamParser::Parse(const uint8* buf, int size) {
   return true;
 }
 
-bool MP4StreamParser::ParseBox(bool* err) {
+bool MP4MediaParser::ParseBox(bool* err) {
   const uint8* buf;
   int size;
   queue_.Peek(&buf, &size);
   if (!size) return false;
 
-  scoped_ptr<BoxReader> reader(
+  scoped_ptr<BoxReader> reader(BoxReader::ReadTopLevelBox(buf, size, err));
-      BoxReader::ReadTopLevelBox(buf, size, log_cb_, err));
   if (reader.get() == NULL) return false;
 
   if (reader->type() == FOURCC_MOOV) {
@@ -145,7 +129,7 @@ bool MP4StreamParser::ParseBox(bool* err) {
     // before the head of the 'moof', so keeping this box around is sufficient.)
     return !(*err);
   } else {
-    MEDIA_LOG(log_cb_) << "Skipping unrecognized top-level box: "
+    LOG(WARNING) << "Skipping unrecognized top-level box: "
                  << FourCCToString(reader->type());
   }
 
@@ -154,7 +138,7 @@ bool MP4StreamParser::ParseBox(bool* err) {
 }
 
 
-bool MP4StreamParser::ParseMoov(BoxReader* reader) {
+bool MP4MediaParser::ParseMoov(BoxReader* reader) {
   moov_.reset(new Movie);
   RCHECK(moov_->Parse(reader));
   runs_.reset();
@@ -162,8 +146,7 @@ bool MP4StreamParser::ParseMoov(BoxReader* reader) {
   has_audio_ = false;
   has_video_ = false;
 
-  AudioDecoderConfig audio_config;
+  std::vector<scoped_refptr<StreamInfo> > streams;
-  VideoDecoderConfig video_config;
 
   for (std::vector<Track>::const_iterator track = moov_->tracks.begin();
        track != moov_->tracks.end(); ++track) {
@@ -187,7 +170,11 @@ bool MP4StreamParser::ParseMoov(BoxReader* reader) {
     RCHECK(desc_idx > 0);
     desc_idx -= 1;  // BMFF descriptor index is one-based
 
-    if (track->media.handler.type == kAudio && !audio_config.IsValidConfig()) {
+    if (track->media.handler.type == kAudio) {
+      // TODO(kqyang): do we need to support multiple audio or video streams in
+      // a single file?
+      RCHECK(!has_audio_);
+
       RCHECK(!samp_descr.audio_entries.empty());
 
       // It is not uncommon to find otherwise-valid files with incorrect sample
@@ -200,68 +187,61 @@ bool MP4StreamParser::ParseMoov(BoxReader* reader) {
       if (!(entry.format == FOURCC_MP4A || entry.format == FOURCC_EAC3 ||
             (entry.format == FOURCC_ENCA &&
              entry.sinf.format.format == FOURCC_MP4A))) {
-        MEDIA_LOG(log_cb_) << "Unsupported audio format 0x"
+        LOG(ERROR) << "Unsupported audio format 0x"
                    << std::hex << entry.format << " in stsd box.";
         return false;
       }
 
-      uint8 audio_type = entry.esds.object_type;
+      ObjectType audio_type = static_cast<ObjectType>(entry.esds.object_type);
       DVLOG(1) << "audio_type " << std::hex << audio_type;
       if (audio_type == kForbidden && entry.format == FOURCC_EAC3) {
         audio_type = kEAC3;
       }
-      if (audio_object_types_.find(audio_type) == audio_object_types_.end()) {
-        MEDIA_LOG(log_cb_) << "audio object type 0x" << std::hex << audio_type
-                           << " does not match what is specified in the"
-                           << " mimetype.";
-        return false;
-      }
 
       AudioCodec codec = kUnknownAudioCodec;
-      ChannelLayout channel_layout = CHANNEL_LAYOUT_NONE;
+      int num_channels = 0;
       int sample_per_second = 0;
       std::vector<uint8> extra_data;
       // Check if it is MPEG4 AAC defined in ISO 14496 Part 3 or
       // supported MPEG2 AAC varients.
       if (ESDescriptor::IsAAC(audio_type)) {
         codec = kCodecAAC;
-        channel_layout = aac.GetChannelLayout(has_sbr_);
+        num_channels = aac.GetNumChannels(has_sbr_);
         sample_per_second = aac.GetOutputSamplesPerSecond(has_sbr_);
 #if defined(OS_ANDROID)
         extra_data = aac.codec_specific_data();
 #endif
       } else if (audio_type == kEAC3) {
         codec = kCodecEAC3;
-        channel_layout = GuessChannelLayout(entry.channelcount);
+        num_channels = entry.channelcount;
         sample_per_second = entry.samplerate;
       } else {
-        MEDIA_LOG(log_cb_) << "Unsupported audio object type 0x" << std::hex
+        LOG(ERROR) << "Unsupported audio object type 0x"
-                           << audio_type << " in esds.";
+                   << std::hex << audio_type << " in esds.";
-        return false;
-      }
-
-      SampleFormat sample_format;
-      if (entry.samplesize == 8) {
-        sample_format = kSampleFormatU8;
-      } else if (entry.samplesize == 16) {
-        sample_format = kSampleFormatS16;
-      } else if (entry.samplesize == 32) {
-        sample_format = kSampleFormatS32;
-      } else {
-        LOG(ERROR) << "Unsupported sample size.";
         return false;
       }
 
       is_audio_track_encrypted_ = entry.sinf.info.track_encryption.is_encrypted;
       DVLOG(1) << "is_audio_track_encrypted_: " << is_audio_track_encrypted_;
-      audio_config.Initialize(
+      streams.push_back(
-          codec, sample_format, channel_layout, sample_per_second,
+          new AudioStreamInfo(track->header.track_id,
-          extra_data.size() ? &extra_data[0] : NULL, extra_data.size(),
+                              track->media.header.timescale,
-          is_audio_track_encrypted_, false);
+                              codec,
+                              entry.samplesize / 8,
+                              num_channels,
+                              sample_per_second,
+                              extra_data.size() ? &extra_data[0] : NULL,
+                              extra_data.size(),
+                              is_audio_track_encrypted_));
       has_audio_ = true;
       audio_track_id_ = track->header.track_id;
     }
-    if (track->media.handler.type == kVideo && !video_config.IsValidConfig()) {
+
+    if (track->media.handler.type == kVideo) {
+      // TODO(kqyang): do we need to support multiple audio or video streams in
+      // a single file?
+      RCHECK(!has_video_);
+
       RCHECK(!samp_descr.video_entries.empty());
       if (desc_idx >= samp_descr.video_entries.size())
         desc_idx = 0;
@@ -270,31 +250,28 @@ bool MP4StreamParser::ParseMoov(BoxReader* reader) {
       if (!(entry.format == FOURCC_AVC1 ||
             (entry.format == FOURCC_ENCV &&
              entry.sinf.format.format == FOURCC_AVC1))) {
-        MEDIA_LOG(log_cb_) << "Unsupported video format 0x"
+        LOG(ERROR) << "Unsupported video format 0x"
                    << std::hex << entry.format << " in stsd box.";
         return false;
       }
 
-      // TODO(strobe): Recover correct crop box
-      gfx::Size coded_size(entry.width, entry.height);
-      gfx::Rect visible_rect(coded_size);
-      gfx::Size natural_size = GetNaturalSize(visible_rect.size(),
-                                              entry.pixel_aspect.h_spacing,
-                                              entry.pixel_aspect.v_spacing);
       is_video_track_encrypted_ = entry.sinf.info.track_encryption.is_encrypted;
       DVLOG(1) << "is_video_track_encrypted_: " << is_video_track_encrypted_;
-      video_config.Initialize(kCodecH264, H264PROFILE_MAIN,  VideoFrame::YV12,
+      streams.push_back(
-                              coded_size, visible_rect, natural_size,
+          new VideoStreamInfo(track->header.track_id,
-                              // No decoder-specific buffer needed for AVC;
+                              track->media.header.timescale,
-                              // SPS/PPS are embedded in the video stream
+                              kCodecH264,
-                              NULL, 0, is_video_track_encrypted_, true);
+                              entry.width,
+                              entry.height,
+                              // No decoder-specific buffer needed for AVC.
+                              NULL, 0,
+                              is_video_track_encrypted_));
       has_video_ = true;
       video_track_id_ = track->header.track_id;
     }
   }
 
-  RCHECK(config_cb_.Run(audio_config, video_config));
+  // TODO(kqyang): figure out how to get duration for every tracks/streams.
-
   base::TimeDelta duration;
   if (moov_->extends.header.fragment_duration > 0) {
     duration = TimeDeltaFromRational(moov_->extends.header.fragment_duration,
@@ -307,27 +284,25 @@ bool MP4StreamParser::ParseMoov(BoxReader* reader) {
     duration = kInfiniteDuration();
   }
 
-  if (!init_cb_.is_null())
+  init_cb_.Run(true, streams);
-    base::ResetAndReturn(&init_cb_).Run(true, duration);
 
   EmitNeedKeyIfNecessary(moov_->pssh);
   return true;
 }
 
-bool MP4StreamParser::ParseMoof(BoxReader* reader) {
+bool MP4MediaParser::ParseMoof(BoxReader* reader) {
   RCHECK(moov_.get());  // Must already have initialization segment
   MovieFragment moof;
   RCHECK(moof.Parse(reader));
   if (!runs_)
-    runs_.reset(new TrackRunIterator(moov_.get(), log_cb_));
+    runs_.reset(new TrackRunIterator(moov_.get()));
   RCHECK(runs_->Init(moof));
   EmitNeedKeyIfNecessary(moof.pssh);
-  new_segment_cb_.Run();
   ChangeState(kEmittingSamples);
   return true;
 }
 
-void MP4StreamParser::EmitNeedKeyIfNecessary(
+void MP4MediaParser::EmitNeedKeyIfNecessary(
     const std::vector<ProtectionSystemSpecificHeader>& headers) {
   // TODO(strobe): ensure that the value of init_data (all PSSH headers
   // concatenated in arbitrary order) matches the EME spec.
@@ -346,78 +321,17 @@ void MP4StreamParser::EmitNeedKeyIfNecessary(
            headers[i].raw_box.size());
     pos += headers[i].raw_box.size();
   }
-  need_key_cb_.Run(kMp4InitDataType, init_data.Pass(), total_size);
+  need_key_cb_.Run(CONTAINER_MOV, init_data.Pass(), total_size);
 }
 
-bool MP4StreamParser::PrepareAVCBuffer(
+bool MP4MediaParser::EnqueueSample(bool* err) {
-    const AVCDecoderConfigurationRecord& avc_config,
-    std::vector<uint8>* frame_buf,
-    std::vector<SubsampleEntry>* subsamples) const {
-  // Convert the AVC NALU length fields to Annex B headers, as expected by
-  // decoding libraries. Since this may enlarge the size of the buffer, we also
-  // update the clear byte count for each subsample if encryption is used to
-  // account for the difference in size between the length prefix and Annex B
-  // start code.
-  RCHECK(AVC::ConvertFrameToAnnexB(avc_config.length_size, frame_buf));
-  if (!subsamples->empty()) {
-    const int nalu_size_diff = 4 - avc_config.length_size;
-    size_t expected_size = runs_->sample_size() +
-        subsamples->size() * nalu_size_diff;
-    RCHECK(frame_buf->size() == expected_size);
-    for (size_t i = 0; i < subsamples->size(); i++)
-      (*subsamples)[i].clear_bytes += nalu_size_diff;
-  }
-
-  if (runs_->is_keyframe()) {
-    // If this is a keyframe, we (re-)inject SPS and PPS headers at the start of
-    // a frame. If subsample info is present, we also update the clear byte
-    // count for that first subsample.
-    std::vector<uint8> param_sets;
-    RCHECK(AVC::ConvertConfigToAnnexB(avc_config, &param_sets));
-    frame_buf->insert(frame_buf->begin(),
-                      param_sets.begin(), param_sets.end());
-    if (!subsamples->empty())
-      (*subsamples)[0].clear_bytes += param_sets.size();
-  }
-  return true;
-}
-
-bool MP4StreamParser::PrepareAACBuffer(
-    const AAC& aac_config, std::vector<uint8>* frame_buf,
-    std::vector<SubsampleEntry>* subsamples) const {
-  // Append an ADTS header to every audio sample.
-  RCHECK(aac_config.ConvertEsdsToADTS(frame_buf));
-
-  // As above, adjust subsample information to account for the headers. AAC is
-  // not required to use subsample encryption, so we may need to add an entry.
-  if (subsamples->empty()) {
-    SubsampleEntry entry;
-    entry.clear_bytes = AAC::kADTSHeaderSize;
-    entry.cypher_bytes = frame_buf->size() - AAC::kADTSHeaderSize;
-    subsamples->push_back(entry);
-  } else {
-    (*subsamples)[0].clear_bytes += AAC::kADTSHeaderSize;
-  }
-  return true;
-}
-
-bool MP4StreamParser::EnqueueSample(BufferQueue* audio_buffers,
-                                    BufferQueue* video_buffers,
-                                    bool* err) {
   if (!runs_->IsRunValid()) {
-    // Flush any buffers we've gotten in this chunk so that buffers don't
-    // cross NewSegment() calls
-    *err = !SendAndFlushSamples(audio_buffers, video_buffers);
-    if (*err)
-      return false;
-
     // Remain in kEnqueueingSamples state, discarding data, until the end of
     // the current 'mdat' box has been appended to the queue.
     if (!queue_.Trim(mdat_tail_))
       return false;
 
     ChangeState(kParsingBoxes);
-    end_of_segment_cb_.Run();
     return true;
   }
 
@@ -468,26 +382,6 @@ bool MP4StreamParser::EnqueueSample(BufferQueue* audio_buffers,
     subsamples = decrypt_config->subsamples();
   }
 
-  std::vector<uint8> frame_buf(buf, buf + runs_->sample_size());
-  if (video) {
-    if (!PrepareAVCBuffer(runs_->video_description().avcc,
-                          &frame_buf, &subsamples)) {
-      MEDIA_LOG(log_cb_) << "Failed to prepare AVC sample for decode";
-      *err = true;
-      return false;
-    }
-  }
-
-  if (audio) {
-    if (ESDescriptor::IsAAC(runs_->audio_description().esds.object_type) &&
-        !PrepareAACBuffer(runs_->audio_description().esds.aac,
-                          &frame_buf, &subsamples)) {
-      MEDIA_LOG(log_cb_) << "Failed to prepare AAC sample for decode";
-      *err = true;
-      return false;
-    }
-  }
-
   if (decrypt_config) {
     if (!subsamples.empty()) {
     // Create a new config with the updated subsamples.
@@ -498,54 +392,33 @@ bool MP4StreamParser::EnqueueSample(BufferQueue* audio_buffers,
         subsamples));
     }
     // else, use the existing config.
-  } else if ((audio && is_audio_track_encrypted_) ||
-             (video && is_video_track_encrypted_)) {
-    // The media pipeline requires a DecryptConfig with an empty |iv|.
-    // TODO(ddorwin): Refactor so we do not need a fake key ID ("1");
-    decrypt_config.reset(
-        new DecryptConfig("1", "", 0, std::vector<SubsampleEntry>()));
   }
 
-  scoped_refptr<StreamParserBuffer> stream_buf =
+  std::vector<uint8> frame_buf(buf, buf + runs_->sample_size());
-    StreamParserBuffer::CopyFrom(&frame_buf[0], frame_buf.size(),
+  scoped_refptr<MediaSample> stream_sample = MediaSample::CopyFrom(
-                                 runs_->is_keyframe());
+      &frame_buf[0], frame_buf.size(), runs_->is_keyframe());
 
   if (decrypt_config)
-    stream_buf->set_decrypt_config(decrypt_config.Pass());
+    stream_sample->set_decrypt_config(decrypt_config.Pass());
 
-  stream_buf->set_duration(runs_->duration());
+  stream_sample->set_dts(runs_->dts());
-  stream_buf->set_timestamp(runs_->cts());
+  stream_sample->set_pts(runs_->cts());
-  stream_buf->SetDecodeTimestamp(runs_->dts());
+  stream_sample->set_duration(runs_->duration());
 
   DVLOG(3) << "Pushing frame: aud=" << audio
            << ", key=" << runs_->is_keyframe()
-           << ", dur=" << runs_->duration().InMilliseconds()
+           << ", dur=" << runs_->duration()
-           << ", dts=" << runs_->dts().InMilliseconds()
+           << ", dts=" << runs_->dts()
-           << ", cts=" << runs_->cts().InMilliseconds()
+           << ", cts=" << runs_->cts()
            << ", size=" << runs_->sample_size();
 
-  if (audio) {
+  new_sample_cb_.Run(runs_->track_id(), stream_sample);
-    audio_buffers->push_back(stream_buf);
-  } else {
-    video_buffers->push_back(stream_buf);
-  }
 
   runs_->AdvanceSample();
   return true;
 }
 
-bool MP4StreamParser::SendAndFlushSamples(BufferQueue* audio_buffers,
+bool MP4MediaParser::ReadAndDiscardMDATsUntil(const int64 offset) {
-                                          BufferQueue* video_buffers) {
-  if (audio_buffers->empty() && video_buffers->empty())
-    return true;
-
-  bool success = new_buffers_cb_.Run(*audio_buffers, *video_buffers);
-  audio_buffers->clear();
-  video_buffers->clear();
-  return success;
-}
-
-bool MP4StreamParser::ReadAndDiscardMDATsUntil(const int64 offset) {
   bool err = false;
   while (mdat_tail_ < offset) {
     const uint8* buf;
@@ -554,12 +427,11 @@ bool MP4StreamParser::ReadAndDiscardMDATsUntil(const int64 offset) {
 
     FourCC type;
     int box_sz;
-    if (!BoxReader::StartTopLevelBox(buf, size, log_cb_,
+    if (!BoxReader::StartTopLevelBox(buf, size, &type, &box_sz, &err))
-                                     &type, &box_sz, &err))
       break;
 
     if (type != FOURCC_MDAT) {
-      MEDIA_LOG(log_cb_) << "Unexpected box type while parsing MDATs: "
+      LOG(ERROR) << "Unexpected box type while parsing MDATs: "
                  << FourCCToString(type);
     }
     mdat_tail_ += box_sz;
@@ -568,7 +440,7 @@ bool MP4StreamParser::ReadAndDiscardMDATsUntil(const int64 offset) {
   return !err;
 }
 
-void MP4StreamParser::ChangeState(State new_state) {
+void MP4MediaParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }

media/mp4/mp4_media_parser.h

@@ -1,42 +1,40 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2013 Google Inc. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef MEDIA_MP4_MP4_STREAM_PARSER_H_
+#ifndef MEDIA_MP4_MP4_MEDIA_PARSER_H_
-#define MEDIA_MP4_MP4_STREAM_PARSER_H_
+#define MEDIA_MP4_MP4_MEDIA_PARSER_H_
 
-#include <set>
 #include <vector>
 
 #include "base/basictypes.h"
-#include "base/callback.h"
+#include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
-#include "media/base/media_export.h"
+#include "media/base/media_parser.h"
-#include "media/base/stream_parser.h"
 #include "media/mp4/offset_byte_queue.h"
-#include "media/mp4/track_run_iterator.h"
 
 namespace media {
+
+class SubsampleEntry;
+
 namespace mp4 {
 
 struct Movie;
+class AAC;
+class AVCDecoderConfigurationRecord;
 class BoxReader;
+class ProtectionSystemSpecificHeader;
+class TrackRunIterator;
 
-class MEDIA_EXPORT MP4StreamParser : public StreamParser {
+class MP4MediaParser : public MediaParser {
  public:
-  MP4StreamParser(const std::set<int>& audio_object_types, bool has_sbr);
+  MP4MediaParser();
-  virtual ~MP4StreamParser();
+  virtual ~MP4MediaParser();
 
-  virtual void Init(const InitCB& init_cb, const NewConfigCB& config_cb,
+  virtual void Init(const InitCB& init_cb,
-                    const NewBuffersCB& new_buffers_cb,
+                    const NewSampleCB& new_sample_cb,
-                    const NewTextBuffersCB& text_cb,
+                    const NeedKeyCB& need_key_cb) OVERRIDE;
-                    const NeedKeyCB& need_key_cb,
-                    const AddTextTrackCB& add_text_track_cb,
-                    const NewMediaSegmentCB& new_segment_cb,
-                    const base::Closure& end_of_segment_cb,
-                    const LogCB& log_cb) OVERRIDE;
-  virtual void Flush() OVERRIDE;
   virtual bool Parse(const uint8* buf, int size) OVERRIDE;
 
  private:
@@ -65,28 +63,15 @@ class MEDIA_EXPORT MP4StreamParser : public StreamParser {
   void ChangeState(State new_state);
 
   bool EmitConfigs();
-  bool PrepareAVCBuffer(const AVCDecoderConfigurationRecord& avc_config,
+
-                        std::vector<uint8>* frame_buf,
+  bool EnqueueSample(bool* err);
-                        std::vector<SubsampleEntry>* subsamples) const;
-  bool PrepareAACBuffer(const AAC& aac_config,
-                        std::vector<uint8>* frame_buf,
-                        std::vector<SubsampleEntry>* subsamples) const;
-  bool EnqueueSample(BufferQueue* audio_buffers,
-                     BufferQueue* video_buffers,
-                     bool* err);
-  bool SendAndFlushSamples(BufferQueue* audio_buffers,
-                           BufferQueue* video_buffers);
 
   void Reset();
 
   State state_;
   InitCB init_cb_;
-  NewConfigCB config_cb_;
+  NewSampleCB new_sample_cb_;
-  NewBuffersCB new_buffers_cb_;
   NeedKeyCB need_key_cb_;
-  NewMediaSegmentCB new_segment_cb_;
-  base::Closure end_of_segment_cb_;
-  LogCB log_cb_;
 
   OffsetByteQueue queue_;
 
@@ -100,23 +85,21 @@ class MEDIA_EXPORT MP4StreamParser : public StreamParser {
   // Valid iff it is greater than the head of the queue.
   int64 mdat_tail_;
 
-  scoped_ptr<mp4::Movie> moov_;
+  scoped_ptr<Movie> moov_;
-  scoped_ptr<mp4::TrackRunIterator> runs_;
+  scoped_ptr<TrackRunIterator> runs_;
 
   bool has_audio_;
   bool has_video_;
   uint32 audio_track_id_;
   uint32 video_track_id_;
-  // The object types allowed for audio tracks.
-  std::set<int> audio_object_types_;
   bool has_sbr_;
   bool is_audio_track_encrypted_;
   bool is_video_track_encrypted_;
 
-  DISALLOW_COPY_AND_ASSIGN(MP4StreamParser);
+  DISALLOW_COPY_AND_ASSIGN(MP4MediaParser);
 };
 
 }  // namespace mp4
 }  // namespace media
 
-#endif  // MEDIA_MP4_MP4_STREAM_PARSER_H_
+#endif  // MEDIA_MP4_MP4_MEDIA_PARSER_H_

media/mp4/mp4_media_parser_unittest.cc

@@ -0,0 +1,128 @@
+// Copyright (c) 2013 Google Inc. 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/mp4/mp4_media_parser.h"
+
+#include <algorithm>
+#include <string>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/time/time.h"
+#include "media/base/media_sample.h"
+#include "media/base/stream_info.h"
+#include "media/base/test_data_util.h"
+#include "media/mp4/es_descriptor.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+namespace mp4 {
+
+class MP4MediaParserTest : public testing::Test {
+ public:
+  MP4MediaParserTest() : configs_received_(false) {
+    parser_.reset(new MP4MediaParser());
+  }
+
+ protected:
+  scoped_ptr<MP4MediaParser> parser_;
+  bool configs_received_;
+
+  bool AppendData(const uint8* data, size_t length) {
+    return parser_->Parse(data, length);
+  }
+
+  bool AppendDataInPieces(const uint8* data, size_t length, size_t piece_size) {
+    const uint8* start = data;
+    const uint8* end = data + length;
+    while (start < end) {
+      size_t append_size = std::min(piece_size,
+                                    static_cast<size_t>(end - start));
+      if (!AppendData(start, append_size))
+        return false;
+      start += append_size;
+    }
+    return true;
+  }
+
+  void InitF(bool init_ok, std::vector<scoped_refptr<StreamInfo> >& streams) {
+    DVLOG(1) << "InitF: ok=" << init_ok;
+    if (init_ok && streams.size() > 0)
+      configs_received_ = true;
+  }
+
+  bool NewSampleF(uint32 track_id, const scoped_refptr<MediaSample>& sample) {
+    DVLOG(2) << "Track Id: " << track_id << " "
+             << sample->ToString();
+    return true;
+  }
+
+  void KeyNeededF(MediaContainerName container,
+                  scoped_ptr<uint8[]> init_data,
+                  int init_data_size) {
+    DVLOG(1) << "KeyNeededF: " << init_data_size;
+    EXPECT_TRUE(init_data.get());
+    EXPECT_GT(init_data_size, 0);
+  }
+
+  void InitializeParser() {
+    parser_->Init(
+        base::Bind(&MP4MediaParserTest::InitF, base::Unretained(this)),
+        base::Bind(&MP4MediaParserTest::NewSampleF, base::Unretained(this)),
+        base::Bind(&MP4MediaParserTest::KeyNeededF, base::Unretained(this)));
+  }
+
+  bool ParseMP4File(const std::string& filename, int append_bytes) {
+    InitializeParser();
+
+    std::vector<uint8> buffer = ReadTestDataFile(filename);
+    EXPECT_TRUE(AppendDataInPieces(buffer.data(),
+                                   buffer.size(),
+                                   append_bytes));
+    return true;
+  }
+};
+
+TEST_F(MP4MediaParserTest, UnalignedAppend) {
+  // Test small, non-segment-aligned appends (small enough to exercise
+  // incremental append system)
+  ParseMP4File("bear-1280x720-av_frag.mp4", 512);
+}
+
+TEST_F(MP4MediaParserTest, BytewiseAppend) {
+  // Ensure no incremental errors occur when parsing
+  ParseMP4File("bear-1280x720-av_frag.mp4", 1);
+}
+
+TEST_F(MP4MediaParserTest, MultiFragmentAppend) {
+  // Large size ensures multiple fragments are appended in one call (size is
+  // larger than this particular test file)
+  ParseMP4File("bear-1280x720-av_frag.mp4", 768432);
+}
+
+TEST_F(MP4MediaParserTest, Reinitialization) {
+  InitializeParser();
+
+  std::vector<uint8> buffer =
+      ReadTestDataFile("bear-1280x720-av_frag.mp4");
+  EXPECT_TRUE(AppendDataInPieces(buffer.data(),
+                                 buffer.size(),
+                                 512));
+  EXPECT_TRUE(AppendDataInPieces(buffer.data(),
+                                 buffer.size(),
+                                 512));
+}
+
+TEST_F(MP4MediaParserTest, MPEG2_AAC_LC) {
+  parser_.reset(new MP4MediaParser());
+  ParseMP4File("bear-mpeg2-aac-only_frag.mp4", 512);
+}
+
+// TODO(strobe): Create and test media which uses CENC auxiliary info stored
+// inside a private box
+
+}  // namespace mp4
+}  // namespace media

media/mp4/mp4_stream_parser_unittest.cc

@@ -1,216 +0,0 @@
-// Copyright (c) 2012 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 <algorithm>
-#include <string>
-
-#include "base/bind.h"
-#include "base/bind_helpers.h"
-#include "base/logging.h"
-#include "base/memory/ref_counted.h"
-#include "base/time/time.h"
-#include "media/base/audio_decoder_config.h"
-#include "media/base/decoder_buffer.h"
-#include "media/base/stream_parser_buffer.h"
-#include "media/base/test_data_util.h"
-#include "media/base/video_decoder_config.h"
-#include "media/mp4/es_descriptor.h"
-#include "media/mp4/mp4_stream_parser.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-using base::TimeDelta;
-
-namespace media {
-namespace mp4 {
-
-// TODO(xhwang): Figure out the init data type appropriately once it's spec'ed.
-static const char kMp4InitDataType[] = "video/mp4";
-
-class MP4StreamParserTest : public testing::Test {
- public:
-  MP4StreamParserTest()
-      : configs_received_(false) {
-    std::set<int> audio_object_types;
-    audio_object_types.insert(kISO_14496_3);
-    parser_.reset(new MP4StreamParser(audio_object_types, false));
-  }
-
- protected:
-  scoped_ptr<MP4StreamParser> parser_;
-  bool configs_received_;
-
-  bool AppendData(const uint8* data, size_t length) {
-    return parser_->Parse(data, length);
-  }
-
-  bool AppendDataInPieces(const uint8* data, size_t length, size_t piece_size) {
-    const uint8* start = data;
-    const uint8* end = data + length;
-    while (start < end) {
-      size_t append_size = std::min(piece_size,
-                                    static_cast<size_t>(end - start));
-      if (!AppendData(start, append_size))
-        return false;
-      start += append_size;
-    }
-    return true;
-  }
-
-  void InitF(bool init_ok, base::TimeDelta duration) {
-    DVLOG(1) << "InitF: ok=" << init_ok
-             << ", dur=" << duration.InMilliseconds();
-  }
-
-  bool NewConfigF(const AudioDecoderConfig& ac, const VideoDecoderConfig& vc) {
-    DVLOG(1) << "NewConfigF: audio=" << ac.IsValidConfig()
-             << ", video=" << vc.IsValidConfig();
-    configs_received_ = true;
-    return true;
-  }
-
-
-  void DumpBuffers(const std::string& label,
-                   const StreamParser::BufferQueue& buffers) {
-    DVLOG(2) << "DumpBuffers: " << label << " size " << buffers.size();
-    for (StreamParser::BufferQueue::const_iterator buf = buffers.begin();
-         buf != buffers.end(); buf++) {
-      DVLOG(3) << "  n=" << buf - buffers.begin()
-               << ", size=" << (*buf)->data_size()
-               << ", dur=" << (*buf)->duration().InMilliseconds();
-    }
-  }
-
-  bool NewBuffersF(const StreamParser::BufferQueue& audio_buffers,
-                   const StreamParser::BufferQueue& video_buffers) {
-    DumpBuffers("audio_buffers", audio_buffers);
-    DumpBuffers("video_buffers", video_buffers);
-    return true;
-  }
-
-  bool NewTextBuffersF(TextTrack* text_track,
-                       const StreamParser::BufferQueue& buffers) {
-    return true;
-  }
-
-  void KeyNeededF(const std::string& type,
-                  scoped_ptr<uint8[]> init_data, int init_data_size) {
-    DVLOG(1) << "KeyNeededF: " << init_data_size;
-    EXPECT_EQ(kMp4InitDataType, type);
-    EXPECT_TRUE(init_data.get());
-    EXPECT_GT(init_data_size, 0);
-  }
-
-  scoped_ptr<TextTrack> AddTextTrackF(
-      TextKind kind,
-      const std::string& label,
-      const std::string& language) {
-    return scoped_ptr<TextTrack>();
-  }
-
-  void NewSegmentF() {
-    DVLOG(1) << "NewSegmentF";
-  }
-
-  void EndOfSegmentF() {
-    DVLOG(1) << "EndOfSegmentF()";
-  }
-
-  void InitializeParser() {
-    parser_->Init(
-        base::Bind(&MP4StreamParserTest::InitF, base::Unretained(this)),
-        base::Bind(&MP4StreamParserTest::NewConfigF, base::Unretained(this)),
-        base::Bind(&MP4StreamParserTest::NewBuffersF, base::Unretained(this)),
-        base::Bind(&MP4StreamParserTest::NewTextBuffersF,
-                   base::Unretained(this)),
-        base::Bind(&MP4StreamParserTest::KeyNeededF, base::Unretained(this)),
-        base::Bind(&MP4StreamParserTest::AddTextTrackF, base::Unretained(this)),
-        base::Bind(&MP4StreamParserTest::NewSegmentF, base::Unretained(this)),
-        base::Bind(&MP4StreamParserTest::EndOfSegmentF,
-                   base::Unretained(this)),
-        LogCB());
-  }
-
-  bool ParseMP4File(const std::string& filename, int append_bytes) {
-    InitializeParser();
-
-    scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile(filename);
-    EXPECT_TRUE(AppendDataInPieces(buffer->data(),
-                                   buffer->data_size(),
-                                   append_bytes));
-    return true;
-  }
-};
-
-TEST_F(MP4StreamParserTest, UnalignedAppend) {
-  // Test small, non-segment-aligned appends (small enough to exercise
-  // incremental append system)
-  ParseMP4File("bear-1280x720-av_frag.mp4", 512);
-}
-
-TEST_F(MP4StreamParserTest, BytewiseAppend) {
-  // Ensure no incremental errors occur when parsing
-  ParseMP4File("bear-1280x720-av_frag.mp4", 1);
-}
-
-TEST_F(MP4StreamParserTest, MultiFragmentAppend) {
-  // Large size ensures multiple fragments are appended in one call (size is
-  // larger than this particular test file)
-  ParseMP4File("bear-1280x720-av_frag.mp4", 768432);
-}
-
-TEST_F(MP4StreamParserTest, Flush) {
-  // Flush while reading sample data, then start a new stream.
-  InitializeParser();
-
-  scoped_refptr<DecoderBuffer> buffer =
-      ReadTestDataFile("bear-1280x720-av_frag.mp4");
-  EXPECT_TRUE(AppendDataInPieces(buffer->data(), 65536, 512));
-  parser_->Flush();
-  EXPECT_TRUE(AppendDataInPieces(buffer->data(),
-                                 buffer->data_size(),
-                                 512));
-}
-
-TEST_F(MP4StreamParserTest, Reinitialization) {
-  InitializeParser();
-
-  scoped_refptr<DecoderBuffer> buffer =
-      ReadTestDataFile("bear-1280x720-av_frag.mp4");
-  EXPECT_TRUE(AppendDataInPieces(buffer->data(),
-                                 buffer->data_size(),
-                                 512));
-  EXPECT_TRUE(AppendDataInPieces(buffer->data(),
-                                 buffer->data_size(),
-                                 512));
-}
-
-TEST_F(MP4StreamParserTest, MPEG2_AAC_LC) {
-  std::set<int> audio_object_types;
-  audio_object_types.insert(kISO_13818_7_AAC_LC);
-  parser_.reset(new MP4StreamParser(audio_object_types, false));
-  ParseMP4File("bear-mpeg2-aac-only_frag.mp4", 512);
-}
-
-// Test that a moov box is not always required after Flush() is called.
-TEST_F(MP4StreamParserTest, NoMoovAfterFlush) {
-  InitializeParser();
-
-  scoped_refptr<DecoderBuffer> buffer =
-      ReadTestDataFile("bear-1280x720-av_frag.mp4");
-  EXPECT_TRUE(AppendDataInPieces(buffer->data(),
-                                 buffer->data_size(),
-                                 512));
-  parser_->Flush();
-
-  const int kFirstMoofOffset = 1307;
-  EXPECT_TRUE(AppendDataInPieces(buffer->data() + kFirstMoofOffset,
-                                 buffer->data_size() - kFirstMoofOffset,
-                                 512));
-}
-
-// TODO(strobe): Create and test media which uses CENC auxiliary info stored
-// inside a private box
-
-}  // namespace mp4
-}  // namespace media

media/mp4/offset_byte_queue.h

@@ -7,7 +7,6 @@
 
 #include "base/basictypes.h"
 #include "media/base/byte_queue.h"
-#include "media/base/media_export.h"
 
 namespace media {
 
@@ -15,7 +14,7 @@ namespace media {
 // monotonically-increasing offset. All buffer access is done by passing these
 // offsets into this class, going some way towards preventing the proliferation
 // of many different meanings of "offset", "head", etc.
-class MEDIA_EXPORT OffsetByteQueue {
+class OffsetByteQueue {
  public:
   OffsetByteQueue();
   ~OffsetByteQueue();
@@ -63,4 +62,4 @@ class MEDIA_EXPORT OffsetByteQueue {
 
 }  // namespace media
 
-#endif  // MEDIA_MP4_MP4_STREAM_PARSER_H_
+#endif  // MEDIA_MP4_OFFSET_BYTE_QUEUE_H_

media/mp4/track_run_iterator.cc

@@ -6,8 +6,6 @@
 
 #include <algorithm>
 
-#include "media/base/buffers.h"
-#include "media/base/stream_parser_buffer.h"
 #include "media/mp4/rcheck.h"
 
 namespace {
@@ -56,16 +54,8 @@ TrackRunInfo::TrackRunInfo()
 }
 TrackRunInfo::~TrackRunInfo() {}
 
-TimeDelta TimeDeltaFromRational(int64 numer, int64 denom) {
+TrackRunIterator::TrackRunIterator(const Movie* moov)
-  DCHECK_LT((numer > 0 ? numer : -numer),
+    : moov_(moov), sample_offset_(0) {
-            kint64max / base::Time::kMicrosecondsPerSecond);
-  return TimeDelta::FromMicroseconds(
-        base::Time::kMicrosecondsPerSecond * numer / denom);
-}
-
-TrackRunIterator::TrackRunIterator(const Movie* moov,
-                                   const LogCB& log_cb)
-    : moov_(moov), log_cb_(log_cb), sample_offset_(0) {
   CHECK(moov);
 }
 
@@ -388,20 +378,19 @@ int TrackRunIterator::sample_size() const {
   return sample_itr_->size;
 }
 
-TimeDelta TrackRunIterator::dts() const {
+int64 TrackRunIterator::dts() const {
   DCHECK(IsSampleValid());
-  return TimeDeltaFromRational(sample_dts_, run_itr_->timescale);
+  return sample_dts_;
 }
 
-TimeDelta TrackRunIterator::cts() const {
+int64 TrackRunIterator::cts() const {
   DCHECK(IsSampleValid());
-  return TimeDeltaFromRational(sample_dts_ + sample_itr_->cts_offset,
+  return sample_dts_ + sample_itr_->cts_offset;
-                               run_itr_->timescale);
 }
 
-TimeDelta TrackRunIterator::duration() const {
+int64 TrackRunIterator::duration() const {
   DCHECK(IsSampleValid());
-  return TimeDeltaFromRational(sample_itr_->duration, run_itr_->timescale);
+  return sample_itr_->duration;
 }
 
 bool TrackRunIterator::is_keyframe() const {
@@ -424,7 +413,7 @@ scoped_ptr<DecryptConfig> TrackRunIterator::GetDecryptConfig() {
   if (!cenc_info.subsamples.empty() &&
       (cenc_info.GetTotalSizeOfSubsamples() !=
        static_cast<size_t>(sample_size()))) {
-    MEDIA_LOG(log_cb_) << "Incorrect CENC subsample size.";
+    LOG(ERROR) << "Incorrect CENC subsample size.";
     return scoped_ptr<DecryptConfig>();
   }
 

media/mp4/track_run_iterator.h

@@ -8,9 +8,6 @@
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
-#include "base/time/time.h"
-#include "media/base/media_export.h"
-#include "media/base/media_log.h"
 #include "media/mp4/box_definitions.h"
 #include "media/mp4/cenc.h"
 
@@ -20,17 +17,14 @@ class DecryptConfig;
 
 namespace mp4 {
 
-using base::TimeDelta;
-base::TimeDelta MEDIA_EXPORT TimeDeltaFromRational(int64 numer, int64 denom);
-
 struct SampleInfo;
 struct TrackRunInfo;
 
-class MEDIA_EXPORT TrackRunIterator {
+class TrackRunIterator {
  public:
   // Create a new TrackRunIterator. A reference to |moov| will be retained for
   // the lifetime of this object.
-  TrackRunIterator(const Movie* moov, const LogCB& log_cb);
+  explicit TrackRunIterator(const Movie* moov);
   ~TrackRunIterator();
 
   // Sets up the iterator to handle all the runs from the current fragment.
@@ -74,9 +68,9 @@ class MEDIA_EXPORT TrackRunIterator {
   // Properties of the current sample. Only valid if IsSampleValid().
   int64 sample_offset() const;
   int sample_size() const;
-  TimeDelta dts() const;
+  int64 dts() const;
-  TimeDelta cts() const;
+  int64 cts() const;
-  TimeDelta duration() const;
+  int64 duration() const;
   bool is_keyframe() const;
 
   // Only call when is_encrypted() is true and AuxInfoNeedsToBeCached() is
@@ -88,7 +82,6 @@ class MEDIA_EXPORT TrackRunIterator {
   const TrackEncryption& track_encryption() const;
 
   const Movie* moov_;
-  LogCB log_cb_;
 
   std::vector<TrackRunInfo> runs_;
   std::vector<TrackRunInfo>::const_iterator run_itr_;

media/mp4/track_run_iterator_unittest.cc

@@ -48,7 +48,6 @@ class TrackRunIteratorTest : public testing::Test {
 
  protected:
   Movie moov_;
-  LogCB log_cb_;
   scoped_ptr<TrackRunIterator> iter_;
 
   void CreateMovie() {
@@ -154,14 +153,14 @@ class TrackRunIteratorTest : public testing::Test {
 };
 
 TEST_F(TrackRunIteratorTest, NoRunsTest) {
-  iter_.reset(new TrackRunIterator(&moov_, log_cb_));
+  iter_.reset(new TrackRunIterator(&moov_));
   ASSERT_TRUE(iter_->Init(MovieFragment()));
   EXPECT_FALSE(iter_->IsRunValid());
   EXPECT_FALSE(iter_->IsSampleValid());
 }
 
 TEST_F(TrackRunIteratorTest, BasicOperationTest) {
-  iter_.reset(new TrackRunIterator(&moov_, log_cb_));
+  iter_.reset(new TrackRunIterator(&moov_));
   MovieFragment moof = CreateFragment();
 
   // Test that runs are sorted correctly, and that properties of the initial
@@ -172,9 +171,9 @@ TEST_F(TrackRunIteratorTest, BasicOperationTest) {
   EXPECT_EQ(iter_->track_id(), 1u);
   EXPECT_EQ(iter_->sample_offset(), 100);
   EXPECT_EQ(iter_->sample_size(), 1);
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(0, kAudioScale));
+  EXPECT_EQ(iter_->dts(), 0);
-  EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(0, kAudioScale));
+  EXPECT_EQ(iter_->cts(), 0);
-  EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(1024, kAudioScale));
+  EXPECT_EQ(iter_->duration(), 1024);
   EXPECT_TRUE(iter_->is_keyframe());
 
   // Advance to the last sample in the current run, and test its properties
@@ -182,8 +181,8 @@ TEST_F(TrackRunIteratorTest, BasicOperationTest) {
   EXPECT_EQ(iter_->track_id(), 1u);
   EXPECT_EQ(iter_->sample_offset(), 100 + kSumAscending1);
   EXPECT_EQ(iter_->sample_size(), 10);
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(1024 * 9, kAudioScale));
+  EXPECT_EQ(iter_->dts(), 1024 * 9);
-  EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(1024, kAudioScale));
+  EXPECT_EQ(iter_->duration(), 1024);
   EXPECT_TRUE(iter_->is_keyframe());
 
   // Test end-of-run
@@ -198,14 +197,14 @@ TEST_F(TrackRunIteratorTest, BasicOperationTest) {
   EXPECT_EQ(iter_->sample_offset(), 200 + kSumAscending1);
   EXPECT_EQ(iter_->sample_size(), 10);
   int64 base_dts = kSumAscending1 + moof.tracks[1].decode_time.decode_time;
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(base_dts, kVideoScale));
+  EXPECT_EQ(iter_->dts(), base_dts);
-  EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(10, kVideoScale));
+  EXPECT_EQ(iter_->duration(), 10);
   EXPECT_FALSE(iter_->is_keyframe());
 
   // Test final run
   iter_->AdvanceRun();
   EXPECT_EQ(iter_->track_id(), 1u);
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(1024 * 10, kAudioScale));
+  EXPECT_EQ(iter_->dts(), 1024 * 10);
   iter_->AdvanceSample();
   EXPECT_EQ(moof.tracks[0].runs[1].data_offset +
             moof.tracks[0].header.default_sample_size,
@@ -219,7 +218,7 @@ TEST_F(TrackRunIteratorTest, TrackExtendsDefaultsTest) {
   moov_.extends.tracks[0].default_sample_size = 3;
   moov_.extends.tracks[0].default_sample_flags =
     kSampleIsDifferenceSampleFlagMask;
-  iter_.reset(new TrackRunIterator(&moov_, log_cb_));
+  iter_.reset(new TrackRunIterator(&moov_));
   MovieFragment moof = CreateFragment();
   moof.tracks[0].header.has_default_sample_flags = false;
   moof.tracks[0].header.default_sample_size = 0;
@@ -230,15 +229,15 @@ TEST_F(TrackRunIteratorTest, TrackExtendsDefaultsTest) {
   EXPECT_FALSE(iter_->is_keyframe());
   EXPECT_EQ(iter_->sample_size(), 3);
   EXPECT_EQ(iter_->sample_offset(), moof.tracks[0].runs[0].data_offset + 3);
-  EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(50, kAudioScale));
+  EXPECT_EQ(iter_->duration(), 50);
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(50, kAudioScale));
+  EXPECT_EQ(iter_->dts(), 50);
 }
 
 TEST_F(TrackRunIteratorTest, FirstSampleFlagTest) {
   // Ensure that keyframes are flagged correctly in the face of BMFF boxes which
   // explicitly specify the flags for the first sample in a run and rely on
   // defaults for all subsequent samples
-  iter_.reset(new TrackRunIterator(&moov_, log_cb_));
+  iter_.reset(new TrackRunIterator(&moov_));
   MovieFragment moof = CreateFragment();
   moof.tracks[1].header.has_default_sample_flags = true;
   moof.tracks[1].header.default_sample_flags =
@@ -267,7 +266,7 @@ TEST_F(TrackRunIteratorTest, ReorderingTest) {
   // (that is, 2 / kVideoTimescale) and a duration of zero (which is treated as
   // infinite according to 14496-12:2012). This will cause the first 80ms of the
   // media timeline - which will be empty, due to CTS biasing - to be discarded.
-  iter_.reset(new TrackRunIterator(&moov_, log_cb_));
+  iter_.reset(new TrackRunIterator(&moov_));
   EditListEntry entry;
   entry.segment_duration = 0;
   entry.media_time = 2;
@@ -290,21 +289,21 @@ TEST_F(TrackRunIteratorTest, ReorderingTest) {
 
   ASSERT_TRUE(iter_->Init(moof));
   iter_->AdvanceRun();
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(0, kVideoScale));
+  EXPECT_EQ(iter_->dts(), 0);
-  EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(0, kVideoScale));
+  EXPECT_EQ(iter_->cts(), 0);
-  EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(1, kVideoScale));
+  EXPECT_EQ(iter_->duration(), 1);
   iter_->AdvanceSample();
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(1, kVideoScale));
+  EXPECT_EQ(iter_->dts(), 1);
-  EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(4, kVideoScale));
+  EXPECT_EQ(iter_->cts(), 4);
-  EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(2, kVideoScale));
+  EXPECT_EQ(iter_->duration(), 2);
   iter_->AdvanceSample();
-  EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(3, kVideoScale));
+  EXPECT_EQ(iter_->dts(), 3);
-  EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(1, kVideoScale));
+  EXPECT_EQ(iter_->cts(), 1);
-  EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(3, kVideoScale));
+  EXPECT_EQ(iter_->duration(), 3);
 }
 
 TEST_F(TrackRunIteratorTest, IgnoreUnknownAuxInfoTest) {
-  iter_.reset(new TrackRunIterator(&moov_, log_cb_));
+  iter_.reset(new TrackRunIterator(&moov_));
   MovieFragment moof = CreateFragment();
   moof.tracks[1].auxiliary_offset.offsets.push_back(50);
   moof.tracks[1].auxiliary_size.default_sample_info_size = 2;
@@ -317,7 +316,7 @@ TEST_F(TrackRunIteratorTest, IgnoreUnknownAuxInfoTest) {
 
 TEST_F(TrackRunIteratorTest, DecryptConfigTest) {
   AddEncryption(&moov_.tracks[1]);
-  iter_.reset(new TrackRunIterator(&moov_, log_cb_));
+  iter_.reset(new TrackRunIterator(&moov_));
 
   MovieFragment moof = CreateFragment();
   AddAuxInfoHeaders(50, &moof.tracks[1]);
@@ -357,7 +356,7 @@ TEST_F(TrackRunIteratorTest, DecryptConfigTest) {
 TEST_F(TrackRunIteratorTest, SharedAuxInfoTest) {
   AddEncryption(&moov_.tracks[0]);
   AddEncryption(&moov_.tracks[1]);
-  iter_.reset(new TrackRunIterator(&moov_, log_cb_));
+  iter_.reset(new TrackRunIterator(&moov_));
 
   MovieFragment moof = CreateFragment();
   moof.tracks[0].runs.resize(1);
@@ -399,7 +398,7 @@ TEST_F(TrackRunIteratorTest, SharedAuxInfoTest) {
 TEST_F(TrackRunIteratorTest, UnexpectedOrderingTest) {
   AddEncryption(&moov_.tracks[0]);
   AddEncryption(&moov_.tracks[1]);
-  iter_.reset(new TrackRunIterator(&moov_, log_cb_));
+  iter_.reset(new TrackRunIterator(&moov_));
 
   MovieFragment moof = CreateFragment();
   AddAuxInfoHeaders(20000, &moof.tracks[0]);