Mirror-Tools
/
shaka-packager
mirror of https://github.com/shaka-project/shaka-packager.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Create MP4MediaParser and its dependents. 

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

Change-Id: I19c2fc73964d9f8fc90acaddd1783f4e6ff87d07
This commit is contained in:
Kongqun Yang 2013-09-23 21:17:12 -07:00
parent 0f24c7f9ac
commit 338e3342b0
39 changed files with 1077 additions and 942 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
media/base/audio_stream_info.cc Normal file
View File

@ -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

76
media/base/audio_stream_info.h Normal file
View File

@ -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_

3
media/base/bit_reader.h
View File

@ -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.

6
media/base/buffers.h
View File

@ -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);
}

3
media/base/byte_queue.h
View File

@ -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();

4
media/base/container_names.cc
View File

@ -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

8
media/base/container_names.h
View File

@ -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,
int buffer_size);
} // namespace container_names
MediaContainerName DetermineContainer(const uint8* buffer, int buffer_size);
} // namespace media

4
media/base/container_names_unittest.cc
View File

@ -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

3
media/base/decrypt_config.h
View File

@ -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;

70
media/base/media_parser.h Normal file
View File

@ -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_

74
media/base/media_sample.cc Normal file
View File

@ -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

162
media/base/media_sample.h Normal file
View File

@ -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_

12
media/base/run_tests_with_atexit_manager.cc Normal file
View File

@ -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();
}

37
media/base/stream_info.cc Normal file
View File

@ -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

70
media/base/stream_info.h Normal file
View File

@ -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_

7
media/base/test_data_util.cc
View File

@ -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;

6
media/base/test_data_util.h
View File

@ -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

48
media/base/video_stream_info.cc Normal file
View File

@ -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

63
media/base/video_stream_info.h Normal file
View File

@ -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_

67
media/mp4/aac.cc
View File

@ -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 -
// Table 1.16 - Sampling Frequency Index.
static const int kFrequencyMap[] = {
namespace {
// 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));
frequency_ = kFrequencyMap[frequency_index_];
RCHECK(frequency_index_ < arraysize(kSampleRates));
frequency_ = kSampleRates[frequency_index_];
}
if (extension_frequency_ == 0 && extension_frequency_index != 0xff) {
RCHECK(extension_frequency_index < arraysize(kFrequencyMap));
extension_frequency_ = kFrequencyMap[extension_frequency_index];
RCHECK(extension_frequency_index < arraysize(kSampleRates));
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;
else
channel_layout_ = ConvertChannelConfigToLayout(channel_config_);
num_channels_ = 2; // CHANNEL_LAYOUT_STEREO
else {
RCHECK(channel_config_ < arraysize(kChannelConfigs));
num_channels_ = kChannelConfigs[channel_config_];
}
return frequency_ != 0 && channel_layout_ != CHANNEL_LAYOUT_UNSUPPORTED &&
profile_ >= 1 && profile_ <= 4 && frequency_index_ != 0xf &&
channel_config_ <= 7;
return frequency_ != 0 && num_channels_ != 0 && profile_ >= 1 &&
profile_ <= 4 && frequency_index_ != 0xf && 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 &&

25
media/mp4/aac.h
View File

@ -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
// AudioDecoderConfig.
ChannelLayout GetChannelLayout(bool sbr_in_mimetype) const;
int GetNumChannels(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
// can be used by Chromium. They are based on the AAC specific
// configuration but can be overridden by extensions in elementary
// stream descriptor.
// The following variables store audio configuration information.
// They are based on the AAC specific configuration but can be overridden
// by extensions in elementary stream descriptor.
int frequency_;
int extension_frequency_;
ChannelLayout channel_layout_;
int num_channels_;
};
} // namespace mp4

14
media/mp4/aac_unittest.cc
View File

@ -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) {

91
media/mp4/avc.cc
View File

@ -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

30
media/mp4/avc.h
View File

@ -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_

95
media/mp4/avc_unittest.cc
View File

@ -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

76
media/mp4/box_definitions.h
View File

@ -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;

22
media/mp4/box_reader.cc
View File

@ -79,10 +79,8 @@ bool BufferReader::Read4sInto8s(int64* v) {
}
BoxReader::BoxReader(const uint8* buf, const int size,
const LogCB& log_cb)
BoxReader::BoxReader(const uint8* buf, const int size)
: 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,
const LogCB& log_cb) {
bool BoxReader::IsValidTopLevelBox(const FourCC& type) {
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"
<< std::hex << type;
LOG(ERROR) << "Unrecognized top-level box type 0x" << 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));

18
media/mp4/box_reader.h
View File

@ -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,
const LogCB& log_cb);
static bool IsValidTopLevelBox(const FourCC& type);
// 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));

14
media/mp4/box_reader_unittest.cc
View File

@ -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);

4
media/mp4/es_descriptor.cc
View File

@ -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_;
}

9
media/mp4/es_descriptor.h
View File

@ -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_;
};

318
media/mp4/mp4_stream_parser.cc → media/mp4/mp4_media_parser.cc
View File

@ -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/stream_parser_buffer.h"
#include "media/base/video_decoder_config.h"
#include "media/base/video_util.h"
#include "media/base/audio_stream_info.h"
#include "media/base/buffers.h"
#include "media/base/media_sample.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.
static const char kMp4InitDataType[] = "video/mp4";
MP4StreamParser::MP4StreamParser(const std::set<int>& audio_object_types,
bool has_sbr)
MP4MediaParser::MP4MediaParser()
: 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),
has_sbr_(has_sbr),
// TODO(kqyang): do we need to care about it??
has_sbr_(false),
is_audio_track_encrypted_(false),
is_video_track_encrypted_(false) {
}
MP4StreamParser::~MP4StreamParser() {}
MP4MediaParser::~MP4MediaParser() {}
void MP4StreamParser::Init(const InitCB& init_cb,
const NewConfigCB& config_cb,
const NewBuffersCB& new_buffers_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) {
void MP4MediaParser::Init(const InitCB& init_cb,
const NewSampleCB& new_sample_cb,
const NeedKeyCB& need_key_cb) {
DCHECK_EQ(state_, kWaitingForInit);
DCHECK(init_cb_.is_null());
DCHECK(!init_cb.is_null());
DCHECK(!config_cb.is_null());
DCHECK(!new_buffers_cb.is_null());
DCHECK(!new_sample_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_buffers_cb_ = new_buffers_cb;
new_sample_cb_ = new_sample_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() {
DCHECK_NE(state_, kWaitingForInit);
Reset();
ChangeState(kParsingBoxes);
}
bool MP4StreamParser::Parse(const uint8* buf, int size) {
bool MP4MediaParser::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(
BoxReader::ReadTopLevelBox(buf, size, log_cb_, err));
scoped_ptr<BoxReader> reader(BoxReader::ReadTopLevelBox(buf, size, 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;
VideoDecoderConfig video_config;
std::vector<scoped_refptr<StreamInfo> > streams;
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
<< 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.";
LOG(ERROR) << "Unsupported audio object type 0x"
<< std::hex << audio_type << " in esds.";
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(
codec, sample_format, channel_layout, sample_per_second,
extra_data.size() ? &extra_data[0] : NULL, extra_data.size(),
is_audio_track_encrypted_, false);
streams.push_back(
new AudioStreamInfo(track->header.track_id,
track->media.header.timescale,
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,
coded_size, visible_rect, natural_size,
// No decoder-specific buffer needed for AVC;
// SPS/PPS are embedded in the video stream
NULL, 0, is_video_track_encrypted_, true);
streams.push_back(
new VideoStreamInfo(track->header.track_id,
track->media.header.timescale,
kCodecH264,
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())
base::ResetAndReturn(&init_cb_).Run(true, duration);
init_cb_.Run(true, streams);
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(
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) {
bool MP4MediaParser::EnqueueSample(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 =
StreamParserBuffer::CopyFrom(&frame_buf[0], frame_buf.size(),
runs_->is_keyframe());
std::vector<uint8> frame_buf(buf, buf + runs_->sample_size());
scoped_refptr<MediaSample> stream_sample = MediaSample::CopyFrom(
&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_buf->set_timestamp(runs_->cts());
stream_buf->SetDecodeTimestamp(runs_->dts());
stream_sample->set_dts(runs_->dts());
stream_sample->set_pts(runs_->cts());
stream_sample->set_duration(runs_->duration());
DVLOG(3) << "Pushing frame: aud=" << audio
<< ", key=" << runs_->is_keyframe()
<< ", dur=" << runs_->duration().InMilliseconds()
<< ", dts=" << runs_->dts().InMilliseconds()
<< ", cts=" << runs_->cts().InMilliseconds()
<< ", dur=" << runs_->duration()
<< ", dts=" << runs_->dts()
<< ", cts=" << runs_->cts()
<< ", size=" << runs_->sample_size();
if (audio) {
audio_buffers->push_back(stream_buf);
} else {
video_buffers->push_back(stream_buf);
}
new_sample_cb_.Run(runs_->track_id(), stream_sample);
runs_->AdvanceSample();
return true;
}
bool MP4StreamParser::SendAndFlushSamples(BufferQueue* audio_buffers,
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 MP4MediaParser::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_,
&type, &box_sz, &err))
if (!BoxReader::StartTopLevelBox(buf, size, &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;
}

67
media/mp4/mp4_stream_parser.h → media/mp4/mp4_media_parser.h
View File

@ -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_
#define MEDIA_MP4_MP4_STREAM_PARSER_H_
#ifndef MEDIA_MP4_MP4_MEDIA_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/stream_parser.h"
#include "media/base/media_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);
virtual ~MP4StreamParser();
MP4MediaParser();
virtual ~MP4MediaParser();
virtual void Init(const InitCB& init_cb, const NewConfigCB& config_cb,
const NewBuffersCB& new_buffers_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) OVERRIDE;
virtual void Flush() OVERRIDE;
virtual void Init(const InitCB& init_cb,
const NewSampleCB& new_sample_cb,
const NeedKeyCB& need_key_cb) 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,
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);
bool EnqueueSample(bool* err);
void Reset();
State state_;
InitCB init_cb_;
NewConfigCB config_cb_;
NewBuffersCB new_buffers_cb_;
NewSampleCB new_sample_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<mp4::TrackRunIterator> runs_;
scoped_ptr<Movie> moov_;
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_

128
media/mp4/mp4_media_parser_unittest.cc Normal file
View File

@ -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

216
media/mp4/mp4_stream_parser_unittest.cc
View File

@ -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

5
media/mp4/offset_byte_queue.h
View File

@ -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_

29
media/mp4/track_run_iterator.cc
View File

@ -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) {
DCHECK_LT((numer > 0 ? numer : -numer),
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) {
TrackRunIterator::TrackRunIterator(const Movie* moov)
: moov_(moov), 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,
run_itr_->timescale);
return sample_dts_ + sample_itr_->cts_offset;
}
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>();
}

17
media/mp4/track_run_iterator.h
View File

@ -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;
TimeDelta cts() const;
TimeDelta duration() const;
int64 dts() const;
int64 cts() 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_;

57
media/mp4/track_run_iterator_unittest.cc
View File

@ -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_->cts(), TimeDeltaFromRational(0, kAudioScale));
EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(1024, kAudioScale));
EXPECT_EQ(iter_->dts(), 0);
EXPECT_EQ(iter_->cts(), 0);
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_->duration(), TimeDeltaFromRational(1024, kAudioScale));
EXPECT_EQ(iter_->dts(), 1024 * 9);
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_->duration(), TimeDeltaFromRational(10, kVideoScale));
EXPECT_EQ(iter_->dts(), base_dts);
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_->dts(), TimeDeltaFromRational(50, kAudioScale));
EXPECT_EQ(iter_->duration(), 50);
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_->cts(), TimeDeltaFromRational(0, kVideoScale));
EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(1, kVideoScale));
EXPECT_EQ(iter_->dts(), 0);
EXPECT_EQ(iter_->cts(), 0);
EXPECT_EQ(iter_->duration(), 1);
iter_->AdvanceSample();
EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(1, kVideoScale));
EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(4, kVideoScale));
EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(2, kVideoScale));
EXPECT_EQ(iter_->dts(), 1);
EXPECT_EQ(iter_->cts(), 4);
EXPECT_EQ(iter_->duration(), 2);
iter_->AdvanceSample();
EXPECT_EQ(iter_->dts(), TimeDeltaFromRational(3, kVideoScale));
EXPECT_EQ(iter_->cts(), TimeDeltaFromRational(1, kVideoScale));
EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(3, kVideoScale));
EXPECT_EQ(iter_->dts(), 3);
EXPECT_EQ(iter_->cts(), 1);
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]);