def test_encrypted_hls(self):
        video = ffmpeg_streaming.input(self.src_video)
        hls_obj = video.hls(Formats.h264())
        hls_obj.encryption(os.path.join(self.src_dir, 'enc.key'),
                           'https://www.aminyazdanpanah.com/enc.key')

        self.assertIsNotNone(hls_obj.options.get('hls_key_info_file', None))

        with open(hls_obj.options.get('hls_key_info_file', None)) 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'))

        hls_obj.auto_generate_representations()

        hls_obj.output(os.path.join(self.src_dir, 'encrypted_hls',
                                    'test.m3u8'),
                       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)
Exemple #2
0
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.')

    parser.add_argument('-fmp4', '--fragmented', default=False, help='Fragmented mp4 output')

    parser.add_argument('-k', '--key', default=None, 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('-u', '--url', default=None, help='A URL (or a path) to access the key on your website ('
                                                          'required)')
    parser.add_argument('-krp', '--key_rotation_period', default=0, help='Use a different key for each set of '
                                                                         'segments, rotating to a new key after this '
                                                                         'many segments.')

    args = parser.parse_args()

    video = ffmpeg_streaming.input(args.input)

    hls = video.hls(Formats.h264())
    hls.auto_generate_representations()

    if args.fragmented:
        hls.fragmented_mp4()

    if args.key is not None and args.url is not None:
        hls.encryption(args.key, args.url, args.key_rotation_period)

    hls.output(args.output, monitor=monitor)
Exemple #3
0
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.')

    parser.add_argument('-hls',
                        '--hls_output',
                        default=False,
                        help='publish hls playlists')

    args = parser.parse_args()

    video = ffmpeg_streaming.input(args.input)

    dash = video.dash(Formats.h264())
    dash.auto_generate_representations()

    if args.hls_output:
        dash.generate_hls_playlist()

    dash.output(args.output, monitor=monitor)
Exemple #4
0
def stop(request):
    video = ffmpeg_streaming.input('')
    hls = video.hls(Formats.h264())
    hls.auto_generate_representations()
    hls.output('/app/static/stream/hls.m3u8')

    return HttpResponse('<h1>Stream is stopped</h1>')
Exemple #5
0
def play_videos():
    page_location = request.args.get("page-location")
    page_location = page_location if page_location else ""
    current_path = get_path(basepath, page_location)
    video = ffmpeg_streaming.input(current_path)
    dash = video.dash(Formats.h264())
    dash.auto_generate_representations()
    dash.output(f"{basepath}/representation.mpd")
    details = {"path": f"/videos/representation.mpd", "type": "video/mp4"}
    return render_template("video.html", details=details)
def videomedia(title, templocation):
    video = ffmpeg_streaming.input(templocation)
    os.makedirs(os.path.join("deployproxy", "media", title))
    hls = video.hls(Formats.h264(), hls_time=3)
    os.makedirs("keys/" + title)
    hls.encryption(os.path.join("keys", title, "key"),
                   "/getkey/?media=" + title)
    hls.auto_generate_representations()
    hls.output(os.path.join("deployproxy", "media", title, "media.m3u8"))
    os.remove(templocation)
    def test_dash(self):
        video = ffmpeg_streaming.input(self.src_video)
        dash_obj = video.dash(Formats.hevc())
        self.assertIsInstance(dash_obj, DASH)
        self.assertEqual(dash_obj.media.input, self.src_video)

        dash_obj.auto_generate_representations()

        dash_obj.output(os.path.join(self.src_dir, 'dash', 'test.mpd'), stderr=False)
        with open(os.path.join(self.src_dir, 'dash', 'test.mpd')) as test_mpd:
            actual_mpd = test_mpd.readlines()
        self.assertEqual(actual_mpd[0].replace('\n', ''), '<?xml version="1.0" encoding="utf-8"?>')
        self.assertEqual(actual_mpd[1].replace('\n', ''), '<MPD xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"')
Exemple #8
0
def download_stream(link: str, out_path: str = "./dl/") -> bool:

    video = ffmpeg_streaming.input(link)
    hls = video.hls(Formats.h264())
    _360p = Representation(Size(640, 360), Bitrate(276 * 1024, 128 * 1024))
    _480p = Representation(Size(854, 480), Bitrate(750 * 1024, 192 * 1024))
    _720p = Representation(Size(1280, 720), Bitrate(2048 * 1024, 320 * 1024))

    hls = video.hls(Formats.h264(), hls_time=3600)
    hls.flags('delete_segments')
    hls.representations(_720p)
    hls.output("/mnt/c/Users/anael/OneDrive/projets/streamFinder/dl/test.mp4")
    return True
Exemple #9
0
def convert_video_to_hls(arg):
    path_root = settings.MEDIA_ROOT + arg.title
    if not os.path.exists(path_root):
        os.makedirs(path_root)
    video = ffmpeg_streaming.input(
        str(settings.MEDIA_ROOT + arg.video_file.name))
    save_to = str(path_root + '/key')
    # A URL (or a path) to access the key on your website
    url = settings.MEDIA_URL + arg.title + '/key'
    # or url = '/"PATH TO THE KEY DIRECTORY"/key';

    hls = video.hls(Formats.h264())
    hls.encryption(save_to, url)
    hls.auto_generate_representations()
    hls.output(str(path_root + '/hls.m3u8'))
Exemple #10
0
def change_it(fn):
    video = ffmpeg_streaming.input('../simulated_server_storage/' + fn)

    def monitor(ffmpeg, duration, time_, time_left, process):
        per = round(time_ / duration * 100)
        sys.stdout.write(
            "\rTranscoding...(%s%%) %s left [%s%s]" %
            (per, datetime.timedelta(seconds=int(time_left)), '#' * per, '-' *
             (100 - per)))
        sys.stdout.flush()

    hls = video.hls(Formats.h264())
    thumbnail.extract(fn)
    hls.auto_generate_representations()
    os.mkdir('static/media/' + fn[:-4:1])

    hls.output('static/media/' + fn[:-4:1] + '/' + fn[:-4:1] + '.m3u8',
               monitor=monitor)
Exemple #11
0
def async_convert_video_and_extract_meta_data(id):
    """
    Converts the uploaded video into 480 mp4 files that can be streamed using the .m38u file.
    The duration of the files is then extracted from the file and resaved in the Video object
    """
    print('async convert video running')
    print(id)
    instance = Video.objects.get(id=id)
    video_path = instance.url.path

    if instance.url.storage.exists(instance.url.name):
        video = ffmpeg_streaming.input(video_path)
        hls = video.hls(Formats.h264())
        _480p = Representation(Size(854, 480), Bitrate(750 * 1024, 192 * 1024))
        hls.representations(_480p)
        hls.output()

        duration_in_seconds = int(float(FFProbe(instance.url.path).streams().video().get('duration', 60)))
        minutes = int(time.strftime('%M', time.gmtime(duration_in_seconds)))
        Video.objects.filter(pk=instance.pk).update(duration=minutes if minutes > 1 else 1)
    def test_hls(self):
        video = ffmpeg_streaming.input(self.src_video)
        hls_obj = video.hls(Formats.h264())
        self.assertIsInstance(hls_obj, HLS)
        self.assertEqual(hls_obj.media.input, self.src_video)

        hls_obj.representations(Representation(Size(256, 144),
                                               Bitrate(102400)))
        rep_1 = hls_obj.reps[0]
        self.assertIsInstance(rep_1, Representation)
        self.assertEqual(str(rep_1.size), '256x144')
        self.assertEqual(rep_1.bitrate.video, '100k')

        hls_obj.auto_generate_representations()
        reps = list(hls_obj.reps)
        self.assertEqual(len(reps), 3)

        for rep_ in reps:
            self.assertIsInstance(rep_, Representation)
        self.assertEqual(str(reps[0].size), '480x270')
        self.assertEqual(reps[0].bitrate.video, '176k')
        self.assertEqual(str(reps[1].size), '426x240')
        self.assertEqual(reps[1].bitrate.video, '88k')
        self.assertEqual(str(reps[2].size), '256x144')
        self.assertEqual(reps[2].bitrate.video, '71k')

        hls_obj.output(os.path.join(self.src_dir, 'hls', 'test.m3u8'))
        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:YES')
def upload(request):
    if request.method == "POST":
        uploaded_file = request.FILES['myFile']
        name_array = uploaded_file.name.split('.')
        uploaded_file.name = name_array[0]
        song = Song.objects.create(title=request.POST.get('title'),
                                   description=request.POST.get('description'),
                                   artist=request.POST.get('artist'),
                                   path=f'{uploaded_file.name}')
        song.save()
        song = Song.objects.all().last()
        song_id = song.id
        os.mkdir(f'{BASE_DIR}\\media\\{song_id}\\')
        fs = FileSystemStorage(BASE_DIR)
        fs.save(uploaded_file.name, uploaded_file)
        video = ffmpeg_streaming.input(f'{BASE_DIR}\\{uploaded_file.name}')
        dash = video.dash(Formats.h264())
        dash.auto_generate_representations()
        dash.output(f'{BASE_DIR}\\media\\{song_id}\\{uploaded_file.name}.mpd')
        os.remove(f'{BASE_DIR}\\{uploaded_file.name}')
        return HttpResponse("uploaded successfully")
    return render(request, 'videos/upload.html')
Exemple #14
0
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.')

    parser.add_argument(
        '-k',
        '--key',
        default=None,
        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(
        '-u',
        '--url',
        default=None,
        help='A URL (or a path) to access the key on your website ('
        'required)')

    args = parser.parse_args()

    video = ffmpeg_streaming.input(args.input)

    hls = video.hls(Formats.h264())
    hls.auto_generate_representations()

    if args.key is not None and args.url is not None:
        hls.encryption(args.key, args.url, 10)

    hls.output(args.output, monitor=monitor)
Exemple #15
0
        data = json.loads(response.content)

        path_lesson = path_section + '/{}_{}'.format(
            index_lesson,
            str(data['LessonTitle']).replace('.', '_').replace('/', '')
        )
        if not os.path.exists(path_lesson):
            os.makedirs(path_lesson)

        if data['Step']['VideoId']:
            file_name_video = '{}/{}'.format(path_lesson, data['Step']['VideoName'])
            if len(data['Step']['VideoId']) >= 10:
                video_src = "https://techmaster.vn/app/video-new/stream-video/" + data['Step']['VideoId'] + ".m3u8"
            else:
                video_src = "https://techmaster.vn/video/stream-video/" + data['Step']['VideoId'] + ".m3u8"
            video = ffmpeg_streaming.input(video_src)
            stream = video.stream2file(Formats.h264())
            stream.output(file_name_video)

        file_name_doc = '{}/{}.html'.format(path_lesson,
                                            str(data['LessonTitle']).replace('.', '_').replace('/', ''))

        f = open(file_name_doc, 'w')
        if data['Step']['VideoId']:
            f.write('''
                <video width="320" height="240" controls>
                    <source src="{}" type="video/mp4">
                </video>
            '''.format(data['Step']['VideoName']))
        f.write(data['Step']['Text'])
        f.close()
import ffmpeg_streaming
from ffmpeg_streaming import Formats
video = ffmpeg_streaming.input('video.mp4')
from ffmpeg_streaming import Formats, Bitrate, Representation, Size

_360p = Representation(Size(640, 360), Bitrate(276 * 1024, 128 * 1024))
_480p = Representation(Size(854, 480), Bitrate(750 * 1024, 192 * 1024))
_720p = Representation(Size(1280, 720), Bitrate(2048 * 1024, 320 * 1024))

hls = video.hls(Formats.h264())
hls.representations(_360p, _480p, _720p)

hls.output('./flask-hls-demo/video/hls.m3u8')
from ffmpeg_streaming import Formats, Bitrate, Representation, Size, input

video = input('rtsp://localhost:8554/live');

_480p  = Representation(Size(854, 480), Bitrate(750 * 1024, 192 * 1024))
hls = video.hls(Formats.h264(), hls_list_size=5, hls_time=2)
hls.flags('delete_segments')
hls.representations(_480p)
hls.output('./output/hls1.m3u8')
import ffmpeg_streaming
import sys
import datetime
import logging
import os
from ffmpeg_streaming import Formats, Bitrate, Representation, Size, GCS, CloudManager

logging.basicConfig(filename='streaming.log', level=logging.NOTSET, format='[%(asctime)s] %(levelname)s: %(message)s')

os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "/Users/vignesh/Vicky/Code/Transcoder/python_transcode/presales.json"
gcs = GCS()
save_to_gcs = CloudManager().add(gcs, bucket_name="viki_trans_py", folder="transcoded_video")

video = ffmpeg_streaming.input('/Users/vignesh/Vicky/Code/Transcoder/python_transcode/sample.mp4')

def monitor(ffmpeg, duration, time_, time_left, process):
  
  per = round(time_ / duration * 100)
  sys.stdout.write(
      "\rTranscoding...(%s%%) %s left [%s%s]" %
      (per, datetime.timedelta(seconds=int(time_left)), '#' * per, '-' * (100 - per))
  )
  sys.stdout.flush()

_360p  = Representation(Size(640, 360), Bitrate(276 * 1024, 128 * 1024))
_480p  = Representation(Size(854, 480), Bitrate(750 * 1024, 192 * 1024))
_720p  = Representation(Size(1280, 720), Bitrate(2048 * 1024, 320 * 1024))

hls = video.hls(Formats.h264())
hls.representations(_360p, _480p, _720p)
hls.output(clouds=save_to_gcs, monitor=monitor)
import ffmpeg_streaming

video_path = "C:\\Users\\Admin\\Downloads\\Video\\people.mp4"
video = ffmpeg_streaming.input(video_path)

from ffmpeg_streaming import Formats, Bitrate, Representation, Size

_144p = Representation(Size(256, 144), Bitrate(95 * 1024, 64 * 1024))
_240p = Representation(Size(426, 240), Bitrate(150 * 1024, 94 * 1024))
_360p = Representation(Size(640, 360), Bitrate(276 * 1024, 128 * 1024))
_480p = Representation(Size(854, 480), Bitrate(750 * 1024, 192 * 1024))
_720p = Representation(Size(1280, 720), Bitrate(2048 * 1024, 320 * 1024))
_1080p = Representation(Size(1920, 1080), Bitrate(4096 * 1024, 320 * 1024))
_2k = Representation(Size(2560, 1440), Bitrate(6144 * 1024, 320 * 1024))
_4k = Representation(Size(3840, 2160), Bitrate(17408 * 1024, 320 * 1024))

dash = video.dash(Formats.h264())
dash.representations(_144p, _240p, _360p, _480p, _720p, _1080p, _2k, _4k)
dash.output('dash.mpd')
Exemple #20
0
import ffmpeg_streaming
from ffmpeg_streaming import Formats, Bitrate, Representation, Size

_144p  = Representation(Size(256, 144), Bitrate(95 * 1024, 64 * 1024))
_240p  = Representation(Size(426, 240), Bitrate(150 * 1024, 94 * 1024))
_360p  = Representation(Size(640, 360), Bitrate(276 * 1024, 128 * 1024))
_480p  = Representation(Size(854, 480), Bitrate(750 * 1024, 192 * 1024))
_720p  = Representation(Size(1280, 720), Bitrate(2048 * 1024, 320 * 1024))


#video = ffmpeg_streaming.input('./bunny.mp4')
video = ffmpeg_streaming.input('./test_input.mp4')
dash = video.dash(ffmpeg_streaming.Formats.h264())
#dash.auto_generate_representations()
dash.representations(_144p, _240p, _360p, _480p, _720p)
dash.output('./dash.mpd')
def convertStreamToMkv(httpPathToM3U8, outputNameAndPath):
    video = ffmpeg_streaming.input(httpPathToM3U8)
    stream = video.stream2file(ffmpeg_streaming.Formats.h264())
    stream.output(outputNameAndPath)
Exemple #22
0
import ffmpeg_streaming
video = ffmpeg_streaming.input('D:\WebVideoPlayerDjango\WebVideoPlayer\media\Borat.Subsequent.Moviefilm.2020.WEBRip.x264-ION10.mp4')
from ffmpeg_streaming import Formats
import sys
import datetime
def monitor(ffmpeg, duration, time_, time_left, process):
    """
    Handling proccess.

    Examples:
    1. Logging or printing ffmpeg command
    logging.info(ffmpeg) or print(ffmpeg)

    2. Handling Process object
    if "something happened":
        process.terminate()

    3. Email someone to inform about the time of finishing process
    if time_left > 3600 and not already_send:  # if it takes more than one hour and you have not emailed them already
        ready_time = time_left + time.time()
        Email.send(
            email='*****@*****.**',
            subject='Your video will be ready by %s' % datetime.timedelta(seconds=ready_time),
            message='Your video takes more than %s hour(s) ...' % round(time_left / 3600)
        )
       already_send = True

    4. Create a socket connection and show a progress bar(or other parameters) to your users
    Socket.broadcast(
        address=127.0.0.1
        port=5050
import ffmpeg_streaming
capture = ffmpeg_streaming.input('CAMERA NAME OR SCREEN NAME', capture=True)
Exemple #24
0
import ffmpeg_streaming
from ffmpeg_streaming import Formats, Bitrate, Representation, Size

import sys

def monitor(ffmpeg, duration, time_):
    per = round(time_ / duration * 100)
    sys.stdout.write("\rTranscoding...(%s%%) [%s%s]" % (per, '#' * per, '-' * (100 - per)))
    sys.stdout.flush()

video = ffmpeg_streaming.input('rtsp://freja.hiof.no:1935/rtplive/_definst_/hessdalen03.stream')

_360p = Representation(Size(640, 360), Bitrate(276 * 1024, 128 * 1024))
_480p = Representation(Size(854, 480), Bitrate(750 * 1024, 192 * 1024))
_720p = Representation(Size(1280, 720), Bitrate(2048 * 1024, 320 * 1024))

hls_stream = video.hls(Formats.h264(), hls_list_size = 10, hls_time = 60)
hls_stream.representations(_480p)
hls_stream.output('/var/media/hls_outputs.m3u8')
import sys
import ffmpeg_streaming
from ffmpeg_streaming import Formats

input_path = sys.argv[1]
video = ffmpeg_streaming.input(input_path)

# from ffmpeg_streaming import Formats

# dash = video.dash(Formats.h264())
# dash.auto_generate_representations()
# dash.output('/var/media/dash.mpd')

hls = video.hls(Formats.h264())
hls.auto_generate_representations()
# hls.output('/var/media/hls.m3u8')

from ffmpeg_streaming import S3, CloudManager

s3 = S3(aws_access_key_id=AWS_ACCESS_KEY,
        aws_secret_access_key=AWS_SECRET_KEY,
        region_name='us-east-1')
save_to_s3 = CloudManager().add(s3, bucket_name="fifteen.pm")

hsl.output(clouds=save_to_s3)
dash.output(clouds=save_to_s3)

#https://docs.videojs.com/docs/guides/setup.html
# https://jsfiddle.net/vm4detdy/
"""
https://stackoverflow.com/questions/49781878/python-flask-ffmpeg-video-streaming-video-does-not-work-in-firefox
import ffmpeg_streaming
from ffmpeg_streaming import Formats, Bitrate, Representation, Size

import sys

def monitor(ffmpeg, duration, time_):
    per = round(time_ / duration * 100)
    sys.stdout.write("\rTranscoding...(%s%%) [%s%s]" % (per, '#' * per, '-' * (100 - per)))
    sys.stdout.flush()

video = ffmpeg_streaming.input('http://wmccpinetop.axiscam.net/mjpg/video.mjpg')

_360p = Representation(Size(640, 360), Bitrate(276 * 1024, 128 * 1024))
_480p = Representation(Size(854, 480), Bitrate(750 * 1024, 192 * 1024))
_720p = Representation(Size(1280, 720), Bitrate(2048 * 1024, 320 * 1024))

hls_stream = video.hls(Formats.h264(), hls_list_size = 10, hls_time = 60)
hls_stream.representations(_480p)
hls_stream.output('/var/media/hls_outputs.m3u8')
Exemple #27
0
def run(request):
    video = ffmpeg_streaming.input(stream_link)
    dash = video.dash(Formats.h264())
    dash.representations(_480p)
    dash.output('/app/static/stream/dash.mpd')
def ffmpeg_livestream(url):
    video = ffmpeg_streaming.input(url)
    hls = video.hls(Formats.h264())
    hls.auto_generate_representations([480])
    hls.fragmented_mp4()
    hls.output("hls.m3u8")
Exemple #29
0
    def initial_protocol(self,
                         input_path: str,
                         output_id: str,
                         request_id: str,
                         encode_format: str,
                         video_codec: str = None,
                         audio_codec: str = None,
                         is_hls: bool = None,
                         fragmented: bool = None,
                         quality_names: list[str] = None,
                         custom_qualities: list[dict] = None):
        """build HLS or MPEG ffmpeg command
        using ffmpeg_streaming package
        """
        # checking file is exist and not empty
        try:
            if os.stat(input_path).st_size == 0:
                self.save_output_status(self.output_status.OUTPUT_FAILED,
                                        output_id, request_id)
                self.save_job_stop_reason(
                    self.stop_reason.INPUT_VIDEO_SIZE_CAN_NOT_BE_ZERO,
                    request_id)
                raise self.raise_ignore(
                    message=self.error_messages.INPUT_SIZE_CAN_NOT_BE_ZERO,
                    request_kwargs=self.request.kwargs)
        except FileNotFoundError:
            # TODO notify developer
            self.save_output_status(self.output_status.OUTPUT_FAILED,
                                    output_id, request_id)
            self.save_job_stop_reason(self.stop_reason.INTERNAL_ERROR,
                                      request_id)
            raise self.raise_ignore(
                message=self.error_messages.INPUT_FILE_IS_NOT_FOUND,
                request_kwargs=self.request.kwargs)

        video = ffmpeg_streaming.input(input_path)
        format_instance = VideoEncodingFormats().get_format_class(
            encode_format,
            video=video_codec,
            audio=audio_codec,
        )
        if is_hls:
            # HLS Protocol
            protocol = video.hls(format_instance)
            if fragmented:
                protocol.fragmented_mp4()
        else:
            # MPEG-Dash Protocol
            protocol = video.dash(format_instance)
        """create a list of Representation instances to
        add to the protocol instance
        """

        # generate default representations
        if not (custom_qualities or quality_names):
            try:
                protocol.auto_generate_representations(
                    ffprobe_bin=settings.FFPROBE_BIN_PATH)
                return
            except RuntimeError as e:
                # TODO capture error and notify developer
                raise self.retry(exc=e)
            except Exception as e:
                # FileNotFoundError:
                # [Errno 2] No such file or directory: 'ffprobe'
                # TODO capture error and notify developer
                raise self.retry(exc=e)

        reps = []

        # quality_names is like ["360p","480p","720p"]
        if quality_names:
            reps.extend(Resolutions().get_reps(quality_names))

        # custom_qualities is like :
        # [dict(size=[256, 144], bitrate=[97280, 65536])]
        for quality in custom_qualities:
            size = quality.get('size', None)
            bitrate = quality.get('bitrate', None)

            # when both of them has not valid value, just continue
            if not (size or bitrate):
                continue

            # when just one of them is exist,
            # force client to fill both of them
            if not size or not bitrate:
                self.save_output_status(self.output_status.OUTPUT_FAILED,
                                        output_id, request_id)
                self.save_job_stop_reason(
                    self.stop_reason.
                    REPRESENTATION_NEEDS_BOTH_SIZE_AND_BITRATE, request_id)
                raise self.raise_ignore(
                    message=self.error_messages.
                    REPRESENTATION_NEEDS_BOTH_SIZE_AND_BITRATE,
                    request_kwargs=self.request.kwargs)

            reps.append(Representation(Size(*size), Bitrate(*bitrate)))

        # generate representations
        protocol.representations(*reps)

        return protocol
Exemple #30
0
import ffmpeg_streaming
import csv
from ffmpeg_streaming import Formats

with open('<your list of m3u8s>.csv', newline='') as csvfile:
    data = list(csv.reader(csvfile))

for x in range(len(data)):
    filename = data[x][0]
    streamlink = data[x][1]
    print("Writing File: " + filename)
    video = ffmpeg_streaming.input(streamlink)
    stream = video.stream2file(Formats.h264())
    stream.output('<your local directory>' + filename + '.mp4')