diff options
Diffstat (limited to 'media/formats')
86 files changed, 983 insertions, 937 deletions
diff --git a/media/formats/common/offset_byte_queue.cc b/media/formats/common/offset_byte_queue.cc index 0bbff80..032ac1f 100644 --- a/media/formats/common/offset_byte_queue.cc +++ b/media/formats/common/offset_byte_queue.cc @@ -18,13 +18,13 @@ void OffsetByteQueue::Reset() { head_ = 0; } -void OffsetByteQueue::Push(const uint8* buf, int size) { +void OffsetByteQueue::Push(const uint8_t* buf, int size) { queue_.Push(buf, size); Sync(); DVLOG(4) << "Buffer pushed. head=" << head() << " tail=" << tail(); } -void OffsetByteQueue::Peek(const uint8** buf, int* size) { +void OffsetByteQueue::Peek(const uint8_t** buf, int* size) { *buf = size_ > 0 ? buf_ : NULL; *size = size_; } @@ -35,7 +35,7 @@ void OffsetByteQueue::Pop(int count) { Sync(); } -void OffsetByteQueue::PeekAt(int64 offset, const uint8** buf, int* size) { +void OffsetByteQueue::PeekAt(int64_t offset, const uint8_t** buf, int* size) { DCHECK(offset >= head()); if (offset < head() || offset >= tail()) { *buf = NULL; @@ -46,7 +46,7 @@ void OffsetByteQueue::PeekAt(int64 offset, const uint8** buf, int* size) { *size = tail() - offset; } -bool OffsetByteQueue::Trim(int64 max_offset) { +bool OffsetByteQueue::Trim(int64_t max_offset) { if (max_offset < head_) return true; if (max_offset > tail()) { Pop(size_); diff --git a/media/formats/common/offset_byte_queue.h b/media/formats/common/offset_byte_queue.h index 0996f07..326609d4 100644 --- a/media/formats/common/offset_byte_queue.h +++ b/media/formats/common/offset_byte_queue.h @@ -5,7 +5,6 @@ #ifndef MEDIA_FORMATS_COMMON_OFFSET_BYTE_QUEUE_H_ #define MEDIA_FORMATS_COMMON_OFFSET_BYTE_QUEUE_H_ -#include "base/basictypes.h" #include "media/base/byte_queue.h" #include "media/base/media_export.h" @@ -22,8 +21,8 @@ class MEDIA_EXPORT OffsetByteQueue { // These work like their underlying ByteQueue counterparts. void Reset(); - void Push(const uint8* buf, int size); - void Peek(const uint8** buf, int* size); + void Push(const uint8_t* buf, int size); + void Peek(const uint8_t** buf, int* size); void Pop(int count); // Sets |buf| to point at the first buffered byte corresponding to |offset|, @@ -32,7 +31,7 @@ class MEDIA_EXPORT OffsetByteQueue { // It is an error if the offset is before the current head. It's not an error // if the current offset is beyond tail(), but you will of course get back // a null |buf| and a |size| of zero. - void PeekAt(int64 offset, const uint8** buf, int* size); + void PeekAt(int64_t offset, const uint8_t** buf, int* size); // Marks the bytes up to (but not including) |max_offset| as ready for // deletion. This is relatively inexpensive, but will not necessarily reduce @@ -42,21 +41,21 @@ class MEDIA_EXPORT OffsetByteQueue { // including the case where |max_offset| is less than the current head. // Returns false if |max_offset| > tail() (although all bytes currently // buffered are still cleared). - bool Trim(int64 max_offset); + bool Trim(int64_t max_offset); // The head and tail positions, in terms of the file's absolute offsets. // tail() is an exclusive bound. - int64 head() { return head_; } - int64 tail() { return head_ + size_; } + int64_t head() { return head_; } + int64_t tail() { return head_ + size_; } private: // Synchronize |buf_| and |size_| with |queue_|. void Sync(); ByteQueue queue_; - const uint8* buf_; + const uint8_t* buf_; int size_; - int64 head_; + int64_t head_; DISALLOW_COPY_AND_ASSIGN(OffsetByteQueue); }; diff --git a/media/formats/common/offset_byte_queue_unittest.cc b/media/formats/common/offset_byte_queue_unittest.cc index ee5914d..574def0 100644 --- a/media/formats/common/offset_byte_queue_unittest.cc +++ b/media/formats/common/offset_byte_queue_unittest.cc @@ -4,7 +4,6 @@ #include <string.h> -#include "base/basictypes.h" #include "base/memory/scoped_ptr.h" #include "media/formats/common/offset_byte_queue.h" #include "testing/gtest/include/gtest/gtest.h" @@ -14,7 +13,7 @@ namespace media { class OffsetByteQueueTest : public testing::Test { public: void SetUp() override { - uint8 buf[256]; + uint8_t buf[256]; for (int i = 0; i < 256; i++) { buf[i] = i; } @@ -35,7 +34,7 @@ TEST_F(OffsetByteQueueTest, SetUp) { EXPECT_EQ(384, queue_->head()); EXPECT_EQ(512, queue_->tail()); - const uint8* buf; + const uint8_t* buf; int size; queue_->Peek(&buf, &size); @@ -45,7 +44,7 @@ TEST_F(OffsetByteQueueTest, SetUp) { } TEST_F(OffsetByteQueueTest, PeekAt) { - const uint8* buf; + const uint8_t* buf; int size; queue_->PeekAt(400, &buf, &size); @@ -67,7 +66,7 @@ TEST_F(OffsetByteQueueTest, Trim) { EXPECT_EQ(400, queue_->head()); EXPECT_EQ(512, queue_->tail()); - const uint8* buf; + const uint8_t* buf; int size; queue_->PeekAt(400, &buf, &size); EXPECT_EQ(queue_->tail() - 400, size); diff --git a/media/formats/common/stream_parser_test_base.cc b/media/formats/common/stream_parser_test_base.cc index b6555b9..29ca747 100644 --- a/media/formats/common/stream_parser_test_base.cc +++ b/media/formats/common/stream_parser_test_base.cc @@ -52,17 +52,18 @@ std::string StreamParserTestBase::ParseFile(const std::string& filename, return results_stream_.str(); } -std::string StreamParserTestBase::ParseData(const uint8* data, size_t length) { +std::string StreamParserTestBase::ParseData(const uint8_t* data, + size_t length) { results_stream_.clear(); EXPECT_TRUE(AppendDataInPieces(data, length, length)); return results_stream_.str(); } -bool StreamParserTestBase::AppendDataInPieces(const uint8* data, +bool StreamParserTestBase::AppendDataInPieces(const uint8_t* data, size_t length, size_t piece_size) { - const uint8* start = data; - const uint8* end = data + length; + const uint8_t* start = data; + const uint8_t* end = data + length; while (start < end) { size_t append_size = std::min(piece_size, static_cast<size_t>(end - start)); if (!parser_->Parse(start, append_size)) @@ -109,7 +110,7 @@ bool StreamParserTestBase::OnNewBuffers( } void StreamParserTestBase::OnKeyNeeded(EmeInitDataType type, - const std::vector<uint8>& init_data) { + const std::vector<uint8_t>& init_data) { DVLOG(1) << __FUNCTION__ << "(" << static_cast<int>(type) << ", " << init_data.size() << ")"; } diff --git a/media/formats/common/stream_parser_test_base.h b/media/formats/common/stream_parser_test_base.h index ea61dd3..f9e483a 100644 --- a/media/formats/common/stream_parser_test_base.h +++ b/media/formats/common/stream_parser_test_base.h @@ -41,7 +41,7 @@ class StreamParserTestBase { // Similar to ParseFile() except parses the given |data| in a single append of // size |length|. - std::string ParseData(const uint8* data, size_t length); + std::string ParseData(const uint8_t* data, size_t length); // The last AudioDecoderConfig handed to OnNewConfig(). const AudioDecoderConfig& last_audio_config() const { @@ -49,7 +49,9 @@ class StreamParserTestBase { } private: - bool AppendDataInPieces(const uint8* data, size_t length, size_t piece_size); + bool AppendDataInPieces(const uint8_t* data, + size_t length, + size_t piece_size); void OnInitDone(const StreamParser::InitParameters& params); bool OnNewConfig(const AudioDecoderConfig& audio_config, const VideoDecoderConfig& video_config, @@ -57,7 +59,7 @@ class StreamParserTestBase { bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers, const StreamParser::BufferQueue& video_buffers, const StreamParser::TextBufferQueueMap& text_map); - void OnKeyNeeded(EmeInitDataType type, const std::vector<uint8>& init_data); + void OnKeyNeeded(EmeInitDataType type, const std::vector<uint8_t>& init_data); void OnNewSegment(); void OnEndOfSegment(); diff --git a/media/formats/mp2t/es_adapter_video.h b/media/formats/mp2t/es_adapter_video.h index f231169..50c162e 100644 --- a/media/formats/mp2t/es_adapter_video.h +++ b/media/formats/mp2t/es_adapter_video.h @@ -54,7 +54,7 @@ class MEDIA_EXPORT EsAdapterVideo { private: typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue; - typedef std::pair<int64, VideoDecoderConfig> ConfigEntry; + typedef std::pair<int64_t, VideoDecoderConfig> ConfigEntry; void ProcessPendingBuffers(bool flush); @@ -80,7 +80,7 @@ class MEDIA_EXPORT EsAdapterVideo { std::list<ConfigEntry> config_list_; // Global index of the first buffer in |buffer_list_|. - int64 buffer_index_; + int64_t buffer_index_; // List of buffer to be emitted and PTS of frames already emitted. BufferQueue buffer_list_; diff --git a/media/formats/mp2t/es_adapter_video_unittest.cc b/media/formats/mp2t/es_adapter_video_unittest.cc index 24feb85..eced6f3 100644 --- a/media/formats/mp2t/es_adapter_video_unittest.cc +++ b/media/formats/mp2t/es_adapter_video_unittest.cc @@ -35,7 +35,7 @@ StreamParserBuffer::BufferQueue GenerateFakeBuffers(const int* frame_pts_ms, const bool* is_key_frame, size_t frame_count) { - uint8 dummy_buffer[] = {0, 0, 0, 0}; + uint8_t dummy_buffer[] = {0, 0, 0, 0}; StreamParserBuffer::BufferQueue buffers(frame_count); for (size_t k = 0; k < frame_count; k++) { diff --git a/media/formats/mp2t/es_parser.cc b/media/formats/mp2t/es_parser.cc index cdd6e07..7512c0b 100644 --- a/media/formats/mp2t/es_parser.cc +++ b/media/formats/mp2t/es_parser.cc @@ -28,7 +28,8 @@ EsParser::EsParser() EsParser::~EsParser() { } -bool EsParser::Parse(const uint8* buf, int size, +bool EsParser::Parse(const uint8_t* buf, + int size, base::TimeDelta pts, DecodeTimestamp dts) { DCHECK(buf); @@ -38,7 +39,7 @@ bool EsParser::Parse(const uint8* buf, int size, // Link the end of the byte queue with the incoming timing descriptor. TimingDesc timing_desc(dts, pts); timing_desc_list_.push_back( - std::pair<int64, TimingDesc>(es_queue_->tail(), timing_desc)); + std::pair<int64_t, TimingDesc>(es_queue_->tail(), timing_desc)); } // Add the incoming bytes to the ES queue. @@ -52,7 +53,7 @@ void EsParser::Reset() { ResetInternal(); } -EsParser::TimingDesc EsParser::GetTimingDescriptor(int64 es_byte_count) { +EsParser::TimingDesc EsParser::GetTimingDescriptor(int64_t es_byte_count) { TimingDesc timing_desc; while (!timing_desc_list_.empty() && timing_desc_list_.front().first <= es_byte_count) { diff --git a/media/formats/mp2t/es_parser.h b/media/formats/mp2t/es_parser.h index b22fe5d..591c115 100644 --- a/media/formats/mp2t/es_parser.h +++ b/media/formats/mp2t/es_parser.h @@ -8,7 +8,6 @@ #include <list> #include <utility> -#include "base/basictypes.h" #include "base/callback.h" #include "base/memory/ref_counted.h" #include "base/time/time.h" @@ -31,7 +30,8 @@ class MEDIA_EXPORT EsParser { // ES parsing. // Should use kNoTimestamp when a timestamp is not valid. - bool Parse(const uint8* buf, int size, + bool Parse(const uint8_t* buf, + int size, base::TimeDelta pts, DecodeTimestamp dts); @@ -62,7 +62,7 @@ class MEDIA_EXPORT EsParser { // This timing descriptor and all the ones that come before (in stream order) // are removed from list |timing_desc_list_|. // If no timing descriptor is found, then the default TimingDesc is returned. - TimingDesc GetTimingDescriptor(int64 es_byte_count); + TimingDesc GetTimingDescriptor(int64_t es_byte_count); // Bytes of the ES stream that have not been emitted yet. scoped_ptr<media::OffsetByteQueue> es_queue_; @@ -79,7 +79,7 @@ class MEDIA_EXPORT EsParser { // in Annex A of Rec. ITU-T H.264 | ISO/IEC 14496-10 video, if a PTS is // present in the PES packet header, it shall refer to the first AVC access // unit that commences in this PES packet. - std::list<std::pair<int64, TimingDesc> > timing_desc_list_; + std::list<std::pair<int64_t, TimingDesc>> timing_desc_list_; DISALLOW_COPY_AND_ASSIGN(EsParser); }; diff --git a/media/formats/mp2t/es_parser_adts.cc b/media/formats/mp2t/es_parser_adts.cc index adf1dbe..a32d9f1 100644 --- a/media/formats/mp2t/es_parser_adts.cc +++ b/media/formats/mp2t/es_parser_adts.cc @@ -6,7 +6,6 @@ #include <vector> -#include "base/basictypes.h" #include "base/logging.h" #include "base/strings/string_number_conversions.h" #include "media/base/audio_timestamp_helper.h" @@ -20,24 +19,24 @@ namespace media { -static int ExtractAdtsFrameSize(const uint8* adts_header) { +static int ExtractAdtsFrameSize(const uint8_t* adts_header) { return ((static_cast<int>(adts_header[5]) >> 5) | (static_cast<int>(adts_header[4]) << 3) | ((static_cast<int>(adts_header[3]) & 0x3) << 11)); } -static size_t ExtractAdtsFrequencyIndex(const uint8* adts_header) { +static size_t ExtractAdtsFrequencyIndex(const uint8_t* adts_header) { return ((adts_header[2] >> 2) & 0xf); } -static size_t ExtractAdtsChannelConfig(const uint8* adts_header) { +static size_t ExtractAdtsChannelConfig(const uint8_t* adts_header) { return (((adts_header[3] >> 6) & 0x3) | ((adts_header[2] & 0x1) << 2)); } // Return true if buf corresponds to an ADTS syncword. // |buf| size must be at least 2. -static bool isAdtsSyncWord(const uint8* buf) { +static bool isAdtsSyncWord(const uint8_t* buf) { // The first 12 bits must be 1. // The layer field (2 bits) must be set to 0. return (buf[0] == 0xff) && ((buf[1] & 0xf6) == 0xf0); @@ -47,18 +46,18 @@ namespace mp2t { struct EsParserAdts::AdtsFrame { // Pointer to the ES data. - const uint8* data; + const uint8_t* data; // Frame size; int size; // Frame offset in the ES queue. - int64 queue_offset; + int64_t queue_offset; }; bool EsParserAdts::LookForAdtsFrame(AdtsFrame* adts_frame) { int es_size; - const uint8* es; + const uint8_t* es; es_queue_->Peek(&es, &es_size); int max_offset = es_size - kADTSHeaderMinSize; @@ -66,7 +65,7 @@ bool EsParserAdts::LookForAdtsFrame(AdtsFrame* adts_frame) { return false; for (int offset = 0; offset < max_offset; offset++) { - const uint8* cur_buf = &es[offset]; + const uint8_t* cur_buf = &es[offset]; if (!isAdtsSyncWord(cur_buf)) continue; @@ -182,7 +181,7 @@ void EsParserAdts::ResetInternal() { last_audio_decoder_config_ = AudioDecoderConfig(); } -bool EsParserAdts::UpdateAudioConfiguration(const uint8* adts_header) { +bool EsParserAdts::UpdateAudioConfiguration(const uint8_t* adts_header) { size_t frequency_index = ExtractAdtsFrequencyIndex(adts_header); if (frequency_index >= kADTSFrequencyTableSize) { // Frequency index 13 & 14 are reserved @@ -213,7 +212,7 @@ bool EsParserAdts::UpdateAudioConfiguration(const uint8* adts_header) { // The following code is written according to ISO 14496 Part 3 Table 1.13 - // Syntax of AudioSpecificConfig. - uint16 extra_data_int = static_cast<uint16>( + uint16_t extra_data_int = static_cast<uint16_t>( // Note: adts_profile is in the range [0,3], since the ADTS header only // allows two bits for its value. ((adts_profile + 1) << 11) + @@ -222,8 +221,8 @@ bool EsParserAdts::UpdateAudioConfiguration(const uint8* adts_header) { // channel_configuration is [0..7], per early out above. (channel_configuration << 3)); std::vector<uint8_t> extra_data; - extra_data.push_back(static_cast<uint8>(extra_data_int >> 8)); - extra_data.push_back(static_cast<uint8>(extra_data_int & 0xff)); + extra_data.push_back(static_cast<uint8_t>(extra_data_int >> 8)); + extra_data.push_back(static_cast<uint8_t>(extra_data_int & 0xff)); AudioDecoderConfig audio_decoder_config( kCodecAAC, diff --git a/media/formats/mp2t/es_parser_adts.h b/media/formats/mp2t/es_parser_adts.h index 740e3ba..87b1aad 100644 --- a/media/formats/mp2t/es_parser_adts.h +++ b/media/formats/mp2t/es_parser_adts.h @@ -58,7 +58,7 @@ class MEDIA_EXPORT EsParserAdts : public EsParser { // Signal any audio configuration change (if any). // Return false if the current audio config is not // a supported ADTS audio config. - bool UpdateAudioConfiguration(const uint8* adts_header); + bool UpdateAudioConfiguration(const uint8_t* adts_header); // Callbacks: // - to signal a new audio configuration, diff --git a/media/formats/mp2t/es_parser_h264.cc b/media/formats/mp2t/es_parser_h264.cc index 8c59112..793e2aa 100644 --- a/media/formats/mp2t/es_parser_h264.cc +++ b/media/formats/mp2t/es_parser_h264.cc @@ -41,7 +41,7 @@ void EsParserH264::Flush() { // Simulate an additional AUD to force emitting the last access unit // which is assumed to be complete at this point. - uint8 aud[] = { 0x00, 0x00, 0x01, 0x09 }; + uint8_t aud[] = {0x00, 0x00, 0x01, 0x09}; es_queue_->Push(aud, sizeof(aud)); ParseFromEsQueue(); @@ -57,9 +57,9 @@ void EsParserH264::ResetInternal() { es_adapter_.Reset(); } -bool EsParserH264::FindAUD(int64* stream_pos) { +bool EsParserH264::FindAUD(int64_t* stream_pos) { while (true) { - const uint8* es; + const uint8_t* es; int size; es_queue_->PeekAt(*stream_pos, &es, &size); @@ -120,10 +120,10 @@ bool EsParserH264::ParseFromEsQueue() { bool is_key_frame = false; int pps_id_for_access_unit = -1; - const uint8* es; + const uint8_t* es; int size; es_queue_->PeekAt(current_access_unit_pos_, &es, &size); - int access_unit_size = base::checked_cast<int, int64>( + int access_unit_size = base::checked_cast<int, int64_t>( next_access_unit_pos_ - current_access_unit_pos_); DCHECK_LE(access_unit_size, size); h264_parser_->SetStream(es, access_unit_size); @@ -195,8 +195,10 @@ bool EsParserH264::ParseFromEsQueue() { return true; } -bool EsParserH264::EmitFrame(int64 access_unit_pos, int access_unit_size, - bool is_key_frame, int pps_id) { +bool EsParserH264::EmitFrame(int64_t access_unit_pos, + int access_unit_size, + bool is_key_frame, + int pps_id) { // Get the access unit timing info. // Note: |current_timing_desc.pts| might be |kNoTimestamp()| at this point // if: @@ -236,7 +238,7 @@ bool EsParserH264::EmitFrame(int64 access_unit_pos, int access_unit_size, DVLOG(LOG_LEVEL_ES) << "Emit frame: stream_pos=" << current_access_unit_pos_ << " size=" << access_unit_size; int es_size; - const uint8* es; + const uint8_t* es; es_queue_->PeekAt(current_access_unit_pos_, &es, &es_size); CHECK_GE(es_size, access_unit_size); diff --git a/media/formats/mp2t/es_parser_h264.h b/media/formats/mp2t/es_parser_h264.h index b37cfc1..1a52c57 100644 --- a/media/formats/mp2t/es_parser_h264.h +++ b/media/formats/mp2t/es_parser_h264.h @@ -8,7 +8,6 @@ #include <list> #include <utility> -#include "base/basictypes.h" #include "base/callback.h" #include "base/compiler_specific.h" #include "base/memory/scoped_ptr.h" @@ -57,12 +56,14 @@ class MEDIA_EXPORT EsParserH264 : public EsParser { // If found, |*stream_pos| corresponds to the position of the AUD start code // in the stream. Otherwise, |*stream_pos| corresponds to the last position // of the start code parser. - bool FindAUD(int64* stream_pos); + bool FindAUD(int64_t* stream_pos); // Emit a frame whose position in the ES queue starts at |access_unit_pos|. // Returns true if successful, false if no PTS is available for the frame. - bool EmitFrame(int64 access_unit_pos, int access_unit_size, - bool is_key_frame, int pps_id); + bool EmitFrame(int64_t access_unit_pos, + int access_unit_size, + bool is_key_frame, + int pps_id); // Update the video decoder config based on an H264 SPS. // Return true if successful. @@ -74,8 +75,8 @@ class MEDIA_EXPORT EsParserH264 : public EsParser { // - |current_access_unit_pos_| is pointing to an annexB syncword // representing the first NALU of an H264 access unit. scoped_ptr<H264Parser> h264_parser_; - int64 current_access_unit_pos_; - int64 next_access_unit_pos_; + int64_t current_access_unit_pos_; + int64_t next_access_unit_pos_; // Last video decoder config. VideoDecoderConfig last_video_decoder_config_; diff --git a/media/formats/mp2t/es_parser_h264_unittest.cc b/media/formats/mp2t/es_parser_h264_unittest.cc index 65f9a37..c134f44 100644 --- a/media/formats/mp2t/es_parser_h264_unittest.cc +++ b/media/formats/mp2t/es_parser_h264_unittest.cc @@ -104,10 +104,10 @@ void EsParserH264Test::GetAccessUnits() { } void EsParserH264Test::InsertAUD() { - uint8 aud[] = { 0x00, 0x00, 0x01, 0x09 }; + uint8_t aud[] = {0x00, 0x00, 0x01, 0x09}; - std::vector<uint8> stream_with_aud( - stream_.size() + access_units_.size() * sizeof(aud)); + std::vector<uint8_t> stream_with_aud(stream_.size() + + access_units_.size() * sizeof(aud)); std::vector<EsParserTestBase::Packet> access_units_with_aud( access_units_.size()); diff --git a/media/formats/mp2t/es_parser_mpeg1audio.cc b/media/formats/mp2t/es_parser_mpeg1audio.cc index 81abc2b..5032887 100644 --- a/media/formats/mp2t/es_parser_mpeg1audio.cc +++ b/media/formats/mp2t/es_parser_mpeg1audio.cc @@ -6,7 +6,6 @@ #include <vector> -#include "base/basictypes.h" #include "base/bind.h" #include "base/logging.h" #include "base/strings/string_number_conversions.h" @@ -24,7 +23,7 @@ namespace mp2t { struct EsParserMpeg1Audio::Mpeg1AudioFrame { // Pointer to the ES data. - const uint8* data; + const uint8_t* data; // Frame size. int size; @@ -33,7 +32,7 @@ struct EsParserMpeg1Audio::Mpeg1AudioFrame { int sample_count; // Frame offset in the ES queue. - int64 queue_offset; + int64_t queue_offset; }; EsParserMpeg1Audio::EsParserMpeg1Audio( @@ -108,7 +107,7 @@ void EsParserMpeg1Audio::ResetInternal() { bool EsParserMpeg1Audio::LookForMpeg1AudioFrame( Mpeg1AudioFrame* mpeg1audio_frame) { int es_size; - const uint8* es; + const uint8_t* es; es_queue_->Peek(&es, &es_size); int max_offset = es_size - MPEG1AudioStreamParser::kHeaderSize; @@ -116,7 +115,7 @@ bool EsParserMpeg1Audio::LookForMpeg1AudioFrame( return false; for (int offset = 0; offset < max_offset; offset++) { - const uint8* cur_buf = &es[offset]; + const uint8_t* cur_buf = &es[offset]; if (cur_buf[0] != 0xff) continue; @@ -161,7 +160,7 @@ bool EsParserMpeg1Audio::LookForMpeg1AudioFrame( } bool EsParserMpeg1Audio::UpdateAudioConfiguration( - const uint8* mpeg1audio_header) { + const uint8_t* mpeg1audio_header) { MPEG1AudioStreamParser::Header header; if (!MPEG1AudioStreamParser::ParseHeader(media_log_, mpeg1audio_header, &header)) { diff --git a/media/formats/mp2t/es_parser_mpeg1audio.h b/media/formats/mp2t/es_parser_mpeg1audio.h index 6ffb197..d1833e6 100644 --- a/media/formats/mp2t/es_parser_mpeg1audio.h +++ b/media/formats/mp2t/es_parser_mpeg1audio.h @@ -41,7 +41,7 @@ class MEDIA_EXPORT EsParserMpeg1Audio : public EsParser { private: // Used to link a PTS with a byte position in the ES stream. - typedef std::pair<int64, base::TimeDelta> EsPts; + typedef std::pair<int64_t, base::TimeDelta> EsPts; typedef std::list<EsPts> EsPtsList; struct Mpeg1AudioFrame; @@ -61,7 +61,7 @@ class MEDIA_EXPORT EsParserMpeg1Audio : public EsParser { // Signal any audio configuration change (if any). // Return false if the current audio config is not // a supported Mpeg1 audio config. - bool UpdateAudioConfiguration(const uint8* mpeg1audio_header); + bool UpdateAudioConfiguration(const uint8_t* mpeg1audio_header); void SkipMpeg1AudioFrame(const Mpeg1AudioFrame& mpeg1audio_frame); diff --git a/media/formats/mp2t/es_parser_test_base.h b/media/formats/mp2t/es_parser_test_base.h index 433bbe1..56930d4 100644 --- a/media/formats/mp2t/es_parser_test_base.h +++ b/media/formats/mp2t/es_parser_test_base.h @@ -64,7 +64,7 @@ class EsParserTestBase { std::vector<Packet> GenerateFixedSizePesPacket(size_t pes_size); // ES stream. - std::vector<uint8> stream_; + std::vector<uint8_t> stream_; // Number of decoder configs received from the ES parser. size_t config_count_; diff --git a/media/formats/mp2t/mp2t_stream_parser.cc b/media/formats/mp2t/mp2t_stream_parser.cc index 0075e6c..37d4797 100644 --- a/media/formats/mp2t/mp2t_stream_parser.cc +++ b/media/formats/mp2t/mp2t_stream_parser.cc @@ -239,14 +239,14 @@ void Mp2tStreamParser::Flush() { timestamp_unroller_.Reset(); } -bool Mp2tStreamParser::Parse(const uint8* buf, int size) { +bool Mp2tStreamParser::Parse(const uint8_t* buf, int size) { DVLOG(1) << "Mp2tStreamParser::Parse size=" << size; // Add the data to the parser state. ts_byte_queue_.Push(buf, size); while (true) { - const uint8* ts_buffer; + const uint8_t* ts_buffer; int ts_buffer_size; ts_byte_queue_.Peek(&ts_buffer, &ts_buffer_size); if (ts_buffer_size < TsPacket::kPacketSize) diff --git a/media/formats/mp2t/mp2t_stream_parser.h b/media/formats/mp2t/mp2t_stream_parser.h index 2bd7fa5..f1aff27 100644 --- a/media/formats/mp2t/mp2t_stream_parser.h +++ b/media/formats/mp2t/mp2t_stream_parser.h @@ -40,7 +40,7 @@ class MEDIA_EXPORT Mp2tStreamParser : public StreamParser { const base::Closure& end_of_segment_cb, const scoped_refptr<MediaLog>& media_log) override; void Flush() override; - bool Parse(const uint8* buf, int size) override; + bool Parse(const uint8_t* buf, int size) override; private: typedef std::map<int, PidState*> PidMap; diff --git a/media/formats/mp2t/mp2t_stream_parser_unittest.cc b/media/formats/mp2t/mp2t_stream_parser_unittest.cc index 6663a05..9bc2b3f 100644 --- a/media/formats/mp2t/mp2t_stream_parser_unittest.cc +++ b/media/formats/mp2t/mp2t_stream_parser_unittest.cc @@ -84,13 +84,15 @@ class Mp2tStreamParserTest : public testing::Test { video_max_dts_ = kNoDecodeTimestamp(); } - bool AppendData(const uint8* data, size_t length) { + bool AppendData(const uint8_t* 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; + bool AppendDataInPieces(const uint8_t* data, + size_t length, + size_t piece_size) { + const uint8_t* start = data; + const uint8_t* end = data + length; while (start < end) { size_t append_size = std::min(piece_size, static_cast<size_t>(end - start)); @@ -171,7 +173,8 @@ class Mp2tStreamParserTest : public testing::Test { return true; } - void OnKeyNeeded(EmeInitDataType type, const std::vector<uint8>& init_data) { + void OnKeyNeeded(EmeInitDataType type, + const std::vector<uint8_t>& init_data) { NOTREACHED() << "OnKeyNeeded not expected in the Mpeg2 TS parser"; } diff --git a/media/formats/mp2t/timestamp_unroller.cc b/media/formats/mp2t/timestamp_unroller.cc index e901b3d..83e568a 100644 --- a/media/formats/mp2t/timestamp_unroller.cc +++ b/media/formats/mp2t/timestamp_unroller.cc @@ -17,7 +17,7 @@ TimestampUnroller::TimestampUnroller() TimestampUnroller::~TimestampUnroller() { } -int64 TimestampUnroller::GetUnrolledTimestamp(int64 timestamp) { +int64_t TimestampUnroller::GetUnrolledTimestamp(int64_t timestamp) { // Mpeg2 TS timestamps have an accuracy of 33 bits. const int nbits = 33; @@ -48,17 +48,16 @@ int64 TimestampUnroller::GetUnrolledTimestamp(int64 timestamp) { // values during that process. // - possible overflows are not considered here since 64 bits on a 90kHz // timescale is way enough to represent several years of playback. - int64 previous_unrolled_time_high = - (previous_unrolled_timestamp_ >> nbits); - int64 time0 = ((previous_unrolled_time_high - 1) << nbits) | timestamp; - int64 time1 = ((previous_unrolled_time_high + 0) << nbits) | timestamp; - int64 time2 = ((previous_unrolled_time_high + 1) << nbits) | timestamp; + int64_t previous_unrolled_time_high = (previous_unrolled_timestamp_ >> nbits); + int64_t time0 = ((previous_unrolled_time_high - 1) << nbits) | timestamp; + int64_t time1 = ((previous_unrolled_time_high + 0) << nbits) | timestamp; + int64_t time2 = ((previous_unrolled_time_high + 1) << nbits) | timestamp; // Select the min absolute difference with the current time // so as to ensure time continuity. - int64 diff0 = time0 - previous_unrolled_timestamp_; - int64 diff1 = time1 - previous_unrolled_timestamp_; - int64 diff2 = time2 - previous_unrolled_timestamp_; + int64_t diff0 = time0 - previous_unrolled_timestamp_; + int64_t diff1 = time1 - previous_unrolled_timestamp_; + int64_t diff2 = time2 - previous_unrolled_timestamp_; if (diff0 < 0) diff0 = -diff0; if (diff1 < 0) @@ -66,8 +65,8 @@ int64 TimestampUnroller::GetUnrolledTimestamp(int64 timestamp) { if (diff2 < 0) diff2 = -diff2; - int64 unrolled_time; - int64 min_diff; + int64_t unrolled_time; + int64_t min_diff; if (diff1 < diff0) { unrolled_time = time1; min_diff = diff1; diff --git a/media/formats/mp2t/timestamp_unroller.h b/media/formats/mp2t/timestamp_unroller.h index 0d05b7c..afebde5 100644 --- a/media/formats/mp2t/timestamp_unroller.h +++ b/media/formats/mp2t/timestamp_unroller.h @@ -5,7 +5,8 @@ #ifndef MEDIA_FORMATS_MP2T_TIMESTAMP_UNROLLER_H_ #define MEDIA_FORMATS_MP2T_TIMESTAMP_UNROLLER_H_ -#include "base/basictypes.h" +#include <stdint.h> + #include "base/macros.h" #include "media/base/media_export.h" @@ -26,7 +27,7 @@ class MEDIA_EXPORT TimestampUnroller { // possible to the previous unrolled timestamp returned by this function // (if this function has not been called before, it will return the timestamp // unmodified). - int64 GetUnrolledTimestamp(int64 timestamp); + int64_t GetUnrolledTimestamp(int64_t timestamp); // Reset the TimestampUnroller to its initial state. void Reset(); @@ -36,7 +37,7 @@ class MEDIA_EXPORT TimestampUnroller { bool is_previous_timestamp_valid_; // This is the last output of GetUnrolledTimestamp. - int64 previous_unrolled_timestamp_; + int64_t previous_unrolled_timestamp_; DISALLOW_COPY_AND_ASSIGN(TimestampUnroller); }; diff --git a/media/formats/mp2t/timestamp_unroller_unittest.cc b/media/formats/mp2t/timestamp_unroller_unittest.cc index 93c214d..d99f5bd8 100644 --- a/media/formats/mp2t/timestamp_unroller_unittest.cc +++ b/media/formats/mp2t/timestamp_unroller_unittest.cc @@ -13,22 +13,22 @@ namespace media { namespace mp2t { -static std::vector<int64> TruncateTimestamps( - const std::vector<int64>& timestamps) { +static std::vector<int64_t> TruncateTimestamps( + const std::vector<int64_t>& timestamps) { const int nbits = 33; - int64 truncate_mask = (INT64_C(1) << nbits) - 1; - std::vector<int64> truncated_timestamps(timestamps.size()); + int64_t truncate_mask = (INT64_C(1) << nbits) - 1; + std::vector<int64_t> truncated_timestamps(timestamps.size()); for (size_t k = 0; k < timestamps.size(); k++) truncated_timestamps[k] = timestamps[k] & truncate_mask; return truncated_timestamps; } -static void RunUnrollTest(const std::vector<int64>& timestamps) { - std::vector<int64> truncated_timestamps = TruncateTimestamps(timestamps); +static void RunUnrollTest(const std::vector<int64_t>& timestamps) { + std::vector<int64_t> truncated_timestamps = TruncateTimestamps(timestamps); TimestampUnroller timestamp_unroller; for (size_t k = 0; k < timestamps.size(); k++) { - int64 unrolled_timestamp = + int64_t unrolled_timestamp = timestamp_unroller.GetUnrolledTimestamp(truncated_timestamps[k]); EXPECT_EQ(timestamps[k], unrolled_timestamp); } @@ -38,19 +38,19 @@ TEST(TimestampUnrollerTest, SingleStream) { // Array of 64 bit timestamps. // This is the expected result from unrolling these timestamps // truncated to 33 bits. - int64 timestamps[] = { - INT64_C(0x0000000000000000), - INT64_C(-190), // - 190 - INT64_C(0x00000000aaaaa9ed), // + 0xaaaaaaab - INT64_C(0x0000000155555498), // + 0xaaaaaaab - INT64_C(0x00000001ffffff43), // + 0xaaaaaaab - INT64_C(0x00000002aaaaa9ee), // + 0xaaaaaaab - INT64_C(0x0000000355555499), // + 0xaaaaaaab - INT64_C(0x00000003ffffff44), // + 0xaaaaaaab + int64_t timestamps[] = { + INT64_C(0x0000000000000000), + INT64_C(-190), // - 190 + INT64_C(0x00000000aaaaa9ed), // + 0xaaaaaaab + INT64_C(0x0000000155555498), // + 0xaaaaaaab + INT64_C(0x00000001ffffff43), // + 0xaaaaaaab + INT64_C(0x00000002aaaaa9ee), // + 0xaaaaaaab + INT64_C(0x0000000355555499), // + 0xaaaaaaab + INT64_C(0x00000003ffffff44), // + 0xaaaaaaab }; - std::vector<int64> timestamps_vector( - timestamps, timestamps + arraysize(timestamps)); + std::vector<int64_t> timestamps_vector(timestamps, + timestamps + arraysize(timestamps)); RunUnrollTest(timestamps_vector); } diff --git a/media/formats/mp2t/ts_packet.cc b/media/formats/mp2t/ts_packet.cc index e134aed..2c03cb6e 100644 --- a/media/formats/mp2t/ts_packet.cc +++ b/media/formats/mp2t/ts_packet.cc @@ -11,10 +11,10 @@ namespace media { namespace mp2t { -static const uint8 kTsHeaderSyncword = 0x47; +static const uint8_t kTsHeaderSyncword = 0x47; // static -int TsPacket::Sync(const uint8* buf, int size) { +int TsPacket::Sync(const uint8_t* buf, int size) { int k = 0; for (; k < size; k++) { // Verify that we have 4 syncwords in a row when possible, @@ -43,7 +43,7 @@ int TsPacket::Sync(const uint8* buf, int size) { } // static -TsPacket* TsPacket::Parse(const uint8* buf, int size) { +TsPacket* TsPacket::Parse(const uint8_t* buf, int size) { if (size < kPacketSize) { DVLOG(1) << "Buffer does not hold one full TS packet:" << " buffer_size=" << size; @@ -73,7 +73,7 @@ TsPacket::TsPacket() { TsPacket::~TsPacket() { } -bool TsPacket::ParseHeader(const uint8* buf) { +bool TsPacket::ParseHeader(const uint8_t* buf) { BitReader bit_reader(buf, kPacketSize); payload_ = buf; payload_size_ = kPacketSize; @@ -161,7 +161,7 @@ bool TsPacket::ParseAdaptationField(BitReader* bit_reader, random_access_indicator_ = (random_access_indicator != 0); if (pcr_flag) { - int64 program_clock_reference_base; + int64_t program_clock_reference_base; int reserved; int program_clock_reference_extension; RCHECK(bit_reader->ReadBits(33, &program_clock_reference_base)); @@ -170,7 +170,7 @@ bool TsPacket::ParseAdaptationField(BitReader* bit_reader, } if (opcr_flag) { - int64 original_program_clock_reference_base; + int64_t original_program_clock_reference_base; int reserved; int original_program_clock_reference_extension; RCHECK(bit_reader->ReadBits(33, &original_program_clock_reference_base)); diff --git a/media/formats/mp2t/ts_packet.h b/media/formats/mp2t/ts_packet.h index a232705..294f464 100644 --- a/media/formats/mp2t/ts_packet.h +++ b/media/formats/mp2t/ts_packet.h @@ -5,7 +5,9 @@ #ifndef MEDIA_FORMATS_MP2T_TS_PACKET_H_ #define MEDIA_FORMATS_MP2T_TS_PACKET_H_ -#include "base/basictypes.h" +#include <stdint.h> + +#include "base/macros.h" namespace media { @@ -19,12 +21,12 @@ class TsPacket { // Return the number of bytes to discard // to be synchronized on a TS syncword. - static int Sync(const uint8* buf, int size); + static int Sync(const uint8_t* buf, int size); // Parse a TS packet. // Return a TsPacket only when parsing was successful. // Return NULL otherwise. - static TsPacket* Parse(const uint8* buf, int size); + static TsPacket* Parse(const uint8_t* buf, int size); ~TsPacket(); @@ -38,7 +40,7 @@ class TsPacket { bool random_access_indicator() const { return random_access_indicator_; } // Return the offset and the size of the payload. - const uint8* payload() const { return payload_; } + const uint8_t* payload() const { return payload_; } int payload_size() const { return payload_size_; } private: @@ -46,12 +48,12 @@ class TsPacket { // Parse an Mpeg2 TS header. // The buffer size should be at least |kPacketSize| - bool ParseHeader(const uint8* buf); + bool ParseHeader(const uint8_t* buf); bool ParseAdaptationField(BitReader* bit_reader, int adaptation_field_length); // Size of the payload. - const uint8* payload_; + const uint8_t* payload_; int payload_size_; // TS header. diff --git a/media/formats/mp2t/ts_section.h b/media/formats/mp2t/ts_section.h index 9273733..7451b9e 100644 --- a/media/formats/mp2t/ts_section.h +++ b/media/formats/mp2t/ts_section.h @@ -24,7 +24,8 @@ class TsSection { // Parse the data bytes of the TS packet. // Return true if parsing is successful. virtual bool Parse(bool payload_unit_start_indicator, - const uint8* buf, int size) = 0; + const uint8_t* buf, + int size) = 0; // Process bytes that have not been processed yet (pending buffers in the // pipe). Flush might thus results in frame emission, as an example. diff --git a/media/formats/mp2t/ts_section_pes.cc b/media/formats/mp2t/ts_section_pes.cc index fe7b4dc..bbfe030 100644 --- a/media/formats/mp2t/ts_section_pes.cc +++ b/media/formats/mp2t/ts_section_pes.cc @@ -14,7 +14,7 @@ static const int kPesStartCode = 0x000001; -static bool IsTimestampSectionValid(int64 timestamp_section) { +static bool IsTimestampSectionValid(int64_t timestamp_section) { // |pts_section| has 40 bits: // - starting with either '0010' or '0011' or '0001' // - and ending with a marker bit. @@ -26,7 +26,7 @@ static bool IsTimestampSectionValid(int64 timestamp_section) { ((timestamp_section & 0x100000000) != 0); } -static int64 ConvertTimestampSectionToTimestamp(int64 timestamp_section) { +static int64_t ConvertTimestampSectionToTimestamp(int64_t timestamp_section) { return (((timestamp_section >> 33) & 0x7) << 30) | (((timestamp_section >> 17) & 0x7fff) << 15) | (((timestamp_section >> 1) & 0x7fff) << 0); @@ -48,7 +48,8 @@ TsSectionPes::~TsSectionPes() { } bool TsSectionPes::Parse(bool payload_unit_start_indicator, - const uint8* buf, int size) { + const uint8_t* buf, + int size) { // Ignore partial PES. if (wait_for_pusi_ && !payload_unit_start_indicator) return true; @@ -59,7 +60,7 @@ bool TsSectionPes::Parse(bool payload_unit_start_indicator, // with an undefined size. // In this case, a unit is emitted when the next unit is coming. int raw_pes_size; - const uint8* raw_pes; + const uint8_t* raw_pes; pes_byte_queue_.Peek(&raw_pes, &raw_pes_size); if (raw_pes_size > 0) parse_result = Emit(true); @@ -95,7 +96,7 @@ void TsSectionPes::Reset() { bool TsSectionPes::Emit(bool emit_for_unknown_size) { int raw_pes_size; - const uint8* raw_pes; + const uint8_t* raw_pes; pes_byte_queue_.Peek(&raw_pes, &raw_pes_size); // A PES should be at least 6 bytes. @@ -126,7 +127,7 @@ bool TsSectionPes::Emit(bool emit_for_unknown_size) { return parse_result; } -bool TsSectionPes::ParseInternal(const uint8* raw_pes, int raw_pes_size) { +bool TsSectionPes::ParseInternal(const uint8_t* raw_pes, int raw_pes_size) { BitReader bit_reader(raw_pes, raw_pes_size); // Read up to the pes_packet_length (6 bytes). @@ -199,8 +200,8 @@ bool TsSectionPes::ParseInternal(const uint8* raw_pes, int raw_pes_size) { // Read the timing information section. bool is_pts_valid = false; bool is_dts_valid = false; - int64 pts_section = 0; - int64 dts_section = 0; + int64_t pts_section = 0; + int64_t dts_section = 0; if (pts_dts_flags == 0x2) { RCHECK(bit_reader.ReadBits(40, &pts_section)); RCHECK((((pts_section >> 36) & 0xf) == 0x2) && @@ -222,12 +223,12 @@ bool TsSectionPes::ParseInternal(const uint8* raw_pes, int raw_pes_size) { base::TimeDelta media_pts(kNoTimestamp()); DecodeTimestamp media_dts(kNoDecodeTimestamp()); if (is_pts_valid) { - int64 pts = timestamp_unroller_->GetUnrolledTimestamp( + int64_t pts = timestamp_unroller_->GetUnrolledTimestamp( ConvertTimestampSectionToTimestamp(pts_section)); media_pts = base::TimeDelta::FromMicroseconds((1000 * pts) / 90); } if (is_dts_valid) { - int64 dts = timestamp_unroller_->GetUnrolledTimestamp( + int64_t dts = timestamp_unroller_->GetUnrolledTimestamp( ConvertTimestampSectionToTimestamp(dts_section)); media_dts = DecodeTimestamp::FromMicroseconds((1000 * dts) / 90); } diff --git a/media/formats/mp2t/ts_section_pes.h b/media/formats/mp2t/ts_section_pes.h index 3be879c..ec12c8f 100644 --- a/media/formats/mp2t/ts_section_pes.h +++ b/media/formats/mp2t/ts_section_pes.h @@ -5,7 +5,6 @@ #ifndef MEDIA_FORMATS_MP2T_TS_SECTION_PES_H_ #define MEDIA_FORMATS_MP2T_TS_SECTION_PES_H_ -#include "base/basictypes.h" #include "base/compiler_specific.h" #include "base/memory/scoped_ptr.h" #include "media/base/byte_queue.h" @@ -25,7 +24,8 @@ class TsSectionPes : public TsSection { // TsSection implementation. bool Parse(bool payload_unit_start_indicator, - const uint8* buf, int size) override; + const uint8_t* buf, + int size) override; void Flush() override; void Reset() override; @@ -37,7 +37,7 @@ class TsSectionPes : public TsSection { bool Emit(bool emit_for_unknown_size); // Parse a PES packet, return true if successful. - bool ParseInternal(const uint8* raw_pes, int raw_pes_size); + bool ParseInternal(const uint8_t* raw_pes, int raw_pes_size); void ResetPesState(); diff --git a/media/formats/mp2t/ts_section_psi.cc b/media/formats/mp2t/ts_section_psi.cc index 64fac9c..b8c9599 100644 --- a/media/formats/mp2t/ts_section_psi.cc +++ b/media/formats/mp2t/ts_section_psi.cc @@ -6,18 +6,17 @@ #include <algorithm> -#include "base/basictypes.h" #include "base/logging.h" #include "media/base/bit_reader.h" #include "media/formats/mp2t/mp2t_common.h" -static bool IsCrcValid(const uint8* buf, int size) { - uint32 crc = 0xffffffffu; - const uint32 kCrcPoly = 0x4c11db7; +static bool IsCrcValid(const uint8_t* buf, int size) { + uint32_t crc = 0xffffffffu; + const uint32_t kCrcPoly = 0x4c11db7; for (int k = 0; k < size; k++) { int nbits = 8; - uint32 data_msb_aligned = buf[k]; + uint32_t data_msb_aligned = buf[k]; data_msb_aligned <<= (32 - nbits); while (nbits > 0) { @@ -48,7 +47,8 @@ TsSectionPsi::~TsSectionPsi() { } bool TsSectionPsi::Parse(bool payload_unit_start_indicator, - const uint8* buf, int size) { + const uint8_t* buf, + int size) { // Ignore partial PSI. if (wait_for_pusi_ && !payload_unit_start_indicator) return true; @@ -79,7 +79,7 @@ bool TsSectionPsi::Parse(bool payload_unit_start_indicator, // Add the data to the parser state. psi_byte_queue_.Push(buf, size); int raw_psi_size; - const uint8* raw_psi; + const uint8_t* raw_psi; psi_byte_queue_.Peek(&raw_psi, &raw_psi_size); // Check whether we have enough data to start parsing. diff --git a/media/formats/mp2t/ts_section_psi.h b/media/formats/mp2t/ts_section_psi.h index 063310c..1495dbd 100644 --- a/media/formats/mp2t/ts_section_psi.h +++ b/media/formats/mp2t/ts_section_psi.h @@ -22,7 +22,8 @@ class TsSectionPsi : public TsSection { // TsSection implementation. bool Parse(bool payload_unit_start_indicator, - const uint8* buf, int size) override; + const uint8_t* buf, + int size) override; void Flush() override; void Reset() override; diff --git a/media/formats/mp4/aac.cc b/media/formats/mp4/aac.cc index 1e30918..ea4765b 100644 --- a/media/formats/mp4/aac.cc +++ b/media/formats/mp4/aac.cc @@ -22,7 +22,7 @@ AAC::AAC() AAC::~AAC() { } -bool AAC::Parse(const std::vector<uint8>& data, +bool AAC::Parse(const std::vector<uint8_t>& data, const scoped_refptr<MediaLog>& media_log) { #if defined(OS_ANDROID) codec_specific_data_ = data; @@ -31,9 +31,9 @@ bool AAC::Parse(const std::vector<uint8>& data, return false; BitReader reader(&data[0], data.size()); - uint8 extension_type = 0; + uint8_t extension_type = 0; bool ps_present = false; - uint8 extension_frequency_index = 0xff; + uint8_t extension_frequency_index = 0xff; frequency_ = 0; extension_frequency_ = 0; @@ -68,9 +68,9 @@ bool AAC::Parse(const std::vector<uint8>& data, // Read extension configuration again // Note: The check for 16 available bits comes from the AAC spec. if (extension_type != 5 && reader.bits_available() >= 16) { - uint16 sync_extension_type; - uint8 sbr_present_flag; - uint8 ps_present_flag; + uint16_t sync_extension_type; + uint8_t sbr_present_flag; + uint8_t ps_present_flag; if (reader.ReadBits(11, &sync_extension_type) && sync_extension_type == 0x2b7) { @@ -178,7 +178,7 @@ ChannelLayout AAC::GetChannelLayout(bool sbr_in_mimetype) const { return channel_layout_; } -bool AAC::ConvertEsdsToADTS(std::vector<uint8>* buffer) const { +bool AAC::ConvertEsdsToADTS(std::vector<uint8_t>* buffer) const { size_t size = buffer->size() + kADTSHeaderMinSize; DCHECK(profile_ >= 1 && profile_ <= 4 && frequency_index_ != 0xf && @@ -188,15 +188,15 @@ bool AAC::ConvertEsdsToADTS(std::vector<uint8>* buffer) const { if (size >= (1 << 13)) return false; - std::vector<uint8>& adts = *buffer; + std::vector<uint8_t>& adts = *buffer; adts.insert(buffer->begin(), kADTSHeaderMinSize, 0); adts[0] = 0xff; adts[1] = 0xf1; adts[2] = ((profile_ - 1) << 6) + (frequency_index_ << 2) + (channel_config_ >> 2); - adts[3] = static_cast<uint8>(((channel_config_ & 0x3) << 6) + (size >> 11)); - adts[4] = static_cast<uint8>((size & 0x7ff) >> 3); + adts[3] = static_cast<uint8_t>(((channel_config_ & 0x3) << 6) + (size >> 11)); + adts[4] = static_cast<uint8_t>((size & 0x7ff) >> 3); adts[5] = ((size & 7) << 5) + 0x1f; adts[6] = 0xfc; @@ -250,9 +250,9 @@ bool AAC::SkipErrorSpecificConfig() const { // The following code is written according to ISO 14496-3:2005 Table 4.1 - // GASpecificConfig. bool AAC::SkipGASpecificConfig(BitReader* bit_reader) const { - uint8 extension_flag = 0; - uint8 depends_on_core_coder; - uint16 dummy; + uint8_t extension_flag = 0; + uint8_t depends_on_core_coder; + uint16_t dummy; RCHECK(bit_reader->ReadBits(1, &dummy)); // frameLengthFlag RCHECK(bit_reader->ReadBits(1, &depends_on_core_coder)); diff --git a/media/formats/mp4/aac.h b/media/formats/mp4/aac.h index e76ea36..4328b56 100644 --- a/media/formats/mp4/aac.h +++ b/media/formats/mp4/aac.h @@ -7,7 +7,6 @@ #include <vector> -#include "base/basictypes.h" #include "media/base/channel_layout.h" #include "media/base/media_export.h" #include "media/base/media_log.h" @@ -31,7 +30,7 @@ class MEDIA_EXPORT AAC { // The function will parse the data and get the ElementaryStreamDescriptor, // then it will parse the ElementaryStreamDescriptor to get audio stream // configurations. - bool Parse(const std::vector<uint8>& data, + bool Parse(const std::vector<uint8_t>& data, const scoped_refptr<MediaLog>& media_log); // Gets the output sample rate for the AAC stream. @@ -52,11 +51,11 @@ class MEDIA_EXPORT AAC { // 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 ConvertEsdsToADTS(std::vector<uint8_t>* buffer) const; #if defined(OS_ANDROID) // Returns the codec specific data needed by android MediaCodec. - std::vector<uint8> codec_specific_data() const { + std::vector<uint8_t> codec_specific_data() const { return codec_specific_data_; } #endif @@ -68,13 +67,13 @@ class MEDIA_EXPORT AAC { // The following variables store the AAC specific configuration information // that are used to generate the ADTS header. - uint8 profile_; - uint8 frequency_index_; - uint8 channel_config_; + uint8_t profile_; + uint8_t frequency_index_; + uint8_t channel_config_; #if defined(OS_ANDROID) // The codec specific data needed by the android MediaCodec. - std::vector<uint8> codec_specific_data_; + std::vector<uint8_t> codec_specific_data_; #endif // The following variables store audio configuration information that diff --git a/media/formats/mp4/aac_unittest.cc b/media/formats/mp4/aac_unittest.cc index 8a079bc..5b6e6b4 100644 --- a/media/formats/mp4/aac_unittest.cc +++ b/media/formats/mp4/aac_unittest.cc @@ -68,7 +68,7 @@ class AACTest : public testing::Test { public: AACTest() : media_log_(new StrictMock<MockMediaLog>()) {} - bool Parse(const std::vector<uint8>& data) { + bool Parse(const std::vector<uint8_t>& data) { return aac_.Parse(data, media_log_); } @@ -77,8 +77,8 @@ class AACTest : public testing::Test { }; TEST_F(AACTest, BasicProfileTest) { - uint8 buffer[] = {0x12, 0x10}; - std::vector<uint8> data; + uint8_t buffer[] = {0x12, 0x10}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); @@ -92,8 +92,8 @@ TEST_F(AACTest, BasicProfileTest) { } TEST_F(AACTest, ExtensionTest) { - uint8 buffer[] = {0x13, 0x08, 0x56, 0xe5, 0x9d, 0x48, 0x80}; - std::vector<uint8> data; + uint8_t buffer[] = {0x13, 0x08, 0x56, 0xe5, 0x9d, 0x48, 0x80}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); @@ -112,8 +112,8 @@ TEST_F(AACTest, ExtensionTest) { // specified. Otherwise stereo should be reported. // See ISO 14496-3:2005 Section 1.6.5.3 for details about this special casing. TEST_F(AACTest, ImplicitSBR_ChannelConfig0) { - uint8 buffer[] = {0x13, 0x08}; - std::vector<uint8> data; + uint8_t buffer[] = {0x13, 0x08}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); @@ -134,8 +134,8 @@ TEST_F(AACTest, ImplicitSBR_ChannelConfig0) { // Tests implicit SBR with a stereo channel config. TEST_F(AACTest, ImplicitSBR_ChannelConfig1) { - uint8 buffer[] = {0x13, 0x10}; - std::vector<uint8> data; + uint8_t buffer[] = {0x13, 0x10}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); @@ -155,8 +155,8 @@ TEST_F(AACTest, ImplicitSBR_ChannelConfig1) { } TEST_F(AACTest, SixChannelTest) { - uint8 buffer[] = {0x11, 0xb0}; - std::vector<uint8> data; + uint8_t buffer[] = {0x11, 0xb0}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); @@ -170,7 +170,7 @@ TEST_F(AACTest, SixChannelTest) { } TEST_F(AACTest, DataTooShortTest) { - std::vector<uint8> data; + std::vector<uint8_t> data; EXPECT_FALSE(Parse(data)); @@ -180,8 +180,8 @@ TEST_F(AACTest, DataTooShortTest) { TEST_F(AACTest, IncorrectProfileTest) { InSequence s; - uint8 buffer[] = {0x0, 0x08}; - std::vector<uint8> data; + uint8_t buffer[] = {0x0, 0x08}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); EXPECT_FALSE(Parse(data)); @@ -200,8 +200,8 @@ TEST_F(AACTest, IncorrectProfileTest) { } TEST_F(AACTest, IncorrectFrequencyTest) { - uint8 buffer[] = {0x0f, 0x88}; - std::vector<uint8> data; + uint8_t buffer[] = {0x0f, 0x88}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); EXPECT_FALSE(Parse(data)); @@ -216,8 +216,8 @@ TEST_F(AACTest, IncorrectFrequencyTest) { } TEST_F(AACTest, IncorrectChannelTest) { - uint8 buffer[] = {0x0e, 0x00}; - std::vector<uint8> data; + uint8_t buffer[] = {0x0e, 0x00}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); EXPECT_FALSE(Parse(data)); @@ -232,8 +232,8 @@ TEST_F(AACTest, IncorrectChannelTest) { TEST_F(AACTest, UnsupportedProfileTest) { InSequence s; - uint8 buffer[] = {0x3a, 0x08}; - std::vector<uint8> data; + uint8_t buffer[] = {0x3a, 0x08}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); EXPECT_MEDIA_LOG(UnsupportedAudioProfileLog("mp4a.40.7")); @@ -250,8 +250,8 @@ TEST_F(AACTest, UnsupportedProfileTest) { TEST_F(AACTest, UnsupportedChannelLayoutTest) { InSequence s; - uint8 buffer[] = {0x12, 0x78}; - std::vector<uint8> data; + uint8_t buffer[] = {0x12, 0x78}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); EXPECT_MEDIA_LOG(UnsupportedChannelConfigLog("15")); @@ -267,8 +267,8 @@ TEST_F(AACTest, UnsupportedChannelLayoutTest) { TEST_F(AACTest, UnsupportedFrequencyIndexTest) { InSequence s; - uint8 buffer[] = {0x17, 0x10}; - std::vector<uint8> data; + uint8_t buffer[] = {0x17, 0x10}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); EXPECT_MEDIA_LOG(UnsupportedFrequencyIndexLog("e")); @@ -284,8 +284,8 @@ TEST_F(AACTest, UnsupportedFrequencyIndexTest) { TEST_F(AACTest, UnsupportedExFrequencyIndexTest) { InSequence s; - uint8 buffer[] = {0x29, 0x17, 0x08, 0x0}; - std::vector<uint8> data; + uint8_t buffer[] = {0x29, 0x17, 0x08, 0x0}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); EXPECT_MEDIA_LOG(UnsupportedExtensionFrequencyIndexLog("e")); diff --git a/media/formats/mp4/avc.cc b/media/formats/mp4/avc.cc index 7451a5f..01f7df2 100644 --- a/media/formats/mp4/avc.cc +++ b/media/formats/mp4/avc.cc @@ -15,14 +15,14 @@ namespace media { namespace mp4 { -static const uint8 kAnnexBStartCode[] = {0, 0, 0, 1}; +static const uint8_t kAnnexBStartCode[] = {0, 0, 0, 1}; static const int kAnnexBStartCodeSize = 4; -static bool ConvertAVCToAnnexBInPlaceForLengthSize4(std::vector<uint8>* buf) { +static bool ConvertAVCToAnnexBInPlaceForLengthSize4(std::vector<uint8_t>* buf) { const int kLengthSize = 4; size_t pos = 0; while (pos + kLengthSize < buf->size()) { - uint32 nal_length = (*buf)[pos]; + uint32_t nal_length = (*buf)[pos]; nal_length = (nal_length << 8) + (*buf)[pos+1]; nal_length = (nal_length << 8) + (*buf)[pos+2]; nal_length = (nal_length << 8) + (*buf)[pos+3]; @@ -40,15 +40,15 @@ static bool ConvertAVCToAnnexBInPlaceForLengthSize4(std::vector<uint8>* buf) { } // static -int AVC::FindSubsampleIndex(const std::vector<uint8>& buffer, +int AVC::FindSubsampleIndex(const std::vector<uint8_t>& buffer, const std::vector<SubsampleEntry>* subsamples, - const uint8* ptr) { + const uint8_t* ptr) { DCHECK(ptr >= &buffer[0]); DCHECK(ptr <= &buffer[buffer.size()-1]); if (!subsamples || subsamples->empty()) return 0; - const uint8* p = &buffer[0]; + const uint8_t* p = &buffer[0]; for (size_t i = 0; i < subsamples->size(); ++i) { p += (*subsamples)[i].clear_bytes + (*subsamples)[i].cypher_bytes; if (p > ptr) @@ -59,14 +59,15 @@ int AVC::FindSubsampleIndex(const std::vector<uint8>& buffer, } // static -bool AVC::ConvertFrameToAnnexB(int length_size, std::vector<uint8>* buffer, +bool AVC::ConvertFrameToAnnexB(int length_size, + std::vector<uint8_t>* buffer, std::vector<SubsampleEntry>* subsamples) { RCHECK(length_size == 1 || length_size == 2 || length_size == 4); if (length_size == 4) return ConvertAVCToAnnexBInPlaceForLengthSize4(buffer); - std::vector<uint8> temp; + std::vector<uint8_t> temp; temp.swap(*buffer); buffer->reserve(temp.size() + 32); @@ -85,7 +86,7 @@ bool AVC::ConvertFrameToAnnexB(int length_size, std::vector<uint8>* buffer, buffer->insert(buffer->end(), kAnnexBStartCode, kAnnexBStartCode + kAnnexBStartCodeSize); if (subsamples && !subsamples->empty()) { - uint8* buffer_pos = &(*(buffer->end() - kAnnexBStartCodeSize)); + uint8_t* buffer_pos = &(*(buffer->end() - kAnnexBStartCodeSize)); int subsample_index = FindSubsampleIndex(*buffer, subsamples, buffer_pos); // We've replaced NALU size value with an AnnexB start code. int size_adjustment = kAnnexBStartCodeSize - length_size; @@ -100,19 +101,19 @@ bool AVC::ConvertFrameToAnnexB(int length_size, std::vector<uint8>* buffer, // static bool AVC::InsertParamSetsAnnexB(const AVCDecoderConfigurationRecord& avc_config, - std::vector<uint8>* buffer, + std::vector<uint8_t>* buffer, std::vector<SubsampleEntry>* subsamples) { DCHECK(AVC::IsValidAnnexB(*buffer, *subsamples)); scoped_ptr<H264Parser> parser(new H264Parser()); - const uint8* start = &(*buffer)[0]; + const uint8_t* start = &(*buffer)[0]; parser->SetEncryptedStream(start, buffer->size(), *subsamples); H264NALU nalu; if (parser->AdvanceToNextNALU(&nalu) != H264Parser::kOk) return false; - std::vector<uint8>::iterator config_insert_point = buffer->begin(); + std::vector<uint8_t>::iterator config_insert_point = buffer->begin(); if (nalu.nal_unit_type == H264NALU::kAUD) { // Move insert point to just after the AUD. @@ -124,7 +125,7 @@ bool AVC::InsertParamSetsAnnexB(const AVCDecoderConfigurationRecord& avc_config, parser.reset(); start = NULL; - std::vector<uint8> param_sets; + std::vector<uint8_t> param_sets; RCHECK(AVC::ConvertConfigToAnnexB(avc_config, ¶m_sets)); if (subsamples && !subsamples->empty()) { @@ -142,9 +143,8 @@ bool AVC::InsertParamSetsAnnexB(const AVCDecoderConfigurationRecord& avc_config, } // static -bool AVC::ConvertConfigToAnnexB( - const AVCDecoderConfigurationRecord& avc_config, - std::vector<uint8>* buffer) { +bool AVC::ConvertConfigToAnnexB(const AVCDecoderConfigurationRecord& avc_config, + std::vector<uint8_t>* buffer) { DCHECK(buffer->empty()); buffer->clear(); int total_size = 0; @@ -171,12 +171,13 @@ bool AVC::ConvertConfigToAnnexB( } // Verifies AnnexB NALU order according to ISO/IEC 14496-10 Section 7.4.1.2.3 -bool AVC::IsValidAnnexB(const std::vector<uint8>& buffer, +bool AVC::IsValidAnnexB(const std::vector<uint8_t>& buffer, const std::vector<SubsampleEntry>& subsamples) { return IsValidAnnexB(&buffer[0], buffer.size(), subsamples); } -bool AVC::IsValidAnnexB(const uint8* buffer, size_t size, +bool AVC::IsValidAnnexB(const uint8_t* buffer, + size_t size, const std::vector<SubsampleEntry>& subsamples) { DVLOG(1) << __FUNCTION__; DCHECK(buffer); @@ -318,7 +319,7 @@ AVCBitstreamConverter::~AVCBitstreamConverter() { } bool AVCBitstreamConverter::ConvertFrame( - std::vector<uint8>* frame_buf, + std::vector<uint8_t>* frame_buf, bool is_keyframe, std::vector<SubsampleEntry>* subsamples) const { // Convert the AVC NALU length fields to Annex B headers, as expected by diff --git a/media/formats/mp4/avc.h b/media/formats/mp4/avc.h index a774ddd..19858b9 100644 --- a/media/formats/mp4/avc.h +++ b/media/formats/mp4/avc.h @@ -7,7 +7,6 @@ #include <vector> -#include "base/basictypes.h" #include "base/memory/scoped_ptr.h" #include "media/base/media_export.h" #include "media/formats/mp4/bitstream_converter.h" @@ -23,7 +22,7 @@ struct AVCDecoderConfigurationRecord; class MEDIA_EXPORT AVC { public: static bool ConvertFrameToAnnexB(int length_size, - std::vector<uint8>* buffer, + std::vector<uint8_t>* buffer, std::vector<SubsampleEntry>* subsamples); // Inserts the SPS & PPS data from |avc_config| into |buffer|. @@ -33,12 +32,12 @@ class MEDIA_EXPORT AVC { // Returns true if the param sets were successfully inserted. static bool InsertParamSetsAnnexB( const AVCDecoderConfigurationRecord& avc_config, - std::vector<uint8>* buffer, + std::vector<uint8_t>* buffer, std::vector<SubsampleEntry>* subsamples); static bool ConvertConfigToAnnexB( const AVCDecoderConfigurationRecord& avc_config, - std::vector<uint8>* buffer); + std::vector<uint8_t>* buffer); // Verifies that the contents of |buffer| conform to // Section 7.4.1.2.3 of ISO/IEC 14496-10. @@ -47,16 +46,17 @@ class MEDIA_EXPORT AVC { // Returns true if |buffer| contains conformant Annex B data // TODO(acolwell): Remove the std::vector version when we can use, // C++11's std::vector<T>::data() method. - static bool IsValidAnnexB(const std::vector<uint8>& buffer, + static bool IsValidAnnexB(const std::vector<uint8_t>& buffer, const std::vector<SubsampleEntry>& subsamples); - static bool IsValidAnnexB(const uint8* buffer, size_t size, + static bool IsValidAnnexB(const uint8_t* buffer, + size_t size, const std::vector<SubsampleEntry>& subsamples); // Given a |buffer| and |subsamples| information and |pts| pointer into the // |buffer| finds the index of the subsample |ptr| is pointing into. - static int FindSubsampleIndex(const std::vector<uint8>& buffer, + static int FindSubsampleIndex(const std::vector<uint8_t>& buffer, const std::vector<SubsampleEntry>* subsamples, - const uint8* ptr); + const uint8_t* ptr); }; // AVCBitstreamConverter converts AVC/H.264 bitstream from MP4 container format @@ -69,9 +69,10 @@ class AVCBitstreamConverter : public BitstreamConverter { scoped_ptr<AVCDecoderConfigurationRecord> avc_config); // BitstreamConverter interface - bool ConvertFrame(std::vector<uint8>* frame_buf, + bool ConvertFrame(std::vector<uint8_t>* frame_buf, bool is_keyframe, std::vector<SubsampleEntry>* subsamples) const override; + private: ~AVCBitstreamConverter() override; scoped_ptr<AVCDecoderConfigurationRecord> avc_config_; diff --git a/media/formats/mp4/avc_unittest.cc b/media/formats/mp4/avc_unittest.cc index 19f10f3..2faf56e 100644 --- a/media/formats/mp4/avc_unittest.cc +++ b/media/formats/mp4/avc_unittest.cc @@ -4,7 +4,6 @@ #include <string.h> -#include "base/basictypes.h" #include "base/strings/string_split.h" #include "base/strings/string_util.h" #include "media/base/decrypt_config.h" @@ -17,16 +16,15 @@ 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_t kNALU1[] = {0x01, 0x02, 0x03}; +static const uint8_t kNALU2[] = {0x04, 0x05, 0x06, 0x07}; +static const uint8_t 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}; +static const uint8_t kExpectedParamSets[] = { + 0x00, 0x00, 0x00, 0x01, 0x67, 0x12, 0x00, 0x00, 0x00, 0x01, + 0x67, 0x34, 0x00, 0x00, 0x00, 0x01, 0x68, 0x56, 0x78}; static H264NALU::Type StringToNALUType(const std::string& name) { if (name == "P") @@ -111,7 +109,7 @@ static std::string NALUTypeToString(int type) { return "UnsupportedType"; } -static void WriteStartCodeAndNALUType(std::vector<uint8>* buffer, +static void WriteStartCodeAndNALUType(std::vector<uint8_t>* buffer, const std::string& nal_unit_type) { buffer->push_back(0x00); buffer->push_back(0x00); @@ -131,7 +129,8 @@ static void WriteStartCodeAndNALUType(std::vector<uint8>* buffer, // The output buffer will contain a valid-looking Annex B (it's valid-looking in // the sense that it has start codes and correct NALU types, but the actual NALU // payload is junk). -void StringToAnnexB(const std::string& str, std::vector<uint8>* buffer, +void StringToAnnexB(const std::string& str, + std::vector<uint8_t>* buffer, std::vector<SubsampleEntry>* subsamples) { DCHECK(!str.empty()); @@ -174,7 +173,7 @@ void StringToAnnexB(const std::string& str, std::vector<uint8>* buffer, } } -std::string AnnexBToString(const std::vector<uint8>& buffer, +std::string AnnexBToString(const std::vector<uint8_t>& buffer, const std::vector<SubsampleEntry>& subsamples) { std::stringstream ss; @@ -202,7 +201,7 @@ std::string AnnexBToString(const std::vector<uint8>& buffer, class AVCConversionTest : public testing::TestWithParam<int> { protected: - void WriteLength(int length_size, int length, std::vector<uint8>* buf) { + void WriteLength(int length_size, int length, std::vector<uint8_t>* buf) { DCHECK_GE(length, 0); DCHECK_LE(length, 255); @@ -211,7 +210,7 @@ class AVCConversionTest : public testing::TestWithParam<int> { buf->push_back(length); } - void MakeInputForLength(int length_size, std::vector<uint8>* buf) { + void MakeInputForLength(int length_size, std::vector<uint8_t>* buf) { buf->clear(); WriteLength(length_size, sizeof(kNALU1), buf); @@ -224,7 +223,7 @@ class AVCConversionTest : public testing::TestWithParam<int> { }; TEST_P(AVCConversionTest, ParseCorrectly) { - std::vector<uint8> buf; + std::vector<uint8_t> buf; std::vector<SubsampleEntry> subsamples; MakeInputForLength(GetParam(), &buf); EXPECT_TRUE(AVC::ConvertFrameToAnnexB(GetParam(), &buf, &subsamples)); @@ -236,14 +235,14 @@ TEST_P(AVCConversionTest, ParseCorrectly) { // Intentionally write NALU sizes that are larger than the buffer. TEST_P(AVCConversionTest, NALUSizeTooLarge) { - std::vector<uint8> buf; + std::vector<uint8_t> buf; WriteLength(GetParam(), 10 * sizeof(kNALU1), &buf); buf.insert(buf.end(), kNALU1, kNALU1 + sizeof(kNALU1)); EXPECT_FALSE(AVC::ConvertFrameToAnnexB(GetParam(), &buf, nullptr)); } TEST_P(AVCConversionTest, NALUSizeIsZero) { - std::vector<uint8> buf; + std::vector<uint8_t> buf; WriteLength(GetParam(), 0, &buf); WriteLength(GetParam(), sizeof(kNALU1), &buf); @@ -258,7 +257,7 @@ TEST_P(AVCConversionTest, NALUSizeIsZero) { } TEST_P(AVCConversionTest, SubsampleSizesUpdatedAfterAnnexBConversion) { - std::vector<uint8> buf; + std::vector<uint8_t> buf; std::vector<SubsampleEntry> subsamples; SubsampleEntry subsample; @@ -298,7 +297,7 @@ TEST_P(AVCConversionTest, SubsampleSizesUpdatedAfterAnnexBConversion) { } TEST_P(AVCConversionTest, ParsePartial) { - std::vector<uint8> buf; + std::vector<uint8_t> buf; MakeInputForLength(GetParam(), &buf); buf.pop_back(); EXPECT_FALSE(AVC::ConvertFrameToAnnexB(GetParam(), &buf, nullptr)); @@ -312,7 +311,7 @@ TEST_P(AVCConversionTest, ParsePartial) { } TEST_P(AVCConversionTest, ParseEmpty) { - std::vector<uint8> buf; + std::vector<uint8_t> buf; EXPECT_TRUE(AVC::ConvertFrameToAnnexB(GetParam(), &buf, nullptr)); EXPECT_EQ(0u, buf.size()); } @@ -333,7 +332,7 @@ TEST_F(AVCConversionTest, ConvertConfigToAnnexB) { avc_config.pps_list[0].push_back(0x56); avc_config.pps_list[0].push_back(0x78); - std::vector<uint8> buf; + std::vector<uint8_t> buf; std::vector<SubsampleEntry> subsamples; EXPECT_TRUE(AVC::ConvertConfigToAnnexB(avc_config, &buf)); EXPECT_EQ(0, memcmp(kExpectedParamSets, &buf[0], @@ -345,7 +344,7 @@ TEST_F(AVCConversionTest, ConvertConfigToAnnexB) { TEST_F(AVCConversionTest, StringConversionFunctions) { std::string str = "AUD SPS SPSExt SPS PPS SEI SEI R14 I P FILL EOSeq EOStr"; - std::vector<uint8> buf; + std::vector<uint8_t> buf; std::vector<SubsampleEntry> subsamples; StringToAnnexB(str, &buf, &subsamples); EXPECT_TRUE(AVC::IsValidAnnexB(buf, subsamples)); @@ -375,7 +374,7 @@ TEST_F(AVCConversionTest, ValidAnnexBConstructs) { }; for (size_t i = 0; i < arraysize(test_cases); ++i) { - std::vector<uint8> buf; + std::vector<uint8_t> buf; std::vector<SubsampleEntry> subsamples; StringToAnnexB(test_cases[i], &buf, NULL); EXPECT_TRUE(AVC::IsValidAnnexB(buf, subsamples)) << "'" << test_cases[i] @@ -400,7 +399,7 @@ TEST_F(AVCConversionTest, InvalidAnnexBConstructs) { }; for (size_t i = 0; i < arraysize(test_cases); ++i) { - std::vector<uint8> buf; + std::vector<uint8_t> buf; std::vector<SubsampleEntry> subsamples; StringToAnnexB(test_cases[i], &buf, NULL); EXPECT_FALSE(AVC::IsValidAnnexB(buf, subsamples)) << "'" << test_cases[i] @@ -441,7 +440,7 @@ TEST_F(AVCConversionTest, InsertParamSetsAnnexB) { avc_config.pps_list[0].push_back(0x78); for (size_t i = 0; i < arraysize(test_cases); ++i) { - std::vector<uint8> buf; + std::vector<uint8_t> buf; std::vector<SubsampleEntry> subsamples; StringToAnnexB(test_cases[i].input, &buf, &subsamples); diff --git a/media/formats/mp4/bitstream_converter.h b/media/formats/mp4/bitstream_converter.h index b5dfdf1..efd6356 100644 --- a/media/formats/mp4/bitstream_converter.h +++ b/media/formats/mp4/bitstream_converter.h @@ -7,7 +7,6 @@ #include <vector> -#include "base/basictypes.h" #include "base/memory/ref_counted.h" namespace media { @@ -32,9 +31,10 @@ class BitstreamConverter // of input frame are encrypted and should update |subsamples| if necessary, // to make sure it correctly describes the converted output frame. See // SubsampleEntry definition in media/base/decrypt_config.h for more info. - virtual bool ConvertFrame(std::vector<uint8>* frame_buf, + virtual bool ConvertFrame(std::vector<uint8_t>* frame_buf, bool is_keyframe, std::vector<SubsampleEntry>* subsamples) const = 0; + protected: friend class base::RefCountedThreadSafe<BitstreamConverter>; virtual ~BitstreamConverter(); diff --git a/media/formats/mp4/box_definitions.cc b/media/formats/mp4/box_definitions.cc index fc0250d..95e0b2f 100644 --- a/media/formats/mp4/box_definitions.cc +++ b/media/formats/mp4/box_definitions.cc @@ -101,12 +101,12 @@ bool SampleAuxiliaryInformationOffset::Parse(BoxReader* reader) { if (reader->flags() & 1) RCHECK(reader->SkipBytes(8)); - uint32 count; + uint32_t count; RCHECK(reader->Read4(&count) && reader->HasBytes(count * (reader->version() == 1 ? 8 : 4))); offsets.resize(count); - for (uint32 i = 0; i < count; i++) { + for (uint32_t i = 0; i < count; i++) { if (reader->version() == 1) { RCHECK(reader->Read8(&offsets[i])); } else { @@ -160,7 +160,7 @@ TrackEncryption::~TrackEncryption() {} FourCC TrackEncryption::BoxType() const { return FOURCC_TENC; } bool TrackEncryption::Parse(BoxReader* reader) { - uint8 flag; + uint8_t flag; RCHECK(reader->ReadFullBoxHeader() && reader->SkipBytes(2) && reader->Read1(&flag) && @@ -291,7 +291,7 @@ SampleDescription::~SampleDescription() {} FourCC SampleDescription::BoxType() const { return FOURCC_STSD; } bool SampleDescription::Parse(BoxReader* reader) { - uint32 count; + uint32_t count; RCHECK(reader->SkipBytes(4) && reader->Read4(&count)); video_entries.clear(); @@ -332,7 +332,7 @@ EditList::~EditList() {} FourCC EditList::BoxType() const { return FOURCC_ELST; } bool EditList::Parse(BoxReader* reader) { - uint32 count; + uint32_t count; RCHECK(reader->ReadFullBoxHeader() && reader->Read4(&count)); if (reader->version() == 1) { @@ -397,7 +397,7 @@ bool AVCDecoderConfigurationRecord::Parse(BoxReader* reader) { return ParseInternal(reader, reader->media_log()); } -bool AVCDecoderConfigurationRecord::Parse(const uint8* data, int data_size) { +bool AVCDecoderConfigurationRecord::Parse(const uint8_t* data, int data_size) { BufferReader reader(data, data_size); return ParseInternal(&reader, new MediaLog()); } @@ -410,19 +410,19 @@ bool AVCDecoderConfigurationRecord::ParseInternal( reader->Read1(&profile_compatibility) && reader->Read1(&avc_level)); - uint8 length_size_minus_one; + uint8_t length_size_minus_one; RCHECK(reader->Read1(&length_size_minus_one)); length_size = (length_size_minus_one & 0x3) + 1; RCHECK(length_size != 3); // Only values of 1, 2, and 4 are valid. - uint8 num_sps; + uint8_t num_sps; RCHECK(reader->Read1(&num_sps)); num_sps &= 0x1f; sps_list.resize(num_sps); for (int i = 0; i < num_sps; i++) { - uint16 sps_length; + uint16_t sps_length; RCHECK(reader->Read2(&sps_length) && reader->ReadVec(&sps_list[i], sps_length)); RCHECK(sps_list[i].size() > 4); @@ -435,12 +435,12 @@ bool AVCDecoderConfigurationRecord::ParseInternal( } } - uint8 num_pps; + uint8_t num_pps; RCHECK(reader->Read1(&num_pps)); pps_list.resize(num_pps); for (int i = 0; i < num_pps; i++) { - uint16 pps_length; + uint16_t pps_length; RCHECK(reader->Read2(&pps_length) && reader->ReadVec(&pps_list[i], pps_length)); } @@ -564,7 +564,7 @@ FourCC ElementaryStreamDescriptor::BoxType() const { } bool ElementaryStreamDescriptor::Parse(BoxReader* reader) { - std::vector<uint8> data; + std::vector<uint8_t> data; ESDescriptor es_desc; RCHECK(reader->ReadFullBoxHeader()); @@ -831,7 +831,7 @@ FourCC TrackFragmentRun::BoxType() const { return FOURCC_TRUN; } bool TrackFragmentRun::Parse(BoxReader* reader) { RCHECK(reader->ReadFullBoxHeader() && reader->Read4(&sample_count)); - const uint32 flags = reader->flags(); + const uint32_t flags = reader->flags(); bool data_offset_present = (flags & 0x1) != 0; bool first_sample_flags_present = (flags & 0x4) != 0; @@ -846,7 +846,7 @@ bool TrackFragmentRun::Parse(BoxReader* reader) { data_offset = 0; } - uint32 first_sample_flags = 0; + uint32_t first_sample_flags = 0; if (first_sample_flags_present) RCHECK(reader->Read4(&first_sample_flags)); @@ -863,7 +863,7 @@ bool TrackFragmentRun::Parse(BoxReader* reader) { if (sample_composition_time_offsets_present) sample_composition_time_offsets.resize(sample_count); - for (uint32 i = 0; i < sample_count; ++i) { + for (uint32_t i = 0; i < sample_count; ++i) { if (sample_duration_present) RCHECK(reader->Read4(&sample_durations[i])); if (sample_size_present) @@ -901,10 +901,10 @@ bool SampleToGroup::Parse(BoxReader* reader) { return true; } - uint32 count; + uint32_t count; RCHECK(reader->Read4(&count)); entries.resize(count); - for (uint32 i = 0; i < count; ++i) { + for (uint32_t i = 0; i < count; ++i) { RCHECK(reader->Read4(&entries[i].sample_count) && reader->Read4(&entries[i].group_description_index)); } @@ -929,29 +929,29 @@ bool SampleGroupDescription::Parse(BoxReader* reader) { return true; } - const uint8 version = reader->version(); + const uint8_t version = reader->version(); const size_t kKeyIdSize = 16; - const size_t kEntrySize = sizeof(uint32) + kKeyIdSize; - uint32 default_length = 0; + const size_t kEntrySize = sizeof(uint32_t) + kKeyIdSize; + uint32_t default_length = 0; if (version == 1) { RCHECK(reader->Read4(&default_length)); RCHECK(default_length == 0 || default_length >= kEntrySize); } - uint32 count; + uint32_t count; RCHECK(reader->Read4(&count)); entries.resize(count); - for (uint32 i = 0; i < count; ++i) { + for (uint32_t i = 0; i < count; ++i) { if (version == 1) { if (default_length == 0) { - uint32 description_length = 0; + uint32_t description_length = 0; RCHECK(reader->Read4(&description_length)); RCHECK(description_length >= kEntrySize); } } - uint8 flag; + uint8_t flag; RCHECK(reader->SkipBytes(2) && // reserved. reader->Read1(&flag) && reader->Read1(&entries[i].iv_size) && @@ -1024,7 +1024,7 @@ bool IndependentAndDisposableSamples::Parse(BoxReader* reader) { int sample_count = reader->size() - reader->pos(); sample_depends_on_.resize(sample_count); for (int i = 0; i < sample_count; ++i) { - uint8 sample_info; + uint8_t sample_info; RCHECK(reader->Read1(&sample_info)); sample_depends_on_[i] = diff --git a/media/formats/mp4/box_definitions.h b/media/formats/mp4/box_definitions.h index e1f1729..eed6581 100644 --- a/media/formats/mp4/box_definitions.h +++ b/media/formats/mp4/box_definitions.h @@ -8,7 +8,6 @@ #include <string> #include <vector> -#include "base/basictypes.h" #include "base/compiler_specific.h" #include "media/base/media_export.h" #include "media/base/media_log.h" @@ -42,7 +41,7 @@ struct MEDIA_EXPORT FileType : Box { DECLARE_BOX_METHODS(FileType); FourCC major_brand; - uint32 minor_version; + uint32_t minor_version; }; // If only copying the 'pssh' boxes, use ProtectionSystemSpecificHeader. @@ -51,29 +50,29 @@ struct MEDIA_EXPORT FileType : Box { struct MEDIA_EXPORT ProtectionSystemSpecificHeader : Box { DECLARE_BOX_METHODS(ProtectionSystemSpecificHeader); - std::vector<uint8> raw_box; + std::vector<uint8_t> raw_box; }; struct MEDIA_EXPORT FullProtectionSystemSpecificHeader : Box { DECLARE_BOX_METHODS(FullProtectionSystemSpecificHeader); - std::vector<uint8> system_id; - std::vector<std::vector<uint8>> key_ids; - std::vector<uint8> data; + std::vector<uint8_t> system_id; + std::vector<std::vector<uint8_t>> key_ids; + std::vector<uint8_t> data; }; struct MEDIA_EXPORT SampleAuxiliaryInformationOffset : Box { DECLARE_BOX_METHODS(SampleAuxiliaryInformationOffset); - std::vector<uint64> offsets; + std::vector<uint64_t> offsets; }; struct MEDIA_EXPORT SampleAuxiliaryInformationSize : Box { DECLARE_BOX_METHODS(SampleAuxiliaryInformationSize); - uint8 default_sample_info_size; - uint32 sample_count; - std::vector<uint8> sample_info_sizes; + uint8_t default_sample_info_size; + uint32_t sample_count; + std::vector<uint8_t> sample_info_sizes; }; struct MEDIA_EXPORT OriginalFormat : Box { @@ -86,7 +85,7 @@ struct MEDIA_EXPORT SchemeType : Box { DECLARE_BOX_METHODS(SchemeType); FourCC type; - uint32 version; + uint32_t version; }; struct MEDIA_EXPORT TrackEncryption : Box { @@ -94,8 +93,8 @@ struct MEDIA_EXPORT TrackEncryption : Box { // Note: this definition is specific to the CENC protection type. bool is_encrypted; - uint8 default_iv_size; - std::vector<uint8> default_kid; + uint8_t default_iv_size; + std::vector<uint8_t> default_kid; }; struct MEDIA_EXPORT SchemeInfo : Box { @@ -115,34 +114,34 @@ struct MEDIA_EXPORT ProtectionSchemeInfo : Box { struct MEDIA_EXPORT MovieHeader : Box { DECLARE_BOX_METHODS(MovieHeader); - uint64 creation_time; - uint64 modification_time; - uint32 timescale; - uint64 duration; - int32 rate; - int16 volume; - uint32 next_track_id; + uint64_t creation_time; + uint64_t modification_time; + uint32_t timescale; + uint64_t duration; + int32_t rate; + int16_t volume; + uint32_t next_track_id; }; struct MEDIA_EXPORT TrackHeader : Box { DECLARE_BOX_METHODS(TrackHeader); - uint64 creation_time; - uint64 modification_time; - uint32 track_id; - uint64 duration; - int16 layer; - int16 alternate_group; - int16 volume; - uint32 width; - uint32 height; + uint64_t creation_time; + uint64_t modification_time; + uint32_t track_id; + uint64_t duration; + int16_t layer; + int16_t alternate_group; + int16_t volume; + uint32_t width; + uint32_t height; }; struct MEDIA_EXPORT EditListEntry { - uint64 segment_duration; - int64 media_time; - int16 media_rate_integer; - int16 media_rate_fraction; + uint64_t segment_duration; + int64_t media_time; + int16_t media_rate_integer; + int16_t media_rate_fraction; }; struct MEDIA_EXPORT EditList : Box { @@ -171,16 +170,16 @@ struct MEDIA_EXPORT AVCDecoderConfigurationRecord : Box { // context and therefore the box header is not expected to be present // in |data|. // Returns true if |data| was successfully parsed. - bool Parse(const uint8* data, int data_size); + bool Parse(const uint8_t* data, int data_size); - uint8 version; - uint8 profile_indication; - uint8 profile_compatibility; - uint8 avc_level; - uint8 length_size; + uint8_t version; + uint8_t profile_indication; + uint8_t profile_compatibility; + uint8_t avc_level; + uint8_t length_size; - typedef std::vector<uint8> SPS; - typedef std::vector<uint8> PPS; + typedef std::vector<uint8_t> SPS; + typedef std::vector<uint8_t> PPS; std::vector<SPS> sps_list; std::vector<PPS> pps_list; @@ -193,17 +192,17 @@ struct MEDIA_EXPORT AVCDecoderConfigurationRecord : Box { struct MEDIA_EXPORT PixelAspectRatioBox : Box { DECLARE_BOX_METHODS(PixelAspectRatioBox); - uint32 h_spacing; - uint32 v_spacing; + uint32_t h_spacing; + uint32_t v_spacing; }; struct MEDIA_EXPORT VideoSampleEntry : Box { DECLARE_BOX_METHODS(VideoSampleEntry); FourCC format; - uint16 data_reference_index; - uint16 width; - uint16 height; + uint16_t data_reference_index; + uint16_t width; + uint16_t height; PixelAspectRatioBox pixel_aspect; ProtectionSchemeInfo sinf; @@ -219,7 +218,7 @@ struct MEDIA_EXPORT VideoSampleEntry : Box { struct MEDIA_EXPORT ElementaryStreamDescriptor : Box { DECLARE_BOX_METHODS(ElementaryStreamDescriptor); - uint8 object_type; + uint8_t object_type; AAC aac; }; @@ -227,10 +226,10 @@ struct MEDIA_EXPORT AudioSampleEntry : Box { DECLARE_BOX_METHODS(AudioSampleEntry); FourCC format; - uint16 data_reference_index; - uint16 channelcount; - uint16 samplesize; - uint32 samplerate; + uint16_t data_reference_index; + uint16_t channelcount; + uint16_t samplesize; + uint32_t samplerate; ProtectionSchemeInfo sinf; ElementaryStreamDescriptor esds; @@ -249,14 +248,14 @@ struct MEDIA_EXPORT CencSampleEncryptionInfoEntry { ~CencSampleEncryptionInfoEntry(); bool is_encrypted; - uint8 iv_size; - std::vector<uint8> key_id; + uint8_t iv_size; + std::vector<uint8_t> key_id; }; struct MEDIA_EXPORT SampleGroupDescription : Box { // 'sgpd'. DECLARE_BOX_METHODS(SampleGroupDescription); - uint32 grouping_type; + uint32_t grouping_type; std::vector<CencSampleEncryptionInfoEntry> entries; }; @@ -274,10 +273,10 @@ struct MEDIA_EXPORT SampleTable : Box { struct MEDIA_EXPORT MediaHeader : Box { DECLARE_BOX_METHODS(MediaHeader); - uint64 creation_time; - uint64 modification_time; - uint32 timescale; - uint64 duration; + uint64_t creation_time; + uint64_t modification_time; + uint32_t timescale; + uint64_t duration; }; struct MEDIA_EXPORT MediaInformation : Box { @@ -305,17 +304,17 @@ struct MEDIA_EXPORT Track : Box { struct MEDIA_EXPORT MovieExtendsHeader : Box { DECLARE_BOX_METHODS(MovieExtendsHeader); - uint64 fragment_duration; + uint64_t fragment_duration; }; struct MEDIA_EXPORT TrackExtends : Box { DECLARE_BOX_METHODS(TrackExtends); - uint32 track_id; - uint32 default_sample_description_index; - uint32 default_sample_duration; - uint32 default_sample_size; - uint32 default_sample_flags; + uint32_t track_id; + uint32_t default_sample_description_index; + uint32_t default_sample_duration; + uint32_t default_sample_size; + uint32_t default_sample_flags; }; struct MEDIA_EXPORT MovieExtends : Box { @@ -338,24 +337,24 @@ struct MEDIA_EXPORT Movie : Box { struct MEDIA_EXPORT TrackFragmentDecodeTime : Box { DECLARE_BOX_METHODS(TrackFragmentDecodeTime); - uint64 decode_time; + uint64_t decode_time; }; struct MEDIA_EXPORT MovieFragmentHeader : Box { DECLARE_BOX_METHODS(MovieFragmentHeader); - uint32 sequence_number; + uint32_t sequence_number; }; struct MEDIA_EXPORT TrackFragmentHeader : Box { DECLARE_BOX_METHODS(TrackFragmentHeader); - uint32 track_id; + uint32_t track_id; - uint32 sample_description_index; - uint32 default_sample_duration; - uint32 default_sample_size; - uint32 default_sample_flags; + uint32_t sample_description_index; + uint32_t default_sample_duration; + uint32_t default_sample_size; + uint32_t default_sample_flags; // As 'flags' might be all zero, we cannot use zeroness alone to identify // when default_sample_flags wasn't specified, unlike the other values. @@ -365,12 +364,12 @@ struct MEDIA_EXPORT TrackFragmentHeader : Box { struct MEDIA_EXPORT TrackFragmentRun : Box { DECLARE_BOX_METHODS(TrackFragmentRun); - uint32 sample_count; - uint32 data_offset; - std::vector<uint32> sample_flags; - std::vector<uint32> sample_sizes; - std::vector<uint32> sample_durations; - std::vector<int32> sample_composition_time_offsets; + uint32_t sample_count; + uint32_t data_offset; + std::vector<uint32_t> sample_flags; + std::vector<uint32_t> sample_sizes; + std::vector<uint32_t> sample_durations; + std::vector<int32_t> sample_composition_time_offsets; }; // sample_depends_on values in ISO/IEC 14496-12 Section 8.40.2.3. @@ -400,15 +399,15 @@ struct MEDIA_EXPORT SampleToGroupEntry { kFragmentGroupDescriptionIndexBase = 0x10000, }; - uint32 sample_count; - uint32 group_description_index; + uint32_t sample_count; + uint32_t group_description_index; }; struct MEDIA_EXPORT SampleToGroup : Box { // 'sbgp'. DECLARE_BOX_METHODS(SampleToGroup); - uint32 grouping_type; - uint32 grouping_type_parameter; // Version 1 only. + uint32_t grouping_type; + uint32_t grouping_type_parameter; // Version 1 only. std::vector<SampleToGroupEntry> entries; }; diff --git a/media/formats/mp4/box_reader_unittest.cc b/media/formats/mp4/box_reader_unittest.cc index 6f08763..fdcec61 100644 --- a/media/formats/mp4/box_reader_unittest.cc +++ b/media/formats/mp4/box_reader_unittest.cc @@ -4,7 +4,6 @@ #include <string.h> -#include "base/basictypes.h" #include "base/logging.h" #include "base/memory/scoped_ptr.h" #include "media/base/mock_media_log.h" @@ -20,21 +19,19 @@ using ::testing::StrictMock; namespace media { namespace mp4 { -static const uint8 kSkipBox[] = { - // Top-level test box containing three children - 0x00, 0x00, 0x00, 0x40, 's', 'k', 'i', 'p', - 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, - 0xf9, 0x0a, 0x0b, 0x0c, 0xfd, 0x0e, 0x0f, 0x10, - // Ordinary (8-byte header) child box - 0x00, 0x00, 0x00, 0x0c, 'p', 's', 's', 'h', 0xde, 0xad, 0xbe, 0xef, - // Extended-size header child box - 0x00, 0x00, 0x00, 0x01, 'p', 's', 's', 'h', - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, - 0xfa, 0xce, 0xca, 0xfe, - // Empty free box - 0x00, 0x00, 0x00, 0x08, 'f', 'r', 'e', 'e', - // Trailing garbage - 0x00 }; +static const uint8_t kSkipBox[] = { + // Top-level test box containing three children + 0x00, 0x00, 0x00, 0x40, 's', 'k', 'i', 'p', 0x01, 0x02, 0x03, 0x04, 0x05, + 0x06, 0x07, 0x08, 0xf9, 0x0a, 0x0b, 0x0c, 0xfd, 0x0e, 0x0f, 0x10, + // Ordinary (8-byte header) child box + 0x00, 0x00, 0x00, 0x0c, 'p', 's', 's', 'h', 0xde, 0xad, 0xbe, 0xef, + // Extended-size header child box + 0x00, 0x00, 0x00, 0x01, 'p', 's', 's', 'h', 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x14, 0xfa, 0xce, 0xca, 0xfe, + // Empty free box + 0x00, 0x00, 0x00, 0x08, 'f', 'r', 'e', 'e', + // Trailing garbage + 0x00}; struct FreeBox : Box { bool Parse(BoxReader* reader) override { @@ -44,7 +41,7 @@ struct FreeBox : Box { }; struct PsshBox : Box { - uint32 val; + uint32_t val; bool Parse(BoxReader* reader) override { return reader->Read4(&val); @@ -53,10 +50,10 @@ struct PsshBox : Box { }; struct SkipBox : Box { - uint8 a, b; - uint16 c; - int32 d; - int64 e; + uint8_t a, b; + uint16_t c; + int32_t d; + int64_t e; std::vector<PsshBox> kids; FreeBox mpty; @@ -86,12 +83,12 @@ class BoxReaderTest : public testing::Test { BoxReaderTest() : media_log_(new StrictMock<MockMediaLog>()) {} protected: - std::vector<uint8> GetBuf() { - return std::vector<uint8>(kSkipBox, kSkipBox + sizeof(kSkipBox)); + std::vector<uint8_t> GetBuf() { + return std::vector<uint8_t>(kSkipBox, kSkipBox + sizeof(kSkipBox)); } - void TestTopLevelBox(const uint8* data, int size, uint32 fourCC) { - std::vector<uint8> buf(data, data + size); + void TestTopLevelBox(const uint8_t* data, int size, uint32_t fourCC) { + std::vector<uint8_t> buf(data, data + size); bool err; scoped_ptr<BoxReader> reader( @@ -100,14 +97,14 @@ class BoxReaderTest : public testing::Test { EXPECT_FALSE(err); EXPECT_TRUE(reader); EXPECT_EQ(fourCC, reader->type()); - EXPECT_EQ(reader->size(), static_cast<uint64>(size)); + EXPECT_EQ(reader->size(), static_cast<uint64_t>(size)); } scoped_refptr<StrictMock<MockMediaLog>> media_log_; }; TEST_F(BoxReaderTest, ExpectedOperationTest) { - std::vector<uint8> buf = GetBuf(); + std::vector<uint8_t> buf = GetBuf(); bool err; scoped_ptr<BoxReader> reader( BoxReader::ReadTopLevelBox(&buf[0], buf.size(), media_log_, &err)); @@ -121,19 +118,19 @@ TEST_F(BoxReaderTest, ExpectedOperationTest) { EXPECT_EQ(0x05, box.a); EXPECT_EQ(0x06, box.b); EXPECT_EQ(0x0708, box.c); - EXPECT_EQ(static_cast<int32>(0xf90a0b0c), box.d); - EXPECT_EQ(static_cast<int32>(0xfd0e0f10), box.e); + EXPECT_EQ(static_cast<int32_t>(0xf90a0b0c), box.d); + EXPECT_EQ(static_cast<int32_t>(0xfd0e0f10), box.e); EXPECT_EQ(2u, box.kids.size()); EXPECT_EQ(0xdeadbeef, box.kids[0].val); EXPECT_EQ(0xfacecafe, box.kids[1].val); // Accounting for the extra byte outside of the box above - EXPECT_EQ(buf.size(), static_cast<uint64>(reader->size() + 1)); + EXPECT_EQ(buf.size(), static_cast<uint64_t>(reader->size() + 1)); } TEST_F(BoxReaderTest, OuterTooShortTest) { - std::vector<uint8> buf = GetBuf(); + std::vector<uint8_t> buf = GetBuf(); bool err; // Create a soft failure by truncating the outer box. @@ -145,7 +142,7 @@ TEST_F(BoxReaderTest, OuterTooShortTest) { } TEST_F(BoxReaderTest, InnerTooLongTest) { - std::vector<uint8> buf = GetBuf(); + std::vector<uint8_t> buf = GetBuf(); bool err; // Make an inner box too big for its outer box. @@ -158,7 +155,7 @@ TEST_F(BoxReaderTest, InnerTooLongTest) { } TEST_F(BoxReaderTest, WrongFourCCTest) { - std::vector<uint8> buf = GetBuf(); + std::vector<uint8_t> buf = GetBuf(); bool err; // Set an unrecognized top-level FourCC. @@ -173,7 +170,7 @@ TEST_F(BoxReaderTest, WrongFourCCTest) { } TEST_F(BoxReaderTest, ScanChildrenTest) { - std::vector<uint8> buf = GetBuf(); + std::vector<uint8_t> buf = GetBuf(); bool err; scoped_ptr<BoxReader> reader( BoxReader::ReadTopLevelBox(&buf[0], buf.size(), media_log_, &err)); @@ -195,7 +192,7 @@ TEST_F(BoxReaderTest, ScanChildrenTest) { } TEST_F(BoxReaderTest, ReadAllChildrenTest) { - std::vector<uint8> buf = GetBuf(); + std::vector<uint8_t> buf = GetBuf(); // Modify buffer to exclude its last 'free' box buf[3] = 0x38; bool err; @@ -209,36 +206,35 @@ TEST_F(BoxReaderTest, ReadAllChildrenTest) { } TEST_F(BoxReaderTest, SkippingBloc) { - static const uint8 kData[] = { - 0x00, 0x00, 0x00, 0x09, 'b', 'l', 'o', 'c', 0x00 - }; + static const uint8_t kData[] = {0x00, 0x00, 0x00, 0x09, 'b', + 'l', 'o', 'c', 0x00}; TestTopLevelBox(kData, sizeof(kData), FOURCC_BLOC); } TEST_F(BoxReaderTest, SkippingEmsg) { - static const uint8 kData[] = { - 0x00, 0x00, 0x00, 0x24, 'e', 'm', 's', 'g', - 0x00, // version = 0 - 0x00, 0x00, 0x00, // flags = 0 - 0x61, 0x00, // scheme_id_uri = "a" - 0x61, 0x00, // value = "a" - 0x00, 0x00, 0x00, 0x01, // timescale = 1 - 0x00, 0x00, 0x00, 0x02, // presentation_time_delta = 2 - 0x00, 0x00, 0x00, 0x03, // event_duration = 3 - 0x00, 0x00, 0x00, 0x04, // id = 4 - 0x05, 0x06, 0x07, 0x08, // message_data[4] = 0x05060708 + static const uint8_t kData[] = { + 0x00, 0x00, 0x00, 0x24, 'e', 'm', 's', 'g', + 0x00, // version = 0 + 0x00, 0x00, 0x00, // flags = 0 + 0x61, 0x00, // scheme_id_uri = "a" + 0x61, 0x00, // value = "a" + 0x00, 0x00, 0x00, 0x01, // timescale = 1 + 0x00, 0x00, 0x00, 0x02, // presentation_time_delta = 2 + 0x00, 0x00, 0x00, 0x03, // event_duration = 3 + 0x00, 0x00, 0x00, 0x04, // id = 4 + 0x05, 0x06, 0x07, 0x08, // message_data[4] = 0x05060708 }; TestTopLevelBox(kData, sizeof(kData), FOURCC_EMSG); } TEST_F(BoxReaderTest, SkippingUuid) { - static const uint8 kData[] = { - 0x00, 0x00, 0x00, 0x19, 'u', 'u', 'i', 'd', - 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, - 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, // usertype - 0x00, + static const uint8_t kData[] = { + 0x00, 0x00, 0x00, 0x19, 'u', 'u', 'i', 'd', + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, + 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, // usertype + 0x00, }; TestTopLevelBox(kData, sizeof(kData), FOURCC_UUID); @@ -251,7 +247,7 @@ TEST_F(BoxReaderTest, NestedBoxWithHugeSize) { // The nested box ('junk') has a large size that was chosen to catch // integer overflows. The nested box should not specify more than the // number of remaining bytes in the enclosing box. - static const uint8 kData[] = { + static const uint8_t kData[] = { 0x00, 0x00, 0x00, 0x24, 'e', 'm', 's', 'g', // outer box 0x7f, 0xff, 0xff, 0xff, 'j', 'u', 'n', 'k', // nested box 0x00, 0x01, 0x00, 0xff, 0xff, 0x00, 0x3b, 0x03, // random data for rest @@ -274,9 +270,9 @@ TEST_F(BoxReaderTest, ScanChildrenWithInvalidChild) { // The sample specifies a large number of EditListEntry's, but only 1 is // actually included in the box. This test verifies that the code checks // properly that the buffer contains the specified number of EditListEntry's - // (does not cause an int32 overflow when checking that the bytes are + // (does not cause an int32_t overflow when checking that the bytes are // available, and does not read past the end of the buffer). - static const uint8 kData[] = { + static const uint8_t kData[] = { 0x00, 0x00, 0x00, 0x2c, 'e', 'm', 's', 'g', // outer box 0x00, 0x00, 0x00, 0x24, 'e', 'l', 's', 't', // nested box 0x01, 0x00, 0x00, 0x00, // version = 1, flags = 0 @@ -305,9 +301,9 @@ TEST_F(BoxReaderTest, ReadAllChildrenWithInvalidChild) { // The nested 'trun' box is used as it includes a count of the number // of samples. The data specifies a large number of samples, but only 1 // is actually included in the box. Verifying that the large count does not - // cause an int32 overflow which would allow parsing of TrackFragmentRun + // cause an int32_t overflow which would allow parsing of TrackFragmentRun // to read past the end of the buffer. - static const uint8 kData[] = { + static const uint8_t kData[] = { 0x00, 0x00, 0x00, 0x28, 'e', 'm', 's', 'g', // outer box 0x00, 0x00, 0x00, 0x20, 't', 'r', 'u', 'n', // nested box 0x00, 0x00, 0x0f, 0x00, // version = 0, flags = samples present diff --git a/media/formats/mp4/cenc.cc b/media/formats/mp4/cenc.cc index 001b6d8..3a7b592 100644 --- a/media/formats/mp4/cenc.cc +++ b/media/formats/mp4/cenc.cc @@ -26,14 +26,14 @@ bool FrameCENCInfo::Parse(int iv_size, BufferReader* reader) { if (!reader->HasBytes(1)) return true; - uint16 subsample_count; + uint16_t subsample_count; RCHECK(reader->Read2(&subsample_count) && reader->HasBytes(subsample_count * kEntrySize)); subsamples.resize(subsample_count); for (int i = 0; i < subsample_count; i++) { - uint16 clear_bytes; - uint32 cypher_bytes; + uint16_t clear_bytes; + uint32_t cypher_bytes; RCHECK(reader->Read2(&clear_bytes) && reader->Read4(&cypher_bytes)); subsamples[i].clear_bytes = clear_bytes; diff --git a/media/formats/mp4/cenc.h b/media/formats/mp4/cenc.h index 9eb3358..44670f3 100644 --- a/media/formats/mp4/cenc.h +++ b/media/formats/mp4/cenc.h @@ -7,7 +7,6 @@ #include <vector> -#include "base/basictypes.h" #include "media/base/decrypt_config.h" namespace media { @@ -16,7 +15,7 @@ namespace mp4 { class BufferReader; struct FrameCENCInfo { - uint8 iv[16]; + uint8_t iv[16]; std::vector<SubsampleEntry> subsamples; FrameCENCInfo(); diff --git a/media/formats/mp4/es_descriptor.cc b/media/formats/mp4/es_descriptor.cc index e1da28a..3377c8c 100644 --- a/media/formats/mp4/es_descriptor.cc +++ b/media/formats/mp4/es_descriptor.cc @@ -9,9 +9,9 @@ // The elementary stream size is specific by up to 4 bytes. // The MSB of a byte indicates if there are more bytes for the size. -static bool ReadESSize(media::BitReader* reader, uint32* size) { - uint8 msb; - uint8 byte; +static bool ReadESSize(media::BitReader* reader, uint32_t* size) { + uint8_t msb; + uint8_t byte; *size = 0; @@ -32,7 +32,7 @@ namespace media { namespace mp4 { // static -bool ESDescriptor::IsAAC(uint8 object_type) { +bool ESDescriptor::IsAAC(uint8_t object_type) { return object_type == kISO_14496_3 || object_type == kISO_13818_7_AAC_LC; } @@ -42,14 +42,14 @@ ESDescriptor::ESDescriptor() ESDescriptor::~ESDescriptor() {} -bool ESDescriptor::Parse(const std::vector<uint8>& data) { +bool ESDescriptor::Parse(const std::vector<uint8_t>& data) { BitReader reader(&data[0], data.size()); - uint8 tag; - uint32 size; - uint8 stream_dependency_flag; - uint8 url_flag; - uint8 ocr_stream_flag; - uint16 dummy; + uint8_t tag; + uint32_t size; + uint8_t stream_dependency_flag; + uint8_t url_flag; + uint8_t ocr_stream_flag; + uint16_t dummy; RCHECK(reader.ReadBits(8, &tag)); RCHECK(tag == kESDescrTag); @@ -72,18 +72,18 @@ bool ESDescriptor::Parse(const std::vector<uint8>& data) { return true; } -uint8 ESDescriptor::object_type() const { +uint8_t ESDescriptor::object_type() const { return object_type_; } -const std::vector<uint8>& ESDescriptor::decoder_specific_info() const { +const std::vector<uint8_t>& ESDescriptor::decoder_specific_info() const { return decoder_specific_info_; } bool ESDescriptor::ParseDecoderConfigDescriptor(BitReader* reader) { - uint8 tag; - uint32 size; - uint64 dummy; + uint8_t tag; + uint32_t size; + uint64_t dummy; RCHECK(reader->ReadBits(8, &tag)); RCHECK(tag == kDecoderConfigDescrTag); @@ -98,15 +98,15 @@ bool ESDescriptor::ParseDecoderConfigDescriptor(BitReader* reader) { } bool ESDescriptor::ParseDecoderSpecificInfo(BitReader* reader) { - uint8 tag; - uint32 size; + uint8_t tag; + uint32_t size; RCHECK(reader->ReadBits(8, &tag)); RCHECK(tag == kDecoderSpecificInfoTag); RCHECK(ReadESSize(reader, &size)); decoder_specific_info_.resize(size); - for (uint32 i = 0; i < size; ++i) + for (uint32_t i = 0; i < size; ++i) RCHECK(reader->ReadBits(8, &decoder_specific_info_[i])); return true; diff --git a/media/formats/mp4/es_descriptor.h b/media/formats/mp4/es_descriptor.h index 1df4526..26ca86d 100644 --- a/media/formats/mp4/es_descriptor.h +++ b/media/formats/mp4/es_descriptor.h @@ -5,9 +5,10 @@ #ifndef MEDIA_FORMATS_MP4_ES_DESCRIPTOR_H_ #define MEDIA_FORMATS_MP4_ES_DESCRIPTOR_H_ +#include <stdint.h> + #include <vector> -#include "base/basictypes.h" #include "media/base/media_export.h" namespace media { @@ -30,15 +31,15 @@ enum ObjectType { class MEDIA_EXPORT ESDescriptor { public: // Utility function to check if the given object type is AAC. - static bool IsAAC(uint8 object_type); + static bool IsAAC(uint8_t object_type); ESDescriptor(); ~ESDescriptor(); - bool Parse(const std::vector<uint8>& data); + bool Parse(const std::vector<uint8_t>& data); - uint8 object_type() const; - const std::vector<uint8>& decoder_specific_info() const; + uint8_t object_type() const; + const std::vector<uint8_t>& decoder_specific_info() const; private: enum Tag { @@ -50,8 +51,8 @@ class MEDIA_EXPORT ESDescriptor { bool ParseDecoderConfigDescriptor(BitReader* reader); bool ParseDecoderSpecificInfo(BitReader* reader); - uint8 object_type_; - std::vector<uint8> decoder_specific_info_; + uint8_t object_type_; + std::vector<uint8_t> decoder_specific_info_; }; } // namespace mp4 diff --git a/media/formats/mp4/es_descriptor_unittest.cc b/media/formats/mp4/es_descriptor_unittest.cc index 6334f5b..4a0262b 100644 --- a/media/formats/mp4/es_descriptor_unittest.cc +++ b/media/formats/mp4/es_descriptor_unittest.cc @@ -12,13 +12,10 @@ namespace mp4 { TEST(ESDescriptorTest, SingleByteLengthTest) { ESDescriptor es_desc; - uint8 buffer[] = { - 0x03, 0x19, 0x00, 0x01, 0x00, 0x04, 0x11, 0x40, - 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x05, 0x02, 0x12, 0x10, - 0x06, 0x01, 0x02 - }; - std::vector<uint8> data; + uint8_t buffer[] = {0x03, 0x19, 0x00, 0x01, 0x00, 0x04, 0x11, 0x40, 0x15, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x05, 0x02, 0x12, 0x10, 0x06, 0x01, 0x02}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); @@ -32,13 +29,10 @@ TEST(ESDescriptorTest, SingleByteLengthTest) { TEST(ESDescriptorTest, NonAACTest) { ESDescriptor es_desc; - uint8 buffer[] = { - 0x03, 0x19, 0x00, 0x01, 0x00, 0x04, 0x11, 0x66, - 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x05, 0x02, 0x12, 0x10, - 0x06, 0x01, 0x02 - }; - std::vector<uint8> data; + uint8_t buffer[] = {0x03, 0x19, 0x00, 0x01, 0x00, 0x04, 0x11, 0x66, 0x15, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x05, 0x02, 0x12, 0x10, 0x06, 0x01, 0x02}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); @@ -51,14 +45,11 @@ TEST(ESDescriptorTest, NonAACTest) { TEST(ESDescriptorTest, MultiByteLengthTest) { ESDescriptor es_desc; - uint8 buffer[] = { - 0x03, 0x80, 0x19, 0x00, 0x01, 0x00, 0x04, 0x80, - 0x80, 0x11, 0x40, 0x15, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, - 0x80, 0x80, 0x80, 0x02, 0x12, 0x10, 0x06, 0x01, - 0x02 - }; - std::vector<uint8> data; + uint8_t buffer[] = {0x03, 0x80, 0x19, 0x00, 0x01, 0x00, 0x04, 0x80, 0x80, + 0x11, 0x40, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x80, 0x80, 0x80, + 0x02, 0x12, 0x10, 0x06, 0x01, 0x02}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); @@ -71,14 +62,11 @@ TEST(ESDescriptorTest, MultiByteLengthTest) { TEST(ESDescriptorTest, FiveByteLengthTest) { ESDescriptor es_desc; - uint8 buffer[] = { - 0x03, 0x80, 0x19, 0x00, 0x01, 0x00, 0x04, 0x80, - 0x80, 0x11, 0x40, 0x15, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, - 0x80, 0x80, 0x80, 0x80, 0x02, 0x12, 0x10, 0x06, - 0x01, 0x02 - }; - std::vector<uint8> data; + uint8_t buffer[] = {0x03, 0x80, 0x19, 0x00, 0x01, 0x00, 0x04, 0x80, 0x80, + 0x11, 0x40, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x80, 0x80, 0x80, + 0x80, 0x02, 0x12, 0x10, 0x06, 0x01, 0x02}; + std::vector<uint8_t> data; data.assign(buffer, buffer + sizeof(buffer)); diff --git a/media/formats/mp4/hevc.cc b/media/formats/mp4/hevc.cc index 4d6b53e..ff964b0 100644 --- a/media/formats/mp4/hevc.cc +++ b/media/formats/mp4/hevc.cc @@ -44,7 +44,7 @@ bool HEVCDecoderConfigurationRecord::Parse(BoxReader* reader) { return ParseInternal(reader, reader->media_log()); } -bool HEVCDecoderConfigurationRecord::Parse(const uint8* data, int data_size) { +bool HEVCDecoderConfigurationRecord::Parse(const uint8_t* data, int data_size) { BufferReader reader(data, data_size); return ParseInternal(&reader, new MediaLog()); } @@ -57,10 +57,10 @@ HEVCDecoderConfigurationRecord::HVCCNALArray::~HVCCNALArray() {} bool HEVCDecoderConfigurationRecord::ParseInternal( BufferReader* reader, const scoped_refptr<MediaLog>& media_log) { - uint8 profile_indication = 0; - uint32 general_constraint_indicator_flags_hi = 0; - uint16 general_constraint_indicator_flags_lo = 0; - uint8 misc = 0; + uint8_t profile_indication = 0; + uint32_t general_constraint_indicator_flags_hi = 0; + uint16_t general_constraint_indicator_flags_lo = 0; + uint8_t misc = 0; RCHECK(reader->Read1(&configurationVersion) && configurationVersion == 1 && reader->Read1(&profile_indication) && reader->Read4(&general_profile_compatibility_flags) && @@ -97,13 +97,13 @@ bool HEVCDecoderConfigurationRecord::ParseInternal( DVLOG(2) << __FUNCTION__ << " numOfArrays=" << (int)numOfArrays; arrays.resize(numOfArrays); - for (uint32 j = 0; j < numOfArrays; j++) { + for (uint32_t j = 0; j < numOfArrays; j++) { RCHECK(reader->Read1(&arrays[j].first_byte)); - uint16 numNalus = 0; + uint16_t numNalus = 0; RCHECK(reader->Read2(&numNalus)); arrays[j].units.resize(numNalus); - for (uint32 i = 0; i < numNalus; ++i) { - uint16 naluLength = 0; + for (uint32_t i = 0; i < numNalus; ++i) { + uint16_t naluLength = 0; RCHECK(reader->Read2(&naluLength) && reader->ReadVec(&arrays[j].units[i], naluLength)); DVLOG(4) << __FUNCTION__ << " naluType=" @@ -119,24 +119,24 @@ bool HEVCDecoderConfigurationRecord::ParseInternal( return true; } -static const uint8 kAnnexBStartCode[] = {0, 0, 0, 1}; +static const uint8_t kAnnexBStartCode[] = {0, 0, 0, 1}; static const int kAnnexBStartCodeSize = 4; bool HEVC::InsertParamSetsAnnexB( const HEVCDecoderConfigurationRecord& hevc_config, - std::vector<uint8>* buffer, + std::vector<uint8_t>* buffer, std::vector<SubsampleEntry>* subsamples) { DCHECK(HEVC::IsValidAnnexB(*buffer, *subsamples)); scoped_ptr<H265Parser> parser(new H265Parser()); - const uint8* start = &(*buffer)[0]; + const uint8_t* start = &(*buffer)[0]; parser->SetEncryptedStream(start, buffer->size(), *subsamples); H265NALU nalu; if (parser->AdvanceToNextNALU(&nalu) != H265Parser::kOk) return false; - std::vector<uint8>::iterator config_insert_point = buffer->begin(); + std::vector<uint8_t>::iterator config_insert_point = buffer->begin(); if (nalu.nal_unit_type == H265NALU::AUD_NUT) { // Move insert point to just after the AUD. @@ -148,7 +148,7 @@ bool HEVC::InsertParamSetsAnnexB( parser.reset(); start = NULL; - std::vector<uint8> param_sets; + std::vector<uint8_t> param_sets; RCHECK(HEVC::ConvertConfigToAnnexB(hevc_config, ¶m_sets)); DVLOG(4) << __FUNCTION__ << " converted hvcC to AnnexB " << " size=" << param_sets.size() << " inserted at " @@ -170,12 +170,12 @@ bool HEVC::InsertParamSetsAnnexB( bool HEVC::ConvertConfigToAnnexB( const HEVCDecoderConfigurationRecord& hevc_config, - std::vector<uint8>* buffer) { + std::vector<uint8_t>* buffer) { DCHECK(buffer->empty()); buffer->clear(); for (size_t j = 0; j < hevc_config.arrays.size(); j++) { - uint8 naluType = hevc_config.arrays[j].first_byte & 0x3f; + uint8_t naluType = hevc_config.arrays[j].first_byte & 0x3f; for (size_t i = 0; i < hevc_config.arrays[j].units.size(); ++i) { DVLOG(3) << __FUNCTION__ << " naluType=" << (int)naluType << " size=" << hevc_config.arrays[j].units[i].size(); @@ -190,12 +190,13 @@ bool HEVC::ConvertConfigToAnnexB( } // Verifies AnnexB NALU order according to section 7.4.2.4.4 of ISO/IEC 23008-2. -bool HEVC::IsValidAnnexB(const std::vector<uint8>& buffer, +bool HEVC::IsValidAnnexB(const std::vector<uint8_t>& buffer, const std::vector<SubsampleEntry>& subsamples) { return IsValidAnnexB(&buffer[0], buffer.size(), subsamples); } -bool HEVC::IsValidAnnexB(const uint8* buffer, size_t size, +bool HEVC::IsValidAnnexB(const uint8_t* buffer, + size_t size, const std::vector<SubsampleEntry>& subsamples) { DCHECK(buffer); @@ -216,7 +217,7 @@ HEVCBitstreamConverter::~HEVCBitstreamConverter() { } bool HEVCBitstreamConverter::ConvertFrame( - std::vector<uint8>* frame_buf, + std::vector<uint8_t>* frame_buf, bool is_keyframe, std::vector<SubsampleEntry>* subsamples) const { RCHECK(AVC::ConvertFrameToAnnexB(hevc_config_->lengthSizeMinusOne + 1, diff --git a/media/formats/mp4/hevc.h b/media/formats/mp4/hevc.h index 06974c0d..bb53e01 100644 --- a/media/formats/mp4/hevc.h +++ b/media/formats/mp4/hevc.h @@ -7,7 +7,6 @@ #include <vector> -#include "base/basictypes.h" #include "base/memory/scoped_ptr.h" #include "media/base/media_export.h" #include "media/formats/mp4/bitstream_converter.h" @@ -27,32 +26,32 @@ struct MEDIA_EXPORT HEVCDecoderConfigurationRecord : Box { // context and therefore the box header is not expected to be present // in |data|. // Returns true if |data| was successfully parsed. - bool Parse(const uint8* data, int data_size); - - uint8 configurationVersion; - uint8 general_profile_space; - uint8 general_tier_flag; - uint8 general_profile_idc; - uint32 general_profile_compatibility_flags; - uint64 general_constraint_indicator_flags; - uint8 general_level_idc; - uint16 min_spatial_segmentation_idc; - uint8 parallelismType; - uint8 chromaFormat; - uint8 bitDepthLumaMinus8; - uint8 bitDepthChromaMinus8; - uint16 avgFrameRate; - uint8 constantFrameRate; - uint8 numTemporalLayers; - uint8 temporalIdNested; - uint8 lengthSizeMinusOne; - uint8 numOfArrays; - - typedef std::vector<uint8> HVCCNALUnit; + bool Parse(const uint8_t* data, int data_size); + + uint8_t configurationVersion; + uint8_t general_profile_space; + uint8_t general_tier_flag; + uint8_t general_profile_idc; + uint32_t general_profile_compatibility_flags; + uint64_t general_constraint_indicator_flags; + uint8_t general_level_idc; + uint16_t min_spatial_segmentation_idc; + uint8_t parallelismType; + uint8_t chromaFormat; + uint8_t bitDepthLumaMinus8; + uint8_t bitDepthChromaMinus8; + uint16_t avgFrameRate; + uint8_t constantFrameRate; + uint8_t numTemporalLayers; + uint8_t temporalIdNested; + uint8_t lengthSizeMinusOne; + uint8_t numOfArrays; + + typedef std::vector<uint8_t> HVCCNALUnit; struct HVCCNALArray { HVCCNALArray(); ~HVCCNALArray(); - uint8 first_byte; + uint8_t first_byte; std::vector<HVCCNALUnit> units; }; std::vector<HVCCNALArray> arrays; @@ -66,11 +65,11 @@ class MEDIA_EXPORT HEVC { public: static bool ConvertConfigToAnnexB( const HEVCDecoderConfigurationRecord& hevc_config, - std::vector<uint8>* buffer); + std::vector<uint8_t>* buffer); static bool InsertParamSetsAnnexB( const HEVCDecoderConfigurationRecord& hevc_config, - std::vector<uint8>* buffer, + std::vector<uint8_t>* buffer, std::vector<SubsampleEntry>* subsamples); // Verifies that the contents of |buffer| conform to @@ -80,9 +79,10 @@ class MEDIA_EXPORT HEVC { // Returns true if |buffer| contains conformant Annex B data // TODO(servolk): Remove the std::vector version when we can use, // C++11's std::vector<T>::data() method. - static bool IsValidAnnexB(const std::vector<uint8>& buffer, + static bool IsValidAnnexB(const std::vector<uint8_t>& buffer, const std::vector<SubsampleEntry>& subsamples); - static bool IsValidAnnexB(const uint8* buffer, size_t size, + static bool IsValidAnnexB(const uint8_t* buffer, + size_t size, const std::vector<SubsampleEntry>& subsamples); }; @@ -92,9 +92,10 @@ class HEVCBitstreamConverter : public BitstreamConverter { scoped_ptr<HEVCDecoderConfigurationRecord> hevc_config); // BitstreamConverter interface - bool ConvertFrame(std::vector<uint8>* frame_buf, + bool ConvertFrame(std::vector<uint8_t>* frame_buf, bool is_keyframe, std::vector<SubsampleEntry>* subsamples) const override; + private: ~HEVCBitstreamConverter() override; scoped_ptr<HEVCDecoderConfigurationRecord> hevc_config_; diff --git a/media/formats/mp4/mp4_stream_parser_unittest.cc b/media/formats/mp4/mp4_stream_parser_unittest.cc index 60e4165..9d3d169 100644 --- a/media/formats/mp4/mp4_stream_parser_unittest.cc +++ b/media/formats/mp4/mp4_stream_parser_unittest.cc @@ -62,13 +62,15 @@ class MP4StreamParserTest : public testing::Test { VideoDecoderConfig video_decoder_config_; DecodeTimestamp lower_bound_; - bool AppendData(const uint8* data, size_t length) { + bool AppendData(const uint8_t* 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; + bool AppendDataInPieces(const uint8_t* data, + size_t length, + size_t piece_size) { + const uint8_t* start = data; + const uint8_t* end = data + length; while (start < end) { size_t append_size = std::min(piece_size, static_cast<size_t>(end - start)); @@ -140,7 +142,7 @@ class MP4StreamParserTest : public testing::Test { return true; } - void KeyNeededF(EmeInitDataType type, const std::vector<uint8>& init_data) { + void KeyNeededF(EmeInitDataType type, const std::vector<uint8_t>& init_data) { DVLOG(1) << "KeyNeededF: " << init_data.size(); EXPECT_EQ(EmeInitDataType::CENC, type); EXPECT_FALSE(init_data.empty()); diff --git a/media/formats/mp4/sample_to_group_iterator.h b/media/formats/mp4/sample_to_group_iterator.h index c2ea60f..9ed6945 100644 --- a/media/formats/mp4/sample_to_group_iterator.h +++ b/media/formats/mp4/sample_to_group_iterator.h @@ -30,13 +30,13 @@ class MEDIA_EXPORT SampleToGroupIterator { bool IsValid() const; // Returns group description index for current sample. - uint32 group_description_index() const { + uint32_t group_description_index() const { return iterator_->group_description_index; } private: // Track how many samples remaining for current table entry. - uint32 remaining_samples_; + uint32_t remaining_samples_; const std::vector<SampleToGroupEntry>& sample_to_group_table_; std::vector<SampleToGroupEntry>::const_iterator iterator_; diff --git a/media/formats/mp4/sample_to_group_iterator_unittest.cc b/media/formats/mp4/sample_to_group_iterator_unittest.cc index 3e8148c..d4486f7 100644 --- a/media/formats/mp4/sample_to_group_iterator_unittest.cc +++ b/media/formats/mp4/sample_to_group_iterator_unittest.cc @@ -20,7 +20,8 @@ class SampleToGroupIteratorTest : public testing::Test { SampleToGroupIteratorTest() { // Build sample group description index table from kSampleToGroupTable. for (size_t i = 0; i < arraysize(kCompactSampleToGroupTable); ++i) { - for (uint32 j = 0; j < kCompactSampleToGroupTable[i].sample_count; ++j) { + for (uint32_t j = 0; j < kCompactSampleToGroupTable[i].sample_count; + ++j) { sample_to_group_table_.push_back( kCompactSampleToGroupTable[i].group_description_index); } @@ -34,7 +35,7 @@ class SampleToGroupIteratorTest : public testing::Test { } protected: - std::vector<uint32> sample_to_group_table_; + std::vector<uint32_t> sample_to_group_table_; SampleToGroup sample_to_group_; scoped_ptr<SampleToGroupIterator> sample_to_group_iterator_; @@ -51,7 +52,7 @@ TEST_F(SampleToGroupIteratorTest, EmptyTable) { TEST_F(SampleToGroupIteratorTest, Advance) { ASSERT_EQ(sample_to_group_table_[0], sample_to_group_iterator_->group_description_index()); - for (uint32 sample = 1; sample < sample_to_group_table_.size(); ++sample) { + for (uint32_t sample = 1; sample < sample_to_group_table_.size(); ++sample) { ASSERT_TRUE(sample_to_group_iterator_->Advance()); ASSERT_EQ(sample_to_group_table_[sample], sample_to_group_iterator_->group_description_index()); diff --git a/media/formats/mp4/track_run_iterator_unittest.cc b/media/formats/mp4/track_run_iterator_unittest.cc index e220f91..9221cc4 100644 --- a/media/formats/mp4/track_run_iterator_unittest.cc +++ b/media/formats/mp4/track_run_iterator_unittest.cc @@ -2,7 +2,6 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "base/basictypes.h" #include "base/logging.h" #include "base/memory/scoped_ptr.h" #include "base/strings/string_split.h" @@ -22,33 +21,27 @@ static const int kSumAscending1 = 45; static const int kAudioScale = 48000; static const int kVideoScale = 25; -static const uint8 kAuxInfo[] = { - 0x41, 0x54, 0x65, 0x73, 0x74, 0x49, 0x76, 0x31, - 0x41, 0x54, 0x65, 0x73, 0x74, 0x49, 0x76, 0x32, - 0x00, 0x02, - 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, - 0x00, 0x03, 0x00, 0x00, 0x00, 0x04 -}; +static const uint8_t kAuxInfo[] = { + 0x41, 0x54, 0x65, 0x73, 0x74, 0x49, 0x76, 0x31, 0x41, 0x54, + 0x65, 0x73, 0x74, 0x49, 0x76, 0x32, 0x00, 0x02, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04}; static const char kIv1[] = { 0x41, 0x54, 0x65, 0x73, 0x74, 0x49, 0x76, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; -static const uint8 kKeyId[] = { - 0x41, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x54, - 0x65, 0x73, 0x74, 0x4b, 0x65, 0x79, 0x49, 0x44 -}; +static const uint8_t kKeyId[] = {0x41, 0x47, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x54, 0x65, 0x73, 0x74, 0x4b, + 0x65, 0x79, 0x49, 0x44}; -static const uint8 kTrackCencSampleGroupKeyId[] = { - 0x46, 0x72, 0x61, 0x67, 0x53, 0x61, 0x6d, 0x70, - 0x6c, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b -}; +static const uint8_t kTrackCencSampleGroupKeyId[] = { + 0x46, 0x72, 0x61, 0x67, 0x53, 0x61, 0x6d, 0x70, + 0x6c, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x4b}; -static const uint8 kFragmentCencSampleGroupKeyId[] = { - 0x6b, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x43, 0x65, 0x6e, 0x63, 0x53, 0x61, 0x6d -}; +static const uint8_t kFragmentCencSampleGroupKeyId[] = { + 0x6b, 0x46, 0x72, 0x61, 0x67, 0x6d, 0x65, 0x6e, + 0x74, 0x43, 0x65, 0x6e, 0x63, 0x53, 0x61, 0x6d}; namespace media { namespace mp4 { @@ -99,7 +92,7 @@ class TrackRunIteratorTest : public testing::Test { moov_.tracks[2].media.information.sample_table.description.type = kHint; } - uint32 ToSampleFlags(const std::string& str) { + uint32_t ToSampleFlags(const std::string& str) { CHECK_EQ(str.length(), 2u); SampleDependsOn sample_depends_on = kSampleDependsOnReserved; @@ -135,7 +128,7 @@ class TrackRunIteratorTest : public testing::Test { << str[1] << "'"; break; } - uint32 flags = static_cast<uint32>(sample_depends_on) << 24; + uint32_t flags = static_cast<uint32_t>(sample_depends_on) << 24; if (is_non_sync_sample) flags |= kSampleIsNonSyncSample; return flags; @@ -272,19 +265,19 @@ class TrackRunIteratorTest : public testing::Test { bool InitMoofWithArbitraryAuxInfo(MovieFragment* moof) { // Add aux info header (equal sized aux info for every sample). - for (uint32 i = 0; i < moof->tracks.size(); ++i) { + for (uint32_t i = 0; i < moof->tracks.size(); ++i) { moof->tracks[i].auxiliary_offset.offsets.push_back(50); moof->tracks[i].auxiliary_size.sample_count = 10; moof->tracks[i].auxiliary_size.default_sample_info_size = 8; } // We don't care about the actual data in aux. - std::vector<uint8> aux_info(1000); + std::vector<uint8_t> aux_info(1000); return iter_->Init(*moof) && iter_->CacheAuxInfo(&aux_info[0], aux_info.size()); } - void SetAscending(std::vector<uint32>* vec) { + void SetAscending(std::vector<uint32_t>* vec) { vec->resize(10); for (size_t i = 0; i < vec->size(); i++) (*vec)[i] = i+1; @@ -335,7 +328,7 @@ TEST_F(TrackRunIteratorTest, BasicOperationTest) { EXPECT_EQ(iter_->track_id(), 2u); EXPECT_EQ(iter_->sample_offset(), 200 + kSumAscending1); EXPECT_EQ(iter_->sample_size(), 10); - int64 base_dts = kSumAscending1 + moof.tracks[1].decode_time.decode_time; + int64_t base_dts = kSumAscending1 + moof.tracks[1].decode_time.decode_time; EXPECT_EQ(iter_->dts(), DecodeTimestampFromRational(base_dts, kVideoScale)); EXPECT_EQ(iter_->duration(), TimeDeltaFromRational(10, kVideoScale)); EXPECT_FALSE(iter_->is_keyframe()); @@ -438,8 +431,8 @@ TEST_F(TrackRunIteratorTest, ReorderingTest) { // maximum compatibility, these values are biased up to [2, 5, 0], and the // extra 80ms is removed via the edit list. MovieFragment moof = CreateFragment(); - std::vector<int32>& cts_offsets = - moof.tracks[1].runs[0].sample_composition_time_offsets; + std::vector<int32_t>& cts_offsets = + moof.tracks[1].runs[0].sample_composition_time_offsets; cts_offsets.resize(10); cts_offsets[0] = 2; cts_offsets[1] = 5; @@ -487,7 +480,7 @@ TEST_F(TrackRunIteratorTest, DecryptConfigTest) { EXPECT_EQ(iter_->track_id(), 2u); EXPECT_TRUE(iter_->is_encrypted()); EXPECT_TRUE(iter_->AuxInfoNeedsToBeCached()); - EXPECT_EQ(static_cast<uint32>(iter_->aux_info_size()), arraysize(kAuxInfo)); + EXPECT_EQ(static_cast<uint32_t>(iter_->aux_info_size()), arraysize(kAuxInfo)); EXPECT_EQ(iter_->aux_info_offset(), 50); EXPECT_EQ(iter_->GetMaxClearOffset(), 50); EXPECT_FALSE(iter_->CacheAuxInfo(NULL, 0)); diff --git a/media/formats/mpeg/adts_stream_parser.cc b/media/formats/mpeg/adts_stream_parser.cc index a59d9ba..90b3689c 100644 --- a/media/formats/mpeg/adts_stream_parser.cc +++ b/media/formats/mpeg/adts_stream_parser.cc @@ -8,14 +8,14 @@ namespace media { -static const uint32 kADTSStartCodeMask = 0xfff00000; +static const uint32_t kADTSStartCodeMask = 0xfff00000; ADTSStreamParser::ADTSStreamParser() : MPEGAudioStreamParserBase(kADTSStartCodeMask, kCodecAAC, 0) {} ADTSStreamParser::~ADTSStreamParser() {} -int ADTSStreamParser::ParseFrameHeader(const uint8* data, +int ADTSStreamParser::ParseFrameHeader(const uint8_t* data, int size, int* frame_size, int* sample_rate, diff --git a/media/formats/mpeg/adts_stream_parser.h b/media/formats/mpeg/adts_stream_parser.h index d08351b..a8ecdbb 100644 --- a/media/formats/mpeg/adts_stream_parser.h +++ b/media/formats/mpeg/adts_stream_parser.h @@ -5,7 +5,6 @@ #ifndef MEDIA_FORMATS_MPEG_ADTS_STREAM_PARSER_H_ #define MEDIA_FORMATS_MPEG_ADTS_STREAM_PARSER_H_ -#include "base/basictypes.h" #include "media/base/media_export.h" #include "media/formats/mpeg/mpeg_audio_stream_parser_base.h" @@ -18,7 +17,7 @@ class MEDIA_EXPORT ADTSStreamParser : public MPEGAudioStreamParserBase { private: // MPEGAudioStreamParserBase overrides. - int ParseFrameHeader(const uint8* data, + int ParseFrameHeader(const uint8_t* data, int size, int* frame_size, int* sample_rate, diff --git a/media/formats/mpeg/mpeg1_audio_stream_parser.cc b/media/formats/mpeg/mpeg1_audio_stream_parser.cc index 67b3705..410c70d 100644 --- a/media/formats/mpeg/mpeg1_audio_stream_parser.cc +++ b/media/formats/mpeg/mpeg1_audio_stream_parser.cc @@ -6,7 +6,7 @@ namespace media { -static const uint32 kMPEG1StartCodeMask = 0xffe00000; +static const uint32_t kMPEG1StartCodeMask = 0xffe00000; // Map that determines which bitrate_index & channel_mode combinations // are allowed. @@ -88,7 +88,7 @@ static const int kCodecDelay = 529; // static bool MPEG1AudioStreamParser::ParseHeader( const scoped_refptr<MediaLog>& media_log, - const uint8* data, + const uint8_t* data, Header* header) { BitReader reader(data, kHeaderSize); int sync; @@ -221,7 +221,7 @@ MPEG1AudioStreamParser::MPEG1AudioStreamParser() MPEG1AudioStreamParser::~MPEG1AudioStreamParser() {} -int MPEG1AudioStreamParser::ParseFrameHeader(const uint8* data, +int MPEG1AudioStreamParser::ParseFrameHeader(const uint8_t* data, int size, int* frame_size, int* sample_rate, diff --git a/media/formats/mpeg/mpeg1_audio_stream_parser.h b/media/formats/mpeg/mpeg1_audio_stream_parser.h index 3b299a1..de9b138 100644 --- a/media/formats/mpeg/mpeg1_audio_stream_parser.h +++ b/media/formats/mpeg/mpeg1_audio_stream_parser.h @@ -5,7 +5,6 @@ #ifndef MEDIA_FORMATS_MPEG_MPEG1_AUDIO_STREAM_PARSER_H_ #define MEDIA_FORMATS_MPEG_MPEG1_AUDIO_STREAM_PARSER_H_ -#include "base/basictypes.h" #include "media/base/media_export.h" #include "media/formats/mpeg/mpeg_audio_stream_parser_base.h" @@ -63,7 +62,7 @@ class MEDIA_EXPORT MPEG1AudioStreamParser : public MPEGAudioStreamParserBase { // Assumption: size of array |data| should be at least |kHeaderSize|. // Returns false if the header is not valid. static bool ParseHeader(const scoped_refptr<MediaLog>& media_log, - const uint8* data, + const uint8_t* data, Header* header); MPEG1AudioStreamParser(); @@ -71,7 +70,7 @@ class MEDIA_EXPORT MPEG1AudioStreamParser : public MPEGAudioStreamParserBase { private: // MPEGAudioStreamParserBase overrides. - int ParseFrameHeader(const uint8* data, + int ParseFrameHeader(const uint8_t* data, int size, int* frame_size, int* sample_rate, diff --git a/media/formats/mpeg/mpeg_audio_stream_parser_base.cc b/media/formats/mpeg/mpeg_audio_stream_parser_base.cc index 23032fa..4dc9df7 100644 --- a/media/formats/mpeg/mpeg_audio_stream_parser_base.cc +++ b/media/formats/mpeg/mpeg_audio_stream_parser_base.cc @@ -14,17 +14,17 @@ namespace media { -static const uint32 kICYStartCode = 0x49435920; // 'ICY ' +static const uint32_t kICYStartCode = 0x49435920; // 'ICY ' // Arbitrary upper bound on the size of an IceCast header before it // triggers an error. static const int kMaxIcecastHeaderSize = 4096; -static const uint32 kID3StartCodeMask = 0xffffff00; -static const uint32 kID3v1StartCode = 0x54414700; // 'TAG\0' +static const uint32_t kID3StartCodeMask = 0xffffff00; +static const uint32_t kID3v1StartCode = 0x54414700; // 'TAG\0' static const int kID3v1Size = 128; static const int kID3v1ExtendedSize = 227; -static const uint32 kID3v2StartCode = 0x49443300; // 'ID3\0' +static const uint32_t kID3v2StartCode = 0x49443300; // 'ID3\0' static int LocateEndOfHeaders(const uint8_t* buf, int buf_len, int i) { bool was_lf = false; @@ -43,7 +43,7 @@ static int LocateEndOfHeaders(const uint8_t* buf, int buf_len, int i) { return -1; } -MPEGAudioStreamParserBase::MPEGAudioStreamParserBase(uint32 start_code_mask, +MPEGAudioStreamParserBase::MPEGAudioStreamParserBase(uint32_t start_code_mask, AudioCodec audio_codec, int codec_delay) : state_(UNINITIALIZED), @@ -84,7 +84,7 @@ void MPEGAudioStreamParserBase::Flush() { in_media_segment_ = false; } -bool MPEGAudioStreamParserBase::Parse(const uint8* buf, int size) { +bool MPEGAudioStreamParserBase::Parse(const uint8_t* buf, int size) { DVLOG(1) << __FUNCTION__ << "(" << size << ")"; DCHECK(buf); DCHECK_GT(size, 0); @@ -100,14 +100,15 @@ bool MPEGAudioStreamParserBase::Parse(const uint8* buf, int size) { bool end_of_segment = true; BufferQueue buffers; for (;;) { - const uint8* data; + const uint8_t* data; int data_size; queue_.Peek(&data, &data_size); if (data_size < 4) break; - uint32 start_code = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; + uint32_t start_code = + data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; int bytes_read = 0; bool parsed_metadata = true; if ((start_code & start_code_mask_) == start_code_mask_) { @@ -161,7 +162,7 @@ void MPEGAudioStreamParserBase::ChangeState(State state) { state_ = state; } -int MPEGAudioStreamParserBase::ParseFrame(const uint8* data, +int MPEGAudioStreamParserBase::ParseFrame(const uint8_t* data, int size, BufferQueue* buffers) { DVLOG(2) << __FUNCTION__ << "(" << size << ")"; @@ -248,7 +249,8 @@ int MPEGAudioStreamParserBase::ParseFrame(const uint8* data, return frame_size; } -int MPEGAudioStreamParserBase::ParseIcecastHeader(const uint8* data, int size) { +int MPEGAudioStreamParserBase::ParseIcecastHeader(const uint8_t* data, + int size) { DVLOG(1) << __FUNCTION__ << "(" << size << ")"; if (size < 4) @@ -271,7 +273,7 @@ int MPEGAudioStreamParserBase::ParseIcecastHeader(const uint8* data, int size) { return offset; } -int MPEGAudioStreamParserBase::ParseID3v1(const uint8* data, int size) { +int MPEGAudioStreamParserBase::ParseID3v1(const uint8_t* data, int size) { DVLOG(1) << __FUNCTION__ << "(" << size << ")"; if (size < kID3v1Size) @@ -282,17 +284,17 @@ int MPEGAudioStreamParserBase::ParseID3v1(const uint8* data, int size) { return !memcmp(data, "TAG+", 4) ? kID3v1ExtendedSize : kID3v1Size; } -int MPEGAudioStreamParserBase::ParseID3v2(const uint8* data, int size) { +int MPEGAudioStreamParserBase::ParseID3v2(const uint8_t* data, int size) { DVLOG(1) << __FUNCTION__ << "(" << size << ")"; if (size < 10) return 0; BitReader reader(data, size); - int32 id; + int32_t id; int version; - uint8 flags; - int32 id3_size; + uint8_t flags; + int32_t id3_size; if (!reader.ReadBits(24, &id) || !reader.ReadBits(16, &version) || @@ -301,7 +303,7 @@ int MPEGAudioStreamParserBase::ParseID3v2(const uint8* data, int size) { return -1; } - int32 actual_tag_size = 10 + id3_size; + int32_t actual_tag_size = 10 + id3_size; // Increment size if 'Footer present' flag is set. if (flags & 0x10) @@ -317,10 +319,10 @@ int MPEGAudioStreamParserBase::ParseID3v2(const uint8* data, int size) { } bool MPEGAudioStreamParserBase::ParseSyncSafeInt(BitReader* reader, - int32* value) { + int32_t* value) { *value = 0; for (int i = 0; i < 4; ++i) { - uint8 tmp; + uint8_t tmp; if (!reader->ReadBits(1, &tmp) || tmp != 0) { MEDIA_LOG(ERROR, media_log_) << "ID3 syncsafe integer byte MSb is not 0!"; return false; @@ -336,21 +338,21 @@ bool MPEGAudioStreamParserBase::ParseSyncSafeInt(BitReader* reader, return true; } -int MPEGAudioStreamParserBase::FindNextValidStartCode(const uint8* data, +int MPEGAudioStreamParserBase::FindNextValidStartCode(const uint8_t* data, int size) const { - const uint8* start = data; - const uint8* end = data + size; + const uint8_t* start = data; + const uint8_t* end = data + size; while (start < end) { int bytes_left = end - start; - const uint8* candidate_start_code = - static_cast<const uint8*>(memchr(start, 0xff, bytes_left)); + const uint8_t* candidate_start_code = + static_cast<const uint8_t*>(memchr(start, 0xff, bytes_left)); if (!candidate_start_code) return 0; bool parse_header_failed = false; - const uint8* sync = candidate_start_code; + const uint8_t* sync = candidate_start_code; // Try to find 3 valid frames in a row. 3 was selected to decrease // the probability of false positives. for (int i = 0; i < 3; ++i) { diff --git a/media/formats/mpeg/mpeg_audio_stream_parser_base.h b/media/formats/mpeg/mpeg_audio_stream_parser_base.h index 8321993..4c81c8f 100644 --- a/media/formats/mpeg/mpeg_audio_stream_parser_base.h +++ b/media/formats/mpeg/mpeg_audio_stream_parser_base.h @@ -8,7 +8,6 @@ #include <set> #include <vector> -#include "base/basictypes.h" #include "base/callback.h" #include "media/base/audio_decoder_config.h" #include "media/base/audio_timestamp_helper.h" @@ -25,7 +24,7 @@ class MEDIA_EXPORT MPEGAudioStreamParserBase : public StreamParser { // referred to as the sync code in the MP3 and ADTS header specifications. // |codec_delay| is the number of samples the decoder will output before the // first real frame. - MPEGAudioStreamParserBase(uint32 start_code_mask, + MPEGAudioStreamParserBase(uint32_t start_code_mask, AudioCodec audio_codec, int codec_delay); ~MPEGAudioStreamParserBase() override; @@ -40,7 +39,7 @@ class MEDIA_EXPORT MPEGAudioStreamParserBase : public StreamParser { const base::Closure& end_of_segment_cb, const scoped_refptr<MediaLog>& media_log) override; void Flush() override; - bool Parse(const uint8* buf, int size) override; + bool Parse(const uint8_t* buf, int size) override; protected: // Subclasses implement this method to parse format specific frame headers. @@ -73,7 +72,7 @@ class MEDIA_EXPORT MPEGAudioStreamParserBase : public StreamParser { // > 0 : The number of bytes parsed. // 0 : If more data is needed to parse the entire frame header. // < 0 : An error was encountered during parsing. - virtual int ParseFrameHeader(const uint8* data, + virtual int ParseFrameHeader(const uint8_t* data, int size, int* frame_size, int* sample_rate, @@ -99,10 +98,10 @@ class MEDIA_EXPORT MPEGAudioStreamParserBase : public StreamParser { // > 0 : The number of bytes parsed. // 0 : If more data is needed to parse the entire element. // < 0 : An error was encountered during parsing. - int ParseFrame(const uint8* data, int size, BufferQueue* buffers); - int ParseIcecastHeader(const uint8* data, int size); - int ParseID3v1(const uint8* data, int size); - int ParseID3v2(const uint8* data, int size); + int ParseFrame(const uint8_t* data, int size, BufferQueue* buffers); + int ParseIcecastHeader(const uint8_t* data, int size); + int ParseID3v1(const uint8_t* data, int size); + int ParseID3v2(const uint8_t* data, int size); // Parses an ID3v2 "sync safe" integer. // |reader| - A BitReader to read from. @@ -112,7 +111,7 @@ class MEDIA_EXPORT MPEGAudioStreamParserBase : public StreamParser { // was set. // Returns false if an error was encountered. The state of |value| is // undefined when false is returned. - bool ParseSyncSafeInt(BitReader* reader, int32* value); + bool ParseSyncSafeInt(BitReader* reader, int32_t* value); // Scans |data| for the next valid start code. // Returns: @@ -120,7 +119,7 @@ class MEDIA_EXPORT MPEGAudioStreamParserBase : public StreamParser { // next start code.. // 0 : If a valid start code was not found and more data is needed. // < 0 : An error was encountered during parsing. - int FindNextValidStartCode(const uint8* data, int size) const; + int FindNextValidStartCode(const uint8_t* data, int size) const; // Sends the buffers in |buffers| to |new_buffers_cb_| and then clears // |buffers|. @@ -144,7 +143,7 @@ class MEDIA_EXPORT MPEGAudioStreamParserBase : public StreamParser { AudioDecoderConfig config_; scoped_ptr<AudioTimestampHelper> timestamp_helper_; bool in_media_segment_; - const uint32 start_code_mask_; + const uint32_t start_code_mask_; const AudioCodec audio_codec_; const int codec_delay_; diff --git a/media/formats/webm/cluster_builder.cc b/media/formats/webm/cluster_builder.cc index 1a3b358..b28b03b 100644 --- a/media/formats/webm/cluster_builder.cc +++ b/media/formats/webm/cluster_builder.cc @@ -10,34 +10,34 @@ namespace media { -static const uint8 kClusterHeader[] = { - 0x1F, 0x43, 0xB6, 0x75, // CLUSTER ID - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // cluster(size = 0) - 0xE7, // Timecode ID - 0x88, // timecode(size=8) - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // timecode value +static const uint8_t kClusterHeader[] = { + 0x1F, 0x43, 0xB6, 0x75, // CLUSTER ID + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // cluster(size = 0) + 0xE7, // Timecode ID + 0x88, // timecode(size=8) + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // timecode value }; -static const uint8 kSimpleBlockHeader[] = { - 0xA3, // SimpleBlock ID - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SimpleBlock(size = 0) +static const uint8_t kSimpleBlockHeader[] = { + 0xA3, // SimpleBlock ID + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // SimpleBlock(size = 0) }; -static const uint8 kBlockGroupHeader[] = { - 0xA0, // BlockGroup ID - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // BlockGroup(size = 0) - 0x9B, // BlockDuration ID - 0x88, // BlockDuration(size = 8) - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // duration - 0xA1, // Block ID - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Block(size = 0) +static const uint8_t kBlockGroupHeader[] = { + 0xA0, // BlockGroup ID + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // BlockGroup(size = 0) + 0x9B, // BlockDuration ID + 0x88, // BlockDuration(size = 8) + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // duration + 0xA1, // Block ID + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Block(size = 0) }; -static const uint8 kBlockGroupHeaderWithoutBlockDuration[] = { - 0xA0, // BlockGroup ID - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // BlockGroup(size = 0) - 0xA1, // Block ID - 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Block(size = 0) +static const uint8_t kBlockGroupHeaderWithoutBlockDuration[] = { + 0xA0, // BlockGroup ID + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // BlockGroup(size = 0) + 0xA1, // Block ID + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Block(size = 0) }; enum { @@ -54,34 +54,37 @@ enum { kInitialBufferSize = 32768, }; -Cluster::Cluster(scoped_ptr<uint8[]> data, int size) +Cluster::Cluster(scoped_ptr<uint8_t[]> data, int size) : data_(data.Pass()), size_(size) {} Cluster::~Cluster() {} ClusterBuilder::ClusterBuilder() { Reset(); } ClusterBuilder::~ClusterBuilder() {} -void ClusterBuilder::SetClusterTimecode(int64 cluster_timecode) { +void ClusterBuilder::SetClusterTimecode(int64_t cluster_timecode) { DCHECK_EQ(cluster_timecode_, -1); cluster_timecode_ = cluster_timecode; // Write the timecode into the header. - uint8* buf = buffer_.get() + kClusterTimecodeOffset; + uint8_t* buf = buffer_.get() + kClusterTimecodeOffset; for (int i = 7; i >= 0; --i) { buf[i] = cluster_timecode & 0xff; cluster_timecode >>= 8; } } -void ClusterBuilder::AddSimpleBlock(int track_num, int64 timecode, int flags, - const uint8* data, int size) { +void ClusterBuilder::AddSimpleBlock(int track_num, + int64_t timecode, + int flags, + const uint8_t* data, + int size) { int block_size = size + 4; int bytes_needed = sizeof(kSimpleBlockHeader) + block_size; if (bytes_needed > (buffer_size_ - bytes_used_)) ExtendBuffer(bytes_needed); - uint8* buf = buffer_.get() + bytes_used_; + uint8_t* buf = buffer_.get() + bytes_used_; int block_offset = bytes_used_; memcpy(buf, kSimpleBlockHeader, sizeof(kSimpleBlockHeader)); UpdateUInt64(block_offset + kSimpleBlockSizeOffset, block_size); @@ -92,24 +95,30 @@ void ClusterBuilder::AddSimpleBlock(int track_num, int64 timecode, int flags, bytes_used_ += bytes_needed; } -void ClusterBuilder::AddBlockGroup(int track_num, int64 timecode, int duration, - int flags, const uint8* data, int size) { +void ClusterBuilder::AddBlockGroup(int track_num, + int64_t timecode, + int duration, + int flags, + const uint8_t* data, + int size) { AddBlockGroupInternal(track_num, timecode, true, duration, flags, data, size); } void ClusterBuilder::AddBlockGroupWithoutBlockDuration(int track_num, - int64 timecode, + int64_t timecode, int flags, - const uint8* data, + const uint8_t* data, int size) { AddBlockGroupInternal(track_num, timecode, false, 0, flags, data, size); } - -void ClusterBuilder::AddBlockGroupInternal(int track_num, int64 timecode, +void ClusterBuilder::AddBlockGroupInternal(int track_num, + int64_t timecode, bool include_block_duration, - int duration, int flags, - const uint8* data, int size) { + int duration, + int flags, + const uint8_t* data, + int size) { int block_size = size + 4; int bytes_needed = block_size; if (include_block_duration) { @@ -123,7 +132,7 @@ void ClusterBuilder::AddBlockGroupInternal(int track_num, int64 timecode, if (bytes_needed > (buffer_size_ - bytes_used_)) ExtendBuffer(bytes_needed); - uint8* buf = buffer_.get() + bytes_used_; + uint8_t* buf = buffer_.get() + bytes_used_; int block_group_offset = bytes_used_; if (include_block_duration) { memcpy(buf, kBlockGroupHeader, sizeof(kBlockGroupHeader)); @@ -150,8 +159,12 @@ void ClusterBuilder::AddBlockGroupInternal(int track_num, int64 timecode, bytes_used_ += bytes_needed; } -void ClusterBuilder::WriteBlock(uint8* buf, int track_num, int64 timecode, - int flags, const uint8* data, int size) { +void ClusterBuilder::WriteBlock(uint8_t* buf, + int track_num, + int64_t timecode, + int flags, + const uint8_t* data, + int size) { DCHECK_GE(track_num, 0); DCHECK_LE(track_num, 126); DCHECK_GE(flags, 0); @@ -160,7 +173,7 @@ void ClusterBuilder::WriteBlock(uint8* buf, int track_num, int64 timecode, DCHECK_GT(size, 0); DCHECK_NE(cluster_timecode_, -1); - int64 timecode_delta = timecode - cluster_timecode_; + int64_t timecode_delta = timecode - cluster_timecode_; DCHECK_GE(timecode_delta, -32768); DCHECK_LE(timecode_delta, 32767); @@ -193,7 +206,7 @@ scoped_ptr<Cluster> ClusterBuilder::FinishWithUnknownSize() { void ClusterBuilder::Reset() { buffer_size_ = kInitialBufferSize; - buffer_.reset(new uint8[buffer_size_]); + buffer_.reset(new uint8_t[buffer_size_]); memcpy(buffer_.get(), kClusterHeader, sizeof(kClusterHeader)); bytes_used_ = sizeof(kClusterHeader); cluster_timecode_ = -1; @@ -205,16 +218,16 @@ void ClusterBuilder::ExtendBuffer(int bytes_needed) { while ((new_buffer_size - bytes_used_) < bytes_needed) new_buffer_size *= 2; - scoped_ptr<uint8[]> new_buffer(new uint8[new_buffer_size]); + scoped_ptr<uint8_t[]> new_buffer(new uint8_t[new_buffer_size]); memcpy(new_buffer.get(), buffer_.get(), bytes_used_); buffer_.reset(new_buffer.release()); buffer_size_ = new_buffer_size; } -void ClusterBuilder::UpdateUInt64(int offset, int64 value) { +void ClusterBuilder::UpdateUInt64(int offset, int64_t value) { DCHECK_LE(offset + 7, buffer_size_); - uint8* buf = buffer_.get() + offset; + uint8_t* buf = buffer_.get() + offset; // Fill the last 7 bytes of size field in big-endian order. for (int i = 7; i > 0; i--) { diff --git a/media/formats/webm/cluster_builder.h b/media/formats/webm/cluster_builder.h index f6f6001..6e32ccc 100644 --- a/media/formats/webm/cluster_builder.h +++ b/media/formats/webm/cluster_builder.h @@ -5,21 +5,20 @@ #ifndef MEDIA_FORMATS_WEBM_CLUSTER_BUILDER_H_ #define MEDIA_FORMATS_WEBM_CLUSTER_BUILDER_H_ -#include "base/basictypes.h" #include "base/memory/scoped_ptr.h" namespace media { class Cluster { public: - Cluster(scoped_ptr<uint8[]> data, int size); + Cluster(scoped_ptr<uint8_t[]> data, int size); ~Cluster(); - const uint8* data() const { return data_.get(); } + const uint8_t* data() const { return data_.get(); } int size() const { return size_; } private: - scoped_ptr<uint8[]> data_; + scoped_ptr<uint8_t[]> data_; int size_; DISALLOW_IMPLICIT_CONSTRUCTORS(Cluster); @@ -30,31 +29,49 @@ class ClusterBuilder { ClusterBuilder(); ~ClusterBuilder(); - void SetClusterTimecode(int64 cluster_timecode); - void AddSimpleBlock(int track_num, int64 timecode, int flags, - const uint8* data, int size); - void AddBlockGroup(int track_num, int64 timecode, int duration, int flags, - const uint8* data, int size); - void AddBlockGroupWithoutBlockDuration(int track_num, int64 timecode, - int flags, const uint8* data, int size); + void SetClusterTimecode(int64_t cluster_timecode); + void AddSimpleBlock(int track_num, + int64_t timecode, + int flags, + const uint8_t* data, + int size); + void AddBlockGroup(int track_num, + int64_t timecode, + int duration, + int flags, + const uint8_t* data, + int size); + void AddBlockGroupWithoutBlockDuration(int track_num, + int64_t timecode, + int flags, + const uint8_t* data, + int size); scoped_ptr<Cluster> Finish(); scoped_ptr<Cluster> FinishWithUnknownSize(); private: - void AddBlockGroupInternal(int track_num, int64 timecode, - bool include_block_duration, int duration, - int flags, const uint8* data, int size); + void AddBlockGroupInternal(int track_num, + int64_t timecode, + bool include_block_duration, + int duration, + int flags, + const uint8_t* data, + int size); void Reset(); void ExtendBuffer(int bytes_needed); - void UpdateUInt64(int offset, int64 value); - void WriteBlock(uint8* buf, int track_num, int64 timecode, int flags, - const uint8* data, int size); + void UpdateUInt64(int offset, int64_t value); + void WriteBlock(uint8_t* buf, + int track_num, + int64_t timecode, + int flags, + const uint8_t* data, + int size); - scoped_ptr<uint8[]> buffer_; + scoped_ptr<uint8_t[]> buffer_; int buffer_size_; int bytes_used_; - int64 cluster_timecode_; + int64_t cluster_timecode_; DISALLOW_COPY_AND_ASSIGN(ClusterBuilder); }; diff --git a/media/formats/webm/tracks_builder.cc b/media/formats/webm/tracks_builder.cc index 927c2a4..6b2aaea 100644 --- a/media/formats/webm/tracks_builder.cc +++ b/media/formats/webm/tracks_builder.cc @@ -10,7 +10,7 @@ namespace media { // Returns size of an integer, formatted using Matroska serialization. -static int GetUIntMkvSize(uint64 value) { +static int GetUIntMkvSize(uint64_t value) { if (value < 0x07FULL) return 1; if (value < 0x03FFFULL) @@ -29,7 +29,7 @@ static int GetUIntMkvSize(uint64 value) { } // Returns the minimium size required to serialize an integer value. -static int GetUIntSize(uint64 value) { +static int GetUIntSize(uint64_t value) { if (value < 0x0100ULL) return 1; if (value < 0x010000ULL) @@ -51,7 +51,7 @@ static int MasterElementSize(int element_id, int payload_size) { return GetUIntSize(element_id) + GetUIntMkvSize(payload_size) + payload_size; } -static int UIntElementSize(int element_id, uint64 value) { +static int UIntElementSize(int element_id, uint64_t value) { return GetUIntSize(element_id) + 1 + GetUIntSize(value); } @@ -65,23 +65,26 @@ static int StringElementSize(int element_id, const std::string& value) { value.length(); } -static void SerializeInt(uint8** buf_ptr, int* buf_size_ptr, - int64 value, int size) { - uint8*& buf = *buf_ptr; +static void SerializeInt(uint8_t** buf_ptr, + int* buf_size_ptr, + int64_t value, + int size) { + uint8_t*& buf = *buf_ptr; int& buf_size = *buf_size_ptr; for (int idx = 1; idx <= size; ++idx) { - *buf++ = static_cast<uint8>(value >> ((size - idx) * 8)); + *buf++ = static_cast<uint8_t>(value >> ((size - idx) * 8)); --buf_size; } } -static void SerializeDouble(uint8** buf_ptr, int* buf_size_ptr, +static void SerializeDouble(uint8_t** buf_ptr, + int* buf_size_ptr, double value) { // Use a union to convert |value| to native endian integer bit pattern. union { double src; - int64 dst; + int64_t dst; } tmp; tmp.src = value; @@ -89,26 +92,28 @@ static void SerializeDouble(uint8** buf_ptr, int* buf_size_ptr, SerializeInt(buf_ptr, buf_size_ptr, tmp.dst, 8); } -static void WriteElementId(uint8** buf, int* buf_size, int element_id) { +static void WriteElementId(uint8_t** buf, int* buf_size, int element_id) { SerializeInt(buf, buf_size, element_id, GetUIntSize(element_id)); } -static void WriteUInt(uint8** buf, int* buf_size, uint64 value) { +static void WriteUInt(uint8_t** buf, int* buf_size, uint64_t value) { const int size = GetUIntMkvSize(value); value |= (1ULL << (size * 7)); // Matroska formatting SerializeInt(buf, buf_size, value, size); } -static void WriteMasterElement(uint8** buf, int* buf_size, - int element_id, int payload_size) { +static void WriteMasterElement(uint8_t** buf, + int* buf_size, + int element_id, + int payload_size) { WriteElementId(buf, buf_size, element_id); WriteUInt(buf, buf_size, payload_size); } -static void WriteUIntElement(uint8** buf, +static void WriteUIntElement(uint8_t** buf, int* buf_size, int element_id, - uint64 value) { + uint64_t value) { WriteElementId(buf, buf_size, element_id); const int size = GetUIntSize(value); @@ -117,21 +122,25 @@ static void WriteUIntElement(uint8** buf, SerializeInt(buf, buf_size, value, size); } -static void WriteDoubleElement(uint8** buf, int* buf_size, - int element_id, double value) { +static void WriteDoubleElement(uint8_t** buf, + int* buf_size, + int element_id, + double value) { WriteElementId(buf, buf_size, element_id); WriteUInt(buf, buf_size, 8); SerializeDouble(buf, buf_size, value); } -static void WriteStringElement(uint8** buf_ptr, int* buf_size_ptr, - int element_id, const std::string& value) { - uint8*& buf = *buf_ptr; +static void WriteStringElement(uint8_t** buf_ptr, + int* buf_size_ptr, + int element_id, + const std::string& value) { + uint8_t*& buf = *buf_ptr; int& buf_size = *buf_size_ptr; WriteElementId(&buf, &buf_size, element_id); - const uint64 size = value.length(); + const uint64_t size = value.length(); WriteUInt(&buf, &buf_size, size); memcpy(buf, value.data(), size); @@ -146,7 +155,7 @@ TracksBuilder::TracksBuilder() TracksBuilder::~TracksBuilder() {} void TracksBuilder::AddVideoTrack(int track_num, - uint64 track_uid, + uint64_t track_uid, const std::string& codec_id, const std::string& name, const std::string& language, @@ -159,7 +168,7 @@ void TracksBuilder::AddVideoTrack(int track_num, } void TracksBuilder::AddAudioTrack(int track_num, - uint64 track_uid, + uint64_t track_uid, const std::string& codec_id, const std::string& name, const std::string& language, @@ -172,7 +181,7 @@ void TracksBuilder::AddAudioTrack(int track_num, } void TracksBuilder::AddTextTrack(int track_num, - uint64 track_uid, + uint64_t track_uid, const std::string& codec_id, const std::string& name, const std::string& language) { @@ -180,9 +189,9 @@ void TracksBuilder::AddTextTrack(int track_num, codec_id, name, language, -1, -1, -1, -1, -1); } -std::vector<uint8> TracksBuilder::Finish() { +std::vector<uint8_t> TracksBuilder::Finish() { // Allocate the storage - std::vector<uint8> buffer; + std::vector<uint8_t> buffer; buffer.resize(GetTracksSize()); // Populate the storage with a tracks header @@ -193,7 +202,7 @@ std::vector<uint8> TracksBuilder::Finish() { void TracksBuilder::AddTrackInternal(int track_num, int track_type, - uint64 track_uid, + uint64_t track_uid, const std::string& codec_id, const std::string& name, const std::string& language, @@ -223,7 +232,7 @@ int TracksBuilder::GetTracksPayloadSize() const { return payload_size; } -void TracksBuilder::WriteTracks(uint8* buf, int buf_size) const { +void TracksBuilder::WriteTracks(uint8_t* buf, int buf_size) const { WriteMasterElement(&buf, &buf_size, kWebMIdTracks, GetTracksPayloadSize()); for (TrackList::const_iterator itr = tracks_.begin(); @@ -234,7 +243,7 @@ void TracksBuilder::WriteTracks(uint8* buf, int buf_size) const { TracksBuilder::Track::Track(int track_num, int track_type, - uint64 track_uid, + uint64_t track_uid, const std::string& codec_id, const std::string& name, const std::string& language, @@ -341,7 +350,7 @@ int TracksBuilder::Track::GetPayloadSize() const { return size; } -void TracksBuilder::Track::Write(uint8** buf, int* buf_size) const { +void TracksBuilder::Track::Write(uint8_t** buf, int* buf_size) const { WriteMasterElement(buf, buf_size, kWebMIdTrackEntry, GetPayloadSize()); WriteUIntElement(buf, buf_size, kWebMIdTrackNumber, track_num_); diff --git a/media/formats/webm/tracks_builder.h b/media/formats/webm/tracks_builder.h index f7786fd..dc0283e 100644 --- a/media/formats/webm/tracks_builder.h +++ b/media/formats/webm/tracks_builder.h @@ -5,11 +5,13 @@ #ifndef MEDIA_FORMATS_WEBM_TRACKS_BUILDER_H_ #define MEDIA_FORMATS_WEBM_TRACKS_BUILDER_H_ +#include <stdint.h> + #include <list> #include <string> #include <vector> -#include "base/basictypes.h" +#include "base/macros.h" namespace media { @@ -28,7 +30,7 @@ class TracksBuilder { // DefaultDuration. Similar applies to |audio_channels|, // |audio_sampling_frequency|, |video_pixel_width| and |video_pixel_height|. void AddVideoTrack(int track_num, - uint64 track_uid, + uint64_t track_uid, const std::string& codec_id, const std::string& name, const std::string& language, @@ -36,7 +38,7 @@ class TracksBuilder { int video_pixel_width, int video_pixel_height); void AddAudioTrack(int track_num, - uint64 track_uid, + uint64_t track_uid, const std::string& codec_id, const std::string& name, const std::string& language, @@ -44,17 +46,17 @@ class TracksBuilder { int audio_channels, double audio_sampling_frequency); void AddTextTrack(int track_num, - uint64 track_uid, + uint64_t track_uid, const std::string& codec_id, const std::string& name, const std::string& language); - std::vector<uint8> Finish(); + std::vector<uint8_t> Finish(); private: void AddTrackInternal(int track_num, int track_type, - uint64 track_uid, + uint64_t track_uid, const std::string& codec_id, const std::string& name, const std::string& language, @@ -65,13 +67,13 @@ class TracksBuilder { double audio_sampling_frequency); int GetTracksSize() const; int GetTracksPayloadSize() const; - void WriteTracks(uint8* buffer, int buffer_size) const; + void WriteTracks(uint8_t* buffer, int buffer_size) const; class Track { public: Track(int track_num, int track_type, - uint64 track_uid, + uint64_t track_uid, const std::string& codec_id, const std::string& name, const std::string& language, @@ -83,7 +85,8 @@ class TracksBuilder { bool allow_invalid_values); int GetSize() const; - void Write(uint8** buf, int* buf_size) const; + void Write(uint8_t** buf, int* buf_size) const; + private: int GetPayloadSize() const; int GetVideoPayloadSize() const; diff --git a/media/formats/webm/webm_audio_client.cc b/media/formats/webm/webm_audio_client.cc index 995746a4..fb6a723a 100644 --- a/media/formats/webm/webm_audio_client.cc +++ b/media/formats/webm/webm_audio_client.cc @@ -25,8 +25,11 @@ void WebMAudioClient::Reset() { } bool WebMAudioClient::InitializeConfig( - const std::string& codec_id, const std::vector<uint8>& codec_private, - int64 seek_preroll, int64 codec_delay, bool is_encrypted, + const std::string& codec_id, + const std::vector<uint8_t>& codec_private, + int64_t seek_preroll, + int64_t codec_delay, + bool is_encrypted, AudioDecoderConfig* config) { DCHECK(config); SampleFormat sample_format = kSampleFormatPlanarF32; @@ -88,7 +91,7 @@ bool WebMAudioClient::InitializeConfig( return config->IsValidConfig(); } -bool WebMAudioClient::OnUInt(int id, int64 val) { +bool WebMAudioClient::OnUInt(int id, int64_t val) { if (id == kWebMIdChannels) { if (channels_ != -1) { MEDIA_LOG(ERROR, media_log_) << "Multiple values for id " << std::hex diff --git a/media/formats/webm/webm_audio_client.h b/media/formats/webm/webm_audio_client.h index 67f5f01..98f0eee 100644 --- a/media/formats/webm/webm_audio_client.h +++ b/media/formats/webm/webm_audio_client.h @@ -30,15 +30,15 @@ class WebMAudioClient : public WebMParserClient { // Returns false if there was unexpected values in the provided parameters or // audio track element fields. bool InitializeConfig(const std::string& codec_id, - const std::vector<uint8>& codec_private, - const int64 seek_preroll, - const int64 codec_delay, + const std::vector<uint8_t>& codec_private, + const int64_t seek_preroll, + const int64_t codec_delay, bool is_encrypted, AudioDecoderConfig* config); private: // WebMParserClient implementation. - bool OnUInt(int id, int64 val) override; + bool OnUInt(int id, int64_t val) override; bool OnFloat(int id, double val) override; scoped_refptr<MediaLog> media_log_; diff --git a/media/formats/webm/webm_cluster_parser.cc b/media/formats/webm/webm_cluster_parser.cc index ee49137..21420b74 100644 --- a/media/formats/webm/webm_cluster_parser.cc +++ b/media/formats/webm/webm_cluster_parser.cc @@ -32,13 +32,13 @@ enum { }; WebMClusterParser::WebMClusterParser( - int64 timecode_scale, + int64_t timecode_scale, int audio_track_num, base::TimeDelta audio_default_duration, int video_track_num, base::TimeDelta video_default_duration, const WebMTracksParser::TextTracks& text_tracks, - const std::set<int64>& ignored_tracks, + const std::set<int64_t>& ignored_tracks, const std::string& audio_encryption_key_id, const std::string& video_encryption_key_id, const AudioCodec audio_codec, @@ -293,8 +293,8 @@ bool WebMClusterParser::OnListEnd(int id) { return result; } -bool WebMClusterParser::OnUInt(int id, int64 val) { - int64* dst; +bool WebMClusterParser::OnUInt(int id, int64_t val) { + int64_t* dst; switch (id) { case kWebMIdTimecode: dst = &cluster_timecode_; @@ -320,7 +320,7 @@ bool WebMClusterParser::ParseBlock(bool is_simple_block, const uint8_t* additional, int additional_size, int duration, - int64 discard_padding) { + int64_t discard_padding) { if (size < 4) return false; @@ -371,7 +371,7 @@ bool WebMClusterParser::OnBinary(int id, const uint8_t* data, int size) { return true; case kWebMIdBlockAdditional: { - uint64 block_add_id = base::HostToNet64(block_add_id_); + uint64_t block_add_id = base::HostToNet64(block_add_id_); if (block_additional_data_) { // TODO(vigneshv): Technically, more than 1 BlockAdditional is allowed // as per matroska spec. But for now we don't have a use case to @@ -397,7 +397,7 @@ bool WebMClusterParser::OnBinary(int id, const uint8_t* data, int size) { discard_padding_set_ = true; // Read in the big-endian integer. - discard_padding_ = static_cast<int8>(data[0]); + discard_padding_ = static_cast<int8_t>(data[0]); for (int i = 1; i < size; ++i) discard_padding_ = (discard_padding_ << 8) | data[i]; @@ -417,7 +417,7 @@ bool WebMClusterParser::OnBlock(bool is_simple_block, int size, const uint8_t* additional, int additional_size, - int64 discard_padding) { + int64_t discard_padding) { DCHECK_GE(size, 0); if (cluster_timecode_ == -1) { MEDIA_LOG(ERROR, media_log_) << "Got a block before cluster timecode."; diff --git a/media/formats/webm/webm_cluster_parser.h b/media/formats/webm/webm_cluster_parser.h index e2d5b98..bd02810 100644 --- a/media/formats/webm/webm_cluster_parser.h +++ b/media/formats/webm/webm_cluster_parser.h @@ -149,13 +149,13 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient { typedef std::map<int, Track> TextTrackMap; public: - WebMClusterParser(int64 timecode_scale, + WebMClusterParser(int64_t timecode_scale, int audio_track_num, base::TimeDelta audio_default_duration, int video_track_num, base::TimeDelta video_default_duration, const WebMTracksParser::TextTracks& text_tracks, - const std::set<int64>& ignored_tracks, + const std::set<int64_t>& ignored_tracks, const std::string& audio_encryption_key_id, const std::string& video_encryption_key_id, const AudioCodec audio_codec, @@ -209,7 +209,7 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient { // WebMParserClient methods. WebMParserClient* OnListStart(int id) override; bool OnListEnd(int id) override; - bool OnUInt(int id, int64 val) override; + bool OnUInt(int id, int64_t val) override; bool OnBinary(int id, const uint8_t* data, int size) override; bool ParseBlock(bool is_simple_block, @@ -218,7 +218,7 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient { const uint8_t* additional, int additional_size, int duration, - int64 discard_padding); + int64_t discard_padding); bool OnBlock(bool is_simple_block, int track_num, int timecode, @@ -228,7 +228,7 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient { int size, const uint8_t* additional, int additional_size, - int64 discard_padding); + int64_t discard_padding); // Resets the Track objects associated with each text track. void ResetTextTracks(); @@ -273,28 +273,28 @@ class MEDIA_EXPORT WebMClusterParser : public WebMParserClient { double timecode_multiplier_; // Multiplier used to convert timecodes into // microseconds. - std::set<int64> ignored_tracks_; + std::set<int64_t> ignored_tracks_; std::string audio_encryption_key_id_; std::string video_encryption_key_id_; const AudioCodec audio_codec_; WebMListParser parser_; - int64 last_block_timecode_ = -1; + int64_t last_block_timecode_ = -1; scoped_ptr<uint8_t[]> block_data_; int block_data_size_ = -1; - int64 block_duration_ = -1; - int64 block_add_id_ = -1; + int64_t block_duration_ = -1; + int64_t block_add_id_ = -1; scoped_ptr<uint8_t[]> block_additional_data_; // Must be 0 if |block_additional_data_| is null. Must be > 0 if // |block_additional_data_| is NOT null. int block_additional_data_size_ = 0; - int64 discard_padding_ = -1; + int64_t discard_padding_ = -1; bool discard_padding_set_ = false; - int64 cluster_timecode_ = -1; + int64_t cluster_timecode_ = -1; base::TimeDelta cluster_start_time_; bool cluster_ended_ = false; diff --git a/media/formats/webm/webm_cluster_parser_unittest.cc b/media/formats/webm/webm_cluster_parser_unittest.cc index 7581bbf..1605dfe 100644 --- a/media/formats/webm/webm_cluster_parser_unittest.cc +++ b/media/formats/webm/webm_cluster_parser_unittest.cc @@ -319,7 +319,7 @@ class WebMClusterParserTest : public testing::Test { base::TimeDelta audio_default_duration, base::TimeDelta video_default_duration, const WebMTracksParser::TextTracks& text_tracks, - const std::set<int64>& ignored_tracks, + const std::set<int64_t>& ignored_tracks, const std::string& audio_encryption_key_id, const std::string& video_encryption_key_id, const AudioCodec audio_codec) { @@ -333,7 +333,7 @@ class WebMClusterParserTest : public testing::Test { // Create a default version of the parser for test. WebMClusterParser* CreateDefaultParser() { return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(), - std::set<int64>(), std::string(), std::string(), + std::set<int64_t>(), std::string(), std::string(), kUnknownAudioCodec); } @@ -344,13 +344,13 @@ class WebMClusterParserTest : public testing::Test { base::TimeDelta video_default_duration, const WebMTracksParser::TextTracks& text_tracks = TextTracks()) { return CreateParserHelper(audio_default_duration, video_default_duration, - text_tracks, std::set<int64>(), std::string(), + text_tracks, std::set<int64_t>(), std::string(), std::string(), kUnknownAudioCodec); } // Create a parser for test with custom ignored tracks. WebMClusterParser* CreateParserWithIgnoredTracks( - std::set<int64>& ignored_tracks) { + std::set<int64_t>& ignored_tracks) { return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(), ignored_tracks, std::string(), std::string(), kUnknownAudioCodec); @@ -362,7 +362,7 @@ class WebMClusterParserTest : public testing::Test { const std::string& video_encryption_key_id, const AudioCodec audio_codec) { return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(), - std::set<int64>(), audio_encryption_key_id, + std::set<int64_t>(), audio_encryption_key_id, video_encryption_key_id, audio_codec); } @@ -579,7 +579,7 @@ TEST_F(WebMClusterParserTest, ParseSimpleBlockAndBlockGroupMixture) { } TEST_F(WebMClusterParserTest, IgnoredTracks) { - std::set<int64> ignored_tracks; + std::set<int64_t> ignored_tracks; ignored_tracks.insert(kTextTrackNum); parser_.reset(CreateParserWithIgnoredTracks(ignored_tracks)); diff --git a/media/formats/webm/webm_constants.h b/media/formats/webm/webm_constants.h index 8a0b8a7..711b40f 100644 --- a/media/formats/webm/webm_constants.h +++ b/media/formats/webm/webm_constants.h @@ -5,7 +5,8 @@ #ifndef MEDIA_FORMATS_WEBM_WEBM_CONSTANTS_H_ #define MEDIA_FORMATS_WEBM_WEBM_CONSTANTS_H_ -#include "base/basictypes.h" +#include <stdint.h> + #include "media/base/media_export.h" namespace media { @@ -200,14 +201,14 @@ const int kWebMIdVideo = 0xE0; const int kWebMIdVoid = 0xEC; const int kWebMIdWritingApp = 0x5741; -const int64 kWebMReservedId = 0x1FFFFFFF; -const int64 kWebMUnknownSize = 0x00FFFFFFFFFFFFFFLL; +const int64_t kWebMReservedId = 0x1FFFFFFF; +const int64_t kWebMUnknownSize = 0x00FFFFFFFFFFFFFFLL; -const uint8 kWebMFlagKeyframe = 0x80; +const uint8_t kWebMFlagKeyframe = 0x80; // Current encrypted WebM request for comments specification is here // http://wiki.webmproject.org/encryption/webm-encryption-rfc -const uint8 kWebMFlagEncryptedFrame = 0x1; +const uint8_t kWebMFlagEncryptedFrame = 0x1; const int kWebMIvSize = 8; const int kWebMSignalByteSize = 1; diff --git a/media/formats/webm/webm_content_encodings.cc b/media/formats/webm/webm_content_encodings.cc index 157c6ac..440dcce 100644 --- a/media/formats/webm/webm_content_encodings.cc +++ b/media/formats/webm/webm_content_encodings.cc @@ -17,7 +17,7 @@ ContentEncoding::ContentEncoding() ContentEncoding::~ContentEncoding() {} -void ContentEncoding::SetEncryptionKeyId(const uint8* encryption_key_id, +void ContentEncoding::SetEncryptionKeyId(const uint8_t* encryption_key_id, int size) { DCHECK(encryption_key_id); DCHECK_GT(size, 0); diff --git a/media/formats/webm/webm_content_encodings.h b/media/formats/webm/webm_content_encodings.h index 5890ecf..1cc68a4 100644 --- a/media/formats/webm/webm_content_encodings.h +++ b/media/formats/webm/webm_content_encodings.h @@ -7,7 +7,6 @@ #include <string> -#include "base/basictypes.h" #include "base/memory/scoped_ptr.h" #include "media/base/media_export.h" @@ -52,8 +51,8 @@ class MEDIA_EXPORT ContentEncoding { ContentEncoding(); ~ContentEncoding(); - int64 order() const { return order_; } - void set_order(int64 order) { order_ = order; } + int64_t order() const { return order_; } + void set_order(int64_t order) { order_ = order; } Scope scope() const { return scope_; } void set_scope(Scope scope) { scope_ = scope; } @@ -67,13 +66,13 @@ class MEDIA_EXPORT ContentEncoding { } const std::string& encryption_key_id() const { return encryption_key_id_; } - void SetEncryptionKeyId(const uint8* encryption_key_id, int size); + void SetEncryptionKeyId(const uint8_t* encryption_key_id, int size); CipherMode cipher_mode() const { return cipher_mode_; } void set_cipher_mode(CipherMode mode) { cipher_mode_ = mode; } private: - int64 order_; + int64_t order_; Scope scope_; Type type_; EncryptionAlgo encryption_algo_; diff --git a/media/formats/webm/webm_content_encodings_client.cc b/media/formats/webm/webm_content_encodings_client.cc index a9783dd..eb1b590 100644 --- a/media/formats/webm/webm_content_encodings_client.cc +++ b/media/formats/webm/webm_content_encodings_client.cc @@ -142,7 +142,7 @@ bool WebMContentEncodingsClient::OnListEnd(int id) { // Multiple occurrence restriction and range are checked in this function. // Mandatory occurrence restriction is checked in OnListEnd. -bool WebMContentEncodingsClient::OnUInt(int id, int64 val) { +bool WebMContentEncodingsClient::OnUInt(int id, int64_t val) { DCHECK(cur_content_encoding_.get()); if (id == kWebMIdContentEncodingOrder) { @@ -152,7 +152,7 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) { return false; } - if (val != static_cast<int64>(content_encodings_.size())) { + if (val != static_cast<int64_t>(content_encodings_.size())) { // According to the spec, encoding order starts with 0 and counts upwards. MEDIA_LOG(ERROR, media_log_) << "Unexpected ContentEncodingOrder."; return false; @@ -252,7 +252,9 @@ bool WebMContentEncodingsClient::OnUInt(int id, int64 val) { // Multiple occurrence restriction is checked in this function. Mandatory // restriction is checked in OnListEnd. -bool WebMContentEncodingsClient::OnBinary(int id, const uint8* data, int size) { +bool WebMContentEncodingsClient::OnBinary(int id, + const uint8_t* data, + int size) { DCHECK(cur_content_encoding_.get()); DCHECK(data); DCHECK_GT(size, 0); diff --git a/media/formats/webm/webm_content_encodings_client.h b/media/formats/webm/webm_content_encodings_client.h index 85f7bf3..1144567 100644 --- a/media/formats/webm/webm_content_encodings_client.h +++ b/media/formats/webm/webm_content_encodings_client.h @@ -30,8 +30,8 @@ class MEDIA_EXPORT WebMContentEncodingsClient : public WebMParserClient { // WebMParserClient methods WebMParserClient* OnListStart(int id) override; bool OnListEnd(int id) override; - bool OnUInt(int id, int64 val) override; - bool OnBinary(int id, const uint8* data, int size) override; + bool OnUInt(int id, int64_t val) override; + bool OnBinary(int id, const uint8_t* data, int size) override; private: scoped_refptr<MediaLog> media_log_; diff --git a/media/formats/webm/webm_content_encodings_client_unittest.cc b/media/formats/webm/webm_content_encodings_client_unittest.cc index d31ad27..657e2c4 100644 --- a/media/formats/webm/webm_content_encodings_client_unittest.cc +++ b/media/formats/webm/webm_content_encodings_client_unittest.cc @@ -53,7 +53,7 @@ class WebMContentEncodingsClientTest : public testing::Test { client_(media_log_), parser_(kWebMIdContentEncodings, &client_) {} - void ParseAndExpectToFail(const uint8* buf, int size) { + void ParseAndExpectToFail(const uint8_t* buf, int size) { int result = parser_.Parse(buf, size); EXPECT_EQ(-1, result); } @@ -65,8 +65,8 @@ class WebMContentEncodingsClientTest : public testing::Test { }; TEST_F(WebMContentEncodingsClientTest, EmptyContentEncodings) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0x80, // ContentEncodings (size = 0) + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0x80, // ContentEncodings (size = 0) }; int size = sizeof(kContentEncodings); EXPECT_MEDIA_LOG(MissingContentEncoding()); @@ -74,25 +74,25 @@ TEST_F(WebMContentEncodingsClientTest, EmptyContentEncodings) { } TEST_F(WebMContentEncodingsClientTest, EmptyContentEncoding) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0x83, // ContentEncodings (size = 3) - 0x63, 0x40, 0x80, // ContentEncoding (size = 0) + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0x83, // ContentEncodings (size = 3) + 0x63, 0x40, 0x80, // ContentEncoding (size = 0) }; int size = sizeof(kContentEncodings); ParseAndExpectToFail(kContentEncodings, size); } TEST_F(WebMContentEncodingsClientTest, SingleContentEncoding) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0xA1, // ContentEncodings (size = 33) - 0x62, 0x40, 0x9e, // ContentEncoding (size = 30) - 0x50, 0x31, 0x81, 0x00, // ContentEncodingOrder (size = 1) - 0x50, 0x32, 0x81, 0x01, // ContentEncodingScope (size = 1) - 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) - 0x50, 0x35, 0x8F, // ContentEncryption (size = 15) - 0x47, 0xE1, 0x81, 0x05, // ContentEncAlgo (size = 1) - 0x47, 0xE2, 0x88, // ContentEncKeyID (size = 8) - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0xA1, // ContentEncodings (size = 33) + 0x62, 0x40, 0x9e, // ContentEncoding (size = 30) + 0x50, 0x31, 0x81, 0x00, // ContentEncodingOrder (size = 1) + 0x50, 0x32, 0x81, 0x01, // ContentEncodingScope (size = 1) + 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) + 0x50, 0x35, 0x8F, // ContentEncryption (size = 15) + 0x47, 0xE1, 0x81, 0x05, // ContentEncAlgo (size = 1) + 0x47, 0xE2, 0x88, // ContentEncKeyID (size = 8) + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, }; int size = sizeof(kContentEncodings); @@ -112,24 +112,24 @@ TEST_F(WebMContentEncodingsClientTest, SingleContentEncoding) { } TEST_F(WebMContentEncodingsClientTest, MultipleContentEncoding) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0xC2, // ContentEncodings (size = 66) - 0x62, 0x40, 0x9e, // ContentEncoding (size = 30) - 0x50, 0x31, 0x81, 0x00, // ContentEncodingOrder (size = 1) - 0x50, 0x32, 0x81, 0x03, // ContentEncodingScope (size = 1) - 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) - 0x50, 0x35, 0x8F, // ContentEncryption (size = 15) - 0x47, 0xE1, 0x81, 0x05, // ContentEncAlgo (size = 1) - 0x47, 0xE2, 0x88, // ContentEncKeyID (size = 8) - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, - 0x62, 0x40, 0x9e, // ContentEncoding (size = 30) - 0x50, 0x31, 0x81, 0x01, // ContentEncodingOrder (size = 1) - 0x50, 0x32, 0x81, 0x03, // ContentEncodingScope (size = 1) - 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) - 0x50, 0x35, 0x8F, // ContentEncryption (size = 15) - 0x47, 0xE1, 0x81, 0x01, // ContentEncAlgo (size = 1) - 0x47, 0xE2, 0x88, // ContentEncKeyID (size = 8) - 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0xC2, // ContentEncodings (size = 66) + 0x62, 0x40, 0x9e, // ContentEncoding (size = 30) + 0x50, 0x31, 0x81, 0x00, // ContentEncodingOrder (size = 1) + 0x50, 0x32, 0x81, 0x03, // ContentEncodingScope (size = 1) + 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) + 0x50, 0x35, 0x8F, // ContentEncryption (size = 15) + 0x47, 0xE1, 0x81, 0x05, // ContentEncAlgo (size = 1) + 0x47, 0xE2, 0x88, // ContentEncKeyID (size = 8) + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + 0x62, 0x40, 0x9e, // ContentEncoding (size = 30) + 0x50, 0x31, 0x81, 0x01, // ContentEncodingOrder (size = 1) + 0x50, 0x32, 0x81, 0x03, // ContentEncodingScope (size = 1) + 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) + 0x50, 0x35, 0x8F, // ContentEncryption (size = 15) + 0x47, 0xE1, 0x81, 0x01, // ContentEncAlgo (size = 1) + 0x47, 0xE2, 0x88, // ContentEncKeyID (size = 8) + 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, 0xBB, }; int size = sizeof(kContentEncodings); @@ -152,14 +152,14 @@ TEST_F(WebMContentEncodingsClientTest, MultipleContentEncoding) { } TEST_F(WebMContentEncodingsClientTest, DefaultValues) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0x8A, // ContentEncodings (size = 10) - 0x62, 0x40, 0x87, // ContentEncoding (size = 7) - // ContentEncodingOrder missing - // ContentEncodingScope missing - 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) - 0x50, 0x35, 0x80, // ContentEncryption (size = 0) - // ContentEncAlgo missing + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0x8A, // ContentEncodings (size = 10) + 0x62, 0x40, 0x87, // ContentEncoding (size = 7) + // ContentEncodingOrder missing + // ContentEncodingScope missing + 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) + 0x50, 0x35, 0x80, // ContentEncryption (size = 0) + // ContentEncAlgo missing }; int size = sizeof(kContentEncodings); @@ -179,16 +179,16 @@ TEST_F(WebMContentEncodingsClientTest, DefaultValues) { } TEST_F(WebMContentEncodingsClientTest, ContentEncodingsClientReuse) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0xA1, // ContentEncodings (size = 33) - 0x62, 0x40, 0x9e, // ContentEncoding (size = 30) - 0x50, 0x31, 0x81, 0x00, // ContentEncodingOrder (size = 1) - 0x50, 0x32, 0x81, 0x01, // ContentEncodingScope (size = 1) - 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) - 0x50, 0x35, 0x8F, // ContentEncryption (size = 15) - 0x47, 0xE1, 0x81, 0x05, // ContentEncAlgo (size = 1) - 0x47, 0xE2, 0x88, // ContentEncKeyID (size = 8) - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0xA1, // ContentEncodings (size = 33) + 0x62, 0x40, 0x9e, // ContentEncoding (size = 30) + 0x50, 0x31, 0x81, 0x00, // ContentEncodingOrder (size = 1) + 0x50, 0x32, 0x81, 0x01, // ContentEncodingScope (size = 1) + 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) + 0x50, 0x35, 0x8F, // ContentEncryption (size = 15) + 0x47, 0xE1, 0x81, 0x05, // ContentEncAlgo (size = 1) + 0x47, 0xE2, 0x88, // ContentEncKeyID (size = 8) + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, }; int size = sizeof(kContentEncodings); @@ -214,12 +214,12 @@ TEST_F(WebMContentEncodingsClientTest, ContentEncodingsClientReuse) { } TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingOrder) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0x8E, // ContentEncodings (size = 14) - 0x62, 0x40, 0x8B, // ContentEncoding (size = 11) - 0x50, 0x31, 0x81, 0xEE, // ContentEncodingOrder (size = 1), invalid - 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) - 0x50, 0x35, 0x80, // ContentEncryption (size = 0) + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0x8E, // ContentEncodings (size = 14) + 0x62, 0x40, 0x8B, // ContentEncoding (size = 11) + 0x50, 0x31, 0x81, 0xEE, // ContentEncodingOrder (size = 1), invalid + 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) + 0x50, 0x35, 0x80, // ContentEncryption (size = 0) }; int size = sizeof(kContentEncodings); EXPECT_MEDIA_LOG(UnexpectedContentEncodingOrder()); @@ -227,12 +227,12 @@ TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingOrder) { } TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingScope) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0x8E, // ContentEncodings (size = 14) - 0x62, 0x40, 0x8B, // ContentEncoding (size = 11) - 0x50, 0x32, 0x81, 0xEE, // ContentEncodingScope (size = 1), invalid - 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) - 0x50, 0x35, 0x80, // ContentEncryption (size = 0) + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0x8E, // ContentEncodings (size = 14) + 0x62, 0x40, 0x8B, // ContentEncoding (size = 11) + 0x50, 0x32, 0x81, 0xEE, // ContentEncodingScope (size = 1), invalid + 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) + 0x50, 0x35, 0x80, // ContentEncryption (size = 0) }; int size = sizeof(kContentEncodings); EXPECT_MEDIA_LOG(UnexpectedContentEncodingScope()); @@ -240,11 +240,11 @@ TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingScope) { } TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingType) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0x8E, // ContentEncodings (size = 14) - 0x62, 0x40, 0x8B, // ContentEncoding (size = 11) - 0x50, 0x33, 0x81, 0x00, // ContentEncodingType (size = 1), invalid - 0x50, 0x35, 0x80, // ContentEncryption (size = 0) + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0x8E, // ContentEncodings (size = 14) + 0x62, 0x40, 0x8B, // ContentEncoding (size = 11) + 0x50, 0x33, 0x81, 0x00, // ContentEncodingType (size = 1), invalid + 0x50, 0x35, 0x80, // ContentEncryption (size = 0) }; int size = sizeof(kContentEncodings); EXPECT_MEDIA_LOG(ContentCompressionNotSupported()); @@ -253,11 +253,11 @@ TEST_F(WebMContentEncodingsClientTest, InvalidContentEncodingType) { // ContentEncodingType is encryption but no ContentEncryption present. TEST_F(WebMContentEncodingsClientTest, MissingContentEncryption) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0x87, // ContentEncodings (size = 7) - 0x62, 0x40, 0x84, // ContentEncoding (size = 4) - 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) - // ContentEncryption missing + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0x87, // ContentEncodings (size = 7) + 0x62, 0x40, 0x84, // ContentEncoding (size = 4) + 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) + // ContentEncryption missing }; int size = sizeof(kContentEncodings); EXPECT_MEDIA_LOG(MissingContentEncryption()); @@ -265,14 +265,14 @@ TEST_F(WebMContentEncodingsClientTest, MissingContentEncryption) { } TEST_F(WebMContentEncodingsClientTest, InvalidContentEncAlgo) { - const uint8 kContentEncodings[] = { - 0x6D, 0x80, 0x99, // ContentEncodings (size = 25) - 0x62, 0x40, 0x96, // ContentEncoding (size = 22) - 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) - 0x50, 0x35, 0x8F, // ContentEncryption (size = 15) - 0x47, 0xE1, 0x81, 0xEE, // ContentEncAlgo (size = 1), invalid - 0x47, 0xE2, 0x88, // ContentEncKeyID (size = 8) - 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, + const uint8_t kContentEncodings[] = { + 0x6D, 0x80, 0x99, // ContentEncodings (size = 25) + 0x62, 0x40, 0x96, // ContentEncoding (size = 22) + 0x50, 0x33, 0x81, 0x01, // ContentEncodingType (size = 1) + 0x50, 0x35, 0x8F, // ContentEncryption (size = 15) + 0x47, 0xE1, 0x81, 0xEE, // ContentEncAlgo (size = 1), invalid + 0x47, 0xE2, 0x88, // ContentEncKeyID (size = 8) + 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, }; int size = sizeof(kContentEncodings); EXPECT_MEDIA_LOG(UnexpectedContentEncAlgo(0xEE)); diff --git a/media/formats/webm/webm_crypto_helpers.cc b/media/formats/webm/webm_crypto_helpers.cc index bd473bc..11e71b1 100644 --- a/media/formats/webm/webm_crypto_helpers.cc +++ b/media/formats/webm/webm_crypto_helpers.cc @@ -16,7 +16,7 @@ namespace { // CTR IV appended with a CTR block counter. |iv| is an 8 byte CTR IV. // |iv_size| is the size of |iv| in btyes. Returns a string of // kDecryptionKeySize bytes. -std::string GenerateWebMCounterBlock(const uint8* iv, int iv_size) { +std::string GenerateWebMCounterBlock(const uint8_t* iv, int iv_size) { std::string counter_block(reinterpret_cast<const char*>(iv), iv_size); counter_block.append(DecryptConfig::kDecryptionKeySize - iv_size, 0); return counter_block; @@ -24,8 +24,10 @@ std::string GenerateWebMCounterBlock(const uint8* iv, int iv_size) { } // namespace anonymous -bool WebMCreateDecryptConfig(const uint8* data, int data_size, - const uint8* key_id, int key_id_size, +bool WebMCreateDecryptConfig(const uint8_t* data, + int data_size, + const uint8_t* key_id, + int key_id_size, scoped_ptr<DecryptConfig>* decrypt_config, int* data_offset) { if (data_size < kWebMSignalByteSize) { @@ -33,7 +35,7 @@ bool WebMCreateDecryptConfig(const uint8* data, int data_size, return false; } - uint8 signal_byte = data[0]; + uint8_t signal_byte = data[0]; int frame_offset = sizeof(signal_byte); // Setting the DecryptConfig object of the buffer while leaving the diff --git a/media/formats/webm/webm_crypto_helpers.h b/media/formats/webm/webm_crypto_helpers.h index 41ad5b1..d386302 100644 --- a/media/formats/webm/webm_crypto_helpers.h +++ b/media/formats/webm/webm_crypto_helpers.h @@ -5,7 +5,6 @@ #ifndef MEDIA_FORMATS_WEBM_WEBM_CRYPTO_HELPERS_H_ #define MEDIA_FORMATS_WEBM_WEBM_CRYPTO_HELPERS_H_ -#include "base/basictypes.h" #include "base/memory/scoped_ptr.h" #include "media/base/decoder_buffer.h" @@ -18,8 +17,10 @@ namespace media { // false otherwise, in which case |decrypt_config| and |data_offset| will not be // changed. Current encrypted WebM request for comments specification is here // http://wiki.webmproject.org/encryption/webm-encryption-rfc -bool WebMCreateDecryptConfig(const uint8* data, int data_size, - const uint8* key_id, int key_id_size, +bool WebMCreateDecryptConfig(const uint8_t* data, + int data_size, + const uint8_t* key_id, + int key_id_size, scoped_ptr<DecryptConfig>* decrypt_config, int* data_offset); diff --git a/media/formats/webm/webm_info_parser.cc b/media/formats/webm/webm_info_parser.cc index 6309c21..be6d708 100644 --- a/media/formats/webm/webm_info_parser.cc +++ b/media/formats/webm/webm_info_parser.cc @@ -20,7 +20,7 @@ WebMInfoParser::WebMInfoParser() WebMInfoParser::~WebMInfoParser() {} -int WebMInfoParser::Parse(const uint8* buf, int size) { +int WebMInfoParser::Parse(const uint8_t* buf, int size) { timecode_scale_ = -1; duration_ = -1; @@ -45,7 +45,7 @@ bool WebMInfoParser::OnListEnd(int id) { return true; } -bool WebMInfoParser::OnUInt(int id, int64 val) { +bool WebMInfoParser::OnUInt(int id, int64_t val) { if (id != kWebMIdTimecodeScale) return true; @@ -73,12 +73,12 @@ bool WebMInfoParser::OnFloat(int id, double val) { return true; } -bool WebMInfoParser::OnBinary(int id, const uint8* data, int size) { +bool WebMInfoParser::OnBinary(int id, const uint8_t* data, int size) { if (id == kWebMIdDateUTC) { if (size != 8) return false; - int64 date_in_nanoseconds = 0; + int64_t date_in_nanoseconds = 0; for (int i = 0; i < size; ++i) date_in_nanoseconds = (date_in_nanoseconds << 8) | data[i]; diff --git a/media/formats/webm/webm_info_parser.h b/media/formats/webm/webm_info_parser.h index 44ef6b2..bec5cd2 100644 --- a/media/formats/webm/webm_info_parser.h +++ b/media/formats/webm/webm_info_parser.h @@ -23,9 +23,9 @@ class MEDIA_EXPORT WebMInfoParser : public WebMParserClient { // Returns -1 if the parse fails. // Returns 0 if more data is needed. // Returns the number of bytes parsed on success. - int Parse(const uint8* buf, int size); + int Parse(const uint8_t* buf, int size); - int64 timecode_scale() const { return timecode_scale_; } + int64_t timecode_scale() const { return timecode_scale_; } double duration() const { return duration_; } base::Time date_utc() const { return date_utc_; } @@ -33,12 +33,12 @@ class MEDIA_EXPORT WebMInfoParser : public WebMParserClient { // WebMParserClient methods WebMParserClient* OnListStart(int id) override; bool OnListEnd(int id) override; - bool OnUInt(int id, int64 val) override; + bool OnUInt(int id, int64_t val) override; bool OnFloat(int id, double val) override; - bool OnBinary(int id, const uint8* data, int size) override; + bool OnBinary(int id, const uint8_t* data, int size) override; bool OnString(int id, const std::string& str) override; - int64 timecode_scale_; + int64_t timecode_scale_; double duration_; base::Time date_utc_; diff --git a/media/formats/webm/webm_stream_parser.cc b/media/formats/webm/webm_stream_parser.cc index b978b96..6695e2e 100644 --- a/media/formats/webm/webm_stream_parser.cc +++ b/media/formats/webm/webm_stream_parser.cc @@ -67,7 +67,7 @@ void WebMStreamParser::Flush() { } } -bool WebMStreamParser::Parse(const uint8* buf, int size) { +bool WebMStreamParser::Parse(const uint8_t* buf, int size) { DCHECK_NE(state_, kWaitingForInit); if (state_ == kError) @@ -77,7 +77,7 @@ bool WebMStreamParser::Parse(const uint8* buf, int size) { int result = 0; int bytes_parsed = 0; - const uint8* cur = NULL; + const uint8_t* cur = NULL; int cur_size = 0; byte_queue_.Peek(&cur, &cur_size); @@ -120,17 +120,17 @@ void WebMStreamParser::ChangeState(State new_state) { state_ = new_state; } -int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) { +int WebMStreamParser::ParseInfoAndTracks(const uint8_t* data, int size) { DVLOG(2) << "ParseInfoAndTracks()"; DCHECK(data); DCHECK_GT(size, 0); - const uint8* cur = data; + const uint8_t* cur = data; int cur_size = size; int bytes_parsed = 0; int id; - int64 element_size; + int64_t element_size; int result = WebMParseElementHeader(cur, cur_size, &id, &element_size); if (result <= 0) @@ -201,7 +201,7 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) { InitParameters params(kInfiniteDuration()); if (info_parser.duration() > 0) { - int64 duration_in_us = info_parser.duration() * timecode_scale_in_us; + int64_t duration_in_us = info_parser.duration() * timecode_scale_in_us; params.duration = base::TimeDelta::FromMicroseconds(duration_in_us); } @@ -247,7 +247,7 @@ int WebMStreamParser::ParseInfoAndTracks(const uint8* data, int size) { return bytes_parsed; } -int WebMStreamParser::ParseCluster(const uint8* data, int size) { +int WebMStreamParser::ParseCluster(const uint8_t* data, int size) { if (!cluster_parser_) return -1; @@ -276,7 +276,7 @@ int WebMStreamParser::ParseCluster(const uint8* data, int size) { } void WebMStreamParser::OnEncryptedMediaInitData(const std::string& key_id) { - std::vector<uint8> key_id_vector(key_id.begin(), key_id.end()); + std::vector<uint8_t> key_id_vector(key_id.begin(), key_id.end()); encrypted_media_init_data_cb_.Run(EmeInitDataType::WEBM, key_id_vector); } diff --git a/media/formats/webm/webm_stream_parser.h b/media/formats/webm/webm_stream_parser.h index bb53c94..7bcf0d9 100644 --- a/media/formats/webm/webm_stream_parser.h +++ b/media/formats/webm/webm_stream_parser.h @@ -31,7 +31,7 @@ class WebMStreamParser : public StreamParser { const base::Closure& end_of_segment_cb, const scoped_refptr<MediaLog>& media_log) override; void Flush() override; - bool Parse(const uint8* buf, int size) override; + bool Parse(const uint8_t* buf, int size) override; private: enum State { @@ -51,7 +51,7 @@ class WebMStreamParser : public StreamParser { // Returns < 0 if the parse fails. // Returns 0 if more data is needed. // Returning > 0 indicates success & the number of bytes parsed. - int ParseInfoAndTracks(const uint8* data, int size); + int ParseInfoAndTracks(const uint8_t* data, int size); // Incrementally parses WebM cluster elements. This method also skips // CUES elements if they are encountered since we currently don't use the @@ -60,7 +60,7 @@ class WebMStreamParser : public StreamParser { // Returns < 0 if the parse fails. // Returns 0 if more data is needed. // Returning > 0 indicates success & the number of bytes parsed. - int ParseCluster(const uint8* data, int size); + int ParseCluster(const uint8_t* data, int size); // Fire needkey event through the |encrypted_media_init_data_cb_|. void OnEncryptedMediaInitData(const std::string& key_id); diff --git a/media/formats/webm/webm_tracks_parser.cc b/media/formats/webm/webm_tracks_parser.cc index 1f2ca69..464a77ff 100644 --- a/media/formats/webm/webm_tracks_parser.cc +++ b/media/formats/webm/webm_tracks_parser.cc @@ -30,11 +30,12 @@ static TextKind CodecIdToTextKind(const std::string& codec_id) { } static base::TimeDelta PrecisionCappedDefaultDuration( - const double timecode_scale_in_us, const int64 duration_in_ns) { + const double timecode_scale_in_us, + const int64_t duration_in_ns) { if (duration_in_ns <= 0) return kNoTimestamp(); - int64 mult = duration_in_ns / 1000; + int64_t mult = duration_in_ns / 1000; mult /= timecode_scale_in_us; if (mult == 0) return kNoTimestamp(); @@ -62,7 +63,7 @@ WebMTracksParser::WebMTracksParser(const scoped_refptr<MediaLog>& media_log, WebMTracksParser::~WebMTracksParser() {} -int WebMTracksParser::Parse(const uint8* buf, int size) { +int WebMTracksParser::Parse(const uint8_t* buf, int size) { track_type_ =-1; track_num_ = -1; default_duration_ = -1; @@ -267,8 +268,8 @@ bool WebMTracksParser::OnListEnd(int id) { return true; } -bool WebMTracksParser::OnUInt(int id, int64 val) { - int64* dst = NULL; +bool WebMTracksParser::OnUInt(int id, int64_t val) { + int64_t* dst = NULL; switch (id) { case kWebMIdTrackNumber: @@ -304,7 +305,7 @@ bool WebMTracksParser::OnFloat(int id, double val) { return true; } -bool WebMTracksParser::OnBinary(int id, const uint8* data, int size) { +bool WebMTracksParser::OnBinary(int id, const uint8_t* data, int size) { if (id == kWebMIdCodecPrivate) { if (!codec_private_.empty()) { MEDIA_LOG(ERROR, media_log_) diff --git a/media/formats/webm/webm_tracks_parser.h b/media/formats/webm/webm_tracks_parser.h index d5513b5..2f94cfb 100644 --- a/media/formats/webm/webm_tracks_parser.h +++ b/media/formats/webm/webm_tracks_parser.h @@ -36,10 +36,10 @@ class MEDIA_EXPORT WebMTracksParser : public WebMParserClient { // Returns -1 if the parse fails. // Returns 0 if more data is needed. // Returns the number of bytes parsed on success. - int Parse(const uint8* buf, int size); + int Parse(const uint8_t* buf, int size); - int64 audio_track_num() const { return audio_track_num_; } - int64 video_track_num() const { return video_track_num_; } + int64_t audio_track_num() const { return audio_track_num_; } + int64_t video_track_num() const { return video_track_num_; } // If TrackEntry DefaultDuration field existed for the associated audio or // video track, returns that value converted from ns to base::TimeDelta with @@ -50,7 +50,7 @@ class MEDIA_EXPORT WebMTracksParser : public WebMParserClient { base::TimeDelta GetVideoDefaultDuration( const double timecode_scale_in_us) const; - const std::set<int64>& ignored_tracks() const { return ignored_tracks_; } + const std::set<int64_t>& ignored_tracks() const { return ignored_tracks_; } const std::string& audio_encryption_key_id() const { return audio_encryption_key_id_; @@ -78,29 +78,29 @@ class MEDIA_EXPORT WebMTracksParser : public WebMParserClient { // WebMParserClient implementation. WebMParserClient* OnListStart(int id) override; bool OnListEnd(int id) override; - bool OnUInt(int id, int64 val) override; + bool OnUInt(int id, int64_t val) override; bool OnFloat(int id, double val) override; - bool OnBinary(int id, const uint8* data, int size) override; + bool OnBinary(int id, const uint8_t* data, int size) override; bool OnString(int id, const std::string& str) override; - int64 track_type_; - int64 track_num_; + int64_t track_type_; + int64_t track_num_; std::string track_name_; std::string track_language_; std::string codec_id_; - std::vector<uint8> codec_private_; - int64 seek_preroll_; - int64 codec_delay_; - int64 default_duration_; + std::vector<uint8_t> codec_private_; + int64_t seek_preroll_; + int64_t codec_delay_; + int64_t default_duration_; scoped_ptr<WebMContentEncodingsClient> track_content_encodings_client_; - int64 audio_track_num_; - int64 audio_default_duration_; - int64 video_track_num_; - int64 video_default_duration_; + int64_t audio_track_num_; + int64_t audio_default_duration_; + int64_t video_track_num_; + int64_t video_default_duration_; bool ignore_text_tracks_; TextTracks text_tracks_; - std::set<int64> ignored_tracks_; + std::set<int64_t> ignored_tracks_; std::string audio_encryption_key_id_; std::string video_encryption_key_id_; scoped_refptr<MediaLog> media_log_; diff --git a/media/formats/webm/webm_tracks_parser_unittest.cc b/media/formats/webm/webm_tracks_parser_unittest.cc index 9c424ec..7e5a067 100644 --- a/media/formats/webm/webm_tracks_parser_unittest.cc +++ b/media/formats/webm/webm_tracks_parser_unittest.cc @@ -27,7 +27,7 @@ class WebMTracksParserTest : public testing::Test { WebMTracksParserTest() : media_log_(new StrictMock<MockMediaLog>()) {} protected: - void VerifyTextTrackInfo(const uint8* buffer, + void VerifyTextTrackInfo(const uint8_t* buffer, int buffer_size, TextKind text_kind, const std::string& name, @@ -61,7 +61,7 @@ TEST_F(WebMTracksParserTest, SubtitleNoNameNoLang) { TracksBuilder tb; tb.AddTextTrack(1, 1, kWebMCodecSubtitles, "", ""); - const std::vector<uint8> buf = tb.Finish(); + const std::vector<uint8_t> buf = tb.Finish(); VerifyTextTrackInfo(&buf[0], buf.size(), kTextSubtitles, "", ""); } @@ -71,7 +71,7 @@ TEST_F(WebMTracksParserTest, SubtitleYesNameNoLang) { TracksBuilder tb; tb.AddTextTrack(1, 1, kWebMCodecSubtitles, "Spock", ""); - const std::vector<uint8> buf = tb.Finish(); + const std::vector<uint8_t> buf = tb.Finish(); VerifyTextTrackInfo(&buf[0], buf.size(), kTextSubtitles, "Spock", ""); } @@ -81,7 +81,7 @@ TEST_F(WebMTracksParserTest, SubtitleNoNameYesLang) { TracksBuilder tb; tb.AddTextTrack(1, 1, kWebMCodecSubtitles, "", "eng"); - const std::vector<uint8> buf = tb.Finish(); + const std::vector<uint8_t> buf = tb.Finish(); VerifyTextTrackInfo(&buf[0], buf.size(), kTextSubtitles, "", "eng"); } @@ -91,7 +91,7 @@ TEST_F(WebMTracksParserTest, SubtitleYesNameYesLang) { TracksBuilder tb; tb.AddTextTrack(1, 1, kWebMCodecSubtitles, "Picard", "fre"); - const std::vector<uint8> buf = tb.Finish(); + const std::vector<uint8_t> buf = tb.Finish(); VerifyTextTrackInfo(&buf[0], buf.size(), kTextSubtitles, "Picard", "fre"); } @@ -102,7 +102,7 @@ TEST_F(WebMTracksParserTest, IgnoringTextTracks) { tb.AddTextTrack(1, 1, kWebMCodecSubtitles, "Subtitles", "fre"); tb.AddTextTrack(2, 2, kWebMCodecSubtitles, "Commentary", "fre"); - const std::vector<uint8> buf = tb.Finish(); + const std::vector<uint8_t> buf = tb.Finish(); scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(media_log_, true)); EXPECT_MEDIA_LOG(HasSubstr("Ignoring text track 1")); @@ -114,7 +114,7 @@ TEST_F(WebMTracksParserTest, IgnoringTextTracks) { EXPECT_EQ(parser->text_tracks().size(), 0u); - const std::set<int64>& ignored_tracks = parser->ignored_tracks(); + const std::set<int64_t>& ignored_tracks = parser->ignored_tracks(); EXPECT_TRUE(ignored_tracks.find(1) != ignored_tracks.end()); EXPECT_TRUE(ignored_tracks.find(2) != ignored_tracks.end()); @@ -137,7 +137,7 @@ TEST_F(WebMTracksParserTest, AudioVideoDefaultDurationUnset) { TracksBuilder tb; tb.AddAudioTrack(1, 1, "A_VORBIS", "audio", "", -1, 2, 8000); tb.AddVideoTrack(2, 2, "V_VP8", "video", "", -1, 320, 240); - const std::vector<uint8> buf = tb.Finish(); + const std::vector<uint8_t> buf = tb.Finish(); scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(media_log_, true)); int result = parser->Parse(&buf[0], buf.size()); @@ -166,7 +166,7 @@ TEST_F(WebMTracksParserTest, AudioVideoDefaultDurationSet) { TracksBuilder tb; tb.AddAudioTrack(1, 1, "A_VORBIS", "audio", "", 12345678, 2, 8000); tb.AddVideoTrack(2, 2, "V_VP8", "video", "", 987654321, 320, 240); - const std::vector<uint8> buf = tb.Finish(); + const std::vector<uint8_t> buf = tb.Finish(); scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(media_log_, true)); int result = parser->Parse(&buf[0], buf.size()); @@ -188,7 +188,7 @@ TEST_F(WebMTracksParserTest, InvalidZeroDefaultDurationSet) { // Confirm parse error if TrackEntry DefaultDuration is present, but is 0ns. TracksBuilder tb(true); tb.AddAudioTrack(1, 1, "A_VORBIS", "audio", "", 0, 2, 8000); - const std::vector<uint8> buf = tb.Finish(); + const std::vector<uint8_t> buf = tb.Finish(); scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(media_log_, true)); @@ -202,7 +202,7 @@ TEST_F(WebMTracksParserTest, HighTrackUID) { // (http://crbug.com/397067). TracksBuilder tb(true); tb.AddAudioTrack(1, 1ULL << 31, "A_VORBIS", "audio", "", 40, 2, 8000); - const std::vector<uint8> buf = tb.Finish(); + const std::vector<uint8_t> buf = tb.Finish(); scoped_ptr<WebMTracksParser> parser(new WebMTracksParser(media_log_, true)); EXPECT_GT(parser->Parse(&buf[0], buf.size()),0); diff --git a/media/formats/webm/webm_video_client.cc b/media/formats/webm/webm_video_client.cc index 29b7dca..6e57dfb 100644 --- a/media/formats/webm/webm_video_client.cc +++ b/media/formats/webm/webm_video_client.cc @@ -31,8 +31,10 @@ void WebMVideoClient::Reset() { } bool WebMVideoClient::InitializeConfig( - const std::string& codec_id, const std::vector<uint8>& codec_private, - bool is_encrypted, VideoDecoderConfig* config) { + const std::string& codec_id, + const std::vector<uint8_t>& codec_private, + bool is_encrypted, + VideoDecoderConfig* config) { DCHECK(config); VideoCodec video_codec = kUnknownVideoCodec; @@ -95,8 +97,8 @@ bool WebMVideoClient::InitializeConfig( return config->IsValidConfig(); } -bool WebMVideoClient::OnUInt(int id, int64 val) { - int64* dst = NULL; +bool WebMVideoClient::OnUInt(int id, int64_t val) { + int64_t* dst = NULL; switch (id) { case kWebMIdPixelWidth: @@ -144,7 +146,7 @@ bool WebMVideoClient::OnUInt(int id, int64 val) { return true; } -bool WebMVideoClient::OnBinary(int id, const uint8* data, int size) { +bool WebMVideoClient::OnBinary(int id, const uint8_t* data, int size) { // Accept binary fields we don't care about for now. return true; } diff --git a/media/formats/webm/webm_video_client.h b/media/formats/webm/webm_video_client.h index f2f1df4..12a6cbb 100644 --- a/media/formats/webm/webm_video_client.h +++ b/media/formats/webm/webm_video_client.h @@ -31,27 +31,27 @@ class WebMVideoClient : public WebMParserClient { // video track element fields. The contents of |config| are undefined in this // case and should not be relied upon. bool InitializeConfig(const std::string& codec_id, - const std::vector<uint8>& codec_private, + const std::vector<uint8_t>& codec_private, bool is_encrypted, VideoDecoderConfig* config); private: // WebMParserClient implementation. - bool OnUInt(int id, int64 val) override; - bool OnBinary(int id, const uint8* data, int size) override; + bool OnUInt(int id, int64_t val) override; + bool OnBinary(int id, const uint8_t* data, int size) override; bool OnFloat(int id, double val) override; scoped_refptr<MediaLog> media_log_; - int64 pixel_width_; - int64 pixel_height_; - int64 crop_bottom_; - int64 crop_top_; - int64 crop_left_; - int64 crop_right_; - int64 display_width_; - int64 display_height_; - int64 display_unit_; - int64 alpha_mode_; + int64_t pixel_width_; + int64_t pixel_height_; + int64_t crop_bottom_; + int64_t crop_top_; + int64_t crop_left_; + int64_t crop_right_; + int64_t display_width_; + int64_t display_height_; + int64_t display_unit_; + int64_t alpha_mode_; DISALLOW_COPY_AND_ASSIGN(WebMVideoClient); }; diff --git a/media/formats/webm/webm_webvtt_parser.cc b/media/formats/webm/webm_webvtt_parser.cc index 64de1ef..d84009c 100644 --- a/media/formats/webm/webm_webvtt_parser.cc +++ b/media/formats/webm/webm_webvtt_parser.cc @@ -6,7 +6,8 @@ namespace media { -void WebMWebVTTParser::Parse(const uint8* payload, int payload_size, +void WebMWebVTTParser::Parse(const uint8_t* payload, + int payload_size, std::string* id, std::string* settings, std::string* content) { @@ -14,10 +15,8 @@ void WebMWebVTTParser::Parse(const uint8* payload, int payload_size, parser.Parse(id, settings, content); } -WebMWebVTTParser::WebMWebVTTParser(const uint8* payload, int payload_size) - : ptr_(payload), - ptr_end_(payload + payload_size) { -} +WebMWebVTTParser::WebMWebVTTParser(const uint8_t* payload, int payload_size) + : ptr_(payload), ptr_end_(payload + payload_size) {} void WebMWebVTTParser::Parse(std::string* id, std::string* settings, @@ -27,7 +26,7 @@ void WebMWebVTTParser::Parse(std::string* id, content->assign(ptr_, ptr_end_); } -bool WebMWebVTTParser::GetByte(uint8* byte) { +bool WebMWebVTTParser::GetByte(uint8_t* byte) { if (ptr_ >= ptr_end_) return false; // indicates end-of-stream @@ -59,7 +58,7 @@ void WebMWebVTTParser::ParseLine(std::string* line) { }; for (;;) { - uint8 byte; + uint8_t byte; if (!GetByte(&byte) || byte == kLF) return; diff --git a/media/formats/webm/webm_webvtt_parser.h b/media/formats/webm/webm_webvtt_parser.h index 12bbbd4..75c3864 100644 --- a/media/formats/webm/webm_webvtt_parser.h +++ b/media/formats/webm/webm_webvtt_parser.h @@ -5,9 +5,11 @@ #ifndef MEDIA_FORMATS_WEBM_WEBM_WEBVTT_PARSER_H_ #define MEDIA_FORMATS_WEBM_WEBM_WEBVTT_PARSER_H_ +#include <stdint.h> + #include <string> -#include "base/basictypes.h" +#include "base/macros.h" #include "media/base/media_export.h" namespace media { @@ -15,7 +17,8 @@ namespace media { class MEDIA_EXPORT WebMWebVTTParser { public: // Utility function to parse the WebVTT cue from a byte stream. - static void Parse(const uint8* payload, int payload_size, + static void Parse(const uint8_t* payload, + int payload_size, std::string* id, std::string* settings, std::string* content); @@ -23,13 +26,13 @@ class MEDIA_EXPORT WebMWebVTTParser { private: // The payload is the embedded WebVTT cue, stored in a WebM block. // The parser treats this as a UTF-8 byte stream. - WebMWebVTTParser(const uint8* payload, int payload_size); + WebMWebVTTParser(const uint8_t* payload, int payload_size); // Parse the cue identifier, settings, and content from the stream. void Parse(std::string* id, std::string* settings, std::string* content); // Remove a byte from the stream, advancing the stream pointer. // Returns true if a character was returned; false means "end of stream". - bool GetByte(uint8* byte); + bool GetByte(uint8_t* byte); // Backup the stream pointer. void UngetByte(); @@ -38,8 +41,8 @@ class MEDIA_EXPORT WebMWebVTTParser { void ParseLine(std::string* line); // Represents the portion of the stream that has not been consumed yet. - const uint8* ptr_; - const uint8* const ptr_end_; + const uint8_t* ptr_; + const uint8_t* const ptr_end_; DISALLOW_COPY_AND_ASSIGN(WebMWebVTTParser); }; diff --git a/media/formats/webm/webm_webvtt_parser_unittest.cc b/media/formats/webm/webm_webvtt_parser_unittest.cc index ecdabd4..c40d1a1 100644 --- a/media/formats/webm/webm_webvtt_parser_unittest.cc +++ b/media/formats/webm/webm_webvtt_parser_unittest.cc @@ -10,13 +10,13 @@ using ::testing::InSequence; namespace media { -typedef std::vector<uint8> Cue; +typedef std::vector<uint8_t> Cue; static Cue EncodeCue(const std::string& id, const std::string& settings, const std::string& content) { const std::string result = id + '\n' + settings + '\n' + content; - const uint8* const buf = reinterpret_cast<const uint8*>(result.data()); + const uint8_t* const buf = reinterpret_cast<const uint8_t*>(result.data()); return Cue(buf, buf + result.length()); } |