Update C++ metadata names to match python

Author: danielflores3

src/torchcodec/_core/Metadata.h

@@ -26,10 +26,10 @@ struct StreamMetadata {
   std::optional<AVCodecID> codecId;
   std::optional<std::string> codecName;
   std::optional<double> durationSecondsFromHeader;
-  std::optional<double> beginStreamFromHeader;
+  std::optional<double> beginStreamSecondsFromHeader;
   std::optional<int64_t> numFramesFromHeader;
   std::optional<int64_t> numKeyFrames;
-  std::optional<double> averageFps;
+  std::optional<double> averageFpsFromHeader;
   std::optional<double> bitRate;
 
   // More accurate duration, obtained by scanning the file.

src/torchcodec/_core/SingleStreamDecoder.cpp

@@ -133,14 +133,14 @@ void SingleStreamDecoder::initializeDecoder() {
           av_q2d(avStream->time_base) * avStream->duration;
     }
     if (avStream->start_time != AV_NOPTS_VALUE) {
-      streamMetadata.beginStreamFromHeader =
+      streamMetadata.beginStreamSecondsFromHeader =
           av_q2d(avStream->time_base) * avStream->start_time;
     }
 
     if (avStream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
       double fps = av_q2d(avStream->r_frame_rate);
       if (fps > 0) {
-        streamMetadata.averageFps = fps;
+        streamMetadata.averageFpsFromHeader = fps;
       }
       containerMetadata_.numVideoStreams++;
     } else if (avStream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
@@ -445,7 +445,7 @@ void SingleStreamDecoder::addVideoStream(
       containerMetadata_.allStreamMetadata[activeStreamIndex_];
 
   if (seekMode_ == SeekMode::approximate &&
-      !streamMetadata.averageFps.has_value()) {
+      !streamMetadata.averageFpsFromHeader.has_value()) {
     throw std::runtime_error(
         "Seek mode is approximate, but stream " +
         std::to_string(activeStreamIndex_) +
@@ -1397,9 +1397,9 @@ int64_t SingleStreamDecoder::secondsToIndexLowerBound(double seconds) {
       auto& streamMetadata =
           containerMetadata_.allStreamMetadata[activeStreamIndex_];
       TORCH_CHECK(
-          streamMetadata.averageFps.has_value(),
+          streamMetadata.averageFpsFromHeader.has_value(),
           "Cannot use approximate mode since we couldn't find the average fps from the metadata.");
-      return std::floor(seconds * streamMetadata.averageFps.value());
+      return std::floor(seconds * streamMetadata.averageFpsFromHeader.value());
     }
     default:
       throw std::runtime_error("Unknown SeekMode");
@@ -1424,9 +1424,9 @@ int64_t SingleStreamDecoder::secondsToIndexUpperBound(double seconds) {
       auto& streamMetadata =
           containerMetadata_.allStreamMetadata[activeStreamIndex_];
       TORCH_CHECK(
-          streamMetadata.averageFps.has_value(),
+          streamMetadata.averageFpsFromHeader.has_value(),
           "Cannot use approximate mode since we couldn't find the average fps from the metadata.");
-      return std::ceil(seconds * streamMetadata.averageFps.value());
+      return std::ceil(seconds * streamMetadata.averageFpsFromHeader.value());
     }
     default:
       throw std::runtime_error("Unknown SeekMode");
@@ -1442,10 +1442,11 @@ int64_t SingleStreamDecoder::getPts(int64_t frameIndex) {
       auto& streamMetadata =
           containerMetadata_.allStreamMetadata[activeStreamIndex_];
       TORCH_CHECK(
-          streamMetadata.averageFps.has_value(),
+          streamMetadata.averageFpsFromHeader.has_value(),
           "Cannot use approximate mode since we couldn't find the average fps from the metadata.");
       return secondsToClosestPts(
-          frameIndex / streamMetadata.averageFps.value(), streamInfo.timeBase);
+          frameIndex / streamMetadata.averageFpsFromHeader.value(),
+          streamInfo.timeBase);
     }
     default:
       throw std::runtime_error("Unknown SeekMode");

src/torchcodec/_core/custom_ops.cpp

@@ -460,14 +460,20 @@ std::string get_json_metadata(at::Tensor& decoder) {
   if (maybeBestVideoStreamIndex.has_value() &&
       videoMetadata.allStreamMetadata[*maybeBestVideoStreamIndex]
           .durationSecondsFromHeader.has_value()) {
+<<<<<<< HEAD
             durationSecondsFromHeader =
+=======
+    durationSecondsFromHeader =
+>>>>>>> e932590 (Update C++ metadata names to match python)
         videoMetadata.allStreamMetadata[*maybeBestVideoStreamIndex]
             .durationSecondsFromHeader.value_or(0);
   } else {
     // Fallback to container-level duration if stream duration is not found.
-    durationSecondsFromHeader = videoMetadata.durationSecondsFromHeader.value_or(0);
+    durationSecondsFromHeader =
+        videoMetadata.durationSecondsFromHeader.value_or(0);
   }
-  metadataMap["durationSecondsFromHeader"] = std::to_string(durationSecondsFromHeader);
+  metadataMap["durationSecondsFromHeader"] =
+      std::to_string(durationSecondsFromHeader);
 
   if (videoMetadata.bitRate.has_value()) {
     metadataMap["bitRate"] = std::to_string(videoMetadata.bitRate.value());
@@ -479,8 +485,9 @@ std::string get_json_metadata(at::Tensor& decoder) {
     if (streamMetadata.numFramesFromScan.has_value()) {
       metadataMap["numFrames"] =
           std::to_string(*streamMetadata.numFramesFromScan);
-    } else if (streamMetadata.numFrames.has_value()) {
-      metadataMap["numFrames"] = std::to_string(*streamMetadata.numFrames);
+    } else if (streamMetadata.numFramesFromHeader.has_value()) {
+      metadataMap["numFrames"] =
+          std::to_string(*streamMetadata.numFramesFromHeader);
     }
     if (streamMetadata.minPtsSecondsFromScan.has_value()) {
       metadataMap["minPtsSecondsFromScan"] =
@@ -499,8 +506,9 @@ std::string get_json_metadata(at::Tensor& decoder) {
     if (streamMetadata.height.has_value()) {
       metadataMap["height"] = std::to_string(*streamMetadata.height);
     }
-    if (streamMetadata.averageFps.has_value()) {
-      metadataMap["averageFps"] = std::to_string(*streamMetadata.averageFps);
+    if (streamMetadata.averageFpsFromHeader.has_value()) {
+      metadataMap["averageFpsFromHeader"] =
+          std::to_string(*streamMetadata.averageFpsFromHeader);
     }
   }
   if (videoMetadata.bestVideoStreamIndex.has_value()) {
@@ -524,7 +532,8 @@ std::string get_container_json_metadata(at::Tensor& decoder) {
   std::map<std::string, std::string> map;
 
   if (containerMetadata.durationSecondsFromHeader.has_value()) {
-    map["durationSecondsFromHeader"] = std::to_string(*containerMetadata.durationSecondsFromHeader);
+    map["durationSecondsFromHeader"] =
+        std::to_string(*containerMetadata.durationSecondsFromHeader);
   }
 
   if (containerMetadata.bitRate.has_value()) {
@@ -563,7 +572,8 @@ std::string get_stream_json_metadata(
   std::map<std::string, std::string> map;
 
   if (streamMetadata.durationSecondsFromHeader.has_value()) {
-    map["durationSecondsFromHeader"] = std::to_string(*streamMetadata.durationSecondsFromHeader);
+    map["durationSecondsFromHeader"] =
+        std::to_string(*streamMetadata.durationSecondsFromHeader);
   }
   if (streamMetadata.bitRate.has_value()) {
     map["bitRate"] = std::to_string(*streamMetadata.bitRate);
@@ -573,11 +583,12 @@ std::string get_stream_json_metadata(
         std::to_string(*streamMetadata.numFramesFromScan);
   }
   if (streamMetadata.numFramesFromHeader.has_value()) {
-    map["numFramesFromHeader"] = std::to_string(*streamMetadata.numFramesFromHeader);
+    map["numFramesFromHeader"] =
+        std::to_string(*streamMetadata.numFramesFromHeader);
   }
-  if (streamMetadata.beginStreamFromHeader.has_value()) {
+  if (streamMetadata.beginStreamSecondsFromHeader.has_value()) {
     map["beginStreamSecondsFromHeader"] =
-        std::to_string(*streamMetadata.beginStreamFromHeader);
+        std::to_string(*streamMetadata.beginStreamSecondsFromHeader);
   }
   if (streamMetadata.minPtsSecondsFromScan.has_value()) {
     map["minPtsSecondsFromScan"] =
@@ -596,8 +607,9 @@ std::string get_stream_json_metadata(
   if (streamMetadata.height.has_value()) {
     map["height"] = std::to_string(*streamMetadata.height);
   }
-  if (streamMetadata.averageFps.has_value()) {
-    map["averageFpsFromHeader"] = std::to_string(*streamMetadata.averageFps);
+  if (streamMetadata.averageFpsFromHeader.has_value()) {
+    map["averageFpsFromHeader"] =
+        std::to_string(*streamMetadata.averageFpsFromHeader);
   }
   if (streamMetadata.sampleRate.has_value()) {
     map["sampleRate"] = std::to_string(*streamMetadata.sampleRate);