From d334eee12e11a5c40d347c61e2361ec450e69cca Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Wed, 12 Oct 2022 15:47:51 +0100
Subject: [PATCH 01/16] add tensor as optional param

---
 torchvision/csrc/io/video/video.cpp | 4 ++--
 torchvision/csrc/io/video/video.h   | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/torchvision/csrc/io/video/video.cpp b/torchvision/csrc/io/video/video.cpp
index 38b35014595..51cfa8d1703 100644
--- a/torchvision/csrc/io/video/video.cpp
+++ b/torchvision/csrc/io/video/video.cpp
@@ -156,7 +156,7 @@ void Video::_getDecoderParams(
 
 } // _get decoder params
 
-Video::Video(std::string videoPath, std::string stream, int64_t numThreads) {
+Video::Video(std::string videoPath, std::string stream, int64_t numThreads, torch::Tensor) {
   C10_LOG_API_USAGE_ONCE("torchvision.csrc.io.video.video.Video");
   // set number of threads global
   numThreads_ = numThreads;
@@ -344,7 +344,7 @@ std::tuple<torch::Tensor, double> Video::Next() {
 
 static auto registerVideo =
     torch::class_<Video>("torchvision", "Video")
-        .def(torch::init<std::string, std::string, int64_t>())
+        .def(torch::init<std::string, std::string, int64_t, torch::Tensor>())
         .def("get_current_stream", &Video::getCurrentStream)
         .def("set_current_stream", &Video::setCurrentStream)
         .def("get_metadata", &Video::getStreamMetadata)
diff --git a/torchvision/csrc/io/video/video.h b/torchvision/csrc/io/video/video.h
index 7cd926b793c..558f1c9ce81 100644
--- a/torchvision/csrc/io/video/video.h
+++ b/torchvision/csrc/io/video/video.h
@@ -19,7 +19,7 @@ struct Video : torch::CustomClassHolder {
   int64_t numThreads_{0};
 
  public:
-  Video(std::string videoPath, std::string stream, int64_t numThreads);
+  Video(std::string videoPath, std::string stream, int64_t numThreads, torch::Tensor = nullptr);
   std::tuple<std::string, int64_t> getCurrentStream() const;
   c10::Dict<std::string, c10::Dict<std::string, std::vector<double>>>
   getStreamMetadata() const;

From be394ae99751f8ea9980792acf45ac00249b012f Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Wed, 12 Oct 2022 16:40:20 +0100
Subject: [PATCH 02/16] add init from memory

---
 torchvision/csrc/io/decoder/defs.h  |  2 +-
 torchvision/csrc/io/video/video.cpp | 36 ++++++++++++++++++++++-------
 torchvision/csrc/io/video/video.h   |  7 +++++-
 3 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/torchvision/csrc/io/decoder/defs.h b/torchvision/csrc/io/decoder/defs.h
index dac6293d366..502e5762e46 100644
--- a/torchvision/csrc/io/decoder/defs.h
+++ b/torchvision/csrc/io/decoder/defs.h
@@ -165,7 +165,7 @@ struct MediaFormat {
 struct DecoderParameters {
   // local file, remote file, http url, rtmp stream uri, etc. anything that
   // ffmpeg can recognize
-  std::string uri;
+  std::string uri{std::string()};
   // timeout on getting bytes for decoding
   size_t timeoutMs{1000};
   // logging level, default AV_LOG_PANIC
diff --git a/torchvision/csrc/io/video/video.cpp b/torchvision/csrc/io/video/video.cpp
index 51cfa8d1703..3a6e6404410 100644
--- a/torchvision/csrc/io/video/video.cpp
+++ b/torchvision/csrc/io/video/video.cpp
@@ -156,8 +156,19 @@ void Video::_getDecoderParams(
 
 } // _get decoder params
 
-Video::Video(std::string videoPath, std::string stream, int64_t numThreads, torch::Tensor) {
-  C10_LOG_API_USAGE_ONCE("torchvision.csrc.io.video.video.Video");
+void Video::initFromFile(std::string videoPath, std::string stream, int64_t numThreads) {
+  TORCH_CHECK(callback == nullptr && params.uri.empty(), "Video object can only be initialized once");
+  params.uri = videoPath;
+  _init(stream, numThreads);
+}
+void Video::initFromMemory(torch::Tensor videoTensor, std::string stream, int64_t numThreads)
+{
+  TORCH_CHECK(callback == nullptr && params.uri.empty(), "Video object can only be initialized once");
+  callback = MemoryBuffer::getCallback(videoData.data_ptr<uint8_t>(), videoData.size(0));
+  _init(stream, numThreads);
+}
+
+void Video::_init(std::string stream, int64_t numThreads) {
   // set number of threads global
   numThreads_ = numThreads;
   // parse stream information
@@ -175,11 +186,6 @@ Video::Video(std::string videoPath, std::string stream, int64_t numThreads, torc
 
   std::string logMessage, logType;
 
-  // TODO: add read from memory option
-  params.uri = videoPath;
-  logType = "file";
-  logMessage = videoPath;
-
   // locals
   std::vector<double> audioFPS, videoFPS;
   std::vector<double> audioDuration, videoDuration, ccDuration, subsDuration;
@@ -232,9 +238,17 @@ Video::Video(std::string videoPath, std::string stream, int64_t numThreads, torc
         << "Stream index set to " << std::get<1>(current_stream)
         << ". If you encounter trouble, consider switching it to automatic stream discovery. \n";
   }
+}
+
+Video::Video(std::string videoPath, std::string stream, int64_t numThreads) {
+  C10_LOG_API_USAGE_ONCE("torchvision.csrc.io.video.video.Video");
+  if (!videoPath.empty()) {
+    init_from_file(videoPath, stream, numThreads);
+  }
 } // video
 
 bool Video::setCurrentStream(std::string stream = "video") {
+  TORCH_CHECK(callback != nullptr || !params.uri.empty(), "Video object has to be initialized first");
   if ((!stream.empty()) && (_parseStream(stream) != current_stream)) {
     current_stream = _parseStream(stream);
   }
@@ -260,15 +274,18 @@ bool Video::setCurrentStream(std::string stream = "video") {
 }
 
 std::tuple<std::string, int64_t> Video::getCurrentStream() const {
+  TORCH_CHECK(callback != nullptr || !params.uri.empty(), "Video object has to be initialized first");
   return current_stream;
 }
 
 c10::Dict<std::string, c10::Dict<std::string, std::vector<double>>> Video::
     getStreamMetadata() const {
+  TORCH_CHECK(callback != nullptr || !params.uri.empty(), "Video object has to be initialized first");
   return streamsMetadata;
 }
 
 void Video::Seek(double ts, bool fastSeek = false) {
+  TORCH_CHECK(callback != nullptr || !params.uri.empty(), "Video object has to be initialized first");
   // initialize the class variables used for seeking and retrurn
   _getDecoderParams(
       ts, // video start
@@ -287,6 +304,7 @@ void Video::Seek(double ts, bool fastSeek = false) {
 }
 
 std::tuple<torch::Tensor, double> Video::Next() {
+  TORCH_CHECK(callback != nullptr || !params.uri.empty(), "Video object has to be initialized first");
   // if failing to decode simply return a null tensor (note, should we
   // raise an exeption?)
   double frame_pts_s;
@@ -344,7 +362,9 @@ std::tuple<torch::Tensor, double> Video::Next() {
 
 static auto registerVideo =
     torch::class_<Video>("torchvision", "Video")
-        .def(torch::init<std::string, std::string, int64_t, torch::Tensor>())
+        .def(torch::init<std::string, std::string, int64_t>())
+        .def("init_from_file", &Video::initFromFile)
+        .def("init_from_memory", &Video::initFromMemory)
         .def("get_current_stream", &Video::getCurrentStream)
         .def("set_current_stream", &Video::setCurrentStream)
         .def("get_metadata", &Video::getStreamMetadata)
diff --git a/torchvision/csrc/io/video/video.h b/torchvision/csrc/io/video/video.h
index 558f1c9ce81..872f2595de9 100644
--- a/torchvision/csrc/io/video/video.h
+++ b/torchvision/csrc/io/video/video.h
@@ -19,7 +19,10 @@ struct Video : torch::CustomClassHolder {
   int64_t numThreads_{0};
 
  public:
-  Video(std::string videoPath, std::string stream, int64_t numThreads, torch::Tensor = nullptr);
+  Video(std::string videoPath = std::string(), std::string stream = std::string("video"), int64_t numThreads = 0);
+  void initFromFile(std::string videoPath, std::string stream, int64_t numThreads);
+  void initFromMemory(torch::Tensor videoTensor, std::string stream, int64_t numThreads);
+
   std::tuple<std::string, int64_t> getCurrentStream() const;
   c10::Dict<std::string, c10::Dict<std::string, std::vector<double>>>
   getStreamMetadata() const;
@@ -34,6 +37,8 @@ struct Video : torch::CustomClassHolder {
   // time in comination with any_frame settings
   double seekTS = -1;
 
+  void _init(std::string stream, int64_t numThreads); // expects params.uri OR callback to be set
+
   void _getDecoderParams(
       double videoStartS,
       int64_t getPtsOnly,

From 4fa6bd446e2c164b07f5eca150a017c6ec59bd16 Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Wed, 12 Oct 2022 16:45:01 +0100
Subject: [PATCH 03/16] fix bug

---
 torchvision/csrc/io/video/video.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/torchvision/csrc/io/video/video.cpp b/torchvision/csrc/io/video/video.cpp
index 3a6e6404410..c4abd9b4a67 100644
--- a/torchvision/csrc/io/video/video.cpp
+++ b/torchvision/csrc/io/video/video.cpp
@@ -164,7 +164,7 @@ void Video::initFromFile(std::string videoPath, std::string stream, int64_t numT
 void Video::initFromMemory(torch::Tensor videoTensor, std::string stream, int64_t numThreads)
 {
   TORCH_CHECK(callback == nullptr && params.uri.empty(), "Video object can only be initialized once");
-  callback = MemoryBuffer::getCallback(videoData.data_ptr<uint8_t>(), videoData.size(0));
+  callback = MemoryBuffer::getCallback(videoTensor.data_ptr<uint8_t>(), videoTensor.size(0));
   _init(stream, numThreads);
 }
 

From 11846c112b093f41e99497e50924f7371fe02de7 Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Wed, 12 Oct 2022 16:49:24 +0100
Subject: [PATCH 04/16] fix bug

---
 torchvision/csrc/io/video/video.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/torchvision/csrc/io/video/video.cpp b/torchvision/csrc/io/video/video.cpp
index c4abd9b4a67..a6639c72c0d 100644
--- a/torchvision/csrc/io/video/video.cpp
+++ b/torchvision/csrc/io/video/video.cpp
@@ -243,7 +243,7 @@ void Video::_init(std::string stream, int64_t numThreads) {
 Video::Video(std::string videoPath, std::string stream, int64_t numThreads) {
   C10_LOG_API_USAGE_ONCE("torchvision.csrc.io.video.video.Video");
   if (!videoPath.empty()) {
-    init_from_file(videoPath, stream, numThreads);
+    initFromFile(videoPath, stream, numThreads);
   }
 } // video
 

From 74b44b5d8aef2e69c406c837bf2e560bc00b8b3b Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Fri, 14 Oct 2022 09:45:20 +0000
Subject: [PATCH 05/16] first working version

---
 torchvision/csrc/io/video/video.cpp | 31 ++++++++++++++++++-----------
 torchvision/csrc/io/video/video.h   |  2 ++
 torchvision/io/video_reader.py      | 24 ++++++++++++++++++----
 3 files changed, 41 insertions(+), 16 deletions(-)

diff --git a/torchvision/csrc/io/video/video.cpp b/torchvision/csrc/io/video/video.cpp
index a6639c72c0d..d9e385860a3 100644
--- a/torchvision/csrc/io/video/video.cpp
+++ b/torchvision/csrc/io/video/video.cpp
@@ -157,13 +157,16 @@ void Video::_getDecoderParams(
 } // _get decoder params
 
 void Video::initFromFile(std::string videoPath, std::string stream, int64_t numThreads) {
-  TORCH_CHECK(callback == nullptr && params.uri.empty(), "Video object can only be initialized once");
+  TORCH_CHECK(!initialized, "Video object can only be initialized once");
+  initialized = true;
   params.uri = videoPath;
   _init(stream, numThreads);
 }
+
 void Video::initFromMemory(torch::Tensor videoTensor, std::string stream, int64_t numThreads)
 {
-  TORCH_CHECK(callback == nullptr && params.uri.empty(), "Video object can only be initialized once");
+  TORCH_CHECK(!initialized, "Video object can only be initialized once");
+  initialized = true;
   callback = MemoryBuffer::getCallback(videoTensor.data_ptr<uint8_t>(), videoTensor.size(0));
   _init(stream, numThreads);
 }
@@ -174,7 +177,7 @@ void Video::_init(std::string stream, int64_t numThreads) {
   // parse stream information
   current_stream = _parseStream(stream);
   // note that in the initial call we want to get all streams
-  Video::_getDecoderParams(
+  _getDecoderParams(
       0, // video start
       0, // headerOnly
       std::get<0>(current_stream), // stream info - remove that
@@ -196,7 +199,8 @@ void Video::_init(std::string stream, int64_t numThreads) {
   c10::Dict<std::string, std::vector<double>> subsMetadata;
 
   // callback and metadata defined in struct
-  succeeded = decoder.init(params, std::move(callback), &metadata);
+  DecoderInCallback tmp_callback = callback;
+  succeeded = decoder.init(params, std::move(tmp_callback), &metadata);
   if (succeeded) {
     for (const auto& header : metadata) {
       double fps = double(header.fps);
@@ -231,7 +235,7 @@ void Video::_init(std::string stream, int64_t numThreads) {
   streamsMetadata.insert("subtitles", subsMetadata);
   streamsMetadata.insert("cc", ccMetadata);
 
-  succeeded = Video::setCurrentStream(stream);
+  succeeded = setCurrentStream(stream);
   LOG(INFO) << "\nDecoder inited with: " << succeeded << "\n";
   if (std::get<1>(current_stream) != -1) {
     LOG(INFO)
@@ -248,7 +252,7 @@ Video::Video(std::string videoPath, std::string stream, int64_t numThreads) {
 } // video
 
 bool Video::setCurrentStream(std::string stream = "video") {
-  TORCH_CHECK(callback != nullptr || !params.uri.empty(), "Video object has to be initialized first");
+  TORCH_CHECK(initialized, "Video object has to be initialized first");
   if ((!stream.empty()) && (_parseStream(stream) != current_stream)) {
     current_stream = _parseStream(stream);
   }
@@ -270,22 +274,23 @@ bool Video::setCurrentStream(std::string stream = "video") {
   );
 
   // callback and metadata defined in Video.h
-  return (decoder.init(params, std::move(callback), &metadata));
+  DecoderInCallback tmp_callback = callback;
+  return (decoder.init(params, std::move(tmp_callback), &metadata));
 }
 
 std::tuple<std::string, int64_t> Video::getCurrentStream() const {
-  TORCH_CHECK(callback != nullptr || !params.uri.empty(), "Video object has to be initialized first");
+  TORCH_CHECK(initialized, "Video object has to be initialized first");
   return current_stream;
 }
 
 c10::Dict<std::string, c10::Dict<std::string, std::vector<double>>> Video::
     getStreamMetadata() const {
-  TORCH_CHECK(callback != nullptr || !params.uri.empty(), "Video object has to be initialized first");
+  TORCH_CHECK(initialized, "Video object has to be initialized first");
   return streamsMetadata;
 }
 
 void Video::Seek(double ts, bool fastSeek = false) {
-  TORCH_CHECK(callback != nullptr || !params.uri.empty(), "Video object has to be initialized first");
+  TORCH_CHECK(initialized, "Video object has to be initialized first");
   // initialize the class variables used for seeking and retrurn
   _getDecoderParams(
       ts, // video start
@@ -299,12 +304,14 @@ void Video::Seek(double ts, bool fastSeek = false) {
   );
 
   // callback and metadata defined in Video.h
-  succeeded = decoder.init(params, std::move(callback), &metadata);
+  DecoderInCallback tmp_callback = callback;
+  succeeded = decoder.init(params, std::move(tmp_callback), &metadata);
+
   LOG(INFO) << "Decoder init at seek " << succeeded << "\n";
 }
 
 std::tuple<torch::Tensor, double> Video::Next() {
-  TORCH_CHECK(callback != nullptr || !params.uri.empty(), "Video object has to be initialized first");
+  TORCH_CHECK(initialized, "Video object has to be initialized first");
   // if failing to decode simply return a null tensor (note, should we
   // raise an exeption?)
   double frame_pts_s;
diff --git a/torchvision/csrc/io/video/video.h b/torchvision/csrc/io/video/video.h
index 872f2595de9..e2696021d76 100644
--- a/torchvision/csrc/io/video/video.h
+++ b/torchvision/csrc/io/video/video.h
@@ -37,6 +37,8 @@ struct Video : torch::CustomClassHolder {
   // time in comination with any_frame settings
   double seekTS = -1;
 
+  bool initialized = false;
+  
   void _init(std::string stream, int64_t numThreads); // expects params.uri OR callback to be set
 
   void _getDecoderParams(
diff --git a/torchvision/io/video_reader.py b/torchvision/io/video_reader.py
index c2ffa049d31..c8ee7a93b28 100644
--- a/torchvision/io/video_reader.py
+++ b/torchvision/io/video_reader.py
@@ -72,7 +72,11 @@ class VideoReader:
 
     Args:
 
-        path (string): Path to the video file in supported format
+        src (string, bytes object, or tensor): The media source.
+            If string-type, it must be a file path supported by FFMPEG.
+            If bytes shoud be an in memory representatin of a file supported by FFMPEG.
+            If Tensor, it is interpreted internally as byte buffer.
+            It must be one-dimensional, of type ``torch.uint8``.
 
         stream (string, optional): descriptor of the required stream, followed by the stream id,
             in the format ``{stream_type}:{stream_id}``. Defaults to ``"video:0"``.
@@ -87,7 +91,7 @@ class VideoReader:
 
     """
 
-    def __init__(self, path: str, stream: str = "video", num_threads: int = 0, device: str = "cpu") -> None:
+    def __init__(self, src: str, stream: str = "video", num_threads: int = 0, device: str = "cpu") -> None:
         _log_api_usage_once(self)
         self.is_cuda = False
         device = torch.device(device)
@@ -104,8 +108,20 @@ def __init__(self, path: str, stream: str = "video", num_threads: int = 0, devic
                 + "ffmpeg (version 4.2 is currently supported) and "
                 + "build torchvision from source."
             )
-
-        self._c = torch.classes.torchvision.Video(path, stream, num_threads)
+    
+        
+        elif isinstance(src, bytes):
+            src = torch.frombuffer(src, dtype=torch.uint8)
+            
+        if isinstance(src, str):
+            self._c = torch.classes.torchvision.Video(src, stream, num_threads)
+        elif isinstance(src, torch.Tensor):
+            if self.is_cuda:
+                raise RuntimeError("GPU VideoReader cannot be initialized from Tensor or bytes object.")
+            self._c = torch.classes.torchvision.Video("", "", 0)
+            self._c.init_from_memory(src, stream, num_threads)
+        else:
+            raise ValueError("`src` must be either string, Tensor or bytes object.")
 
     def __next__(self) -> Dict[str, Any]:
         """Decodes and returns the next frame of the current stream.

From 2ddf1733868203de53920dd1304c5c5810d2a65d Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Fri, 14 Oct 2022 11:21:21 +0100
Subject: [PATCH 06/16] apply formatting and add tests

---
 test/test_videoapi.py               | 20 ++++++++++++++++----
 torchvision/csrc/io/video/video.cpp | 14 ++++++++++----
 torchvision/csrc/io/video/video.h   | 21 ++++++++++++++++-----
 torchvision/io/video_reader.py      |  5 ++---
 4 files changed, 44 insertions(+), 16 deletions(-)

diff --git a/test/test_videoapi.py b/test/test_videoapi.py
index 895b9b83555..e2ac238f0b5 100644
--- a/test/test_videoapi.py
+++ b/test/test_videoapi.py
@@ -57,8 +57,8 @@ def test_frame_reading(self, test_video):
         full_path = os.path.join(VIDEO_DIR, test_video)
         with av.open(full_path) as av_reader:
             if av_reader.streams.video:
-                av_frames, vr_frames = [], []
-                av_pts, vr_pts = [], []
+                av_frames, vr_frames, vr_frames_mem = [], [], []
+                av_pts, vr_pts, vr_pts_mem = [], [], []
                 # get av frames
                 for av_frame in av_reader.decode(av_reader.streams.video[0]):
                     av_frames.append(torch.tensor(av_frame.to_rgb().to_ndarray()).permute(2, 0, 1))
@@ -70,13 +70,24 @@ def test_frame_reading(self, test_video):
                     vr_frames.append(vr_frame["data"])
                     vr_pts.append(vr_frame["pts"])
 
+                # get vr frames = read from memory
+                with open(full_path, "rb") as f:
+                    video_reader_from_mem = VideoReader(f.read())
+                    for vr_frame_from_mem in video_reader_from_mem:
+                        vr_frames_mem.append(vr_frame_from_mem["data"])
+                        vr_pts_mem.append(vr_frame_from_mem["pts"])
+
                 # same number of frames
-                assert len(vr_frames) == len(av_frames)
-                assert len(vr_pts) == len(av_pts)
+                assert len(vr_frames) == len(av_frames) == len(vr_frames_mem)
+                assert len(vr_pts) == len(av_pts) == len(vr_pts_mem)
 
                 # compare the frames and ptss
                 for i in range(len(vr_frames)):
+                    assert vr_pts[i] == vr_pts_mem[i]
                     assert float(av_pts[i]) == approx(vr_pts[i], abs=0.1)
+
+                    torch.equal(vr_frames[i], vr_frames_mem[i])
+
                     mean_delta = torch.mean(torch.abs(av_frames[i].float() - vr_frames[i].float()))
                     # on average the difference is very small and caused
                     # by decoding (around 1%)
@@ -84,6 +95,7 @@ def test_frame_reading(self, test_video):
                     # averaged over all frames
                     assert mean_delta.item() < 2.55
 
+
                 del vr_frames, av_frames, vr_pts, av_pts
 
         # test audio reading compared to PYAV
diff --git a/torchvision/csrc/io/video/video.cpp b/torchvision/csrc/io/video/video.cpp
index d9e385860a3..d8b36a35adc 100644
--- a/torchvision/csrc/io/video/video.cpp
+++ b/torchvision/csrc/io/video/video.cpp
@@ -156,18 +156,24 @@ void Video::_getDecoderParams(
 
 } // _get decoder params
 
-void Video::initFromFile(std::string videoPath, std::string stream, int64_t numThreads) {
+void Video::initFromFile(
+    std::string videoPath,
+    std::string stream,
+    int64_t numThreads) {
   TORCH_CHECK(!initialized, "Video object can only be initialized once");
   initialized = true;
   params.uri = videoPath;
   _init(stream, numThreads);
 }
 
-void Video::initFromMemory(torch::Tensor videoTensor, std::string stream, int64_t numThreads)
-{
+void Video::initFromMemory(
+    torch::Tensor videoTensor,
+    std::string stream,
+    int64_t numThreads) {
   TORCH_CHECK(!initialized, "Video object can only be initialized once");
   initialized = true;
-  callback = MemoryBuffer::getCallback(videoTensor.data_ptr<uint8_t>(), videoTensor.size(0));
+  callback = MemoryBuffer::getCallback(
+      videoTensor.data_ptr<uint8_t>(), videoTensor.size(0));
   _init(stream, numThreads);
 }
 
diff --git a/torchvision/csrc/io/video/video.h b/torchvision/csrc/io/video/video.h
index e2696021d76..5249ee00349 100644
--- a/torchvision/csrc/io/video/video.h
+++ b/torchvision/csrc/io/video/video.h
@@ -19,9 +19,18 @@ struct Video : torch::CustomClassHolder {
   int64_t numThreads_{0};
 
  public:
-  Video(std::string videoPath = std::string(), std::string stream = std::string("video"), int64_t numThreads = 0);
-  void initFromFile(std::string videoPath, std::string stream, int64_t numThreads);
-  void initFromMemory(torch::Tensor videoTensor, std::string stream, int64_t numThreads);
+  Video(
+      std::string videoPath = std::string(),
+      std::string stream = std::string("video"),
+      int64_t numThreads = 0);
+  void initFromFile(
+      std::string videoPath,
+      std::string stream,
+      int64_t numThreads);
+  void initFromMemory(
+      torch::Tensor videoTensor,
+      std::string stream,
+      int64_t numThreads);
 
   std::tuple<std::string, int64_t> getCurrentStream() const;
   c10::Dict<std::string, c10::Dict<std::string, std::vector<double>>>
@@ -38,8 +47,10 @@ struct Video : torch::CustomClassHolder {
   double seekTS = -1;
 
   bool initialized = false;
-  
-  void _init(std::string stream, int64_t numThreads); // expects params.uri OR callback to be set
+
+  void _init(
+      std::string stream,
+      int64_t numThreads); // expects params.uri OR callback to be set
 
   void _getDecoderParams(
       double videoStartS,
diff --git a/torchvision/io/video_reader.py b/torchvision/io/video_reader.py
index c8ee7a93b28..e34af07e4bd 100644
--- a/torchvision/io/video_reader.py
+++ b/torchvision/io/video_reader.py
@@ -108,11 +108,10 @@ def __init__(self, src: str, stream: str = "video", num_threads: int = 0, device
                 + "ffmpeg (version 4.2 is currently supported) and "
                 + "build torchvision from source."
             )
-    
-        
+
         elif isinstance(src, bytes):
             src = torch.frombuffer(src, dtype=torch.uint8)
-            
+
         if isinstance(src, str):
             self._c = torch.classes.torchvision.Video(src, stream, num_threads)
         elif isinstance(src, torch.Tensor):

From 94a12b574088332e159c2cb0fe332fce79c277b3 Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Fri, 14 Oct 2022 11:38:48 +0100
Subject: [PATCH 07/16] simplify tests

---
 test/test_videoapi.py | 52 ++++++++++++++++++++++++++++++-------------
 1 file changed, 37 insertions(+), 15 deletions(-)

diff --git a/test/test_videoapi.py b/test/test_videoapi.py
index e2ac238f0b5..5fb7372cf37 100644
--- a/test/test_videoapi.py
+++ b/test/test_videoapi.py
@@ -57,8 +57,8 @@ def test_frame_reading(self, test_video):
         full_path = os.path.join(VIDEO_DIR, test_video)
         with av.open(full_path) as av_reader:
             if av_reader.streams.video:
-                av_frames, vr_frames, vr_frames_mem = [], [], []
-                av_pts, vr_pts, vr_pts_mem = [], [], []
+                av_frames, vr_frames = [], []
+                av_pts, vr_pts = [], []
                 # get av frames
                 for av_frame in av_reader.decode(av_reader.streams.video[0]):
                     av_frames.append(torch.tensor(av_frame.to_rgb().to_ndarray()).permute(2, 0, 1))
@@ -70,24 +70,14 @@ def test_frame_reading(self, test_video):
                     vr_frames.append(vr_frame["data"])
                     vr_pts.append(vr_frame["pts"])
 
-                # get vr frames = read from memory
-                with open(full_path, "rb") as f:
-                    video_reader_from_mem = VideoReader(f.read())
-                    for vr_frame_from_mem in video_reader_from_mem:
-                        vr_frames_mem.append(vr_frame_from_mem["data"])
-                        vr_pts_mem.append(vr_frame_from_mem["pts"])
-
                 # same number of frames
-                assert len(vr_frames) == len(av_frames) == len(vr_frames_mem)
-                assert len(vr_pts) == len(av_pts) == len(vr_pts_mem)
+                assert len(vr_frames) == len(av_frames)
+                assert len(vr_pts) == len(av_pts)
 
                 # compare the frames and ptss
                 for i in range(len(vr_frames)):
-                    assert vr_pts[i] == vr_pts_mem[i]
                     assert float(av_pts[i]) == approx(vr_pts[i], abs=0.1)
 
-                    torch.equal(vr_frames[i], vr_frames_mem[i])
-
                     mean_delta = torch.mean(torch.abs(av_frames[i].float() - vr_frames[i].float()))
                     # on average the difference is very small and caused
                     # by decoding (around 1%)
@@ -95,7 +85,6 @@ def test_frame_reading(self, test_video):
                     # averaged over all frames
                     assert mean_delta.item() < 2.55
 
-
                 del vr_frames, av_frames, vr_pts, av_pts
 
         # test audio reading compared to PYAV
@@ -126,6 +115,39 @@ def test_frame_reading(self, test_video):
                     # we assure that there is never more than 1% difference in signal
                     assert max_delta.item() < 0.001
 
+    @pytest.mark.parametrize("stream", ["video", "audio"])
+    @pytest.mark.parametrize("test_video", test_videos.keys())
+    def test_frame_reading_mem_vs_file(self, test_video, stream):
+        full_path = os.path.join(VIDEO_DIR, test_video)
+
+        # Test video reading from file vs from memory
+        vr_frames, vr_frames_mem = [], []
+        vr_pts, vr_pts_mem = [], []
+        # get vr frames
+        video_reader = VideoReader(full_path, stream)
+        for vr_frame in video_reader:
+            vr_frames.append(vr_frame["data"])
+            vr_pts.append(vr_frame["pts"])
+
+        # get vr frames = read from memory
+        with open(full_path, "rb") as f:
+            video_reader_from_mem = VideoReader(f.read(), "video")
+            for vr_frame_from_mem in video_reader_from_mem:
+                vr_frames_mem.append(vr_frame_from_mem["data"])
+                vr_pts_mem.append(vr_frame_from_mem["pts"])
+
+        # same number of frames
+        assert len(vr_frames) == len(vr_frames_mem)
+        assert len(vr_pts) == len(vr_pts_mem)
+
+        # compare the frames and ptss
+        for i in range(len(vr_frames)):
+            assert vr_pts[i] == vr_pts_mem[i]
+
+            torch.equal(vr_frames[i], vr_frames_mem[i])
+
+        del vr_frames, vr_pts, vr_frames_mem, vr_pts_mem
+
     @pytest.mark.parametrize("test_video,config", test_videos.items())
     def test_metadata(self, test_video, config):
         """

From 901c5304e34eb7e81411d71bbf2f725f1df88e33 Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Fri, 14 Oct 2022 12:00:41 +0000
Subject: [PATCH 08/16] fix tests

---
 test/test_videoapi.py | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/test/test_videoapi.py b/test/test_videoapi.py
index 5fb7372cf37..4688e5a640b 100644
--- a/test/test_videoapi.py
+++ b/test/test_videoapi.py
@@ -130,11 +130,14 @@ def test_frame_reading_mem_vs_file(self, test_video, stream):
             vr_pts.append(vr_frame["pts"])
 
         # get vr frames = read from memory
-        with open(full_path, "rb") as f:
-            video_reader_from_mem = VideoReader(f.read(), "video")
-            for vr_frame_from_mem in video_reader_from_mem:
-                vr_frames_mem.append(vr_frame_from_mem["data"])
-                vr_pts_mem.append(vr_frame_from_mem["pts"])
+        f = open(full_path, "rb")
+        fbytes = f.read()
+        f.close()
+        video_reader_from_mem = VideoReader(fbytes, stream)
+
+        for vr_frame_from_mem in video_reader_from_mem:
+            vr_frames_mem.append(vr_frame_from_mem["data"])
+            vr_pts_mem.append(vr_frame_from_mem["pts"])
 
         # same number of frames
         assert len(vr_frames) == len(vr_frames_mem)
@@ -143,8 +146,12 @@ def test_frame_reading_mem_vs_file(self, test_video, stream):
         # compare the frames and ptss
         for i in range(len(vr_frames)):
             assert vr_pts[i] == vr_pts_mem[i]
-
-            torch.equal(vr_frames[i], vr_frames_mem[i])
+            mean_delta = torch.mean(torch.abs(vr_frames[i].float() - vr_frames_mem[i].float()))
+            # on average the difference is very small and caused
+            # by decoding (around 1%)
+            # TODO: asses empirically how to set this? atm it's 1%
+            # averaged over all frames
+            assert mean_delta.item() < 2.55
 
         del vr_frames, vr_pts, vr_frames_mem, vr_pts_mem
 

From 1b6fee559885429c70098ea51813d062ef7e6bc8 Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Fri, 14 Oct 2022 15:51:47 +0100
Subject: [PATCH 09/16] fix wrong variable name

---
 torchvision/io/video_reader.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/torchvision/io/video_reader.py b/torchvision/io/video_reader.py
index e34af07e4bd..d288ed228e4 100644
--- a/torchvision/io/video_reader.py
+++ b/torchvision/io/video_reader.py
@@ -99,7 +99,7 @@ def __init__(self, src: str, stream: str = "video", num_threads: int = 0, device
             if not _HAS_GPU_VIDEO_DECODER:
                 raise RuntimeError("Not compiled with GPU decoder support.")
             self.is_cuda = True
-            self._c = torch.classes.torchvision.GPUDecoder(path, device)
+            self._c = torch.classes.torchvision.GPUDecoder(src, device)
             return
         if not _has_video_opt():
             raise RuntimeError(

From 288afa40310aee285029c06323822d752a0351c4 Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Tue, 18 Oct 2022 14:15:13 +0100
Subject: [PATCH 10/16] add path as optional parameter

---
 torchvision/io/video_reader.py | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/torchvision/io/video_reader.py b/torchvision/io/video_reader.py
index d288ed228e4..149d0b900f7 100644
--- a/torchvision/io/video_reader.py
+++ b/torchvision/io/video_reader.py
@@ -1,4 +1,4 @@
-from typing import Any, Dict, Iterator
+from typing import Any, Dict, Iterator, Optional
 
 import torch
 
@@ -89,9 +89,15 @@ class VideoReader:
         device (str, optional): Device to be used for decoding. Defaults to ``"cpu"``.
             To use GPU decoding, pass ``device="cuda"``.
 
+        path (str, optional):
+            .. warning:
+                This parameter was deprecated in ``0.15`` and will be removed in ``0.17``. Please use ``src`` instead.
+
     """
 
-    def __init__(self, src: str, stream: str = "video", num_threads: int = 0, device: str = "cpu") -> None:
+    def __init__(
+        self, src: str, stream: str = "video", num_threads: int = 0, device: str = "cpu", path: Optional[str] = None
+    ) -> None:
         _log_api_usage_once(self)
         self.is_cuda = False
         device = torch.device(device)
@@ -109,6 +115,10 @@ def __init__(self, src: str, stream: str = "video", num_threads: int = 0, device
                 + "build torchvision from source."
             )
 
+        # for bc compatibility of path is provided it will override src
+        if path:
+            src = path
+
         elif isinstance(src, bytes):
             src = torch.frombuffer(src, dtype=torch.uint8)
 

From 9bbdd14a1ef840623ab3186438c222e553791b3f Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Tue, 18 Oct 2022 14:51:13 +0100
Subject: [PATCH 11/16] add src as optional

---
 torchvision/io/video_reader.py | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/torchvision/io/video_reader.py b/torchvision/io/video_reader.py
index 149d0b900f7..60ea2affe8d 100644
--- a/torchvision/io/video_reader.py
+++ b/torchvision/io/video_reader.py
@@ -71,12 +71,10 @@ class VideoReader:
         If only stream type is passed, the decoder auto-detects first stream of that type.
 
     Args:
-
-        src (string, bytes object, or tensor): The media source.
-            If string-type, it must be a file path supported by FFMPEG.
-            If bytes shoud be an in memory representatin of a file supported by FFMPEG.
-            If Tensor, it is interpreted internally as byte buffer.
-            It must be one-dimensional, of type ``torch.uint8``.
+        path (str, bytes object, or tensor):
+            .. warning:
+                This parameter was deprecated in ``0.15`` and will be removed in ``0.17``.
+                Please use ``src`` instead.
 
         stream (string, optional): descriptor of the required stream, followed by the stream id,
             in the format ``{stream_type}:{stream_id}``. Defaults to ``"video:0"``.
@@ -89,14 +87,17 @@ class VideoReader:
         device (str, optional): Device to be used for decoding. Defaults to ``"cpu"``.
             To use GPU decoding, pass ``device="cuda"``.
 
-        path (str, optional):
-            .. warning:
-                This parameter was deprecated in ``0.15`` and will be removed in ``0.17``. Please use ``src`` instead.
 
+
+        src (string, bytes object, or tensor, optional): The media source.
+            If string-type, it must be a file path supported by FFMPEG.
+            If bytes shoud be an in memory representatin of a file supported by FFMPEG.
+            If Tensor, it is interpreted internally as byte buffer.
+            It must be one-dimensional, of type ``torch.uint8``.
     """
 
     def __init__(
-        self, src: str, stream: str = "video", num_threads: int = 0, device: str = "cpu", path: Optional[str] = None
+        self, path: str, stream: str = "video", num_threads: int = 0, device: str = "cpu", src: Optional[str] = None
     ) -> None:
         _log_api_usage_once(self)
         self.is_cuda = False

From 382838da6ab310f6ba2f31a2ba54258e26fa1a57 Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Tue, 18 Oct 2022 21:16:45 +0100
Subject: [PATCH 12/16] address pr comments

---
 torchvision/io/video_reader.py | 35 ++++++++++++++++++++++------------
 1 file changed, 23 insertions(+), 12 deletions(-)

diff --git a/torchvision/io/video_reader.py b/torchvision/io/video_reader.py
index 60ea2affe8d..472572e0b64 100644
--- a/torchvision/io/video_reader.py
+++ b/torchvision/io/video_reader.py
@@ -1,3 +1,4 @@
+import warnings
 from typing import Any, Dict, Iterator, Optional
 
 import torch
@@ -71,10 +72,13 @@ class VideoReader:
         If only stream type is passed, the decoder auto-detects first stream of that type.
 
     Args:
-        path (str, bytes object, or tensor):
-            .. warning:
-                This parameter was deprecated in ``0.15`` and will be removed in ``0.17``.
-                Please use ``src`` instead.
+        src (string, bytes object, or tensor): The media source.
+            If string-type, it must be a file path supported by FFMPEG.
+            If bytes shoud be an in memory representatin of a file supported by FFMPEG.
+            If Tensor, it is interpreted internally as byte buffer.
+            It must be one-dimensional, of type ``torch.uint8``.
+
+
 
         stream (string, optional): descriptor of the required stream, followed by the stream id,
             in the format ``{stream_type}:{stream_id}``. Defaults to ``"video:0"``.
@@ -87,17 +91,22 @@ class VideoReader:
         device (str, optional): Device to be used for decoding. Defaults to ``"cpu"``.
             To use GPU decoding, pass ``device="cuda"``.
 
+        path (str, optional):
+            .. warning:
+                This parameter was deprecated in ``0.15`` and will be removed in ``0.17``.
+                Please use ``src`` instead.
+
 
 
-        src (string, bytes object, or tensor, optional): The media source.
-            If string-type, it must be a file path supported by FFMPEG.
-            If bytes shoud be an in memory representatin of a file supported by FFMPEG.
-            If Tensor, it is interpreted internally as byte buffer.
-            It must be one-dimensional, of type ``torch.uint8``.
     """
 
     def __init__(
-        self, path: str, stream: str = "video", num_threads: int = 0, device: str = "cpu", src: Optional[str] = None
+        self,
+        src: str = "",
+        stream: str = "video",
+        num_threads: int = 0,
+        device: str = "cpu",
+        path: Optional[str] = None,
     ) -> None:
         _log_api_usage_once(self)
         self.is_cuda = False
@@ -116,9 +125,11 @@ def __init__(
                 + "build torchvision from source."
             )
 
-        # for bc compatibility of path is provided it will override src
-        if path:
+        if src == "":
+            if path is None:
+                raise ValueError("src cannot be empty")
             src = path
+            warnings.warn("path is deprecated ...")
 
         elif isinstance(src, bytes):
             src = torch.frombuffer(src, dtype=torch.uint8)

From 5e6cb0ded0af24873a2f9bd2f55c28c7f644d846 Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Tue, 18 Oct 2022 21:27:03 +0100
Subject: [PATCH 13/16] Fix warning messages

---
 torchvision/io/video_reader.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/torchvision/io/video_reader.py b/torchvision/io/video_reader.py
index 472572e0b64..f51a661183b 100644
--- a/torchvision/io/video_reader.py
+++ b/torchvision/io/video_reader.py
@@ -129,7 +129,7 @@ def __init__(
             if path is None:
                 raise ValueError("src cannot be empty")
             src = path
-            warnings.warn("path is deprecated ...")
+            warnings.warn("path is deprecated and will be removed in 0.17. Please use src instead")
 
         elif isinstance(src, bytes):
             src = torch.frombuffer(src, dtype=torch.uint8)

From 8eb26928095ec8152f67bce89254b7bb918f2484 Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Wed, 19 Oct 2022 14:11:56 +0100
Subject: [PATCH 14/16] address pr comments

---
 torchvision/io/video_reader.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/torchvision/io/video_reader.py b/torchvision/io/video_reader.py
index f51a661183b..0449d6d1ea4 100644
--- a/torchvision/io/video_reader.py
+++ b/torchvision/io/video_reader.py
@@ -127,7 +127,7 @@ def __init__(
 
         if src == "":
             if path is None:
-                raise ValueError("src cannot be empty")
+                raise TypeError("src cannot be empty")
             src = path
             warnings.warn("path is deprecated and will be removed in 0.17. Please use src instead")
 
@@ -142,7 +142,7 @@ def __init__(
             self._c = torch.classes.torchvision.Video("", "", 0)
             self._c.init_from_memory(src, stream, num_threads)
         else:
-            raise ValueError("`src` must be either string, Tensor or bytes object.")
+            raise TypeError("`src` must be either string, Tensor or bytes object.")
 
     def __next__(self) -> Dict[str, Any]:
         """Decodes and returns the next frame of the current stream.

From 6c92e94e8372f381c9496c9f885c2c71b6a4356b Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Thu, 20 Oct 2022 12:33:52 +0000
Subject: [PATCH 15/16] make tests stricter

---
 test/test_videoapi.py | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/test/test_videoapi.py b/test/test_videoapi.py
index 4688e5a640b..6ec85bd0776 100644
--- a/test/test_videoapi.py
+++ b/test/test_videoapi.py
@@ -76,14 +76,8 @@ def test_frame_reading(self, test_video):
 
                 # compare the frames and ptss
                 for i in range(len(vr_frames)):
-                    assert float(av_pts[i]) == approx(vr_pts[i], abs=0.1)
-
-                    mean_delta = torch.mean(torch.abs(av_frames[i].float() - vr_frames[i].float()))
-                    # on average the difference is very small and caused
-                    # by decoding (around 1%)
-                    # TODO: asses empirically how to set this? atm it's 1%
-                    # averaged over all frames
-                    assert mean_delta.item() < 2.55
+                    assert av_pts[i] == vr_pts[i]
+                    torch.test.assert_equal(av_frames[i], vr_frames[i])
 
                 del vr_frames, av_frames, vr_pts, av_pts
 

From 76ec9d2a5a97e289b15479631d5721dc902c026f Mon Sep 17 00:00:00 2001
From: Joao Gomes <jdsgomes@fb.com>
Date: Thu, 20 Oct 2022 13:21:08 +0000
Subject: [PATCH 16/16] Revert "make tests stricter"

This reverts commit 6c92e94e8372f381c9496c9f885c2c71b6a4356b.
---
 test/test_videoapi.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/test/test_videoapi.py b/test/test_videoapi.py
index 6ec85bd0776..4688e5a640b 100644
--- a/test/test_videoapi.py
+++ b/test/test_videoapi.py
@@ -76,8 +76,14 @@ def test_frame_reading(self, test_video):
 
                 # compare the frames and ptss
                 for i in range(len(vr_frames)):
-                    assert av_pts[i] == vr_pts[i]
-                    torch.test.assert_equal(av_frames[i], vr_frames[i])
+                    assert float(av_pts[i]) == approx(vr_pts[i], abs=0.1)
+
+                    mean_delta = torch.mean(torch.abs(av_frames[i].float() - vr_frames[i].float()))
+                    # on average the difference is very small and caused
+                    # by decoding (around 1%)
+                    # TODO: asses empirically how to set this? atm it's 1%
+                    # averaged over all frames
+                    assert mean_delta.item() < 2.55
 
                 del vr_frames, av_frames, vr_pts, av_pts