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
