Revert status name change

Author: scotts

src/torchcodec/decoders/_core/VideoDecoder.cpp

@@ -68,12 +68,12 @@ VideoDecoder::VideoDecoder(const std::string& videoFilePath, SeekMode seekMode)
   av_log_set_level(AV_LOG_QUIET);
 
   AVFormatContext* rawContext = nullptr;
-  int status =
+  int ffmpegStatus =
       avformat_open_input(&rawContext, videoFilePath.c_str(), nullptr, nullptr);
   TORCH_CHECK(
-      status == 0,
+      ffmpegStatus == 0,
       "Could not open input file: " + videoFilePath + " " +
-          getFFMPEGErrorStringFromErrorCode(status));
+          getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
   TORCH_CHECK(rawContext != nullptr);
   formatContext_.reset(rawContext);
 
@@ -97,13 +97,14 @@ VideoDecoder::VideoDecoder(const void* data, size_t length, SeekMode seekMode)
   TORCH_CHECK(rawContext != nullptr, "Unable to alloc avformat context");
 
   rawContext->pb = ioBytesContext_->getAVIO();
-  int status = avformat_open_input(&rawContext, nullptr, nullptr, nullptr);
-  if (status != 0) {
+  int ffmpegStatus =
+      avformat_open_input(&rawContext, nullptr, nullptr, nullptr);
+  if (ffmpegStatus != 0) {
     avformat_free_context(rawContext);
     TORCH_CHECK(
         false,
         "Failed to open input buffer: " +
-            getFFMPEGErrorStringFromErrorCode(status));
+            getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
   }
 
   formatContext_.reset(rawContext);
@@ -131,11 +132,11 @@ void VideoDecoder::initializeDecoder() {
   // store enough info in the header, so we call avformat_find_stream_info()
   // which decodes a few frames to get missing info. For more, see:
   //   https://ffmpeg.org/doxygen/7.0/group__lavf__decoding.html
-  int status = avformat_find_stream_info(formatContext_.get(), nullptr);
-  if (status < 0) {
+  int ffmpegStatus = avformat_find_stream_info(formatContext_.get(), nullptr);
+  if (ffmpegStatus < 0) {
     throw std::runtime_error(
         "Failed to find stream info: " +
-        getFFMPEGErrorStringFromErrorCode(status));
+        getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
   }
 
   for (unsigned int i = 0; i < formatContext_->nb_streams; i++) {
@@ -230,16 +231,16 @@ void VideoDecoder::scanFileAndUpdateMetadataAndIndex() {
     ReferenceAVPacket packet(autoAVPacket);
 
     // av_read_frame is a misleading name: it gets the next **packet**.
-    int status = av_read_frame(formatContext_.get(), packet.get());
+    int ffmpegStatus = av_read_frame(formatContext_.get(), packet.get());
 
-    if (status == AVERROR_EOF) {
+    if (ffmpegStatus == AVERROR_EOF) {
       break;
     }
 
-    if (status != AVSUCCESS) {
+    if (ffmpegStatus != AVSUCCESS) {
       throw std::runtime_error(
           "Failed to read frame from input file: " +
-          getFFMPEGErrorStringFromErrorCode(status));
+          getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
     }
 
     if (packet->flags & AV_PKT_FLAG_DISCARD) {
@@ -922,23 +923,23 @@ VideoDecoder::AVFrameStream VideoDecoder::decodeAVFrame(
   // Need to get the next frame or error from PopFrame.
   UniqueAVFrame avFrame(av_frame_alloc());
   AutoAVPacket autoAVPacket;
-  int status = AVSUCCESS;
+  int ffmpegStatus = AVSUCCESS;
   bool reachedEOF = false;
   while (true) {
-    status =
+    ffmpegStatus =
         avcodec_receive_frame(streamInfo.codecContext.get(), avFrame.get());
 
-    if (status != AVSUCCESS && status != AVERROR(EAGAIN)) {
+    if (ffmpegStatus != AVSUCCESS && ffmpegStatus != AVERROR(EAGAIN)) {
       // Non-retriable error
       break;
     }
 
     decodeStats_.numFramesReceivedByDecoder++;
     // Is this the kind of frame we're looking for?
-    if (status == AVSUCCESS && filterFunction(avFrame.get())) {
+    if (ffmpegStatus == AVSUCCESS && filterFunction(avFrame.get())) {
       // Yes, this is the frame we'll return; break out of the decoding loop.
       break;
-    } else if (status == AVSUCCESS) {
+    } else if (ffmpegStatus == AVSUCCESS) {
       // No, but we received a valid frame - just not the kind we're looking
       // for. The logic below will read packets and send them to the decoder.
       // But since we did just receive a frame, we should skip reading more
@@ -957,29 +958,29 @@ VideoDecoder::AVFrameStream VideoDecoder::decodeAVFrame(
     // packets and send them to the decoder.
     ReferenceAVPacket packet(autoAVPacket);
     do {
-      status = av_read_frame(formatContext_.get(), packet.get());
+      ffmpegStatus = av_read_frame(formatContext_.get(), packet.get());
       decodeStats_.numPacketsRead++;
 
-      if (status == AVERROR_EOF) {
+      if (ffmpegStatus == AVERROR_EOF) {
         // End of file reached. We must drain the codec by sending a nullptr
         // packet.
-        status = avcodec_send_packet(
+        ffmpegStatus = avcodec_send_packet(
             streamInfo.codecContext.get(),
             /*avpkt=*/nullptr);
-        if (status < AVSUCCESS) {
+        if (ffmpegStatus < AVSUCCESS) {
           throw std::runtime_error(
               "Could not flush decoder: " +
-              getFFMPEGErrorStringFromErrorCode(status));
+              getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
         }
 
         reachedEOF = true;
         break;
       }
 
-      if (status < AVSUCCESS) {
+      if (ffmpegStatus < AVSUCCESS) {
         throw std::runtime_error(
             "Could not read frame from input file: " +
-            getFFMPEGErrorStringFromErrorCode(status));
+            getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
       }
     } while (packet->stream_index != activeStreamIndex_);
 
@@ -991,25 +992,26 @@ VideoDecoder::AVFrameStream VideoDecoder::decodeAVFrame(
 
     // We got a valid packet. Send it to the decoder, and we'll receive it in
     // the next iteration.
-    status = avcodec_send_packet(streamInfo.codecContext.get(), packet.get());
-    if (status < AVSUCCESS) {
+    ffmpegStatus =
+        avcodec_send_packet(streamInfo.codecContext.get(), packet.get());
+    if (ffmpegStatus < AVSUCCESS) {
       throw std::runtime_error(
           "Could not push packet to decoder: " +
-          getFFMPEGErrorStringFromErrorCode(status));
+          getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
     }
 
     decodeStats_.numPacketsSentToDecoder++;
   }
 
-  if (status < AVSUCCESS) {
-    if (reachedEOF || status == AVERROR_EOF) {
+  if (ffmpegStatus < AVSUCCESS) {
+    if (reachedEOF || ffmpegStatus == AVERROR_EOF) {
       throw VideoDecoder::EndOfFileException(
           "Requested next frame while there are no more frames left to "
           "decode.");
     }
     throw std::runtime_error(
         "Could not receive frame from decoder: " +
-        getFFMPEGErrorStringFromErrorCode(status));
+        getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
   }
 
   // Note that we don't flush the decoder when we reach EOF (even though that's
@@ -1195,14 +1197,14 @@ torch::Tensor VideoDecoder::convertAVFrameToTensorUsingFilterGraph(
     const AVFrame* avFrame) {
   FilterGraphContext& filterGraphContext =
       streamInfos_[activeStreamIndex_].filterGraphContext;
-  int status =
+  int ffmpegStatus =
       av_buffersrc_write_frame(filterGraphContext.sourceContext, avFrame);
-  if (status < AVSUCCESS) {
+  if (ffmpegStatus < AVSUCCESS) {
     throw std::runtime_error("Failed to add frame to buffer source context");
   }
 
   UniqueAVFrame filteredAVFrame(av_frame_alloc());
-  status = av_buffersink_get_frame(
+  ffmpegStatus = av_buffersink_get_frame(
       filterGraphContext.sinkContext, filteredAVFrame.get());
   TORCH_CHECK_EQ(filteredAVFrame->format, AV_PIX_FMT_RGB24);
 
@@ -1326,44 +1328,44 @@ void VideoDecoder::createFilterGraph(
   filterArgs << ":pixel_aspect=" << codecContext->sample_aspect_ratio.num << "/"
              << codecContext->sample_aspect_ratio.den;
 
-  int status = avfilter_graph_create_filter(
+  int ffmpegStatus = avfilter_graph_create_filter(
       &filterGraphContext.sourceContext,
       buffersrc,
       "in",
       filterArgs.str().c_str(),
       nullptr,
       filterGraphContext.filterGraph.get());
-  if (status < 0) {
+  if (ffmpegStatus < 0) {
     throw std::runtime_error(
         std::string("Failed to create filter graph: ") + filterArgs.str() +
-        ": " + getFFMPEGErrorStringFromErrorCode(status));
+        ": " + getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
   }
 
-  status = avfilter_graph_create_filter(
+  ffmpegStatus = avfilter_graph_create_filter(
       &filterGraphContext.sinkContext,
       buffersink,
       "out",
       nullptr,
       nullptr,
       filterGraphContext.filterGraph.get());
-  if (status < 0) {
+  if (ffmpegStatus < 0) {
     throw std::runtime_error(
         "Failed to create filter graph: " +
-        getFFMPEGErrorStringFromErrorCode(status));
+        getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
   }
 
   enum AVPixelFormat pix_fmts[] = {AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE};
 
-  status = av_opt_set_int_list(
+  ffmpegStatus = av_opt_set_int_list(
       filterGraphContext.sinkContext,
       "pix_fmts",
       pix_fmts,
       AV_PIX_FMT_NONE,
       AV_OPT_SEARCH_CHILDREN);
-  if (status < 0) {
+  if (ffmpegStatus < 0) {
     throw std::runtime_error(
         "Failed to set output pixel formats: " +
-        getFFMPEGErrorStringFromErrorCode(status));
+        getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
   }
 
   UniqueAVFilterInOut outputs(avfilter_inout_alloc());
@@ -1384,25 +1386,26 @@ void VideoDecoder::createFilterGraph(
 
   AVFilterInOut* outputsTmp = outputs.release();
   AVFilterInOut* inputsTmp = inputs.release();
-  status = avfilter_graph_parse_ptr(
+  ffmpegStatus = avfilter_graph_parse_ptr(
       filterGraphContext.filterGraph.get(),
       description.str().c_str(),
       &inputsTmp,
       &outputsTmp,
       nullptr);
   outputs.reset(outputsTmp);
   inputs.reset(inputsTmp);
-  if (status < 0) {
+  if (ffmpegStatus < 0) {
     throw std::runtime_error(
         "Failed to parse filter description: " +
-        getFFMPEGErrorStringFromErrorCode(status));
+        getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
   }
 
-  status = avfilter_graph_config(filterGraphContext.filterGraph.get(), nullptr);
-  if (status < 0) {
+  ffmpegStatus =
+      avfilter_graph_config(filterGraphContext.filterGraph.get(), nullptr);
+  if (ffmpegStatus < 0) {
     throw std::runtime_error(
         "Failed to configure filter graph: " +
-        getFFMPEGErrorStringFromErrorCode(status));
+        getFFMPEGErrorStringFromErrorCode(ffmpegStatus));
   }
 }