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

cleanup: Convert all time parameters to signed 

This converts all time parameters to signed, finishing a cleanup that
was started in 2018 in b4256bf0.  This changes the type of:
  - timestamps
    - PTS specifically
  - timestamp offsets
  - timescales
  - durations

This excludes:
  - MP4 box definitions
  - DTS specifically

This is meant to address signed/unsigned conversion issues on arm64
that caused some test cases to fail.

Change-Id: Ic752a20cbc6e31fea6bc0894d1771833171e7cbe
This commit is contained in:
Joey Parrish 2021-08-04 11:56:44 -07:00
parent eba176f032
commit cfbe5c08c2
146 changed files with 546 additions and 514 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
packager/app/muxer_factory.h
View File

@ -42,7 +42,7 @@ class MuxerFactory {
/// this will replace the clock for all muxers created after this call.
void OverrideClock(base::Clock* clock);
void SetTsStreamOffset(uint32_t offset_ms) {
void SetTsStreamOffset(int32_t offset_ms) {
transport_stream_timestamp_offset_ms_ = offset_ms;
}
@ -52,7 +52,7 @@ class MuxerFactory {
const Mp4OutputParams mp4_params_;
const std::string temp_dir_;
uint32_t transport_stream_timestamp_offset_ms_ = 0;
int32_t transport_stream_timestamp_offset_ms_ = 0;
base::Clock* clock_ = nullptr;
};

2
packager/file/http_file.cc
View File

@ -157,7 +157,7 @@ HttpFile::HttpFile(HttpMethod method,
const std::string& url,
const std::string& upload_content_type,
const std::vector<std::string>& headers,
uint32_t timeout_in_seconds)
int32_t timeout_in_seconds)
: File(url.c_str()),
url_(url),
upload_content_type_(upload_content_type),

4
packager/file/http_file.h
View File

@ -42,7 +42,7 @@ class HttpFile : public File {
const std::string& url,
const std::string& upload_content_type,
const std::vector<std::string>& headers,
uint32_t timeout_in_seconds);
int32_t timeout_in_seconds);
HttpFile(const HttpFile&) = delete;
HttpFile& operator=(const HttpFile&) = delete;
@ -75,7 +75,7 @@ class HttpFile : public File {
const std::string url_;
const std::string upload_content_type_;
const uint32_t timeout_in_seconds_;
const int32_t timeout_in_seconds_;
const HttpMethod method_;
IoCache download_cache_;
IoCache upload_cache_;

10
packager/hls/base/hls_notifier.h
View File

@ -48,7 +48,7 @@ class HlsNotifier {
/// @return true on success, false otherwise. This may fail if the stream
/// specified by @a stream_id does not exist.
virtual bool NotifySampleDuration(uint32_t stream_id,
uint32_t sample_duration) = 0;
int32_t sample_duration) = 0;
/// @param stream_id is the value set by NotifyNewStream().
/// @param segment_name is the name of the new segment.
@ -60,8 +60,8 @@ class HlsNotifier {
/// @param size is the size in bytes.
virtual bool NotifyNewSegment(uint32_t stream_id,
const std::string& segment_name,
uint64_t start_time,
uint64_t duration,
int64_t start_time,
int64_t duration,
uint64_t start_byte_offset,
uint64_t size) = 0;
@ -72,14 +72,14 @@ class HlsNotifier {
/// @param start_byte_offset is the offset of where the keyframe starts.
/// @param size is the size in bytes.
virtual bool NotifyKeyFrame(uint32_t stream_id,
uint64_t timestamp,
int64_t timestamp,
uint64_t start_byte_offset,
uint64_t size) = 0;
/// @param stream_id is the value set by NotifyNewStream().
/// @param timestamp is the timestamp of the CueEvent.
/// @return true on success, false otherwise.
virtual bool NotifyCueEvent(uint32_t stream_id, uint64_t timestamp) = 0;
virtual bool NotifyCueEvent(uint32_t stream_id, int64_t timestamp) = 0;
/// @param stream_id is the value set by NotifyNewStream().
/// @param key_id is the key ID for the stream.

14
packager/hls/base/media_playlist.cc
View File

@ -25,7 +25,7 @@ namespace shaka {
namespace hls {
namespace {
uint32_t GetTimeScale(const MediaInfo& media_info) {
int32_t GetTimeScale(const MediaInfo& media_info) {
if (media_info.has_reference_time_scale())
return media_info.reference_time_scale();
@ -34,7 +34,7 @@ uint32_t GetTimeScale(const MediaInfo& media_info) {
if (media_info.has_audio_info())
return media_info.audio_info().time_scale();
return 0u;
return 0;
}
std::string AdjustVideoCodec(const std::string& codec) {
@ -103,7 +103,7 @@ void AppendExtXMap(const MediaInfo& media_info, std::string* out) {
std::string CreatePlaylistHeader(
const MediaInfo& media_info,
uint32_t target_duration,
int32_t target_duration,
HlsPlaylistType type,
MediaPlaylist::MediaPlaylistStreamType stream_type,
uint32_t media_sequence_number,
@ -371,7 +371,7 @@ void MediaPlaylist::SetCharacteristicsForTesting(
}
bool MediaPlaylist::SetMediaInfo(const MediaInfo& media_info) {
const uint32_t time_scale = GetTimeScale(media_info);
const int32_t time_scale = GetTimeScale(media_info);
if (time_scale == 0) {
LOG(ERROR) << "MediaInfo does not contain a valid timescale.";
return false;
@ -400,7 +400,7 @@ bool MediaPlaylist::SetMediaInfo(const MediaInfo& media_info) {
return true;
}
void MediaPlaylist::SetSampleDuration(uint32_t sample_duration) {
void MediaPlaylist::SetSampleDuration(int32_t sample_duration) {
if (media_info_.has_video_info())
media_info_.mutable_video_info()->set_frame_duration(sample_duration);
}
@ -506,7 +506,7 @@ double MediaPlaylist::GetLongestSegmentDuration() const {
return longest_segment_duration_seconds_;
}
void MediaPlaylist::SetTargetDuration(uint32_t target_duration) {
void MediaPlaylist::SetTargetDuration(int32_t target_duration) {
if (target_duration_set_) {
if (target_duration_ == target_duration)
return;
@ -664,7 +664,7 @@ void MediaPlaylist::SlideWindow() {
hls_params_.playlist_type != HlsPlaylistType::kLive) {
return;
}
DCHECK_GT(time_scale_, 0u);
DCHECK_GT(time_scale_, 0);
if (current_buffer_depth_ <= hls_params_.time_shift_buffer_depth)
return;

8
packager/hls/base/media_playlist.h
View File

@ -103,7 +103,7 @@ class MediaPlaylist {
/// Sample duration is not available right away especially. This allows
/// setting the sample duration after the Media Playlist has been initialized.
/// @param sample_duration is the duration of a sample.
virtual void SetSampleDuration(uint32_t sample_duration);
virtual void SetSampleDuration(int32_t sample_duration);
/// Segments must be added in order.
/// @param file_name is the file name of the segment.
@ -183,7 +183,7 @@ class MediaPlaylist {
/// The spec does not allow changing EXT-X-TARGETDURATION. However, this class
/// has no control over the input source.
/// @param target_duration is the target duration for this playlist.
virtual void SetTargetDuration(uint32_t target_duration);
virtual void SetTargetDuration(int32_t target_duration);
/// @return number of channels for audio. 0 is returned for video.
virtual int GetNumChannels() const;
@ -265,7 +265,7 @@ class MediaPlaylist {
int discontinuity_sequence_number_ = 0;
double longest_segment_duration_seconds_ = 0.0;
uint32_t time_scale_ = 0;
int32_t time_scale_ = 0;
BandwidthEstimator bandwidth_estimator_;
@ -275,7 +275,7 @@ class MediaPlaylist {
// See SetTargetDuration() comments.
bool target_duration_set_ = false;
uint32_t target_duration_ = 0;
int32_t target_duration_ = 0;
// TODO(kqyang): This could be managed better by a separate class, than having
// all them managed in MediaPlaylist.

6
packager/hls/base/media_playlist_unittest.cc
View File

@ -27,7 +27,7 @@ namespace {
const char kDefaultPlaylistFileName[] = "default_playlist.m3u8";
const double kTimeShiftBufferDepth = 20;
const uint64_t kTimeScale = 90000;
const int64_t kTimeScale = 90000;
const uint64_t kMBytes = 1000000;
const uint64_t kZeroByteOffset = 0;
@ -1002,8 +1002,8 @@ const char kIgnoredSegmentName[] = "ignored_segment_name";
const char kSegmentTemplateTime[] = "memory://$Time$.mp4";
const char kSegmentTemplateTimeUrl[] = "video/$Time$.mp4";
const uint64_t kInitialStartTime = 0;
const uint64_t kDuration = kTimeScale;
const int64_t kInitialStartTime = 0;
const int64_t kDuration = kTimeScale;
} // namespace
class MediaPlaylistDeleteSegmentsTest

2
packager/hls/base/mock_media_playlist.h
View File

@ -46,7 +46,7 @@ class MockMediaPlaylist : public MediaPlaylist {
MOCK_CONST_METHOD0(MaxBitrate, uint64_t());
MOCK_CONST_METHOD0(AvgBitrate, uint64_t());
MOCK_CONST_METHOD0(GetLongestSegmentDuration, double());
MOCK_METHOD1(SetTargetDuration, void(uint32_t target_duration));
MOCK_METHOD1(SetTargetDuration, void(int32_t target_duration));
MOCK_CONST_METHOD0(GetNumChannels, int());
MOCK_CONST_METHOD0(GetEC3JocComplexity, int());
MOCK_CONST_METHOD0(GetAC4ImsFlag, bool());

14
packager/hls/base/simple_hls_notifier.cc
View File

@ -345,7 +345,7 @@ bool SimpleHlsNotifier::NotifyNewStream(const MediaInfo& media_info,
}
bool SimpleHlsNotifier::NotifySampleDuration(uint32_t stream_id,
uint32_t sample_duration) {
int32_t sample_duration) {
base::AutoLock auto_lock(lock_);
auto stream_iterator = stream_map_.find(stream_id);
if (stream_iterator == stream_map_.end()) {
@ -359,8 +359,8 @@ bool SimpleHlsNotifier::NotifySampleDuration(uint32_t stream_id,
bool SimpleHlsNotifier::NotifyNewSegment(uint32_t stream_id,
const std::string& segment_name,
uint64_t start_time,
uint64_t duration,
int64_t start_time,
int64_t duration,
uint64_t start_byte_offset,
uint64_t size) {
base::AutoLock auto_lock(lock_);
@ -377,8 +377,8 @@ bool SimpleHlsNotifier::NotifyNewSegment(uint32_t stream_id,
start_byte_offset, size);
// Update target duration.
uint32_t longest_segment_duration =
static_cast<uint32_t>(ceil(media_playlist->GetLongestSegmentDuration()));
int32_t longest_segment_duration =
static_cast<int32_t>(ceil(media_playlist->GetLongestSegmentDuration()));
bool target_duration_updated = false;
if (longest_segment_duration > target_duration_) {
target_duration_ = longest_segment_duration;
@ -409,7 +409,7 @@ bool SimpleHlsNotifier::NotifyNewSegment(uint32_t stream_id,
}
bool SimpleHlsNotifier::NotifyKeyFrame(uint32_t stream_id,
uint64_t timestamp,
int64_t timestamp,
uint64_t start_byte_offset,
uint64_t size) {
base::AutoLock auto_lock(lock_);
@ -423,7 +423,7 @@ bool SimpleHlsNotifier::NotifyKeyFrame(uint32_t stream_id,
return true;
}
bool SimpleHlsNotifier::NotifyCueEvent(uint32_t stream_id, uint64_t timestamp) {
bool SimpleHlsNotifier::NotifyCueEvent(uint32_t stream_id, int64_t timestamp) {
base::AutoLock auto_lock(lock_);
auto stream_iterator = stream_map_.find(stream_id);
if (stream_iterator == stream_map_.end()) {

12
packager/hls/base/simple_hls_notifier.h
View File

@ -50,18 +50,18 @@ class SimpleHlsNotifier : public HlsNotifier {
const std::string& group_id,
uint32_t* stream_id) override;
bool NotifySampleDuration(uint32_t stream_id,
uint32_t sample_duration) override;
int32_t sample_duration) override;
bool NotifyNewSegment(uint32_t stream_id,
const std::string& segment_name,
uint64_t start_time,
uint64_t duration,
int64_t start_time,
int64_t duration,
uint64_t start_byte_offset,
uint64_t size) override;
bool NotifyKeyFrame(uint32_t stream_id,
uint64_t timestamp,
int64_t timestamp,
uint64_t start_byte_offset,
uint64_t size) override;
bool NotifyCueEvent(uint32_t container_id, uint64_t timestamp) override;
bool NotifyCueEvent(uint32_t container_id, int64_t timestamp) override;
bool NotifyEncryptionUpdate(
uint32_t stream_id,
const std::vector<uint8_t>& key_id,
@ -80,7 +80,7 @@ class SimpleHlsNotifier : public HlsNotifier {
};
std::string master_playlist_dir_;
uint32_t target_duration_ = 0;
int32_t target_duration_ = 0;
std::unique_ptr<MediaPlaylistFactory> media_playlist_factory_;
std::unique_ptr<MasterPlaylist> master_playlist_;

26
packager/hls/base/simple_hls_notifier_unittest.cc
View File

@ -79,8 +79,8 @@ const double kTestTimeShiftBufferDepth = 1800.0;
const char kTestPrefix[] = "http://testprefix.com/";
const char kAnyOutputDir[] = "anything";
const uint64_t kAnyStartTime = 10;
const uint64_t kAnyDuration = 1000;
const int64_t kAnyStartTime = 10;
const int64_t kAnyDuration = 1000;
const uint64_t kAnySize = 2000;
const char kCencProtectionScheme[] = "cenc";
@ -209,8 +209,8 @@ TEST_F(SimpleHlsNotifierTest, NotifyNewSegment) {
EXPECT_CALL(*factory, CreateMock(_, _, _, _))
.WillOnce(Return(mock_media_playlist));
const uint64_t kStartTime = 1328;
const uint64_t kDuration = 398407;
const int64_t kStartTime = 1328;
const int64_t kDuration = 398407;
const uint64_t kSize = 6595840;
const std::string segment_name = "segmentname";
EXPECT_CALL(*mock_media_playlist,
@ -218,7 +218,7 @@ TEST_F(SimpleHlsNotifierTest, NotifyNewSegment) {
kDuration, 203, kSize));
const double kLongestSegmentDuration = 11.3;
const uint32_t kTargetDuration = 12; // ceil(kLongestSegmentDuration).
const int32_t kTargetDuration = 12; // ceil(kLongestSegmentDuration).
EXPECT_CALL(*mock_media_playlist, GetLongestSegmentDuration())
.WillOnce(Return(kLongestSegmentDuration));
@ -261,7 +261,7 @@ TEST_F(SimpleHlsNotifierTest, NotifyKeyFrame) {
const uint32_t stream_id =
SetupStream(kCencProtectionScheme, mock_media_playlist, &notifier);
const uint64_t kTimestamp = 12345;
const int64_t kTimestamp = 12345;
const uint64_t kStartByteOffset = 888;
const uint64_t kSize = 555;
EXPECT_CALL(*mock_media_playlist,
@ -369,7 +369,7 @@ TEST_F(SimpleHlsNotifierTest, NotifyCueEvent) {
SetupStream(kCencProtectionScheme, mock_media_playlist, &notifier);
EXPECT_CALL(*mock_media_playlist, AddPlacementOpportunity());
const uint64_t kCueEventTimestamp = 12345;
const int64_t kCueEventTimestamp = 12345;
EXPECT_TRUE(notifier.NotifyCueEvent(stream_id, kCueEventTimestamp));
}
@ -538,8 +538,8 @@ TEST_P(LiveOrEventSimpleHlsNotifierTest, NotifyNewSegment) {
EXPECT_CALL(*factory, CreateMock(_, _, _, _))
.WillOnce(Return(mock_media_playlist));
const uint64_t kStartTime = 1328;
const uint64_t kDuration = 398407;
const int64_t kStartTime = 1328;
const int64_t kDuration = 398407;
const uint64_t kSize = 6595840;
const std::string segment_name = "segmentname";
EXPECT_CALL(*mock_media_playlist,
@ -547,7 +547,7 @@ TEST_P(LiveOrEventSimpleHlsNotifierTest, NotifyNewSegment) {
kDuration, _, kSize));
const double kLongestSegmentDuration = 11.3;
const uint32_t kTargetDuration = 12; // ceil(kLongestSegmentDuration).
const int32_t kTargetDuration = 12; // ceil(kLongestSegmentDuration).
EXPECT_CALL(*mock_media_playlist, GetLongestSegmentDuration())
.WillOnce(Return(kLongestSegmentDuration));
@ -578,8 +578,8 @@ TEST_P(LiveOrEventSimpleHlsNotifierTest, NotifyNewSegment) {
}
TEST_P(LiveOrEventSimpleHlsNotifierTest, NotifyNewSegmentsWithMultipleStreams) {
const uint64_t kStartTime = 1328;
const uint64_t kDuration = 398407;
const int64_t kStartTime = 1328;
const int64_t kDuration = 398407;
const uint64_t kSize = 6595840;
InSequence in_sequence;
@ -619,7 +619,7 @@ TEST_P(LiveOrEventSimpleHlsNotifierTest, NotifyNewSegmentsWithMultipleStreams) {
EXPECT_CALL(*mock_media_playlist1, AddSegment(_, _, _, _, _)).Times(1);
const double kLongestSegmentDuration = 11.3;
const uint32_t kTargetDuration = 12; // ceil(kLongestSegmentDuration).
const int32_t kTargetDuration = 12; // ceil(kLongestSegmentDuration).
EXPECT_CALL(*mock_media_playlist1, GetLongestSegmentDuration())
.WillOnce(Return(kLongestSegmentDuration));

34
packager/media/base/audio_stream_info.cc
View File

@ -65,15 +65,31 @@ FourCC CodecToFourCC(Codec codec) {
}
} // namespace
AudioStreamInfo::AudioStreamInfo(
int track_id, uint32_t time_scale, uint64_t duration, Codec codec,
const std::string& codec_string, const uint8_t* codec_config,
size_t codec_config_size, uint8_t sample_bits, uint8_t num_channels,
uint32_t sampling_frequency, uint64_t seek_preroll_ns,
uint64_t codec_delay_ns, uint32_t max_bitrate, uint32_t avg_bitrate,
const std::string& language, bool is_encrypted)
: StreamInfo(kStreamAudio, track_id, time_scale, duration, codec,
codec_string, codec_config, codec_config_size, language,
AudioStreamInfo::AudioStreamInfo(int track_id,
int32_t time_scale,
int64_t duration,
Codec codec,
const std::string& codec_string,
const uint8_t* codec_config,
size_t codec_config_size,
uint8_t sample_bits,
uint8_t num_channels,
uint32_t sampling_frequency,
uint64_t seek_preroll_ns,
uint64_t codec_delay_ns,
uint32_t max_bitrate,
uint32_t avg_bitrate,
const std::string& language,
bool is_encrypted)
: StreamInfo(kStreamAudio,
track_id,
time_scale,
duration,
codec,
codec_string,
codec_config,
codec_config_size,
language,
is_encrypted),
sample_bits_(sample_bits),
num_channels_(num_channels),

22
packager/media/base/audio_stream_info.h
View File

@ -18,13 +18,21 @@ namespace media {
class AudioStreamInfo : public StreamInfo {
public:
/// Construct an initialized audio stream info object.
AudioStreamInfo(int track_id, uint32_t time_scale, uint64_t duration,
Codec codec, const std::string& codec_string,
const uint8_t* codec_config, size_t codec_config_size,
uint8_t sample_bits, uint8_t num_channels,
uint32_t sampling_frequency, uint64_t seek_preroll_ns,
uint64_t codec_delay_ns, uint32_t max_bitrate,
uint32_t avg_bitrate, const std::string& language,
AudioStreamInfo(int track_id,
int32_t time_scale,
int64_t duration,
Codec codec,
const std::string& codec_string,
const uint8_t* codec_config,
size_t codec_config_size,
uint8_t sample_bits,
uint8_t num_channels,
uint32_t sampling_frequency,
uint64_t seek_preroll_ns,
uint64_t codec_delay_ns,
uint32_t max_bitrate,
uint32_t avg_bitrate,
const std::string& language,
bool is_encrypted);
~AudioStreamInfo() override;

2
packager/media/base/audio_timestamp_helper.cc
View File

@ -10,7 +10,7 @@
namespace shaka {
namespace media {
AudioTimestampHelper::AudioTimestampHelper(uint32_t timescale,
AudioTimestampHelper::AudioTimestampHelper(int32_t timescale,
uint32_t samples_per_second)
: base_timestamp_(kNoTimestamp), frame_count_(0) {
DCHECK_GT(samples_per_second, 0u);

3
packager/media/base/audio_timestamp_helper.h
View File

@ -29,8 +29,7 @@ namespace media {
// accumulated frames to reach a target timestamp.
class AudioTimestampHelper {
public:
explicit AudioTimestampHelper(uint32_t timescale,
uint32_t samples_per_second);
explicit AudioTimestampHelper(int32_t timescale, uint32_t samples_per_second);
// Sets the base timestamp to |base_timestamp| and the sets count to 0.
void SetBaseTimestamp(int64_t base_timestamp);

2
packager/media/base/audio_timestamp_helper_unittest.cc
View File

@ -11,7 +11,7 @@ namespace shaka {
namespace media {
static const uint32_t kDefaultSampleRate = 44100;
static const uint32_t kTimescale = 1000000;
static const int32_t kTimescale = 1000000;
class AudioTimestampHelperTest : public ::testing::Test {
public:

2
packager/media/base/http_key_fetcher.cc
View File

@ -24,7 +24,7 @@ constexpr size_t kBufferSize = 64 * 1024;
HttpKeyFetcher::HttpKeyFetcher() : timeout_in_seconds_(0) {}
HttpKeyFetcher::HttpKeyFetcher(uint32_t timeout_in_seconds)
HttpKeyFetcher::HttpKeyFetcher(int32_t timeout_in_seconds)
: timeout_in_seconds_(timeout_in_seconds) {}
HttpKeyFetcher::~HttpKeyFetcher() {}

4
packager/media/base/http_key_fetcher.h
View File

@ -28,7 +28,7 @@ class HttpKeyFetcher : public KeyFetcher {
HttpKeyFetcher();
/// Create a fetcher with timeout.
/// @param timeout_in_seconds specifies the timeout in seconds.
HttpKeyFetcher(uint32_t timeout_in_seconds);
HttpKeyFetcher(int32_t timeout_in_seconds);
~HttpKeyFetcher() override;
/// @name KeyFetcher implementation overrides.
@ -56,7 +56,7 @@ class HttpKeyFetcher : public KeyFetcher {
Status FetchInternal(HttpMethod method, const std::string& url,
const std::string& data, std::string* response);
const uint32_t timeout_in_seconds_;
const int32_t timeout_in_seconds_;
DISALLOW_COPY_AND_ASSIGN(HttpKeyFetcher);
};

4
packager/media/base/http_key_fetcher_unittest.cc
View File

@ -80,7 +80,7 @@ TEST(DISABLED_HttpKeyFetcherTest, UrlWithPort) {
}
TEST(DISABLED_HttpKeyFetcherTest, SmallTimeout) {
const uint32_t kTimeoutInSeconds = 1;
const int32_t kTimeoutInSeconds = 1;
HttpKeyFetcher fetcher(kTimeoutInSeconds);
std::string response;
Status status = fetcher.FetchKeys(kTestUrl, kDelayTwoSecs, &response);
@ -88,7 +88,7 @@ TEST(DISABLED_HttpKeyFetcherTest, SmallTimeout) {
}
TEST(DISABLED_HttpKeyFetcherTest, BigTimeout) {
const uint32_t kTimeoutInSeconds = 5;
const int32_t kTimeoutInSeconds = 5;
HttpKeyFetcher fetcher(kTimeoutInSeconds);
std::string response;
Status status = fetcher.FetchKeys(kTestUrl, kDelayTwoSecs, &response);

2
packager/media/base/key_source.h
View File

@ -87,7 +87,7 @@ class KeySource {
/// key. Owner retains ownership, and may not be NULL.
/// @return OK on success, an error status otherwise.
virtual Status GetCryptoPeriodKey(uint32_t crypto_period_index,
uint32_t crypto_period_duration_in_seconds,
int32_t crypto_period_duration_in_seconds,
const std::string& stream_label,
EncryptionKey* key) = 0;

16
packager/media/base/media_handler_test_base.cc
View File

@ -14,7 +14,7 @@
namespace {
const int kTrackId = 1;
const uint64_t kDuration = 10000;
const int64_t kDuration = 10000;
const char kCodecString[] = "codec string";
const uint8_t kSampleBits = 1;
const uint8_t kNumChannels = 2;
@ -175,25 +175,25 @@ bool MediaHandlerTestBase::IsVideoCodec(Codec codec) const {
}
std::unique_ptr<StreamInfo> MediaHandlerTestBase::GetVideoStreamInfo(
uint32_t time_scale) const {
int32_t time_scale) const {
return GetVideoStreamInfo(time_scale, kCodecVP9, kWidth, kHeight);
}
std::unique_ptr<StreamInfo> MediaHandlerTestBase::GetVideoStreamInfo(
uint32_t time_scale,
int32_t time_scale,
uint32_t width,
uint64_t height) const {
return GetVideoStreamInfo(time_scale, kCodecVP9, width, height);
}
std::unique_ptr<StreamInfo> MediaHandlerTestBase::GetVideoStreamInfo(
uint32_t time_scale,
int32_t time_scale,
Codec codec) const {
return GetVideoStreamInfo(time_scale, codec, kWidth, kHeight);
}
std::unique_ptr<StreamInfo> MediaHandlerTestBase::GetVideoStreamInfo(
uint32_t time_scale,
int32_t time_scale,
Codec codec,
uint32_t width,
uint64_t height) const {
@ -205,12 +205,12 @@ std::unique_ptr<StreamInfo> MediaHandlerTestBase::GetVideoStreamInfo(
}
std::unique_ptr<StreamInfo> MediaHandlerTestBase::GetAudioStreamInfo(
uint32_t time_scale) const {
int32_t time_scale) const {
return GetAudioStreamInfo(time_scale, kCodecAAC);
}
std::unique_ptr<StreamInfo> MediaHandlerTestBase::GetAudioStreamInfo(
uint32_t time_scale,
int32_t time_scale,
Codec codec) const {
return std::unique_ptr<AudioStreamInfo>(new AudioStreamInfo(
kTrackId, time_scale, kDuration, codec, kCodecString, kCodecConfig,
@ -254,7 +254,7 @@ std::unique_ptr<SegmentInfo> MediaHandlerTestBase::GetSegmentInfo(
}
std::unique_ptr<StreamInfo> MediaHandlerTestBase::GetTextStreamInfo(
uint32_t timescale) const {
int32_t timescale) const {
// None of this information is actually used by the text out handler.
// The stream info is just needed to signal the start of the stream.
return std::unique_ptr<StreamInfo>(

14
packager/media/base/media_handler_test_base.h
View File

@ -292,23 +292,23 @@ class MediaHandlerTestBase : public ::testing::Test {
protected:
bool IsVideoCodec(Codec codec) const;
std::unique_ptr<StreamInfo> GetVideoStreamInfo(uint32_t time_scale) const;
std::unique_ptr<StreamInfo> GetVideoStreamInfo(int32_t time_scale) const;
std::unique_ptr<StreamInfo> GetVideoStreamInfo(uint32_t time_scale,
std::unique_ptr<StreamInfo> GetVideoStreamInfo(int32_t time_scale,
uint32_t width,
uint64_t height) const;
std::unique_ptr<StreamInfo> GetVideoStreamInfo(uint32_t time_scale,
std::unique_ptr<StreamInfo> GetVideoStreamInfo(int32_t time_scale,
Codec codec) const;
std::unique_ptr<StreamInfo> GetVideoStreamInfo(uint32_t time_scale,
std::unique_ptr<StreamInfo> GetVideoStreamInfo(int32_t time_scale,
Codec codec,
uint32_t width,
uint64_t height) const;
std::unique_ptr<StreamInfo> GetAudioStreamInfo(uint32_t time_scale) const;
std::unique_ptr<StreamInfo> GetAudioStreamInfo(int32_t time_scale) const;
std::unique_ptr<StreamInfo> GetAudioStreamInfo(uint32_t time_scale,
std::unique_ptr<StreamInfo> GetAudioStreamInfo(int32_t time_scale,
Codec codec) const;
std::shared_ptr<MediaSample> GetMediaSample(int64_t timestamp,
@ -325,7 +325,7 @@ class MediaHandlerTestBase : public ::testing::Test {
int64_t duration,
bool is_subsegment) const;
std::unique_ptr<StreamInfo> GetTextStreamInfo(uint32_t timescale) const;
std::unique_ptr<StreamInfo> GetTextStreamInfo(int32_t timescale) const;
std::unique_ptr<TextSample> GetTextSample(const std::string& id,
int64_t start,

2
packager/media/base/muxer_options.h
View File

@ -26,7 +26,7 @@ struct MuxerOptions {
// A positive value, in milliseconds, by which output timestamps are offset to
// compensate for negative timestamps in the input.
uint32_t transport_stream_timestamp_offset_ms = 0;
int32_t transport_stream_timestamp_offset_ms = 0;
/// Output file name. If segment_template is not specified, the Muxer
/// generates this single output file with all segments concatenated;

2
packager/media/base/muxer_util.cc
View File

@ -109,7 +109,7 @@ Status ValidateSegmentTemplate(const std::string& segment_template) {
}
std::string GetSegmentName(const std::string& segment_template,
uint64_t segment_start_time,
int64_t segment_start_time,
uint32_t segment_index,
uint32_t bandwidth) {
DCHECK_EQ(Status::OK, ValidateSegmentTemplate(segment_template));

2
packager/media/base/muxer_util.h
View File

@ -33,7 +33,7 @@ Status ValidateSegmentTemplate(const std::string& segment_template);
/// @param bandwidth represents the bit rate, in bits/sec, of the stream.
/// @return The segment name with identifier substituted.
std::string GetSegmentName(const std::string& segment_template,
uint64_t segment_start_time,
int64_t segment_start_time,
uint32_t segment_index,
uint32_t bandwidth);

6
packager/media/base/muxer_util_unittest.cc
View File

@ -61,7 +61,7 @@ TEST(MuxerUtilTest, ValidateSegmentTemplateWithFormatTag) {
}
TEST(MuxerUtilTest, GetSegmentName) {
const uint64_t kSegmentStartTime = 180180;
const int64_t kSegmentStartTime = 180180;
const uint32_t kSegmentIndex = 11;
const uint32_t kBandwidth = 1234;
EXPECT_EQ("12", GetSegmentName("$Number$",
@ -118,7 +118,7 @@ TEST(MuxerUtilTest, GetSegmentName) {
}
TEST(MuxerUtilTest, GetSegmentNameWithIndexZero) {
const uint64_t kSegmentStartTime = 0;
const int64_t kSegmentStartTime = 0;
const uint32_t kSegmentIndex = 0;
const uint32_t kBandwidth = 0;
EXPECT_EQ("1", GetSegmentName("$Number$",
@ -143,7 +143,7 @@ TEST(MuxerUtilTest, GetSegmentNameWithIndexZero) {
}
TEST(MuxerUtilTest, GetSegmentNameLargeTime) {
const uint64_t kSegmentStartTime = 1601599839840ULL;
const int64_t kSegmentStartTime = 1601599839840ULL;
const uint32_t kSegmentIndex = 8888888;
const uint32_t kBandwidth = 444444;
EXPECT_EQ("1601599839840",

7
packager/media/base/playready_key_source.cc
View File

@ -23,7 +23,7 @@ namespace media {
namespace {
const uint32_t kHttpFetchTimeout = 60; // In seconds
const int32_t kHttpFetchTimeout = 60; // In seconds
const std::string kAcquireLicenseRequest =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
"<soap:Envelope xmlns=\"http://schemas.xmlsoap.org/soap/envelope/\" "
@ -194,8 +194,9 @@ Status PlayReadyKeySource::GetKey(const std::vector<uint8_t>& key_id,
return Status::OK;
}
Status PlayReadyKeySource::GetCryptoPeriodKey(uint32_t crypto_period_index,
uint32_t crypto_period_duration_in_seconds,
Status PlayReadyKeySource::GetCryptoPeriodKey(
uint32_t crypto_period_index,
int32_t crypto_period_duration_in_seconds,
const std::string& stream_label,
EncryptionKey* key) {
// TODO(robinconnell): Implement key rotation.

2
packager/media/base/playready_key_source.h
View File

@ -35,7 +35,7 @@ class PlayReadyKeySource : public KeySource {
Status GetKey(const std::vector<uint8_t>& key_id,
EncryptionKey* key) override;
Status GetCryptoPeriodKey(uint32_t crypto_period_index,
uint32_t crypto_period_duration_in_seconds,
int32_t crypto_period_duration_in_seconds,
const std::string& stream_label,
EncryptionKey* key) override;
/// @}

5
packager/media/base/raw_key_source.cc
View File

@ -58,8 +58,9 @@ Status RawKeySource::GetKey(const std::vector<uint8_t>& key_id,
" was not found.");
}
Status RawKeySource::GetCryptoPeriodKey(uint32_t crypto_period_index,
uint32_t crypto_period_duration_in_seconds,
Status RawKeySource::GetCryptoPeriodKey(
uint32_t crypto_period_index,
int32_t crypto_period_duration_in_seconds,
const std::string& stream_label,
EncryptionKey* key) {
RETURN_IF_ERROR(GetKey(stream_label, key));

2
packager/media/base/raw_key_source.h
View File

@ -30,7 +30,7 @@ class RawKeySource : public KeySource {
Status GetKey(const std::vector<uint8_t>& key_id,
EncryptionKey* key) override;
Status GetCryptoPeriodKey(uint32_t crypto_period_index,
uint32_t crypto_period_duration_in_seconds,
int32_t crypto_period_duration_in_seconds,
const std::string& stream_label,
EncryptionKey* key) override;
/// @}

4
packager/media/base/stream_info.cc
View File

@ -33,8 +33,8 @@ std::string StreamTypeToString(StreamType type) {
StreamInfo::StreamInfo(StreamType stream_type,
int track_id,
uint32_t time_scale,
uint64_t duration,
int32_t time_scale,
int64_t duration,
Codec codec,
const std::string& codec_string,
const uint8_t* codec_config,

14
packager/media/base/stream_info.h
View File

@ -70,8 +70,8 @@ class StreamInfo {
StreamInfo(StreamType stream_type,
int track_id,
uint32_t time_scale,
uint64_t duration,
int32_t time_scale,
int64_t duration,
Codec codec,
const std::string& codec_string,
const uint8_t* codec_config,
@ -95,8 +95,8 @@ class StreamInfo {
StreamType stream_type() const { return stream_type_; }
uint32_t track_id() const { return track_id_; }
uint32_t time_scale() const { return time_scale_; }
uint64_t duration() const { return duration_; }
int32_t time_scale() const { return time_scale_; }
int64_t duration() const { return duration_; }
Codec codec() const { return codec_; }
const std::string& codec_string() const { return codec_string_; }
const std::vector<uint8_t>& codec_config() const { return codec_config_; }
@ -107,7 +107,7 @@ class StreamInfo {
return encryption_config_;
}
void set_duration(uint64_t duration) { duration_ = duration; }
void set_duration(int64_t duration) { duration_ = duration; }
void set_codec(Codec codec) { codec_ = codec; }
void set_codec_config(const std::vector<uint8_t>& data) {
codec_config_ = data;
@ -129,9 +129,9 @@ class StreamInfo {
StreamType stream_type_;
uint32_t track_id_;
// The actual time is calculated as time / time_scale_ in seconds.
uint32_t time_scale_;
int32_t time_scale_;
// Duration base on time_scale.
uint64_t duration_;
int64_t duration_;
Codec codec_;
std::string codec_string_;
std::string language_;

4
packager/media/base/text_muxer.cc
View File

@ -76,8 +76,8 @@ Status TextMuxer::FinalizeSegment(size_t stream_id,
const std::string& segment_template = options().segment_template;
DCHECK(!segment_template.empty());
const uint32_t index = segment_index_++;
const uint64_t start = segment_info.start_timestamp;
const uint64_t duration = segment_info.duration;
const int64_t start = segment_info.start_timestamp;
const int64_t duration = segment_info.duration;
const uint32_t bandwidth = options().bandwidth;
const std::string filename =

4
packager/media/base/text_muxer.h
View File

@ -36,8 +36,8 @@ class TextMuxer : public Muxer {
/// also clear any buffered samples.
virtual Status WriteToFile(const std::string& filename, uint64_t* size) = 0;
uint64_t total_duration_ms_ = 0;
uint64_t last_cue_ms_ = 0;
int64_t total_duration_ms_ = 0;
int64_t last_cue_ms_ = 0;
uint32_t segment_index_ = 0;
};

21
packager/media/base/text_stream_info.cc
View File

@ -11,16 +11,25 @@
namespace shaka {
namespace media {
TextStreamInfo::TextStreamInfo(int track_id, uint32_t time_scale,
uint64_t duration,
TextStreamInfo::TextStreamInfo(int track_id,
int32_t time_scale,
int64_t duration,
Codec codec,
const std::string& codec_string,
const std::string& codec_config, uint16_t width,
uint16_t height, const std::string& language)
: StreamInfo(kStreamText, track_id, time_scale, duration, codec,
const std::string& codec_config,
uint16_t width,
uint16_t height,
const std::string& language)
: StreamInfo(kStreamText,
track_id,
time_scale,
duration,
codec,
codec_string,
reinterpret_cast<const uint8_t*>(codec_config.data()),
codec_config.size(), language, false),
codec_config.size(),
language,
false),
width_(width),
height_(height) {}

10
packager/media/base/text_stream_info.h
View File

@ -60,11 +60,15 @@ class TextStreamInfo : public StreamInfo {
/// @param width of the text. This may be 0.
/// @param height of the text. This may be 0.
/// @param language is the language of this stream. This may be empty.
TextStreamInfo(int track_id, uint32_t time_scale, uint64_t duration,
TextStreamInfo(int track_id,
int32_t time_scale,
int64_t duration,
Codec codec,
const std::string& codec_string,
const std::string& codec_config, uint16_t width,
uint16_t height, const std::string& language);
const std::string& codec_config,
uint16_t width,
uint16_t height,
const std::string& language);
~TextStreamInfo() override;

4
packager/media/base/video_stream_info.cc
View File

@ -39,8 +39,8 @@ std::string VideoCodecToString(Codec codec) {
} // namespace
VideoStreamInfo::VideoStreamInfo(int track_id,
uint32_t time_scale,
uint64_t duration,
int32_t time_scale,
int64_t duration,
Codec codec,
H26xStreamFormat h26x_stream_format,
const std::string& codec_string,

4
packager/media/base/video_stream_info.h
View File

@ -28,8 +28,8 @@ class VideoStreamInfo : public StreamInfo {
/// @param pixel_width is the width of the pixel. 0 if unknown.
/// @param pixel_height is the height of the pixels. 0 if unknown.
VideoStreamInfo(int track_id,
uint32_t time_scale,
uint64_t duration,
int32_t time_scale,
int64_t duration,
Codec codec,
H26xStreamFormat h26x_stream_format,
const std::string& codec_string,

5
packager/media/base/widevine_key_source.cc
View File

@ -216,8 +216,9 @@ Status WidevineKeySource::GetKey(const std::vector<uint8_t>& key_id,
"Cannot find key with specified key ID");
}
Status WidevineKeySource::GetCryptoPeriodKey(uint32_t crypto_period_index,
uint32_t crypto_period_duration_in_seconds,
Status WidevineKeySource::GetCryptoPeriodKey(
uint32_t crypto_period_index,
int32_t crypto_period_duration_in_seconds,
const std::string& stream_label,
EncryptionKey* key) {
DCHECK(key_production_thread_.HasBeenStarted());

4
packager/media/base/widevine_key_source.h
View File

@ -48,7 +48,7 @@ class WidevineKeySource : public KeySource {
Status GetKey(const std::vector<uint8_t>& key_id,
EncryptionKey* key) override;
Status GetCryptoPeriodKey(uint32_t crypto_period_index,
uint32_t crypto_period_duration_in_seconds,
int32_t crypto_period_duration_in_seconds,
const std::string& stream_label,
EncryptionKey* key) override;
/// @}
@ -130,7 +130,7 @@ class WidevineKeySource : public KeySource {
bool key_production_started_ = false;
base::WaitableEvent start_key_production_;
uint32_t first_crypto_period_index_ = 0;
uint32_t crypto_period_duration_in_seconds_ = 0;
int32_t crypto_period_duration_in_seconds_ = 0;
std::vector<uint8_t> group_id_;
bool enable_entitlement_license_ = false;
std::unique_ptr<EncryptionKeyQueue> key_pool_;

2
packager/media/chunking/chunking_handler.cc
View File

@ -88,7 +88,7 @@ Status ChunkingHandler::OnCueEvent(std::shared_ptr<const CueEvent> event) {
Status ChunkingHandler::OnMediaSample(
std::shared_ptr<const MediaSample> sample) {
DCHECK_NE(time_scale_, 0u) << "kStreamInfo should arrive before kMediaSample";
DCHECK_GT(time_scale_, 0) << "kStreamInfo should arrive before kMediaSample";
const int64_t timestamp = sample->pts();

2
packager/media/chunking/chunking_handler.h
View File

@ -81,7 +81,7 @@ class ChunkingHandler : public MediaHandler {
base::Optional<int64_t> segment_start_time_;
base::Optional<int64_t> subsegment_start_time_;
int64_t max_segment_time_ = 0;
uint32_t time_scale_ = 0;
int32_t time_scale_ = 0;
// The offset is applied to sample timestamps so a full segment is generated
// after cue points.

4
packager/media/chunking/chunking_handler_unittest.cc
View File

@ -20,8 +20,8 @@ namespace shaka {
namespace media {
namespace {
const size_t kStreamIndex = 0;
const uint32_t kTimeScale0 = 800;
const uint32_t kTimeScale1 = 1000;
const int32_t kTimeScale0 = 800;
const int32_t kTimeScale1 = 1000;
const int64_t kDuration = 300;
const bool kKeyFrame = true;
const bool kIsSubsegment = true;

4
packager/media/chunking/cue_alignment_handler.cc
View File

@ -46,7 +46,7 @@ int64_t GetScaledTime(const StreamInfo& info, const StreamData& data) {
double TimeInSeconds(const StreamInfo& info, const StreamData& data) {
const int64_t scaled_time = GetScaledTime(info, data);
const uint32_t time_scale = info.time_scale();
const int32_t time_scale = info.time_scale();
return static_cast<double>(scaled_time) / time_scale;
}
@ -55,7 +55,7 @@ double TextEndTimeInSeconds(const StreamInfo& info, const StreamData& data) {
DCHECK(data.text_sample);
const int64_t scaled_time = data.text_sample->EndTime();
const uint32_t time_scale = info.time_scale();
const int32_t time_scale = info.time_scale();
return static_cast<double>(scaled_time) / time_scale;
}

2
packager/media/chunking/cue_alignment_handler_unittest.cc
View File

@ -30,7 +30,7 @@ const size_t kThreeOutputs = 3;
const bool kKeyFrame = true;
const uint32_t kMsTimeScale = 1000;
const int32_t kMsTimeScale = 1000;
const size_t kStreamIndex = 0;
} // namespace

16
packager/media/chunking/text_chunker_unittest.cc
View File

@ -18,7 +18,7 @@ namespace media {
namespace {
const uint64_t kStreamIndex = 0;
const uint64_t kMsTimeScale = 1000u;
const int64_t kTimescaleMs = 1000;
const size_t kInputs = 1;
const size_t kOutputs = 1;
@ -29,8 +29,6 @@ const size_t kOutput = 0;
const bool kEncrypted = true;
const bool kSubSegment = true;
const uint64_t kTimescaleMs = 1000;
const char* kNoId = "";
const char* kNoPayload = "";
} // namespace
@ -83,7 +81,7 @@ TEST_F(TextChunkerTest, SegmentsStartAtFirstSample) {
}
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
kStreamIndex, GetTextStreamInfo(kMsTimeScale))));
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
@ -128,7 +126,7 @@ TEST_F(TextChunkerTest, SampleEndingOnSegmentStart) {
}
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
kStreamIndex, GetTextStreamInfo(kMsTimeScale))));
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
@ -188,7 +186,7 @@ TEST_F(TextChunkerTest, CreatesSegmentsForSamples) {
}
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
kStreamIndex, GetTextStreamInfo(kMsTimeScale))));
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
@ -258,7 +256,7 @@ TEST_F(TextChunkerTest, OutputsEmptySegments) {
}
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
kStreamIndex, GetTextStreamInfo(kMsTimeScale))));
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));
@ -409,7 +407,7 @@ TEST_F(TextChunkerTest, PreservesOrder) {
}
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
kStreamIndex, GetTextStreamInfo(kMsTimeScale))));
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
GetTextSample(kSampleAId, kSampleAStart, kSampleAEnd, kNoPayload))));
@ -508,7 +506,7 @@ TEST_F(TextChunkerTest, NestedSamples) {
}
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromStreamInfo(
kStreamIndex, GetTextStreamInfo(kMsTimeScale))));
kStreamIndex, GetTextStreamInfo(kTimescaleMs))));
ASSERT_OK(Input(kInput)->Dispatch(StreamData::FromTextSample(
kStreamIndex,
GetTextSample(kNoId, kSampleAStart, kSampleAEnd, kNoPayload))));

4
packager/media/crypto/encryption_handler.cc
View File

@ -279,8 +279,8 @@ Status EncryptionHandler::ProcessMediaSample(
// in that case.
const int64_t dts = std::max(clear_sample->dts(), static_cast<int64_t>(0));
const int64_t current_crypto_period_index = dts / crypto_period_duration_;
const uint32_t crypto_period_duration_in_seconds =
static_cast<uint32_t>(encryption_params_.crypto_period_duration_in_seconds);
const int32_t crypto_period_duration_in_seconds = static_cast<int32_t>(
encryption_params_.crypto_period_duration_in_seconds);
if (current_crypto_period_index != prev_crypto_period_index_) {
EncryptionKey encryption_key;
RETURN_IF_ERROR(key_source_->GetCryptoPeriodKey(

2
packager/media/crypto/encryption_handler.h
View File

@ -79,7 +79,7 @@ class EncryptionHandler : public MediaHandler {
// Remaining clear lead in the stream's time scale.
int64_t remaining_clear_lead_ = 0;
// Crypto period duration in the stream's time scale.
uint64_t crypto_period_duration_ = 0;
int64_t crypto_period_duration_ = 0;
// Previous crypto period index if key rotation is enabled.
int64_t prev_crypto_period_index_ = -1;
bool check_new_crypto_period_ = false;

4
packager/media/crypto/encryption_handler_unittest.cc
View File

@ -38,7 +38,7 @@ using ::testing::ValuesIn;
using ::testing::WithParamInterface;
const size_t kStreamIndex = 0;
const uint32_t kTimeScale = 1000;
const int32_t kTimeScale = 1000;
const char kAudioStreamLabel[] = "AUDIO";
const char kSdVideoStreamLabel[] = "SD";
@ -66,7 +66,7 @@ class MockKeySource : public RawKeySource {
Status(const std::string& stream_label, EncryptionKey* key));
MOCK_METHOD4(GetCryptoPeriodKey,
Status(uint32_t crypto_period_index,
uint32_t crypto_period_duration_in_seconds,
int32_t crypto_period_duration_in_seconds,
const std::string& stream_label,
EncryptionKey* key));
};

4
packager/media/crypto/subsample_generator_unittest.cc
View File

@ -52,8 +52,8 @@ const uint8_t kH264CodecConfig[] = {
};
const uint8_t kAV1CodecConfig[] = {0x00, 0x01, 0x02, 0x03};
const int kTrackId = 1;
const uint32_t kTimeScale = 1000;
const uint64_t kDuration = 10000;
const int32_t kTimeScale = 1000;
const int64_t kDuration = 10000;
const char kCodecString[] = "codec string";
const char kLanguage[] = "eng";
const bool kEncrypted = true;

4
packager/media/event/combined_muxer_listener.cc
View File

@ -35,7 +35,7 @@ void CombinedMuxerListener::OnEncryptionStart() {
void CombinedMuxerListener::OnMediaStart(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) {
for (auto& listener : muxer_listeners_) {
listener->OnMediaStart(muxer_options, stream_info, time_scale,
@ -43,7 +43,7 @@ void CombinedMuxerListener::OnMediaStart(const MuxerOptions& muxer_options,
}
}
void CombinedMuxerListener::OnSampleDurationReady(uint32_t sample_duration) {
void CombinedMuxerListener::OnSampleDurationReady(int32_t sample_duration) {
for (auto& listener : muxer_listeners_) {
listener->OnSampleDurationReady(sample_duration);
}

4
packager/media/event/combined_muxer_listener.h
View File

@ -34,9 +34,9 @@ class CombinedMuxerListener : public MuxerListener {
void OnEncryptionStart() override;
void OnMediaStart(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) override;
void OnSampleDurationReady(uint32_t sample_duration) override;
void OnSampleDurationReady(int32_t sample_duration) override;
void OnMediaEnd(const MediaRanges& media_ranges,
float duration_seconds) override;
void OnNewSegment(const std::string& file_name,

4
packager/media/event/hls_notify_muxer_listener.cc
View File

@ -84,7 +84,7 @@ void HlsNotifyMuxerListener::OnEncryptionStart() {
void HlsNotifyMuxerListener::OnMediaStart(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) {
std::unique_ptr<MediaInfo> media_info(new MediaInfo);
if (!internal::GenerateMediaInfo(muxer_options, stream_info, time_scale,
@ -125,7 +125,7 @@ void HlsNotifyMuxerListener::OnMediaStart(const MuxerOptions& muxer_options,
}
}
void HlsNotifyMuxerListener::OnSampleDurationReady(uint32_t sample_duration) {
void HlsNotifyMuxerListener::OnSampleDurationReady(int32_t sample_duration) {
if (stream_id_) {
// This happens in live mode.
hls_notifier_->NotifySampleDuration(stream_id_.value(), sample_duration);

4
packager/media/event/hls_notify_muxer_listener.h
View File

@ -59,9 +59,9 @@ class HlsNotifyMuxerListener : public MuxerListener {
void OnEncryptionStart() override;
void OnMediaStart(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) override;
void OnSampleDurationReady(uint32_t sample_duration) override;
void OnSampleDurationReady(int32_t sample_duration) override;
void OnMediaEnd(const MediaRanges& media_ranges,
float duration_seconds) override;
void OnNewSegment(const std::string& file_name,

18
packager/media/event/hls_notify_muxer_listener_unittest.cc
View File

@ -39,20 +39,20 @@ class MockHlsNotifier : public hls::HlsNotifier {
const std::string& group_id,
uint32_t* stream_id));
MOCK_METHOD2(NotifySampleDuration,
bool(uint32_t stream_id, uint32_t sample_duration));
bool(uint32_t stream_id, int32_t sample_duration));
MOCK_METHOD6(NotifyNewSegment,
bool(uint32_t stream_id,
const std::string& segment_name,
uint64_t start_time,
uint64_t duration,
int64_t start_time,
int64_t duration,
uint64_t start_byte_offset,
uint64_t size));
MOCK_METHOD4(NotifyKeyFrame,
bool(uint32_t stream_id,
uint64_t timestamp,
int64_t timestamp,
uint64_t start_byte_offset,
uint64_t size));
MOCK_METHOD2(NotifyCueEvent, bool(uint32_t stream_id, uint64_t timestamp));
MOCK_METHOD2(NotifyCueEvent, bool(uint32_t stream_id, int64_t timestamp));
MOCK_METHOD5(
NotifyEncryptionUpdate,
bool(uint32_t stream_id,
@ -75,13 +75,13 @@ const uint8_t kAnyData[] = {
};
const uint64_t kSegmentStartOffset = 10000;
const uint64_t kSegmentStartTime = 19283;
const uint64_t kSegmentDuration = 98028;
const int64_t kSegmentStartTime = 19283;
const int64_t kSegmentDuration = 98028;
const uint64_t kSegmentSize = 756739;
const uint64_t kCueStartTime = kSegmentStartTime;
const int64_t kCueStartTime = kSegmentStartTime;
const uint64_t kKeyFrameTimestamp = 20123;
const int64_t kKeyFrameTimestamp = 20123;
const uint64_t kKeyFrameStartByteOffset = 3456;
const uint64_t kKeyFrameSize = 543234;

4
packager/media/event/mock_muxer_listener.h
View File

@ -35,10 +35,10 @@ class MockMuxerListener : public MuxerListener {
MOCK_METHOD4(OnMediaStart,
void(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type));
MOCK_METHOD1(OnSampleDurationReady, void(uint32_t sample_duration));
MOCK_METHOD1(OnSampleDurationReady, void(int32_t sample_duration));
MOCK_METHOD9(OnMediaEndMock,
void(bool has_init_range,

8
packager/media/event/mpd_notify_muxer_listener.cc
View File

@ -57,10 +57,9 @@ void MpdNotifyMuxerListener::OnEncryptionInfoReady(
void MpdNotifyMuxerListener::OnEncryptionStart() {}
void MpdNotifyMuxerListener::OnMediaStart(
const MuxerOptions& muxer_options,
void MpdNotifyMuxerListener::OnMediaStart(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) {
std::unique_ptr<MediaInfo> media_info(new MediaInfo());
if (!internal::GenerateMediaInfo(muxer_options,
@ -108,8 +107,7 @@ void MpdNotifyMuxerListener::OnMediaStart(
// Record the sample duration in the media info for VOD so that OnMediaEnd, all
// the information is in the media info.
void MpdNotifyMuxerListener::OnSampleDurationReady(
uint32_t sample_duration) {
void MpdNotifyMuxerListener::OnSampleDurationReady(int32_t sample_duration) {
if (mpd_notifier_->dash_profile() == DashProfile::kLive) {
mpd_notifier_->NotifySampleDuration(notification_id_.value(),
sample_duration);

4
packager/media/event/mpd_notify_muxer_listener.h
View File

@ -42,9 +42,9 @@ class MpdNotifyMuxerListener : public MuxerListener {
void OnEncryptionStart() override;
void OnMediaStart(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) override;
void OnSampleDurationReady(uint32_t sample_duration) override;
void OnSampleDurationReady(int32_t sample_duration) override;
void OnMediaEnd(const MediaRanges& media_ranges,
float duration_seconds) override;
void OnNewSegment(const std::string& file_name,

56
packager/media/event/mpd_notify_muxer_listener_unittest.cc
View File

@ -279,7 +279,7 @@ TEST_F(MpdNotifyMuxerListenerTest, VodOnSampleDurationReady) {
VideoStreamInfoParameters video_params = GetDefaultVideoStreamInfoParams();
std::shared_ptr<StreamInfo> video_stream_info =
CreateVideoStreamInfo(video_params);
const uint32_t kSampleDuration = 1234u;
const int32_t kSampleDuration = 1234;
const char kExpectedMediaInfo[] =
"video_info {\n"
" frame_duration: 1234\n" // Should match the constant above.
@ -303,7 +303,7 @@ TEST_F(MpdNotifyMuxerListenerTest, VodOnSampleDurationReady) {
"media_file_name: 'test_output_file_name.mp4'\n"
"media_duration_seconds: 10.5\n";
const uint32_t kReferenceTimeScale = 1111u; // Should match the protobuf.
const int32_t kReferenceTimeScale = 1111; // Should match the protobuf.
EXPECT_CALL(*notifier_, NotifyNewContainer(_, _)).Times(0);
listener_->OnMediaStart(muxer_options, *video_stream_info,
@ -326,7 +326,7 @@ TEST_F(MpdNotifyMuxerListenerTest, VodOnSampleDurationReadySegmentList) {
VideoStreamInfoParameters video_params = GetDefaultVideoStreamInfoParams();
std::shared_ptr<StreamInfo> video_stream_info =
CreateVideoStreamInfo(video_params);
const uint32_t kSampleDuration = 1234u;
const int32_t kSampleDuration = 1234;
const char kExpectedMediaInfo[] =
"video_info {\n"
" frame_duration: 1234\n" // Should match the constant above.
@ -353,7 +353,7 @@ TEST_F(MpdNotifyMuxerListenerTest, VodOnSampleDurationReadySegmentList) {
" begin: 222\n"
" end: 9999\n"
"}\n";
const uint32_t kReferenceTimeScale = 1111u; // Should match the protobuf.
const int32_t kReferenceTimeScale = 1111; // Should match the protobuf.
EXPECT_CALL(*notifier_, NotifyNewContainer(_, _)).Times(0);
listener_->OnMediaStart(muxer_options, *video_stream_info,
@ -378,11 +378,11 @@ TEST_F(MpdNotifyMuxerListenerTest, VodOnNewSegment) {
std::shared_ptr<StreamInfo> video_stream_info =
CreateVideoStreamInfo(video_params);
const uint64_t kStartTime1 = 0u;
const uint64_t kDuration1 = 1000u;
const int64_t kStartTime1 = 0;
const int64_t kDuration1 = 1000;
const uint64_t kSegmentFileSize1 = 29812u;
const uint64_t kStartTime2 = 1001u;
const uint64_t kDuration2 = 3787u;
const int64_t kStartTime2 = 1001;
const int64_t kDuration2 = 3787;
const uint64_t kSegmentFileSize2 = 83743u;
EXPECT_CALL(*notifier_, NotifyNewContainer(_, _)).Times(0);
@ -416,11 +416,11 @@ TEST_F(MpdNotifyMuxerListenerTest, VodOnNewSegmentSegmentList) {
std::shared_ptr<StreamInfo> video_stream_info =
CreateVideoStreamInfo(video_params);
const uint64_t kStartTime1 = 0u;
const uint64_t kDuration1 = 1000u;
const int64_t kStartTime1 = 0;
const int64_t kDuration1 = 1000;
const uint64_t kSegmentFileSize1 = 29812u;
const uint64_t kStartTime2 = 1001u;
const uint64_t kDuration2 = 3787u;
const int64_t kStartTime2 = 1001;
const int64_t kDuration2 = 3787;
const uint64_t kSegmentFileSize2 = 83743u;
EXPECT_CALL(*notifier_, NotifyNewContainer(_, _)).Times(0);
@ -466,11 +466,11 @@ TEST_F(MpdNotifyMuxerListenerTest, VodMultipleFiles) {
std::shared_ptr<StreamInfo> video_stream_info =
CreateVideoStreamInfo(video_params);
const uint64_t kStartTime1 = 0u;
const uint64_t kDuration1 = 1000u;
const int64_t kStartTime1 = 0;
const int64_t kDuration1 = 1000;
const uint64_t kSegmentFileSize1 = 29812u;
const uint64_t kStartTime2 = 1001u;
const uint64_t kDuration2 = 3787u;
const int64_t kStartTime2 = 1001;
const int64_t kDuration2 = 3787;
const uint64_t kSegmentFileSize2 = 83743u;
// Expectation for first file before OnMediaEnd.
@ -528,11 +528,11 @@ TEST_F(MpdNotifyMuxerListenerTest, VodMultipleFilesSegmentList) {
std::shared_ptr<StreamInfo> video_stream_info =
CreateVideoStreamInfo(video_params);
const uint64_t kStartTime1 = 0u;
const uint64_t kDuration1 = 1000u;
const int64_t kStartTime1 = 0;
const int64_t kDuration1 = 1000;
const uint64_t kSegmentFileSize1 = 29812u;
const uint64_t kStartTime2 = 1001u;
const uint64_t kDuration2 = 3787u;
const int64_t kStartTime2 = 1001;
const int64_t kDuration2 = 3787;
const uint64_t kSegmentFileSize2 = 83743u;
// Expectation for first file before OnMediaEnd.
@ -605,11 +605,11 @@ TEST_P(MpdNotifyMuxerListenerTest, LiveNoKeyRotation) {
" include_mspr_pro: 1\n"
"}\n";
const uint64_t kStartTime1 = 0u;
const uint64_t kDuration1 = 1000u;
const int64_t kStartTime1 = 0;
const int64_t kDuration1 = 1000;
const uint64_t kSegmentFileSize1 = 29812u;
const uint64_t kStartTime2 = 1001u;
const uint64_t kDuration2 = 3787u;
const int64_t kStartTime2 = 1001;
const int64_t kDuration2 = 3787;
const uint64_t kSegmentFileSize2 = 83743u;
const std::vector<uint8_t> default_key_id(
kDefaultKeyId, kDefaultKeyId + arraysize(kDefaultKeyId) - 1);
@ -678,11 +678,11 @@ TEST_P(MpdNotifyMuxerListenerTest, LiveWithKeyRotation) {
" include_mspr_pro: 1\n"
"}\n";
const uint64_t kStartTime1 = 0u;
const uint64_t kDuration1 = 1000u;
const int64_t kStartTime1 = 0;
const int64_t kDuration1 = 1000;
const uint64_t kSegmentFileSize1 = 29812u;
const uint64_t kStartTime2 = 1001u;
const uint64_t kDuration2 = 3787u;
const int64_t kStartTime2 = 1001;
const int64_t kDuration2 = 3787;
const uint64_t kSegmentFileSize2 = 83743u;
const std::vector<uint8_t> default_key_id(
kDefaultKeyId, kDefaultKeyId + arraysize(kDefaultKeyId) - 1);

2
packager/media/event/multi_codec_muxer_listener.cc
View File

@ -15,7 +15,7 @@ namespace media {
void MultiCodecMuxerListener::OnMediaStart(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) {
size_t num_codecs = 0;
for (const std::string& codec_string :

2
packager/media/event/multi_codec_muxer_listener.h
View File

@ -27,7 +27,7 @@ class MultiCodecMuxerListener : public CombinedMuxerListener {
/// @{
void OnMediaStart(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) override;
/// @}

6
packager/media/event/multi_codec_muxer_listener_unittest.cc
View File

@ -23,10 +23,10 @@ using ::testing::StrictMock;
namespace {
const uint64_t kSegmentStartTime = 19283;
const uint64_t kSegmentDuration = 98028;
const int64_t kSegmentStartTime = 19283;
const int64_t kSegmentDuration = 98028;
const uint64_t kSegmentSize = 756739;
const uint32_t kTimescale = 90000;
const int32_t kTimescale = 90000;
MuxerListener::ContainerType kContainer = MuxerListener::kContainerMpeg2ts;
} // namespace

4
packager/media/event/muxer_listener.h
View File

@ -97,12 +97,12 @@ class MuxerListener {
/// @param container_type is the container of this media.
virtual void OnMediaStart(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) = 0;
/// Called when the average sample duration of the media is determined.
/// @param sample_duration in timescale of the media.
virtual void OnSampleDurationReady(uint32_t sample_duration) = 0;
virtual void OnSampleDurationReady(int32_t sample_duration) = 0;
/// Called when all files are written out and the muxer object does not output
/// any more files.

2
packager/media/event/muxer_listener_internal.cc
View File

@ -226,7 +226,7 @@ MediaInfo GetCompatibleComparisonMediaInfo(const MediaInfo& media_info) {
bool GenerateMediaInfo(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t reference_time_scale,
int32_t reference_time_scale,
MuxerListener::ContainerType container_type,
MediaInfo* media_info) {
DCHECK(media_info);

2
packager/media/event/muxer_listener_internal.h
View File

@ -29,7 +29,7 @@ namespace internal {
/// @return true on success, false otherwise.
bool GenerateMediaInfo(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t reference_time_scale_,
int32_t reference_time_scale_,
MuxerListener::ContainerType container_type,
MediaInfo* media_info);

2
packager/media/event/muxer_listener_internal_unittest.cc
View File

@ -15,7 +15,7 @@ namespace shaka {
namespace media {
namespace internal {
namespace {
const uint32_t kReferenceTimeScale = 1000;
const int32_t kReferenceTimeScale = 1000;
} // namespace
class MuxerListenerInternalTest : public ::testing::Test {};

4
packager/media/event/muxer_listener_test_helper.cc
View File

@ -29,8 +29,8 @@ std::shared_ptr<VideoStreamInfo> CreateVideoStreamInfo(
VideoStreamInfoParameters GetDefaultVideoStreamInfoParams() {
const int kTrackId = 0;
const uint32_t kTimeScale = 10;
const uint64_t kVideoStreamDuration = 200;
const int32_t kTimeScale = 10;
const int64_t kVideoStreamDuration = 200;
const Codec kH264Codec = kCodecH264;
const char* kCodecString = "avc1.010101";
const char* kLanuageUndefined = "und";

10
packager/media/event/muxer_listener_test_helper.h
View File

@ -70,7 +70,7 @@ const char kExpectedDefaultMediaInfoSubsegmentRange[] =
" end: 9999\n"
"}\n";
const uint32_t kDefaultReferenceTimeScale = 1000u;
const int32_t kDefaultReferenceTimeScale = 1000;
// Struct that gets passed for to CreateVideoStreamInfo() to create a
// StreamInfo instance. Useful for generating multiple VideoStreamInfo with
@ -79,8 +79,8 @@ struct VideoStreamInfoParameters {
VideoStreamInfoParameters();
~VideoStreamInfoParameters();
int track_id;
uint32_t time_scale;
uint64_t duration;
int32_t time_scale;
int64_t duration;
Codec codec;
std::string codec_string;
std::string language;
@ -95,8 +95,8 @@ struct VideoStreamInfoParameters {
struct OnNewSegmentParameters {
std::string file_name;
uint64_t start_time;
uint64_t duration;
int64_t start_time;
int64_t duration;
uint64_t segment_file_size;
};

4
packager/media/event/vod_media_info_dump_muxer_listener.cc
View File

@ -46,7 +46,7 @@ void VodMediaInfoDumpMuxerListener::OnEncryptionInfoReady(
void VodMediaInfoDumpMuxerListener::OnMediaStart(
const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) {
DCHECK(muxer_options.segment_template.empty());
media_info_.reset(new MediaInfo());
@ -68,7 +68,7 @@ void VodMediaInfoDumpMuxerListener::OnMediaStart(
void VodMediaInfoDumpMuxerListener::OnEncryptionStart() {}
void VodMediaInfoDumpMuxerListener::OnSampleDurationReady(
uint32_t sample_duration) {
int32_t sample_duration) {
// Assume one VideoInfo.
if (media_info_->has_video_info()) {
media_info_->mutable_video_info()->set_frame_duration(sample_duration);

4
packager/media/event/vod_media_info_dump_muxer_listener.h
View File

@ -41,9 +41,9 @@ class VodMediaInfoDumpMuxerListener : public MuxerListener {
void OnEncryptionStart() override;
void OnMediaStart(const MuxerOptions& muxer_options,
const StreamInfo& stream_info,
uint32_t time_scale,
int32_t time_scale,
ContainerType container_type) override;
void OnSampleDurationReady(uint32_t sample_duration) override;
void OnSampleDurationReady(int32_t sample_duration) override;
void OnMediaEnd(const MediaRanges& media_ranges,
float duration_seconds) override;
void OnNewSegment(const std::string& file_name,

2
packager/media/event/vod_media_info_dump_muxer_listener_unittest.cc
View File

@ -88,7 +88,7 @@ class VodMediaInfoDumpMuxerListenerTest : public ::testing::Test {
bool enable_encryption) {
MuxerOptions muxer_options;
SetDefaultMuxerOptions(&muxer_options);
const uint32_t kReferenceTimeScale = 1000;
const int32_t kReferenceTimeScale = 1000;
if (enable_encryption) {
std::vector<uint8_t> bogus_default_key_id(
kBogusDefaultKeyId,

2
packager/media/formats/mp2t/es_parser_h26x.cc
View File

@ -326,7 +326,7 @@ bool EsParserH26x::EmitFrame(int64_t access_unit_pos,
const int64_t kArbitrarySmallDuration = 0.001 * kMpeg2Timescale; // 1ms.
pending_sample_->set_duration(kArbitrarySmallDuration);
} else {
uint64_t sample_duration = media_sample->dts() - pending_sample_->dts();
int64_t sample_duration = media_sample->dts() - pending_sample_->dts();
pending_sample_->set_duration(sample_duration);
const int kArbitraryGapScale = 10;

2
packager/media/formats/mp2t/es_parser_h26x.h
View File

@ -127,7 +127,7 @@ class EsParserH26x : public EsParser {
// Frame for which we do not yet have a duration.
std::shared_ptr<MediaSample> pending_sample_;
uint64_t pending_sample_duration_ = 0;
int64_t pending_sample_duration_ = 0;
// Indicates whether waiting for first key frame.
bool waiting_for_key_frame_ = true;

2
packager/media/formats/mp2t/mp2t_common.h
View File

@ -22,7 +22,7 @@
namespace shaka {
namespace media {
const uint32_t kMpeg2Timescale = 90000;
const int32_t kMpeg2Timescale = 90000;
} // namespace media
} // namespace shaka

2
packager/media/formats/mp2t/pes_packet_generator.cc
View File

@ -31,7 +31,7 @@ const double kTsTimescale = 90000.0;
} // namespace
PesPacketGenerator::PesPacketGenerator(
uint32_t transport_stream_timestamp_offset)
int32_t transport_stream_timestamp_offset)
: transport_stream_timestamp_offset_(transport_stream_timestamp_offset) {}
PesPacketGenerator::~PesPacketGenerator() {}

4
packager/media/formats/mp2t/pes_packet_generator.h
View File

@ -31,7 +31,7 @@ class PesPacketGenerator {
/// @param transport_stream_timestamp_offset is the offset to be applied to
/// sample timestamps to compensate for possible negative timestamps in
/// the input.
explicit PesPacketGenerator(uint32_t transport_stream_timestamp_offset);
explicit PesPacketGenerator(int32_t transport_stream_timestamp_offset);
virtual ~PesPacketGenerator();
/// Initialize the object. This clears the internal state first so any
@ -65,7 +65,7 @@ class PesPacketGenerator {
StreamType stream_type_;
const uint32_t transport_stream_timestamp_offset_ = 0;
const int32_t transport_stream_timestamp_offset_ = 0;
// Calculated by 90000 / input stream's timescale. This is used to scale the
// timestamps.
double timescale_scale_ = 0.0;

14
packager/media/formats/mp2t/pes_packet_generator_unittest.cc
View File

@ -36,7 +36,7 @@ using ::testing::SetArgPointee;
namespace {
const uint32_t kZeroTransportStreamTimestampOffset = 0;
const int32_t kZeroTransportStreamTimestampOffset = 0;
// Bogus data for testing.
const uint8_t kAnyData[] = {
@ -75,8 +75,8 @@ const uint8_t kVideoExtraData[] = {
const uint8_t kAudioExtraData[] = {0x12, 0x10};
const int kTrackId = 0;
const uint32_t kTimeScale = 90000;
const uint64_t kDuration = 180000;
const int32_t kTimeScale = 90000;
const int64_t kDuration = 180000;
const char kCodecString[] = "avc1";
const char kLanguage[] = "eng";
const uint32_t kWidth = 1280;
@ -198,7 +198,7 @@ TEST_F(PesPacketGeneratorTest, AddVideoSample) {
std::shared_ptr<MediaSample> sample =
MediaSample::CopyFrom(kAnyData, arraysize(kAnyData), kIsKeyFrame);
const uint32_t kPts = 12345;
const int32_t kPts = 12345;
const uint32_t kDts = 12300;
sample->set_pts(kPts);
sample->set_dts(kDts);
@ -236,7 +236,7 @@ TEST_F(PesPacketGeneratorTest, AddEncryptedVideoSample) {
std::shared_ptr<MediaSample> sample =
MediaSample::CopyFrom(kAnyData, arraysize(kAnyData), kIsKeyFrame);
const uint32_t kPts = 12345;
const int32_t kPts = 12345;
const uint32_t kDts = 12300;
sample->set_pts(kPts);
sample->set_dts(kDts);
@ -352,7 +352,7 @@ TEST_F(PesPacketGeneratorTest, AddAudioSampleFailedToConvert) {
// Because TS has to use 90000 as its timescale, make sure that the timestamps
// are scaled.
TEST_F(PesPacketGeneratorTest, TimeStampScaling) {
const uint32_t kTestTimescale = 1000;
const int32_t kTestTimescale = 1000;
std::shared_ptr<VideoStreamInfo> stream_info(new VideoStreamInfo(
kTrackId, kTestTimescale, kDuration, kH264Codec,
H26xStreamFormat::kAnnexbByteStream, kCodecString, kVideoExtraData,
@ -365,7 +365,7 @@ TEST_F(PesPacketGeneratorTest, TimeStampScaling) {
std::shared_ptr<MediaSample> sample =
MediaSample::CopyFrom(kAnyData, arraysize(kAnyData), kIsKeyFrame);
const uint32_t kPts = 5000;
const int32_t kPts = 5000;
const uint32_t kDts = 4000;
sample->set_pts(kPts);
sample->set_dts(kDts);

2
packager/media/formats/mp2t/ts_muxer.cc
View File

@ -11,7 +11,7 @@ namespace media {
namespace mp2t {
namespace {
const uint32_t kTsTimescale = 90000;
const int32_t kTsTimescale = 90000;
} // namespace
TsMuxer::TsMuxer(const MuxerOptions& muxer_options) : Muxer(muxer_options) {}

3
packager/media/formats/mp2t/ts_segmenter.cc
View File

@ -163,8 +163,7 @@ Status TsSegmenter::WritePesPackets() {
return Status::OK;
}
Status TsSegmenter::FinalizeSegment(uint64_t start_timestamp,
uint64_t duration) {
Status TsSegmenter::FinalizeSegment(int64_t start_timestamp, int64_t duration) {
if (!pes_packet_generator_->Flush()) {
return Status(error::MUXER_FAILURE, "Failed to flush PesPacketGenerator.");
}

4
packager/media/formats/mp2t/ts_segmenter.h
View File

@ -58,7 +58,7 @@ class TsSegmenter {
// TODO(kqyang): Remove the usage of segment start timestamp and duration in
// xx_segmenter, which could cause confusions on which is the source of truth
// as the segment start timestamp and duration could be tracked locally.
Status FinalizeSegment(uint64_t start_timestamp, uint64_t duration);
Status FinalizeSegment(int64_t start_timestamp, int64_t duration);
/// Only for testing.
void InjectTsWriterForTesting(std::unique_ptr<TsWriter> writer);
@ -83,7 +83,7 @@ class TsSegmenter {
Codec codec_ = kUnknownCodec;
std::vector<uint8_t> audio_codec_config_;
const uint32_t transport_stream_timestamp_offset_ = 0;
const int32_t transport_stream_timestamp_offset_ = 0;
// Scale used to scale the input stream to TS's timesccale (which is 90000).
// Used for calculating the duration in seconds fo the current segment.
double timescale_scale_ = 1.0;

10
packager/media/formats/mp2t/ts_segmenter_unittest.cc
View File

@ -36,9 +36,9 @@ const uint8_t kExtraData[] = {
0x00,
};
const int kTrackId = 0;
const uint32_t kZeroTransportStreamTimestampOffset = 0;
const uint32_t kTimeScale = 90000;
const uint64_t kDuration = 180000;
const int32_t kZeroTransportStreamTimestampOffset = 0;
const int32_t kTimeScale = 90000;
const int64_t kDuration = 180000;
const char kCodecString[] = "avc1";
const char kLanguage[] = "eng";
const uint32_t kWidth = 1280;
@ -181,7 +181,7 @@ TEST_F(TsSegmenterTest, AddSample) {
TEST_F(TsSegmenterTest, PassedSegmentDuration) {
// Use something significantly smaller than 90000 to check that the scaling is
// done correctly in the segmenter.
const uint32_t kInputTimescale = 1001;
const int32_t kInputTimescale = 1001;
std::shared_ptr<VideoStreamInfo> stream_info(new VideoStreamInfo(
kTrackId, kInputTimescale, kDuration, kH264Codec,
H26xStreamFormat::kAnnexbByteStream, kCodecString, kExtraData,
@ -194,7 +194,7 @@ TEST_F(TsSegmenterTest, PassedSegmentDuration) {
MockMuxerListener mock_listener;
TsSegmenter segmenter(options, &mock_listener);
const uint32_t kFirstPts = 1000;
const int32_t kFirstPts = 1000;
EXPECT_CALL(*mock_pes_packet_generator_, Initialize(_))
.WillOnce(Return(true));

4
packager/media/formats/mp4/decoding_time_iterator.cc
View File

@ -37,12 +37,12 @@ bool DecodingTimeIterator::IsValid() const {
sample_index_ < iterator_->sample_count;
}
uint64_t DecodingTimeIterator::Duration(uint32_t start_sample,
int64_t DecodingTimeIterator::Duration(uint32_t start_sample,
uint32_t end_sample) const {
DCHECK_LE(start_sample, end_sample);
uint32_t current_sample = 0;
uint32_t prev_sample = 0;
uint64_t duration = 0;
int64_t duration = 0;
std::vector<DecodingTime>::const_iterator it = decoding_time_table_.begin();
for (; it != decoding_time_table_.end(); ++it) {
current_sample += it->sample_count;

2
packager/media/formats/mp4/decoding_time_iterator.h
View File

@ -40,7 +40,7 @@ class DecodingTimeIterator {
uint32_t sample_delta() const { return iterator_->sample_delta; }
/// @return Duration from start_sample to end_sample, both 1-based, inclusive.
uint64_t Duration(uint32_t start_sample, uint32_t end_sample) const;
int64_t Duration(uint32_t start_sample, uint32_t end_sample) const;
/// @return Total number of samples in the table.
uint32_t NumSamples() const;

2
packager/media/formats/mp4/decoding_time_iterator_unittest.cc
View File

@ -19,7 +19,7 @@ class DecodingTimeIteratorTest : public testing::Test {
public:
DecodingTimeIteratorTest() {
// Build decoding time table from kDecodingTimes.
uint32_t decoding_time = 0;
int32_t decoding_time = 0;
uint32_t length = sizeof(kDecodingTimes) / sizeof(DecodingTime);
for (uint32_t i = 0; i < length; ++i) {
for (uint32_t j = 0; j < kDecodingTimes[i].sample_count; ++j) {

3
packager/media/formats/mp4/fragmenter.cc
View File

@ -90,8 +90,7 @@ Status Fragmenter::AddSample(const MediaSample& sample) {
if (stream_info_->stream_type() == StreamType::kStreamVideo &&
sample.is_key_frame()) {
key_frame_infos_.push_back(
{static_cast<uint64_t>(pts), data_->Size(), sample.data_size()});
key_frame_infos_.push_back({pts, data_->Size(), sample.data_size()});
}
data_->AppendArray(sample.data(), sample.data_size());

6
packager/media/formats/mp4/fragmenter.h
View File

@ -59,9 +59,9 @@ class Fragmenter {
void ClearFragmentFinalized() { fragment_finalized_ = false; }
uint64_t fragment_duration() const { return fragment_duration_; }
uint64_t first_sap_time() const { return first_sap_time_; }
uint64_t earliest_presentation_time() const {
int64_t fragment_duration() const { return fragment_duration_; }
int64_t first_sap_time() const { return first_sap_time_; }
int64_t earliest_presentation_time() const {
return earliest_presentation_time_;
}
bool fragment_initialized() const { return fragment_initialized_; }

2
packager/media/formats/mp4/key_frame_info.h
View File

@ -15,7 +15,7 @@ namespace mp4 {
/// Tracks key frame information.
struct KeyFrameInfo {
uint64_t timestamp;
int64_t timestamp;
uint64_t start_byte_offset;
uint64_t size;
};

10
packager/media/formats/mp4/mp4_media_parser.cc
View File

@ -39,9 +39,9 @@ namespace media {
namespace mp4 {
namespace {
uint64_t Rescale(uint64_t time_in_old_scale,
uint32_t old_scale,
uint32_t new_scale) {
int64_t Rescale(int64_t time_in_old_scale,
int32_t old_scale,
int32_t new_scale) {
return (static_cast<double>(time_in_old_scale) / old_scale) * new_scale;
}
@ -386,10 +386,10 @@ bool MP4MediaParser::ParseMoov(BoxReader* reader) {
for (std::vector<Track>::const_iterator track = moov_->tracks.begin();
track != moov_->tracks.end(); ++track) {
const uint32_t timescale = track->media.header.timescale;
const int32_t timescale = track->media.header.timescale;
// Calculate duration (based on timescale).
uint64_t duration = 0;
int64_t duration = 0;
if (track->media.header.duration > 0) {
duration = track->media.header.duration;
} else if (moov_->extends.header.fragment_duration > 0) {

2
packager/media/formats/mp4/mp4_muxer.cc
View File

@ -655,7 +655,7 @@ void MP4Muxer::FireOnMediaStartEvent() {
}
DCHECK(!streams().empty()) << "Media started without a stream.";
const uint32_t timescale = segmenter_->GetReferenceTimeScale();
const int32_t timescale = segmenter_->GetReferenceTimeScale();
muxer_listener()->OnMediaStart(options(), *streams().front(), timescale,
MuxerListener::kContainerMp4);
}

2
packager/media/formats/mp4/multi_segment_segmenter.cc
View File

@ -148,7 +148,7 @@ Status MultiSegmentSegmenter::WriteSegment() {
", possibly file permission issue or running out of disk space.");
}
uint64_t segment_duration = 0;
int64_t segment_duration = 0;
// ISO/IEC 23009-1:2012: the value shall be identical to sum of the the
// values of all Subsegment_duration fields in the first ‘sidx’ box.
for (size_t i = 0; i < sidx()->references.size(); ++i)

15
packager/media/formats/mp4/segmenter.cc
View File

@ -28,9 +28,9 @@ namespace mp4 {
namespace {
uint64_t Rescale(uint64_t time_in_old_scale,
uint32_t old_scale,
uint32_t new_scale) {
int64_t Rescale(int64_t time_in_old_scale,
int32_t old_scale,
int32_t new_scale) {
return static_cast<double>(time_in_old_scale) / old_scale * new_scale;
}
@ -111,10 +111,11 @@ Status Segmenter::Finalize() {
// file for VOD and static live case only.
moov_->extends.header.fragment_duration = 0;
for (size_t i = 0; i < stream_durations_.size(); ++i) {
uint64_t duration =
int64_t duration =
Rescale(stream_durations_[i], moov_->tracks[i].media.header.timescale,
moov_->header.timescale);
if (duration > moov_->extends.header.fragment_duration)
if (duration >
static_cast<int64_t>(moov_->extends.header.fragment_duration))
moov_->extends.header.fragment_duration = duration;
}
return DoFinalize();
@ -234,12 +235,12 @@ Status Segmenter::FinalizeSegment(size_t stream_id,
return Status::OK;
}
uint32_t Segmenter::GetReferenceTimeScale() const {
int32_t Segmenter::GetReferenceTimeScale() const {
return moov_->header.timescale;
}
double Segmenter::GetDuration() const {
uint64_t duration = moov_->extends.header.fragment_duration;
int64_t duration = moov_->extends.header.fragment_duration;
if (duration == 0) {
// Handling the case where this is not properly initialized.
return 0.0;

6
packager/media/formats/mp4/segmenter.h
View File

@ -91,14 +91,14 @@ class Segmenter {
// Otherwise, a vector of ranges for the media segments are returned.
virtual std::vector<Range> GetSegmentRanges() = 0;
uint32_t GetReferenceTimeScale() const;
int32_t GetReferenceTimeScale() const;
/// @return The total length, in seconds, of segmented media files.
double GetDuration() const;
/// @return The sample duration in the timescale of the media.
/// Returns 0 if no samples are added yet.
uint32_t sample_duration() const { return sample_duration_; }
int32_t sample_duration() const { return sample_duration_; }
protected:
/// Update segmentation progress using ProgressListener.
@ -144,7 +144,7 @@ class Segmenter {
ProgressListener* progress_listener_ = nullptr;
uint64_t progress_target_ = 0u;
uint64_t accumulated_progress_ = 0u;
uint32_t sample_duration_ = 0u;
int32_t sample_duration_ = 0;
std::vector<uint64_t> stream_durations_;
std::vector<KeyFrameInfo> key_frame_infos_;

2
packager/media/formats/mp4/single_segment_segmenter.cc
View File

@ -174,7 +174,7 @@ Status SingleSegmentSegmenter::DoFinalizeSegment() {
// reference, which contains all the fragments in sidx().
std::vector<SegmentReference>& refs = sidx()->references;
SegmentReference& vod_ref = refs[0];
uint64_t first_sap_time =
int64_t first_sap_time =
refs[0].sap_delta_time + refs[0].earliest_presentation_time;
for (uint32_t i = 1; i < refs.size(); ++i) {
vod_ref.referenced_size += refs[i].referenced_size;

4
packager/media/formats/mp4/track_run_iterator.cc
View File

@ -26,8 +26,8 @@ namespace {
const int64_t kInvalidOffset = std::numeric_limits<int64_t>::max();
int64_t Rescale(int64_t time_in_old_scale,
uint32_t old_scale,
uint32_t new_scale) {
int32_t old_scale,
int32_t new_scale) {
return (static_cast<double>(time_in_old_scale) / old_scale) * new_scale;
}

4
packager/media/formats/packed_audio/packed_audio_segmenter.cc
View File

@ -17,7 +17,7 @@
namespace shaka {
namespace media {
namespace {
std::string TimestampToString(uint64_t timestamp) {
std::string TimestampToString(int64_t timestamp) {
// https://tools.ietf.org/html/rfc8216 The ID3 payload MUST be a 33-bit MPEG-2
// Program Elementary Stream timestamp expressed as a big-endian eight-octet
// number, with the upper 31 bits set to zero.
@ -30,7 +30,7 @@ std::string TimestampToString(uint64_t timestamp) {
} // namespace
PackedAudioSegmenter::PackedAudioSegmenter(
uint32_t transport_stream_timestamp_offset)
int32_t transport_stream_timestamp_offset)
: transport_stream_timestamp_offset_(transport_stream_timestamp_offset) {}
PackedAudioSegmenter::~PackedAudioSegmenter() = default;

4
packager/media/formats/packed_audio/packed_audio_segmenter.h
View File

@ -42,7 +42,7 @@ class PackedAudioSegmenter {
/// @param transport_stream_timestamp_offset is the offset to be applied to
/// sample timestamps to compensate for possible negative timestamps in
/// the input.
explicit PackedAudioSegmenter(uint32_t transport_stream_timestamp_offset);
explicit PackedAudioSegmenter(int32_t transport_stream_timestamp_offset);
virtual ~PackedAudioSegmenter();
/// Initialize the object.
@ -81,7 +81,7 @@ class PackedAudioSegmenter {
Status EncryptionAudioSetup(const MediaSample& sample);
Status StartNewSegment(const MediaSample& first_sample);
const uint32_t transport_stream_timestamp_offset_ = 0;
const int32_t transport_stream_timestamp_offset_ = 0;
// Codec for the stream.
Codec codec_ = kUnknownCodec;
std::vector<uint8_t> audio_codec_config_;

6
packager/media/formats/packed_audio/packed_audio_segmenter_unittest.cc
View File

@ -28,13 +28,13 @@ namespace shaka {
namespace media {
namespace {
constexpr uint32_t kZeroTransportStreamTimestampOffset = 0;
constexpr uint32_t kTimescale = 5625;
constexpr int32_t kZeroTransportStreamTimestampOffset = 0;
constexpr int32_t kTimescale = 5625;
constexpr double kExpectedTimescaleScale = kPackedAudioTimescale / kTimescale;
static_assert(kExpectedTimescaleScale == 16.0, "");
const int kTrackId = 0;
const uint64_t kDuration = 180000;
const int64_t kDuration = 180000;
const char kCodecString[] = "codec-string";
const char kLanguage[] = "eng";
const bool kIsEncrypted = true;

2
packager/media/formats/packed_audio/packed_audio_writer.cc
View File

@ -73,7 +73,7 @@ Status PackedAudioWriter::FinalizeSegment(size_t stream_id,
RETURN_IF_ERROR(segmenter_->FinalizeSegment());
const uint64_t segment_timestamp =
const int64_t segment_timestamp =
segment_info.start_timestamp * segmenter_->TimescaleScale();
std::string segment_path =
options().segment_template.empty()

4
packager/media/formats/packed_audio/packed_audio_writer.h
View File

@ -43,14 +43,14 @@ class PackedAudioWriter : public Muxer {
Status CloseFile(std::unique_ptr<File, FileCloser> file);
const uint32_t transport_stream_timestamp_offset_ = 0;
const int32_t transport_stream_timestamp_offset_ = 0;
std::unique_ptr<PackedAudioSegmenter> segmenter_;
// Used in single segment mode.
std::unique_ptr<File, FileCloser> output_file_;
// Keeps track of segment ranges in single segment mode.
MuxerListener::MediaRanges media_ranges_;
uint64_t total_duration_ = 0;
int64_t total_duration_ = 0;
// Used in multi-segment mode for segment template.
uint64_t segment_number_ = 0;

4
packager/media/formats/packed_audio/packed_audio_writer_unittest.cc
View File

@ -35,8 +35,8 @@ const size_t kOutputs = 0;
const size_t kInput = 0;
const size_t kStreamIndex = 0;
const uint32_t kZeroTransportStreamTimestampOffset = 0;
const uint32_t kTimescale = 9000;
const int32_t kZeroTransportStreamTimestampOffset = 0;
const int32_t kTimescale = 9000;
// For single-segment mode.
const char kOutputFile[] = "memory://test.aac";

Some files were not shown because too many files have changed in this diff Show More