def test_write1(): for n in (1, 9, 14, 279, 280, 281): # Prepare for writing gen = imageio_ffmpeg.write_frames(test_file2, (64, 64)) assert isinstance(gen, types.GeneratorType) gen.send(None) # seed # Write n frames for i in range(n): data = bytes([min(255, 100 + i * 10)] * 64 * 64 * 3) gen.send(data) gen.close() # Check that number of frames is correct nframes, nsecs = imageio_ffmpeg.count_frames_and_secs(test_file2) assert nframes == n # Check again by actually reading gen2 = imageio_ffmpeg.read_frames(test_file2) gen2.__next__() # == meta count = 0 for frame in gen2: count += 1 assert count == n
def test_reading4(): # Same as 1, but wrong, using an insane bpp, to invoke eof halfway a frame gen = imageio_ffmpeg.read_frames(test_file1, bpp=13) gen.__next__() # == meta with raises(RuntimeError) as info: for frame in gen: pass msg = str(info.value).lower() assert "end of file reached before full frame could be read" in msg assert "ffmpeg version" in msg # The log is included
def test_read_frames_resource_warning(): """ Test issue #61: ensure no warnings are raised when the generator is closed todo: use pytest.does_not_warn() as soon as it becomes available (see https://github.com/pytest-dev/pytest/issues/9404) """ with warns(None) as warnings: gen = imageio_ffmpeg.read_frames(test_file1) next(gen) gen.close() # there should not be any warnings, but show warning messages if there are assert not [w.message for w in warnings]
def test_reading3(): # Same as 1, but using other fps gen = imageio_ffmpeg.read_frames(test_file1, output_params=["-r", "5.0"]) meta = gen.__next__() framesize = meta["size"][0] * meta["size"][1] * 3 assert framesize == 1280 * 720 * 3 count = 0 for frame in gen: count += 1 assert isinstance(frame, bytes) and len(frame) == framesize assert 50 < count < 100 # because smaller fps, same duration
def test_reading2(): # Same as 1, but using other pixel format gen = imageio_ffmpeg.read_frames(test_file1, pix_fmt="gray", bpp=1) meta = gen.__next__() framesize = meta["size"][0] * meta["size"][1] * 1 assert framesize == 1280 * 720 * 1 count = 0 for frame in gen: count += 1 assert isinstance(frame, bytes) and len(frame) == framesize assert count == 280
def test_write_wmv(): # Switch to MS friendly codec when writing .wmv files for ext, codec in [("", "h264"), (".wmv", "msmpeg4")]: fname = test_file2 + ext gen = imageio_ffmpeg.write_frames(fname, (64, 64)) gen.send(None) # seed for i in range(9): data = bytes([min(255, 100 + i * 10)] * 64 * 64 * 3) gen.send(data) gen.close() # meta = imageio_ffmpeg.read_frames(fname).__next__() assert meta["codec"].startswith(codec)
def test_reader_close(): for i in range(N): pids0 = get_ffmpeg_pids() r = imageio_ffmpeg.read_frames(test_file1) pids1 = get_ffmpeg_pids().difference( pids0) # generator has not started r.__next__() # == meta pids2 = get_ffmpeg_pids().difference(pids0) # now ffmpeg is running r.close() pids3 = get_ffmpeg_pids().difference(pids0) # now its not assert len(pids1) == 0 assert len(pids2) == 1 assert len(pids3) == 0
def test_reading_invalid_video(): """ Check whether invalid video is handled correctly without timeouts """ # empty file as an example of invalid video _, test_invalid_file = tempfile.mkstemp(dir=test_dir) gen = imageio_ffmpeg.read_frames(test_invalid_file) start = time.time() with raises(OSError): gen.__next__() end = time.time() # check if metadata extraction doesn't hang # for a timeout period assert end - start < 1, "Metadata extraction hangs"
def test_write_audio_path(): # Provide an audio gen = imageio_ffmpeg.write_frames(test_file2, (64, 64), audio_path=test_file3, audio_codec="aac") gen.send(None) # seed for i in range(9): data = bytes([min(255, 100 + i * 10)] * 64 * 64 * 3) gen.send(data) gen.close() # Check nframes nframes, nsecs = imageio_ffmpeg.count_frames_and_secs(test_file2) assert nframes == 9 # Check size meta = imageio_ffmpeg.read_frames(test_file2).__next__() audio_codec = meta["audio_codec"] assert nframes == 9 assert audio_codec == "aac"
def test_write_macro_block_size(): frame_sizes = [] for mbz in [None, 10]: # None is default == 16 # Prepare for writing gen = imageio_ffmpeg.write_frames(test_file2, (40, 50), macro_block_size=mbz) gen.send(None) # seed for i in range(9): data = bytes([min(255, 100 + i * 10)] * 40 * 50 * 3) gen.send(data) gen.close() # Check nframes nframes, nsecs = imageio_ffmpeg.count_frames_and_secs(test_file2) assert nframes == 9 # Check size meta = imageio_ffmpeg.read_frames(test_file2).__next__() frame_sizes.append(meta["size"]) assert frame_sizes[0] == (48, 64) assert frame_sizes[1] == (40, 50)
def test_reading5(): # Same as 1, but using other pixel format and bits_per_pixel bits_per_pixel = 12 bits_per_bytes = 8 gen = imageio_ffmpeg.read_frames(test_file3, pix_fmt="yuv420p", bits_per_pixel=bits_per_pixel) meta = gen.__next__() assert isinstance(meta, dict) for key in ("size", "fps", "duration"): assert key in meta # Read frames framesize = meta["size"][0] * meta["size"][1] * bits_per_pixel / bits_per_bytes assert framesize == 320 * 240 * bits_per_pixel / bits_per_bytes count = 0 for frame in gen: assert isinstance(frame, bytes) and len(frame) == framesize count += 1 assert count == 36
def test_reading1(): # Calling returns a generator gen = imageio_ffmpeg.read_frames(test_file1) assert isinstance(gen, types.GeneratorType) # First yield is a meta dict meta = gen.__next__() assert isinstance(meta, dict) for key in ("size", "fps", "duration"): assert key in meta # Read frames framesize = meta["size"][0] * meta["size"][1] * 3 assert framesize == 1280 * 720 * 3 count = 0 for frame in gen: assert isinstance(frame, bytes) and len(frame) == framesize count += 1 assert count == 280
def compare_videos(encoded_video_path: str, expected_video: np.ndarray): """Compare an encoded video with its original source""" reader = mpg.read_frames(encoded_video_path, pix_fmt="gray8", bits_per_pixel=8) meta = reader.__next__() obt_nframes = int(np.round(meta['duration'] * meta['fps'])) assert obt_nframes == len(expected_video) obt_frames = [] for frame in reader: parsed_frame = np.frombuffer(frame, dtype='uint8') parsed_frame = parsed_frame.reshape(meta["size"][::-1]) obt_frames.append(parsed_frame) obt_video = np.array(obt_frames) assert obt_video.shape == expected_video.shape # the default settings for imageio-ffmpeg are not lossless # so can't test for exact match np.testing.assert_allclose(obt_video, expected_video, atol=20)
filename = os.path.expanduser("~/Desktop/foo.mp4") w = imageio_ffmpeg.write_frames(filename, (1000, 1000), ffmpeg_timeout=0) w.send(None) for i in range(200): w.send(ims[i % 10]) print(i) w.close() # %% Behavior of KeyboardInterrupt / Ctrl+C import os import imageio_ffmpeg filename = os.path.expanduser("~/.imageio/images/cockatoo.mp4") reader = imageio_ffmpeg.read_frames(filename) meta = reader.__next__() try: input("Do a manual KeyboardInterrupt now [Ctrl]+[c]") # Note: Raising an error with code won't trigger the original error. except BaseException as err: print(err) print("out1", len(reader.__next__())) print("out2", len(reader.__next__())) print("closing") reader.close() print("closed")
from imageio_ffmpeg import read_frames # limited functionality import av # pip install av # fast from guang.cv.video import getFrame # I'm the best from guang.Utils.toolsFunc import path reader = read_frames(path(r"F:\硬盘\高阶V\888")) meta = reader.__next__() """ >>> meta {'ffmpeg_version': '4.2.2 built with gcc 9.2.1 (GCC) 20200122', 'codec': 'h264', 'pix_fmt': 'yuv420p(tv', 'fps': 29.97, 'source_size': (720, 396), 'size': (720, 396), 'duration': 6971.0} """
def make_iterator(q, n): for i in range(n): gen = imageio_ffmpeg.read_frames(test_file1) gen.__next__() # meta data q.put(gen.__next__()) # first frame