def test_webm_lossless_filter(mocker, http_client, base_url, ffmpeg_path):
mocker.spy(FFmpegEngine, 'run_cmd')
response = yield http_client.fetch(
"%s/unsafe/filters:lossless()/hotdog.webm" % (base_url))
FFmpegEngine.run_cmd.assert_called_once_with(mocker.ANY, mocker.ANY)
cmd = FFmpegEngine.run_cmd.mock_calls[0].args[1]
assert '-lossless' in cmd
assert cmd[cmd.index('-lossless') + 1] == '1'
assert response.code == 200
assert response.headers.get('content-type') == 'video/webm'
file_info = ffprobe(response.body)
expected = {
'codec_name': 'vp9',
'width': 200,
'height': 150,
'pix_fmt': 'yuv420p',
}
actual = {k: file_info.get(k) for k in expected}
assert expected == actual
def test_h265_tune_filter(mocker, http_client, base_url, ffmpeg_path):
mocker.spy(FFmpegEngine, 'run_cmd')
response = yield http_client.fetch(
"%s/unsafe/filters:tune(animation):format(h265)/hotdog.mp4" % base_url)
assert response.code == 200
assert response.headers.get('content-type') == 'video/mp4'
FFmpegEngine.run_cmd.assert_called_once_with(mocker.ANY, mocker.ANY)
cmd = FFmpegEngine.run_cmd.mock_calls[0][1][1]
assert '-tune' in cmd
assert cmd[cmd.index('-tune') + 1] == 'animation'
file_info = ffprobe(response.body)
expected = {
'codec_name': 'hevc',
'width': 200,
'height': 150,
'pix_fmt': 'yuv420p',
}
actual = {k: file_info.get(k) for k in expected}
assert expected == actual
def probe(self):
# If self.image, we have an animated image (e.g. webp) that ffmpeg
# cannot yet decode, but pillow can.
if self.image:
self.original_size = self.image.size
duration_ms = 0
# Load all frames, get the sum of all frames' durations
for frame in ImageSequence.Iterator(self.image):
frame.load()
duration_ms += frame.info['duration']
self.image.seek(0)
self.duration = Decimal(duration_ms) / Decimal(1000)
else:
ffprobe_data = ffprobe(self.buffer, extension=self.extension)
self.original_size = ffprobe_data['width'], ffprobe_data['height']
self.duration = Decimal(ffprobe_data['duration'])
def test_transcode_to_h265(http_client, base_url, src_ext):
response = yield http_client.fetch(
"%s/unsafe/filters:format(h265)/hotdog.%s" % (base_url, src_ext))
assert response.code == 200
assert response.headers.get('content-type') == 'video/mp4'
file_info = ffprobe(response.body)
expected = {
'codec_name': 'hevc',
'width': 200,
'height': 150,
'pix_fmt': 'yuv420p',
}
actual = {k: file_info.get(k) for k in expected}
assert expected == actual
def test_mp4_resize_odd_dimensions(http_client, base_url, codec):
"""h264 and h265 require videos to have width and height be even integers"""
response = yield http_client.fetch(
"%s/unsafe/100x75/filters:format(%s)/hotdog.mp4" % (base_url, codec))
assert response.code == 200
assert response.headers.get('content-type') == 'video/mp4'
file_info = ffprobe(response.body)
expected = {
'codec_name': codec,
'width': 100,
'height': 74,
'pix_fmt': 'yuv420p',
}
actual = {k: file_info.get(k) for k in expected}
assert expected == actual
def test_filter_grayscale(mocker, http_client, base_url):
mocker.spy(FFmpegEngine, 'convert_to_grayscale')
mocker.spy(FFmpegEngine, 'run_cmd')
response = yield http_client.fetch(
"%s/unsafe/filters:grayscale()/hotdog.mp4" % base_url)
assert response.code == 200
assert response.headers.get('content-type') == 'video/mp4'
FFmpegEngine.convert_to_grayscale.assert_called_once()
FFmpegEngine.run_cmd.assert_called_once_with(mocker.ANY, mocker.ANY)
cmd = FFmpegEngine.run_cmd.mock_calls[0].args[1]
assert '-vf' in cmd
assert cmd[cmd.index('-vf') + 1] == 'hue=s=0'
file_info = ffprobe(response.body)
assert (file_info['width'], file_info['height']) == (200, 150)
def test_crop(mocker, http_client, base_url):
mocker.spy(FFmpegEngine, 'crop')
mocker.spy(FFmpegEngine, 'run_cmd')
response = yield http_client.fetch("%s/unsafe/50x25:150x125/hotdog.mp4" %
base_url)
assert response.code == 200
assert response.headers.get('content-type') == 'video/mp4'
FFmpegEngine.crop.assert_called_once_with(mocker.ANY, 50, 25, 150, 125)
FFmpegEngine.run_cmd.assert_called_once_with(mocker.ANY, mocker.ANY)
cmd = FFmpegEngine.run_cmd.mock_calls[0].args[1]
assert '-vf' in cmd
assert cmd[cmd.index('-vf') + 1] == 'crop=100:100:50:25'
file_info = ffprobe(response.body)
assert (file_info['width'], file_info['height']) == (100, 100)
def test_flip_vertically(mocker, http_client, base_url):
mocker.spy(FFmpegEngine, 'flip_vertically')
mocker.spy(FFmpegEngine, 'run_cmd')
response = yield http_client.fetch("%s/unsafe/200x-150/hotdog.mp4" %
base_url)
assert response.code == 200
assert response.headers.get('content-type') == 'video/mp4'
FFmpegEngine.flip_vertically.assert_called_once()
FFmpegEngine.run_cmd.assert_called_once_with(mocker.ANY, mocker.ANY)
cmd = FFmpegEngine.run_cmd.mock_calls[0][1][1]
assert '-vf' in cmd
assert cmd[cmd.index('-vf') + 1] == 'vflip'
file_info = ffprobe(response.body)
assert (file_info['width'], file_info['height']) == (200, 150)
def test_transcode_to_webm(http_client, base_url, src_ext):
url_filter = "/filters:format(webm)" if src_ext else ""
if src_ext is None:
src_ext = "webm"
response = yield http_client.fetch("%s/unsafe%s/hotdog.%s" %
(base_url, url_filter, src_ext))
assert response.code == 200
assert response.headers.get('content-type') == 'video/webm'
file_info = ffprobe(response.body)
expected = {
'codec_name': 'vp9',
'width': 200,
'height': 150,
'pix_fmt': 'yuv420p',
}
actual = {k: file_info.get(k) for k in expected}
assert expected == actual
def test_transcode_to_gif(config_key, config_val, http_client, base_url,
config, src_ext):
setattr(config, config_key, config_val)
url_filter = "/filters:format(gif)" if src_ext else ""
if src_ext is None:
src_ext = "gif"
response = yield http_client.fetch("%s/unsafe%s/hotdog.%s" %
(base_url, url_filter, src_ext))
assert response.code == 200
assert response.headers.get('content-type') == 'image/gif'
file_info = ffprobe(response.body)
expected = {
'codec_name': 'gif',
'width': 200,
'height': 150,
'pix_fmt': 'bgra',
}
actual = {k: file_info.get(k) for k in expected}
assert expected == actual
