def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'-i',
'--input',
required=True,
help='The path to the video file(or a supported resource) (required).')
parser.add_argument(
'-m',
'--master_playlist',
required=True,
help='The path to write the master playlist (required).')
parser.add_argument(
'-o',
'--output',
required=True,
help=
'A URL(or a supported resource e.x. http://website.com/live-out.m3u8) to upload files.'
)
args = parser.parse_args()
(ffmpeg_streaming.hls(args.input,
master_playlist_path=args.master_playlist).format(
'libx264').auto_rep().package(args.output,
progress=progress))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-i',
'--input',
required=True,
help='The path to the video file (required).')
parser.add_argument(
'-key',
'--key',
required=True,
help='The full pathname of the file where a random key will '
'be created (required). Note: The path of the key should '
'be accessible from your website(e.g. '
'"/var/www/public_html/keys/enc.key")')
parser.add_argument(
'-url',
'--url',
required=True,
help='A URL (or a path) to access the key on your website ('
'required). It is highly recommended to protect the key '
'on your website(e.g using a token or check a '
'session/cookie)')
parser.add_argument('-o',
'--output',
default=None,
help='The output to write files.')
args = parser.parse_args()
(ffmpeg_streaming.hls(args.input).encryption(
args.url, args.key).format('libx264').auto_rep().package(
args.output, progress=transcode_progress))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-i',
'--input',
required=True,
help='The path to the video file (required).')
parser.add_argument('-o',
'--output',
default=None,
help='The output to write files.')
args = parser.parse_args()
rep1 = Representation(width=256,
height=144,
kilo_bitrate=200,
audio_k_bitrate=64)
rep2 = Representation(width=854,
height=480,
kilo_bitrate=500,
audio_k_bitrate=128)
rep3 = Representation(width=1080,
height=720,
kilo_bitrate=1000,
audio_k_bitrate=320)
(ffmpeg_streaming.hls(args.input, hls_time=10,
hls_allow_cache=1).format('libx264').add_rep(
rep1, rep2,
rep3).package(args.output,
progress=transcode_progress))
def create_encrypted_hls_files(_input,
_output,
url_to_key,
save_to,
__progress=None):
(ffmpeg_streaming.hls(_input).encryption(
url_to_key,
save_to).format('libx264').auto_rep().package(_output, __progress))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-i',
'--input',
required=True,
help='The path to the video file (required).')
parser.add_argument('-o',
'--output',
default=None,
help='The output to write files.')
args = parser.parse_args()
(ffmpeg_streaming.hls(args.input,
hls_time=20).format('libx264').auto_rep().package(
args.output, progress=transcode_progress))
def create_hls_files(_input, _output, __progress=None):
rep1 = Representation(width=256,
height=144,
kilo_bitrate=200,
audio_k_bitrate=64)
rep2 = Representation(width=854,
height=480,
kilo_bitrate=500,
audio_k_bitrate=128)
rep3 = Representation(width=1080,
height=720,
kilo_bitrate=1000,
audio_k_bitrate=320)
(ffmpeg_streaming.hls(_input, hls_time=10,
hls_allow_cache=1).format('libx264').add_rep(
rep1, rep2, rep3).package(_output, __progress))
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'-i',
'--input',
required=True,
help=
'A URL to DASH manifest e.x. http://website.com/dash-manifest.mpd (required).'
)
parser.add_argument('-o',
'--output',
default=None,
help='The output to write files.')
args = parser.parse_args()
(ffmpeg_streaming.hls(args.input).format('libx264').auto_rep(
heights=[360, 240]).package(args.output, progress=progress))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-b',
'--bucket_name',
required=True,
help='Bucket name (required).')
parser.add_argument('-k',
'--key',
required=True,
help='Key name (required)')
args = parser.parse_args()
from_aws_cloud, to_aws_cloud = aws_cloud(args.bucket_name, args.key)
(ffmpeg_streaming.hls(from_aws_cloud).format('libx264').auto_rep().package(
clouds=to_aws_cloud, progress=transcode_progress))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-c',
'--container',
required=True,
help='Bucket name (required).')
parser.add_argument('-b',
'--blob',
required=True,
help='Key name (required)')
args = parser.parse_args()
from_azure_cloud, to_azure_cloud = azure_cloud(args.container, args.blob)
(ffmpeg_streaming.hls(from_azure_cloud).format(
'libx264').auto_rep().package(clouds=to_azure_cloud,
progress=transcode_progress))
def main():
parser = argparse.ArgumentParser()
parser.add_argument('-b',
'--bucket_name',
required=True,
help='Bucket name (required).')
parser.add_argument('-o',
'--object_name',
required=True,
help='object name (required).')
args = parser.parse_args()
from_google_cloud, to_google_cloud = google_cloud(args.bucket_name,
args.object_name)
(ffmpeg_streaming.hls(from_google_cloud).format(
'libx264').auto_rep().package('/var/www/media/stream.mpd',
to_google_cloud, transcode_progress))
def test_hls(self):
hls_obj = ffmpeg_streaming.hls(self.src_video)
self.assertIsInstance(hls_obj, HLS)
self.assertEqual(hls_obj.filename, self.src_video)
self.assertEqual(hls_obj.hls_time, 10)
self.assertEqual(hls_obj.hls_allow_cache, 0)
hls_obj.add_rep(Representation(width=256, height=144, kilo_bitrate=100))
rep_1 = hls_obj.reps[0]
self.assertIsInstance(rep_1, Representation)
self.assertEqual(rep_1.size, '256x144')
self.assertEqual(rep_1.bit_rate, '100k')
hls_obj.auto_rep()
self.assertEqual(len(hls_obj.reps), 3)
for rep_ in hls_obj.reps:
self.assertIsInstance(rep_, Representation)
rep_1 = hls_obj.reps[0]
self.assertEqual(rep_1.size, '480x270')
self.assertEqual(rep_1.bit_rate, '176k')
rep_2 = hls_obj.reps[1]
self.assertEqual(rep_2.size, '426x240')
self.assertEqual(rep_2.bit_rate, '117k')
rep_3 = hls_obj.reps[2]
self.assertEqual(rep_3.size, '256x144')
self.assertEqual(rep_3.bit_rate, '88k')
hls_obj.format('libx264')
self.assertEqual(hls_obj.video_format, 'libx264')
hls_obj.package(os.path.join(self.src_dir, 'hls', 'test.m3u8'), c_stderr=False)
with open(os.path.join(self.src_dir, 'fixture_test.m3u8')) as test_m3u8:
expected_m3u8 = test_m3u8.read()
with open(os.path.join(self.src_dir, 'hls', 'test.m3u8')) as test_m3u8:
actual_m3u8 = test_m3u8.read()
self.assertEqual(actual_m3u8, expected_m3u8)
with open(os.path.join(self.src_dir, 'hls', 'test_270p.m3u8')) as test_m3u8:
actual_270_m3u8 = test_m3u8.readlines()
self.assertEqual(actual_270_m3u8[0].replace('\n', ''), '#EXTM3U')
self.assertEqual(actual_270_m3u8[1].replace('\n', ''), '#EXT-X-VERSION:3')
self.assertEqual(actual_270_m3u8[2].replace('\n', ''), '#EXT-X-ALLOW-CACHE:NO')
def test_encrypted_hls(self):
encrypted_hls = ffmpeg_streaming.hls(self.src_video).encryption(
'https://www.aminyazdanpanah.com/enc.key',
os.path.join(self.src_dir, 'enc.key')
)
self.assertIsNotNone(encrypted_hls.hls_key_info_file)
with open(encrypted_hls.hls_key_info_file) as key_info:
key_info = key_info.readlines()
self.assertEqual(key_info[0].replace('\n', ''), 'https://www.aminyazdanpanah.com/enc.key')
self.assertEqual(key_info[1].replace('\n', ''), os.path.join(self.src_dir, 'enc.key'))
encrypted_hls.auto_rep()
encrypted_hls.format('libx264')
encrypted_hls.package(os.path.join(self.src_dir, 'encrypted_hls', 'test.m3u8'), c_stderr=False)
with open(os.path.join(self.src_dir, 'fixture_test.m3u8')) as test_m3u8:
expected_m3u8 = test_m3u8.read()
with open(os.path.join(self.src_dir, 'encrypted_hls', 'test.m3u8')) as test_m3u8:
actual_encrypted_m3u8 = test_m3u8.read()
self.assertEqual(actual_encrypted_m3u8, expected_m3u8)
import ffmpeg_streaming
from ffmpeg_streaming import Representation
rep1 = Representation(width=256, height=144, kilo_bitrate=200)
rep2 = Representation(width=426, height=240, kilo_bitrate=500)
rep3 = Representation(width=640, height=360, kilo_bitrate=1000)
(ffmpeg_streaming.hls('/var/www/media/videos/test.mp4',
hls_time=10,
hls_allow_cache=1).format('libx264').add_rep(
rep1, rep2,
rep3).package('/var/www/media/videos/hls/test.m3u8'))
def create_hls_files(_input, _output, __progress=None):
(ffmpeg_streaming.hls(_input,
hls_time=20).format('libx264').auto_rep().package(
_output, __progress))
def main():
(ffmpeg_streaming.hls(args.input, hls_flags="periodic_rekey").encryption(
args.url, args.key,
key_info_path=key_info_file_path).format('libx264').auto_rep().package(
args.output, progress=progress))
def HLSForm(f):
print(f.temporary_file_path())
(ffmpeg_streaming.hls(f.temporary_file_path(),
hls_time=20).format('libx264').auto_rep())
import ffmpeg_streaming
(ffmpeg_streaming.hls(
'/var/www/media/videos/test.mp4',
hls_time=10,
hls_allow_cache=1,
hls_key_info_file='/path/to/keyinfo').format('libx264').auto_rep().package(
'/var/www/media/videos/hls/test.m3u8'))
