StartNumber as 1 based.

shaka-project · Mar 23, 2021 · f8c6d87 · f8c6d87
1 parent 3afebfd
commit f8c6d87
Show file tree

Hide file tree

Showing 32 changed files with 163 additions and 196 deletions.
diff --git a/packager/hls/base/media_playlist.cc b/packager/hls/base/media_playlist.cc
@@ -720,9 +720,9 @@ void MediaPlaylist::RemoveOldSegment(int64_t start_time) {
   if (stream_type_ == MediaPlaylistStreamType::kVideoIFramesOnly)
     return;
 
-  segments_to_be_removed_.push_back(
-      media::GetSegmentName(media_info_.segment_template(), start_time,
-                            media_sequence_number_, media_info_.bandwidth()));
+  segments_to_be_removed_.push_back(media::GetSegmentName(
+      media_info_.segment_template(), start_time, media_sequence_number_ + 1,
+      media_info_.bandwidth()));
   while (segments_to_be_removed_.size() >
          hls_params_.preserved_segments_outside_live_window) {
     VLOG(2) << "Deleting " << segments_to_be_removed_.front();

diff --git a/packager/media/base/media_handler.h b/packager/media/base/media_handler.h
@@ -57,7 +57,7 @@ struct SegmentInfo {
   bool is_encrypted = false;
   int64_t start_timestamp = -1;
   int64_t duration = 0;
-  int64_t segment_number = 0;
+  int64_t segment_number = 1;
   // This is only available if key rotation is enabled. Note that we may have
   // a |key_rotation_encryption_config| even if the segment is not encrypted,
   // which is the case for clear lead.

diff --git a/packager/media/base/muxer.h b/packager/media/base/muxer.h
@@ -114,7 +114,7 @@ class Muxer : public MediaHandler {
   // In VOD single segment case with Ad Cues, |output_file_name| is allowed to
   // be a template. In this case, there will be NumAdCues + 1 files generated.
   std::string output_file_template_;
-  size_t output_file_index_ = 0;
+  size_t output_file_index_ = 1;
 };
 
 }  // namespace media

diff --git a/packager/media/base/muxer_util.cc b/packager/media/base/muxer_util.cc
@@ -110,7 +110,7 @@ Status ValidateSegmentTemplate(const std::string& segment_template) {
 
 std::string GetSegmentName(const std::string& segment_template,
                            uint64_t segment_start_time,
-                           uint32_t segment_index,
+                           uint32_t segment_number,
                            uint32_t bandwidth) {
   DCHECK_EQ(Status::OK, ValidateSegmentTemplate(segment_template));
 
@@ -150,8 +150,8 @@ std::string GetSegmentName(const std::string& segment_template,
 
     if (identifier == "Number") {
       // SegmentNumber starts from 1.
-      segment_name += base::StringPrintf(
-          format_tag.c_str(), static_cast<uint64_t>(segment_index + 1));
+      segment_name += base::StringPrintf(format_tag.c_str(),
+                                         static_cast<uint64_t>(segment_number));
     } else if (identifier == "Time") {
       segment_name +=
           base::StringPrintf(format_tag.c_str(), segment_start_time);

diff --git a/packager/media/base/muxer_util.h b/packager/media/base/muxer_util.h
@@ -29,12 +29,12 @@ Status ValidateSegmentTemplate(const std::string& segment_template);
 /// @param segment_template is the segment template pattern, which should
 ///        comply with ISO/IEC 23009-1:2012 5.3.9.4.4.
 /// @param segment_start_time specifies the segment start time.
-/// @param segment_index specifies the segment index.
+/// @param segment_number specifies the segment number.
 /// @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,
-                           uint32_t segment_index,
+                           uint32_t segment_number,
                            uint32_t bandwidth);
 
 }  // namespace media

diff --git a/packager/media/base/muxer_util_unittest.cc b/packager/media/base/muxer_util_unittest.cc
@@ -62,95 +62,57 @@ TEST(MuxerUtilTest, ValidateSegmentTemplateWithFormatTag) {
 
 TEST(MuxerUtilTest, GetSegmentName) {
   const uint64_t kSegmentStartTime = 180180;
-  const uint32_t kSegmentIndex = 11;
+  const uint32_t kSegmentNumber = 12;
   const uint32_t kBandwidth = 1234;
-  EXPECT_EQ("12", GetSegmentName("$Number$",
-                                 kSegmentStartTime,
-                                 kSegmentIndex,
+  EXPECT_EQ("12", GetSegmentName("$Number$", kSegmentStartTime, kSegmentNumber,
                                  kBandwidth));
-  EXPECT_EQ("012",
-            GetSegmentName("$Number%03d$",
-                           kSegmentStartTime,
-                           kSegmentIndex,
-                           kBandwidth));
-  EXPECT_EQ(
-      "12$foo$00012",
-      GetSegmentName(
-          "$Number%01d$$$foo$$$Number%05d$",
-          kSegmentStartTime,
-          kSegmentIndex,
-          kBandwidth));
-
-  EXPECT_EQ("180180",
-            GetSegmentName("$Time$",
-                           kSegmentStartTime,
-                           kSegmentIndex,
-                           kBandwidth));
+  EXPECT_EQ("012", GetSegmentName("$Number%03d$", kSegmentStartTime,
+                                  kSegmentNumber, kBandwidth));
+  EXPECT_EQ("12$foo$00012",
+            GetSegmentName("$Number%01d$$$foo$$$Number%05d$", kSegmentStartTime,
+                           kSegmentNumber, kBandwidth));
+
+  EXPECT_EQ("180180", GetSegmentName("$Time$", kSegmentStartTime,
+                                     kSegmentNumber, kBandwidth));
   EXPECT_EQ("foo$_$18018000180180.m4s",
             GetSegmentName("foo$$_$$$Time%01d$$Time%08d$.m4s",
-                           kSegmentStartTime,
-                           kSegmentIndex,
-                           kBandwidth));
+                           kSegmentStartTime, kSegmentNumber, kBandwidth));
 
   // Combo values.
-  EXPECT_EQ("12-1234",
-            GetSegmentName("$Number$-$Bandwidth$",
-                           kSegmentStartTime,
-                           kSegmentIndex,
-                           kBandwidth));
+  EXPECT_EQ("12-1234", GetSegmentName("$Number$-$Bandwidth$", kSegmentStartTime,
+                                      kSegmentNumber, kBandwidth));
   EXPECT_EQ("012-001234",
-            GetSegmentName("$Number%03d$-$Bandwidth%06d$",
-                           kSegmentStartTime,
-                           kSegmentIndex,
-                           kBandwidth));
+            GetSegmentName("$Number%03d$-$Bandwidth%06d$", kSegmentStartTime,
+                           kSegmentNumber, kBandwidth));
 
   // Format specifier edge cases.
-  EXPECT_EQ("12",
-            GetSegmentName("$Number%00d$",
-                           kSegmentStartTime,
-                           kSegmentIndex,
-                           kBandwidth));
-  EXPECT_EQ("00012",
-            GetSegmentName("$Number%005d$",
-                           kSegmentStartTime,
-                           kSegmentIndex,
-                           kBandwidth));
+  EXPECT_EQ("12", GetSegmentName("$Number%00d$", kSegmentStartTime,
+                                 kSegmentNumber, kBandwidth));
+  EXPECT_EQ("00012", GetSegmentName("$Number%005d$", kSegmentStartTime,
+                                    kSegmentNumber, kBandwidth));
 }
 
 TEST(MuxerUtilTest, GetSegmentNameWithIndexZero) {
   const uint64_t kSegmentStartTime = 0;
-  const uint32_t kSegmentIndex = 0;
+  const uint32_t kSegmentNumber = 1;
   const uint32_t kBandwidth = 0;
-  EXPECT_EQ("1", GetSegmentName("$Number$",
-                                kSegmentStartTime,
-                                kSegmentIndex,
+  EXPECT_EQ("1", GetSegmentName("$Number$", kSegmentStartTime, kSegmentNumber,
                                 kBandwidth));
-  EXPECT_EQ("001",
-            GetSegmentName("$Number%03d$",
-                           kSegmentStartTime,
-                           kSegmentIndex,
-                           kBandwidth));
-
-  EXPECT_EQ("0", GetSegmentName("$Time$",
-                                kSegmentStartTime,
-                                kSegmentIndex,
+  EXPECT_EQ("001", GetSegmentName("$Number%03d$", kSegmentStartTime,
+                                  kSegmentNumber, kBandwidth));
+
+  EXPECT_EQ("0", GetSegmentName("$Time$", kSegmentStartTime, kSegmentNumber,
                                 kBandwidth));
-  EXPECT_EQ("00000000.m4s",
-            GetSegmentName("$Time%08d$.m4s",
-                           kSegmentStartTime,
-                           kSegmentIndex,
-                           kBandwidth));
+  EXPECT_EQ("00000000.m4s", GetSegmentName("$Time%08d$.m4s", kSegmentStartTime,
+                                           kSegmentNumber, kBandwidth));
 }
 
 TEST(MuxerUtilTest, GetSegmentNameLargeTime) {
   const uint64_t kSegmentStartTime = 1601599839840ULL;
-  const uint32_t kSegmentIndex = 8888888;
+  const uint32_t kSegmentNumber = 8888889;
   const uint32_t kBandwidth = 444444;
-  EXPECT_EQ("1601599839840",
-            GetSegmentName("$Time$",
-                           kSegmentStartTime,
-                           kSegmentIndex,
-                           kBandwidth));
+  EXPECT_EQ("1601599839840", GetSegmentName("$Time$", kSegmentStartTime,
+                                            kSegmentNumber, kBandwidth));
 }
 
 }  // namespace media

diff --git a/packager/media/chunking/chunking_handler.cc b/packager/media/chunking/chunking_handler.cc
@@ -31,7 +31,7 @@ bool IsNewSegmentIndex(int64_t new_index, int64_t current_index) {
 ChunkingHandler::ChunkingHandler(const ChunkingParams& chunking_params)
     : chunking_params_(chunking_params) {
   CHECK_NE(chunking_params.segment_duration_in_seconds, 0u);
-  segment_number_ = chunking_params.start_segment_number - 1;
+  segment_number_ = chunking_params.start_segment_number;
 }
 
 Status ChunkingHandler::InitializeInternal() {
@@ -153,6 +153,7 @@ Status ChunkingHandler::EndSegmentIfStarted() {
   segment_info->start_timestamp = segment_start_time_.value();
   segment_info->duration = max_segment_time_ - segment_start_time_.value();
   segment_info->segment_number = segment_number_++;
+
   return DispatchSegmentInfo(kStreamIndex, std::move(segment_info));
 }
 

diff --git a/packager/media/chunking/chunking_handler.h b/packager/media/chunking/chunking_handler.h
@@ -74,7 +74,8 @@ class ChunkingHandler : public MediaHandler {
   int64_t subsegment_duration_ = 0;
 
   // Segment number that keeps monotically increasing.
-  int64_t segment_number_ = 0;
+  // Set to start_segment_number in constructor.
+  int64_t segment_number_ = 1;
 
   // Current segment index, useful to determine where to do chunking.
   int64_t current_segment_index_ = -1;

diff --git a/packager/media/chunking/text_chunker.cc b/packager/media/chunking/text_chunker.cc
@@ -17,7 +17,7 @@ const size_t kStreamIndex = 0;
 TextChunker::TextChunker(double segment_duration_in_seconds,
                          int64_t start_segment_number)
     : segment_duration_in_seconds_(segment_duration_in_seconds),
-      segment_number_(start_segment_number - 1){};
+      segment_number_(start_segment_number){};
 
 Status TextChunker::Process(std::unique_ptr<StreamData> data) {
   switch (data->stream_data_type) {

diff --git a/packager/media/chunking/text_chunker.h b/packager/media/chunking/text_chunker.h
@@ -52,7 +52,10 @@ class TextChunker : public MediaHandler {
   // Time values are in scaled units.
   int64_t segment_start_ = -1;     // Set when the first sample comes in.
   int64_t segment_duration_ = -1;  // Set in OnStreamInfo.
-  int64_t segment_number_ = 0;  // Set to start_segment_number in constructor.
+
+  // Segment number that keeps monotically increasing.
+  // Set to start_segment_number in constructor.
+  int64_t segment_number_ = 1;
 
   // All samples that make up the current segment. We must store the samples
   // until the segment ends because a cue event may end the segment sooner

diff --git a/packager/media/crypto/encryption_handler_unittest.cc b/packager/media/crypto/encryption_handler_unittest.cc
@@ -356,7 +356,7 @@ TEST_P(EncryptionHandlerEncryptionTest, ClearLeadWithNoKeyRotation) {
                                      kIsKeyFrame, kData, kDataSize))));
     ASSERT_OK(Process(StreamData::FromSegmentInfo(
         kStreamIndex, GetSegmentInfo(i * kSegmentDuration, kSegmentDuration,
-                                     !kIsSubsegment, i))));
+                                     !kIsSubsegment, i + 1))));
     const bool is_encrypted = i == 2;
     const auto& output_stream_data = GetOutputStreamDataVector();
     EXPECT_THAT(output_stream_data,

diff --git a/packager/media/event/hls_notify_muxer_listener.h b/packager/media/event/hls_notify_muxer_listener.h
@@ -68,7 +68,7 @@ class HlsNotifyMuxerListener : public MuxerListener {
                     int64_t start_time,
                     int64_t duration,
                     uint64_t segment_file_size,
-                    int64_t segment_index) override;
+                    int64_t segment_number) override;
   void OnKeyFrame(int64_t timestamp, uint64_t start_byte_offset, uint64_t size);
   void OnCueEvent(int64_t timestamp, const std::string& cue_data) override;
   /// @}

diff --git a/packager/media/event/hls_notify_muxer_listener_unittest.cc b/packager/media/event/hls_notify_muxer_listener_unittest.cc
@@ -78,7 +78,7 @@ const uint64_t kSegmentStartOffset = 10000;
 const uint64_t kSegmentStartTime = 19283;
 const uint64_t kSegmentDuration = 98028;
 const uint64_t kSegmentSize = 756739;
-const int64_t kSegmentNumber = 9;
+const int64_t kAnySegmentNumber = 10;
 
 const uint64_t kCueStartTime = kSegmentStartTime;
 
@@ -346,7 +346,7 @@ TEST_F(HlsNotifyMuxerListenerTest, OnNewSegmentAndCueEvent) {
                        kSegmentDuration, _, kSegmentSize));
   listener_.OnCueEvent(kCueStartTime, "dummy cue data");
   listener_.OnNewSegment("new_segment_name10.ts", kSegmentStartTime,
-                         kSegmentDuration, kSegmentSize, kSegmentNumber);
+                         kSegmentDuration, kSegmentSize, kAnySegmentNumber);
 }
 
 // Verify that the notifier is called for every segment in OnMediaEnd if
@@ -364,7 +364,7 @@ TEST_F(HlsNotifyMuxerListenerTest, NoSegmentTemplateOnMediaEnd) {
 
   listener_.OnCueEvent(kCueStartTime, "dummy cue data");
   listener_.OnNewSegment("filename.mp4", kSegmentStartTime, kSegmentDuration,
-                         kSegmentSize, kSegmentNumber);
+                         kSegmentSize, kAnySegmentNumber);
 
   EXPECT_CALL(mock_notifier_, NotifyCueEvent(_, kCueStartTime));
   EXPECT_CALL(
@@ -394,7 +394,7 @@ TEST_F(HlsNotifyMuxerListenerTest, NoSegmentTemplateOnMediaEndTwice) {
   listener_.OnMediaStart(muxer_options1, *video_stream_info, 90000,
                          MuxerListener::kContainerMpeg2ts);
   listener_.OnNewSegment("filename1.mp4", kSegmentStartTime, kSegmentDuration,
-                         kSegmentSize, kSegmentNumber);
+                         kSegmentSize, kAnySegmentNumber);
   listener_.OnCueEvent(kCueStartTime, "dummy cue data");
 
   EXPECT_CALL(mock_notifier_, NotifyNewStream(_, _, _, _, _))
@@ -411,7 +411,7 @@ TEST_F(HlsNotifyMuxerListenerTest, NoSegmentTemplateOnMediaEndTwice) {
   listener_.OnMediaStart(muxer_options2, *video_stream_info, 90000,
                          MuxerListener::kContainerMpeg2ts);
   listener_.OnNewSegment("filename2.mp4", kSegmentStartTime + kSegmentDuration,
-                         kSegmentDuration, kSegmentSize, kSegmentNumber);
+                         kSegmentDuration, kSegmentSize, kAnySegmentNumber);
   EXPECT_CALL(mock_notifier_,
               NotifyNewSegment(_, StrEq("filename2.mp4"),
                                kSegmentStartTime + kSegmentDuration, _, _, _));
@@ -437,7 +437,7 @@ TEST_F(HlsNotifyMuxerListenerTest,
                          MuxerListener::kContainerMpeg2ts);
 
   listener_.OnNewSegment("filename.mp4", kSegmentStartTime, kSegmentDuration,
-                         kSegmentSize, kSegmentNumber);
+                         kSegmentSize, kAnySegmentNumber);
   EXPECT_CALL(
       mock_notifier_,
       NotifyNewSegment(_, StrEq("filename.mp4"), kSegmentStartTime,
@@ -499,7 +499,7 @@ TEST_P(HlsNotifyMuxerListenerKeyFrameTest, NoSegmentTemplate) {
   listener_.OnKeyFrame(kKeyFrameTimestamp, kKeyFrameStartByteOffset,
                        kKeyFrameSize);
   listener_.OnNewSegment("filename.mp4", kSegmentStartTime, kSegmentDuration,
-                         kSegmentSize, kSegmentNumber);
+                         kSegmentSize, kAnySegmentNumber);
 
   EXPECT_CALL(mock_notifier_,
               NotifyKeyFrame(_, kKeyFrameTimestamp,