예제 #1
0
    def _get_sample_manifest(self):
        encoding_output = self._get_sample_encoding_output()
        manifest = HlsManifest(manifest_name='bitmovin-python_Sample_HLS_Manifest.m3u8', outputs=[encoding_output],
                                name='Sample HLS Manifest')

        self.assertIsNotNone(manifest)
        self.assertIsNotNone(manifest.manifestName)
        self.assertIsNotNone(manifest.outputs)
        return manifest
def create_hls_manifest(output_id, encoding_id, audio_representation_info):
    manifest_output = EncodingOutput(output_id=output_id,
                                     output_path=OUTPUT_BASE_PATH)
    hls_manifest = HlsManifest(manifest_name='stream.m3u8',
                               outputs=[manifest_output],
                               name='Sample HLS Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(hls_manifest).resource

    segment_path = audio_representation_info.get(
        'ts_muxing').outputs[0].outputPath
    segment_path = remove_output_base_path(segment_path)

    audio_media = AudioMedia(
        name='Sample Audio Media',
        group_id='audio_group',
        segment_path=segment_path,
        encoding_id=encoding_id,
        stream_id=audio_representation_info.get('stream').id,
        muxing_id=audio_representation_info.get('ts_muxing').id,
        language='en',
        uri='audio.m3u8')

    audio_media = bitmovin.manifests.HLS.AudioMedia.create(
        manifest_id=hls_manifest.id, object_=audio_media).resource

    muxings = bitmovin.encodings.Muxing.TS.list(
        encoding_id=encoding_id).resource
    for muxing in muxings:
        segment_path = muxing.outputs[0].outputPath
        if 'audio' in segment_path:
            continue
        if '{uuid}' in segment_path:
            continue
        segment_path = remove_output_base_path(segment_path)

        variant_stream = VariantStream(audio=audio_media.groupId,
                                       closed_captions='NONE',
                                       segment_path=segment_path,
                                       uri='video_{}.m3u8'.format(
                                           muxing.avgBitrate),
                                       encoding_id=encoding_id,
                                       stream_id=muxing.streams[0].streamId,
                                       muxing_id=muxing.id)

        variant_stream = bitmovin.manifests.HLS.VariantStream.create(
            manifest_id=hls_manifest.id, object_=variant_stream).resource

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id)
    except BitmovinError as bitmovin_error:
        print(
            "Exception occurred while waiting for HLS manifest creation to finish: {}"
            .format(bitmovin_error))
def main():
    resource_response = bitmovin.inputs.RTMP.list()

    if not resource_response or \
       not resource_response.resource or \
       not isinstance(resource_response.resource, list) or \
       len(resource_response.resource) < 1:
        print('Could not find any RTMP inputs. Please contact support.')
        sys.exit(3)

    rtmp_input_id = resource_response.resource[0].id
    print('Found RTMP input with ID \'{}\''.format(rtmp_input_id))

    rtmp_input = bitmovin.inputs.RTMP.retrieve(id_=rtmp_input_id).resource

    video_input_stream = StreamInput(input_id=rtmp_input.id,
                                     input_path='live',
                                     position=0,
                                     selection_mode=SelectionMode.AUTO)
    audio_input_stream = StreamInput(input_id=rtmp_input.id,
                                     input_path='live',
                                     position=1,
                                     selection_mode=SelectionMode.AUTO)

    s3_output = S3Output(
        name='S3 Output',
        access_key=S3_OUTPUT_ACCESS_KEY,
        secret_key=S3_OUTPUT_SECRET_KEY,
        bucket_name=S3_OUTPUT_BUCKET_NAME,
    )
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    encoding = Encoding(name='Test Live Stream',
                        encoder_version=ENCODER_VERSION,
                        cloud_region=CloudRegion.AWS_EU_WEST_1)
    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)
    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])

    dash_manifest = DashManifest(
        name='Sample DASH Manifest Live',
        manifest_name='stream.mpd',
        outputs=[manifest_output],
        description='Bitmovin Python Test Live DASH Manifest')
    dash_manifest = bitmovin.manifests.DASH.create(dash_manifest).resource

    period = Period()
    period = bitmovin.manifests.DASH.add_period(
        object_=period, manifest_id=dash_manifest.id).resource

    video_adaptation_set = VideoAdaptationSet()
    video_adaptation_set = bitmovin.manifests.DASH.add_video_adaptation_set(
        object_=video_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    audio_adaptation_set = AudioAdaptationSet(lang='en')
    audio_adaptation_set = bitmovin.manifests.DASH.add_audio_adaptation_set(
        object_=audio_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    hls_manifest = HlsManifest(name='Sample HLS Manifest',
                               manifest_name='stream.m3u8',
                               outputs=[manifest_output])
    hls_manifest = bitmovin.manifests.HLS.create(object_=hls_manifest).resource

    createH264Rendition(encoding, dash_manifest, period, video_adaptation_set,
                        hls_manifest, 'audio', video_input_stream, s3_output,
                        'video/1080p', 4800000, VIDEO_FRAME_RATE, 1920, 1080,
                        H264Profile.HIGH)

    createH264Rendition(encoding, dash_manifest, period, video_adaptation_set,
                        hls_manifest, 'audio', video_input_stream, s3_output,
                        'video/720p', 2400000, VIDEO_FRAME_RATE, 1280, 720,
                        H264Profile.HIGH)

    createH264Rendition(encoding, dash_manifest, period, video_adaptation_set,
                        hls_manifest, 'audio', video_input_stream, s3_output,
                        'video/480p', 1200000, VIDEO_FRAME_RATE, 854, 480,
                        H264Profile.HIGH)

    createH264Rendition(encoding, dash_manifest, period, video_adaptation_set,
                        hls_manifest, 'audio', video_input_stream, s3_output,
                        'video/360p', 800000, VIDEO_FRAME_RATE, 640, 360,
                        H264Profile.HIGH)

    createH264Rendition(encoding, dash_manifest, period, video_adaptation_set,
                        hls_manifest, 'audio', video_input_stream, s3_output,
                        'video/240p', 400000, VIDEO_FRAME_RATE, 426, 240,
                        H264Profile.HIGH)

    createAACRendition(encoding, dash_manifest, period, audio_adaptation_set,
                       hls_manifest, 'audio', audio_input_stream, s3_output,
                       'audio/128kbps', 128000, AUDIO_SAMPLE_RATE)

    live_dash_manifest = LiveDashManifest(
        manifest_id=dash_manifest.id,
        time_shift=TIMESHIFT_IN_SECONDS,
        live_edge_offset=DASH_LIVE_EDGE_OFFSET_IN_SECONDS)

    live_hls_manifest = LiveHlsManifest(manifest_id=hls_manifest.id,
                                        time_shift=TIMESHIFT_IN_SECONDS)

    live_stream_configuration = LiveStreamConfiguration(
        stream_key=STREAM_KEY,
        live_dash_manifests=[live_dash_manifest],
        live_hls_manifests=[live_hls_manifest])

    resource_response = bitmovin.encodings.Encoding.start_live(
        encoding_id=encoding.id,
        live_stream_configuration=live_stream_configuration)

    bitmovin.encodings.Encoding.wait_until_running(
        encoding_id=resource_response.resource.id)

    live_details = None
    retry = 0

    while retry < LIVE_STREAM_INFORMATION_FETCH_MAX_RETRIES:
        try:
            live_details = bitmovin.encodings.Encoding.retrieve_live(
                encoding_id=resource_response.resource.id)
            break
        except BitmovinApiError as bitmovin_api_error:
            if bitmovin_api_error.response.data.code != ERROR_CODE_LIVE_STREAM_NOT_READY:
                sys.exit(2)
            print(
                'Live stream is not ready yet. Retrying to fetch live stream information in {} seconds...'
                .format(LIVE_STREAM_INFORMATION_FETCH_RETRY_INTERVAL))
            retry += 1
            time.sleep(LIVE_STREAM_INFORMATION_FETCH_RETRY_INTERVAL)

    if live_details is not None:
        print_live_stream_details(encoding_id=encoding.id,
                                  live_stream_details=live_details.resource)
    else:
        print('Unable to fetch live stream details!')
        sys.exit(1)
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    # Create an S3 input. This resource is then used as base bucket for the input file.
    s3_input = S3Input(access_key=S3_INPUT_ACCESSKEY,
                       secret_key=S3_INPUT_SECRETKEY,
                       bucket_name=S3_INPUT_BUCKETNAME,
                       name='S3 Input')
    s3_input = bitmovin.inputs.S3.create(s3_input).resource

    # Create an S3 Output. This will be used as target bucket for the muxings, sprites and manifests
    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    video_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)
    audio_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    encoding_analysis = Encoding(name='Per title encoding analysis',
                                 cloud_region=CloudRegion.AWS_EU_WEST_1)
    encoding_analysis = bitmovin.encodings.Encoding.create(
        encoding_analysis).resource

    # Do analysis encoding to get the complexity factor
    encoding_analysis = bitmovin.encodings.Encoding.create(
        encoding_analysis).resource
    encoding_analysis_config = H264CodecConfiguration(
        name='H264 Per Title Analysis Configuration',
        bitrate=None,
        crf=23.0,
        height=360,
        rate=None,
        profile=H264Profile.MAIN)
    encoding_analysis_config = bitmovin.codecConfigurations.H264.create(
        encoding_analysis_config).resource

    encoding_analysis_stream = Stream(
        codec_configuration_id=encoding_analysis_config.id,
        input_streams=[video_input_stream],
        name='Per Title Analysis Stream')
    encoding_analysis_stream = bitmovin.encodings.Stream.create(
        object_=encoding_analysis_stream,
        encoding_id=encoding_analysis.id).resource

    encoding_analysis_output = EncodingOutput(output_id=s3_output.id,
                                              output_path=OUTPUT_BASE_PATH +
                                              'video/quality_analysis/',
                                              acl=[acl_entry])

    encoding_analysis_muxing_stream = MuxingStream(encoding_analysis_stream.id)
    encoding_analysis_muxing = FMP4Muxing(
        segment_length=4,
        segment_naming='seg_%number%.m4s',
        init_segment_name='init.mp4',
        streams=[encoding_analysis_muxing_stream],
        outputs=[encoding_analysis_output],
        name='Per Title Analysis Muxing')
    encoding_analysis_muxing = bitmovin.encodings.Muxing.FMP4.create(
        object_=encoding_analysis_muxing,
        encoding_id=encoding_analysis.id).resource

    bitmovin.encodings.Encoding.start(encoding_id=encoding_analysis.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(
            encoding_id=encoding_analysis.id, check_interval=5)
    except BitmovinError as bitmovin_error:
        print('Exception occurred while waiting for encoding to finish: {}'.
              format(bitmovin_error))
        exit(-1)

    encoding_analysis_muxing = bitmovin.encodings.Muxing.FMP4.retrieve(
        encoding_id=encoding_analysis.id,
        muxing_id=encoding_analysis_muxing.id).resource

    # Calculate and saturate the complexity factor
    complexity_factor = encoding_analysis_muxing.avgBitrate / MEDIAN_BITRATE

    if complexity_factor > MAX_COMPLEXITY_FACTOR:
        complexity_factor = MAX_COMPLEXITY_FACTOR
    elif complexity_factor < MIN_COMPLEXITY_FACTOR:
        complexity_factor = MIN_COMPLEXITY_FACTOR

    print('Got complexity factor of: {:0.2f}'.format(complexity_factor))

    print('Updating encoding profile from:')
    pprint(encoding_profiles)
    print('To')
    # Multiply every bitrate with the complexity factor
    for profile in encoding_profiles:
        profile['bitrate'] = int(profile['bitrate'] * complexity_factor)
    pprint(encoding_profiles)

    # Create an Encoding. This will run in AWS_AP_SOUTHEAST_1. This is the base entity used to configure the encoding.
    encoding = Encoding(name='Per title encoding',
                        cloud_region=CloudRegion.AWS_EU_WEST_1)

    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    encoding_configs = []

    # Iterate over all encoding profiles and create the H264 configuration with the defined height and bitrate.
    for encoding_profile in encoding_profiles:
        encoding_config = dict(profile=encoding_profile)
        codec = H264CodecConfiguration(
            name='H264 Codec {}p {}k Configuration'.format(
                encoding_profile.get('height'),
                encoding_profile.get('bitrate')),
            bitrate=encoding_profile.get('bitrate') * 1000,
            height=encoding_profile.get('height'),
            rate=encoding_profile.get('fps'),
            profile=H264Profile.HIGH)
        encoding_config['codec'] = bitmovin.codecConfigurations.H264.create(
            codec).resource
        encoding_configs.append(encoding_config)

    # Also the AAC configuration has to be created, which will be later on used to create the streams.
    audio_codec_configuration = AACCodecConfiguration(
        name='AAC Codec Configuration', bitrate=128000, rate=48000)
    audio_codec_configuration = bitmovin.codecConfigurations.AAC.create(
        audio_codec_configuration).resource

    # With the configurations and the input file streams are now created and muxed later on.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        video_stream = Stream(
            codec_configuration_id=encoding_config.get('codec').id,
            input_streams=[video_input_stream],
            name='Stream {}p_{}k'.format(encoding_profile.get('height'),
                                         encoding_profile.get('bitrate')))
        encoding_config['stream'] = bitmovin.encodings.Stream.create(
            object_=video_stream, encoding_id=encoding.id).resource

    audio_stream = Stream(codec_configuration_id=audio_codec_configuration.id,
                          input_streams=[audio_input_stream],
                          name='Audio Stream')
    audio_stream = bitmovin.encodings.Stream.create(
        object_=audio_stream, encoding_id=encoding.id).resource

    # Create FMP4 muxings which are later used for the DASH manifest. The current settings will set a segment length
    # of 4 seconds.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        video_muxing_stream = MuxingStream(encoding_config.get('stream').id)
        video_muxing_output = EncodingOutput(
            output_id=s3_output.id,
            output_path=OUTPUT_BASE_PATH +
            'video/dash/{}p_{}k/'.format(encoding_profile.get('height'),
                                         encoding_profile.get('bitrate')),
            acl=[acl_entry])
        video_muxing = FMP4Muxing(segment_length=4,
                                  segment_naming='seg_%number%.m4s',
                                  init_segment_name='init.mp4',
                                  streams=[video_muxing_stream],
                                  outputs=[video_muxing_output],
                                  name='FMP4 Muxing {}p_{}k'.format(
                                      encoding_profile.get('height'),
                                      encoding_profile.get('bitrate')))
        encoding_config['fmp4_muxing'] = bitmovin.encodings.Muxing.FMP4.create(
            object_=video_muxing, encoding_id=encoding.id).resource

    audio_muxing_stream = MuxingStream(audio_stream.id)
    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH +
                                         'audio_dash/',
                                         acl=[acl_entry])
    audio_fmp4_muxing = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[audio_muxing_stream],
                                   outputs=[audio_muxing_output],
                                   name='Audio FMP4 Muxing')
    audio_fmp4_muxing = bitmovin.encodings.Muxing.FMP4.create(
        object_=audio_fmp4_muxing, encoding_id=encoding.id).resource

    # Create TS muxings which are later used for the DASH manifest. The current settings will set a segment length
    # of 4 seconds.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        video_muxing_stream = MuxingStream(encoding_config.get('stream').id)
        video_muxing_output = EncodingOutput(
            output_id=s3_output.id,
            output_path=OUTPUT_BASE_PATH +
            'video/hls/{}p_{}k/'.format(encoding_profile.get('height'),
                                        encoding_profile.get('bitrate')),
            acl=[acl_entry])
        video_muxing = TSMuxing(segment_length=4,
                                segment_naming='seg_%number%.ts',
                                streams=[video_muxing_stream],
                                outputs=[video_muxing_output],
                                name='TS Muxing {}p_{}k'.format(
                                    encoding_profile.get('height'),
                                    encoding_profile.get('bitrate')))
        encoding_config['ts_muxing'] = bitmovin.encodings.Muxing.TS.create(
            object_=video_muxing, encoding_id=encoding.id).resource

    audio_muxing_stream = MuxingStream(audio_stream.id)
    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH +
                                         'audio_hls/',
                                         acl=[acl_entry])
    audio_ts_muxing = TSMuxing(segment_length=4,
                               segment_naming='seg_%number%.ts',
                               streams=[audio_muxing_stream],
                               outputs=[audio_muxing_output],
                               name='Audio TS Muxing')
    audio_ts_muxing = bitmovin.encodings.Muxing.TS.create(
        object_=audio_ts_muxing, encoding_id=encoding.id).resource

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(
            encoding_id=encoding.id, check_interval=5)
    except BitmovinError as bitmovin_error:
        print('Exception occurred while waiting for encoding to finish: {}'.
              format(bitmovin_error))
        exit(-1)

    # Specify the output for manifest which will be in the OUTPUT_BASE_PATH.
    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])
    # Create a DASH manifest and add one period with an adapation set for audio and video
    dash_manifest = DashManifest(manifest_name='stream.mpd',
                                 outputs=[manifest_output],
                                 name='DASH Manifest')
    dash_manifest = bitmovin.manifests.DASH.create(dash_manifest).resource
    period = Period()
    period = bitmovin.manifests.DASH.add_period(
        object_=period, manifest_id=dash_manifest.id).resource
    video_adaptation_set = VideoAdaptationSet()
    video_adaptation_set = bitmovin.manifests.DASH.add_video_adaptation_set(
        object_=video_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    audio_adaptation_set = AudioAdaptationSet(lang='en')
    audio_adaptation_set = bitmovin.manifests.DASH.add_audio_adaptation_set(
        object_=audio_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    # Add all representation to the video adaption set
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        muxing = encoding_config.get('fmp4_muxing')
        fmp4_representation_1080p = FMP4Representation(
            FMP4RepresentationType.TEMPLATE,
            encoding_id=encoding.id,
            muxing_id=muxing.id,
            segment_path='video/dash/{}p_{}k/'.format(
                encoding_profile.get('height'),
                encoding_profile.get('bitrate')))
        encoding_config[
            'dash'] = bitmovin.manifests.DASH.add_fmp4_representation(
                object_=fmp4_representation_1080p,
                manifest_id=dash_manifest.id,
                period_id=period.id,
                adaptationset_id=video_adaptation_set.id).resource

    fmp4_representation_audio = FMP4Representation(
        FMP4RepresentationType.TEMPLATE,
        encoding_id=encoding.id,
        muxing_id=audio_fmp4_muxing.id,
        segment_path='audio_dash/')
    bitmovin.manifests.DASH.add_fmp4_representation(
        object_=fmp4_representation_audio,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=audio_adaptation_set.id)

    bitmovin.manifests.DASH.start(manifest_id=dash_manifest.id)

    # Create a HLS manifest and add one period with an adapation set for audio and video
    hls_manifest = HlsManifest(manifest_name='stream.m3u8',
                               outputs=[manifest_output],
                               name='HLS Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(hls_manifest).resource

    audio_media = AudioMedia(name='HLS Audio Media',
                             group_id='audio',
                             segment_path='audio_hls/',
                             encoding_id=encoding.id,
                             stream_id=audio_stream.id,
                             muxing_id=audio_ts_muxing.id,
                             language='en',
                             uri='audio.m3u8')
    audio_media = bitmovin.manifests.HLS.AudioMedia.create(
        manifest_id=hls_manifest.id, object_=audio_media).resource

    # Add all representation to the video adaption set
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        stream = encoding_config.get('stream')
        muxing = encoding_config.get('ts_muxing')
        variant_stream = VariantStream(
            audio='audio',
            closed_captions='NONE',
            segment_path='video/hls/{}p_{}k/'.format(
                encoding_profile.get('height'),
                encoding_profile.get('bitrate')),
            uri='video_{}p_{}k.m3u8'.format(encoding_profile.get('height'),
                                            encoding_profile.get('bitrate')),
            encoding_id=encoding.id,
            stream_id=stream.id,
            muxing_id=muxing.id)
        variant_stream = bitmovin.manifests.HLS.VariantStream.create(
            manifest_id=hls_manifest.id, object_=variant_stream).resource

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.DASH.wait_until_finished(
            manifest_id=dash_manifest.id, check_interval=1)
    except BitmovinError as bitmovin_error:
        print(
            'Exception occurred while waiting for manifest creation to finish: {}'
            .format(bitmovin_error))
        exit(-1)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id,
                                                   check_interval=1)
    except BitmovinError as bitmovin_error:
        print(
            'Exception occurred while waiting for manifest creation to finish: {}'
            .format(bitmovin_error))
        exit(-1)
예제 #5
0
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    # Create an HTTPs input. This resource is then used as base URL for the input file.
    https_input = HTTPSInput(name='HTTPS input', host=HTTPS_INPUT_HOST)
    https_input = bitmovin.inputs.HTTPS.create(https_input).resource

    # Create an S3 Output. This will be used as target bucket for the muxings, sprites and manifests
    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    # Create an Encoding. This will run in AWS_EU_WEST_1. This is the base entity used to configure the encoding.
    encoding = Encoding(name='HEVC Encoding with Python',
                        cloud_region=CloudRegion.GOOGLE_EUROPE_WEST_1)

    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    encoding_configs = []

    # Iterate over all encoding profiles and create the H265 configuration with the defined height and bitrate.
    # If you want to extend the config you have to set the values here as well.
    for encoding_profile in hevc_encoding_profiles:
        encoding_config = dict(profile=encoding_profile)
        codec = H265CodecConfiguration(
            name='H265 Codec {}p {}k Configuration'.format(
                encoding_profile.get('height'),
                encoding_profile.get('bitrate')),
            bitrate=encoding_profile.get('bitrate') * 1000,
            height=encoding_profile.get('height'),
            rate=encoding_profile.get('fps'),
            profile=encoding_profile.get('profile'))
        encoding_config['codec'] = bitmovin.codecConfigurations.H265.create(
            codec).resource
        encoding_configs.append(encoding_config)

    # Also the AAC configuration has to be created, which will be later on used to create the streams.
    audio_codec_configuration = AACCodecConfiguration(
        name='AAC Codec Configuration', bitrate=128000, rate=48000)

    audio_codec_configuration = bitmovin.codecConfigurations.AAC.create(
        audio_codec_configuration).resource

    video_input_stream = StreamInput(input_id=https_input.id,
                                     input_path=HTTPS_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)
    audio_input_stream = StreamInput(input_id=https_input.id,
                                     input_path=HTTPS_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)

    # With the configurations and the input file streams are now created and muxed later on.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        video_stream = Stream(
            codec_configuration_id=encoding_config.get('codec').id,
            input_streams=[video_input_stream],
            name='Stream {}p_{}k'.format(encoding_profile.get('height'),
                                         encoding_profile.get('bitrate')))
        encoding_config['stream'] = bitmovin.encodings.Stream.create(
            object_=video_stream, encoding_id=encoding.id).resource

    audio_stream = Stream(codec_configuration_id=audio_codec_configuration.id,
                          input_streams=[audio_input_stream],
                          name='Audio Stream')
    audio_stream = bitmovin.encodings.Stream.create(
        object_=audio_stream, encoding_id=encoding.id).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    # Create FMP4 muxings which are later used for the DASH manifest. The current settings will set a segment length
    # of 4 seconds.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        video_muxing_stream = MuxingStream(encoding_config.get('stream').id)
        video_muxing_output = EncodingOutput(
            output_id=s3_output.id,
            output_path=OUTPUT_BASE_PATH +
            'video/{}p_{}k/'.format(encoding_profile.get('height'),
                                    encoding_profile.get('bitrate')),
            acl=[acl_entry])
        video_muxing = FMP4Muxing(segment_length=4,
                                  segment_naming='seg_%number%.m4s',
                                  init_segment_name='init.mp4',
                                  streams=[video_muxing_stream],
                                  outputs=[video_muxing_output],
                                  name='FMP4 Muxing {}p_{}k'.format(
                                      encoding_profile.get('height'),
                                      encoding_profile.get('bitrate')))
        encoding_config['fmp4_muxing'] = bitmovin.encodings.Muxing.FMP4.create(
            object_=video_muxing, encoding_id=encoding.id).resource

    audio_muxing_stream = MuxingStream(audio_stream.id)
    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH +
                                         'audio/',
                                         acl=[acl_entry])
    audio_fmp4_muxing = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[audio_muxing_stream],
                                   outputs=[audio_muxing_output],
                                   name='Audio FMP4 Muxing')
    audio_fmp4_muxing = bitmovin.encodings.Muxing.FMP4.create(
        object_=audio_fmp4_muxing, encoding_id=encoding.id).resource

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(
            encoding_id=encoding.id, check_interval=5)
    except BitmovinError as bitmovin_error:
        print('Exception occurred while waiting for encoding to finish: {}'.
              format(bitmovin_error))

    # Specify the output for manifest which will be in the OUTPUT_BASE_PATH.
    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])
    # Create a DASH manifest and add one period with an adapation set for audio and video
    dash_manifest = DashManifest(manifest_name='stream.mpd',
                                 outputs=[manifest_output],
                                 name='DASH Manifest')
    dash_manifest = bitmovin.manifests.DASH.create(dash_manifest).resource
    period = Period()
    period = bitmovin.manifests.DASH.add_period(
        object_=period, manifest_id=dash_manifest.id).resource
    video_adaptation_set = VideoAdaptationSet()
    video_adaptation_set = bitmovin.manifests.DASH.add_video_adaptation_set(
        object_=video_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    audio_adaptation_set = AudioAdaptationSet(lang='en')
    audio_adaptation_set = bitmovin.manifests.DASH.add_audio_adaptation_set(
        object_=audio_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    # Add all representation to the video adaption set
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        muxing = encoding_config.get('fmp4_muxing')
        fmp4_representation_1080p = FMP4Representation(
            FMP4RepresentationType.TEMPLATE,
            encoding_id=encoding.id,
            muxing_id=muxing.id,
            segment_path='video/{}p_{}k/'.format(
                encoding_profile.get('height'),
                encoding_profile.get('bitrate')))
        encoding_config[
            'dash'] = bitmovin.manifests.DASH.add_fmp4_representation(
                object_=fmp4_representation_1080p,
                manifest_id=dash_manifest.id,
                period_id=period.id,
                adaptationset_id=video_adaptation_set.id).resource

    fmp4_representation_audio = FMP4Representation(
        FMP4RepresentationType.TEMPLATE,
        encoding_id=encoding.id,
        muxing_id=audio_fmp4_muxing.id,
        segment_path='audio/')
    bitmovin.manifests.DASH.add_fmp4_representation(
        object_=fmp4_representation_audio,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=audio_adaptation_set.id)

    bitmovin.manifests.DASH.start(manifest_id=dash_manifest.id)

    # Create a HLS manifest and add one period with an adapation set for audio and video
    hls_manifest = HlsManifest(manifest_name='stream.m3u8',
                               outputs=[manifest_output],
                               name='HLS Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(hls_manifest).resource

    audio_media = AudioMedia(name='HLS Audio Media',
                             group_id='audio',
                             segment_path='audio/',
                             encoding_id=encoding.id,
                             stream_id=audio_stream.id,
                             muxing_id=audio_fmp4_muxing.id,
                             language='en',
                             uri='audio.m3u8')

    bitmovin.manifests.HLS.AudioMedia.create(manifest_id=hls_manifest.id,
                                             object_=audio_media)

    # Add all representation to the video adaption set
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        stream = encoding_config.get('stream')
        muxing = encoding_config.get('fmp4_muxing')
        variant_stream = VariantStream(audio='audio',
                                       closed_captions='NONE',
                                       segment_path='video/{}p_{}k/'.format(
                                           encoding_profile.get('height'),
                                           encoding_profile.get('bitrate')),
                                       uri='video_{}p_{}k.m3u8'.format(
                                           encoding_profile.get('height'),
                                           encoding_profile.get('bitrate')),
                                       encoding_id=encoding.id,
                                       stream_id=stream.id,
                                       muxing_id=muxing.id)
        bitmovin.manifests.HLS.VariantStream.create(
            manifest_id=hls_manifest.id, object_=variant_stream)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.DASH.wait_until_finished(
            manifest_id=dash_manifest.id, check_interval=1)
    except BitmovinError as bitmovin_error:
        print(
            'Exception occurred while waiting for manifest creation to finish: {}'
            .format(bitmovin_error))

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id,
                                                   check_interval=1)
    except BitmovinError as bitmovin_error:
        print(
            'Exception occurred while waiting for manifest creation to finish: {}'
            .format(bitmovin_error))
예제 #6
0
def main():
    bitmovin = Bitmovin(api_key=API_KEY)
    resource_response = bitmovin.inputs.RTMP.list()

    if not resource_response or \
       not resource_response.resource or \
       not isinstance(resource_response.resource, list) or \
       len(resource_response.resource) < 1:
        print('Could not find any RTMP inputs. Please contact support.')
        sys.exit(3)

    rtmp_input_id = resource_response.resource[0].id
    print("Found RTMP input with ID '{}'".format(rtmp_input_id))

    rtmp_input = bitmovin.inputs.RTMP.retrieve(id_=rtmp_input_id).resource

    output = GenericS3Output(access_key=GENERIC_S3_OUTPUT_ACCESSKEY,
                             secret_key=GENERIC_S3_OUTPUT_SECRETKEY,
                             bucket_name=GENERIC_S3_OUTPUT_BUCKETNAME,
                             host=GENERIC_S3_OUTPUT_HOST,
                             port=GENERIC_S3_OUTPUT_PORT,
                             name='Sample Generic S3 Output')
    output = bitmovin.outputs.GenericS3.create(output).resource

    encoding = Encoding(name='example python hls live stream encoding',
                        encoder_version=ENCODER_VERSION,
                        cloud_region=CLOUD_REGION,
                        infrastructure_id=INFRASTRUCTURE_ID)
    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    video_codec_configuration_1080p = H264CodecConfiguration(
        name='example_video_codec_configuration_1080p',
        bitrate=4800000,
        rate=25.0,
        width=1920,
        height=1080,
        profile=H264Profile.HIGH)
    video_codec_configuration_1080p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_1080p).resource

    video_codec_configuration_720p = H264CodecConfiguration(
        name='example_video_codec_configuration_720p',
        bitrate=2400000,
        rate=25.0,
        width=1280,
        height=720,
        profile=H264Profile.HIGH)
    video_codec_configuration_720p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_720p).resource

    video_codec_configuration_360p = H264CodecConfiguration(
        name='example_video_codec_configuration_720p',
        bitrate=800000,
        rate=25.0,
        width=640,
        height=360,
        profile=H264Profile.HIGH)
    video_codec_configuration_360p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_360p).resource

    audio_codec_configuration = AACCodecConfiguration(
        name='example_audio_codec_configuration_english',
        bitrate=128000,
        rate=48000)
    audio_codec_configuration = bitmovin.codecConfigurations.AAC.create(
        audio_codec_configuration).resource

    video_input_stream = StreamInput(input_id=rtmp_input.id,
                                     input_path='live',
                                     position=0,
                                     selection_mode=SelectionMode.AUTO)
    audio_input_stream = StreamInput(input_id=rtmp_input.id,
                                     input_path='live',
                                     position=1,
                                     selection_mode=SelectionMode.AUTO)

    video_stream_1080p = Stream(
        codec_configuration_id=video_codec_configuration_1080p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 1080p')
    video_stream_1080p = bitmovin.encodings.Stream.create(
        object_=video_stream_1080p, encoding_id=encoding.id).resource

    video_stream_720p = Stream(
        codec_configuration_id=video_codec_configuration_720p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 720p')
    video_stream_720p = bitmovin.encodings.Stream.create(
        object_=video_stream_720p, encoding_id=encoding.id).resource

    video_stream_360p = Stream(
        codec_configuration_id=video_codec_configuration_360p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 360p')
    video_stream_360p = bitmovin.encodings.Stream.create(
        object_=video_stream_360p, encoding_id=encoding.id).resource

    audio_stream = Stream(codec_configuration_id=audio_codec_configuration.id,
                          input_streams=[audio_input_stream],
                          name='Sample Stream AUDIO')
    audio_stream = bitmovin.encodings.Stream.create(
        object_=audio_stream, encoding_id=encoding.id).resource

    video_muxing_stream_1080p = MuxingStream(video_stream_1080p.id)
    video_muxing_stream_720p = MuxingStream(video_stream_720p.id)
    video_muxing_stream_360p = MuxingStream(video_stream_360p.id)
    audio_muxing_stream = MuxingStream(audio_stream.id)

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    video_muxing_1080p_output = EncodingOutput(output_id=output.id,
                                               output_path=OUTPUT_BASE_PATH +
                                               'video/1080p',
                                               acl=[acl_entry])
    video_muxing_1080p = TSMuxing(segment_length=4,
                                  segment_naming='seg_%number%.ts',
                                  streams=[video_muxing_stream_1080p],
                                  outputs=[video_muxing_1080p_output],
                                  name='Sample Muxing 1080p')
    video_muxing_1080p = bitmovin.encodings.Muxing.TS.create(
        object_=video_muxing_1080p, encoding_id=encoding.id).resource
    video_muxing_720p_output = EncodingOutput(output_id=output.id,
                                              output_path=OUTPUT_BASE_PATH +
                                              'video/720p',
                                              acl=[acl_entry])
    video_muxing_720p = TSMuxing(segment_length=4,
                                 segment_naming='seg_%number%.m4s',
                                 streams=[video_muxing_stream_720p],
                                 outputs=[video_muxing_720p_output],
                                 name='Sample Muxing 720p')
    video_muxing_720p = bitmovin.encodings.Muxing.TS.create(
        object_=video_muxing_720p, encoding_id=encoding.id).resource

    video_muxing_360p_output = EncodingOutput(output_id=output.id,
                                              output_path=OUTPUT_BASE_PATH +
                                              'video/360p',
                                              acl=[acl_entry])
    video_muxing_360p = TSMuxing(segment_length=4,
                                 segment_naming='seg_%number%.m4s',
                                 streams=[video_muxing_stream_360p],
                                 outputs=[video_muxing_360p_output],
                                 name='Sample Muxing 360p')
    video_muxing_360p = bitmovin.encodings.Muxing.TS.create(
        object_=video_muxing_360p, encoding_id=encoding.id).resource

    audio_muxing_output = EncodingOutput(output_id=output.id,
                                         output_path=OUTPUT_BASE_PATH +
                                         'audio/128k',
                                         acl=[acl_entry])
    audio_muxing = TSMuxing(segment_length=4,
                            segment_naming='seg_%number%.m4s',
                            streams=[audio_muxing_stream],
                            outputs=[audio_muxing_output],
                            name='Sample Muxing AUDIO')
    audio_muxing = bitmovin.encodings.Muxing.TS.create(
        object_=audio_muxing, encoding_id=encoding.id).resource

    #### Manifest #####################################################################################################

    manifest_output = EncodingOutput(output_id=output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])
    hls_manifest = HlsManifest(
        manifest_name='example_live_manifest.m3u8',
        outputs=[manifest_output],
        name='Sample HLS Manifest Live',
        description='Bitmovin Python Test Live HLS Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(hls_manifest).resource

    audio_media = AudioMedia(name='Sample Audio Media',
                             group_id='audio_group',
                             segment_path="audio/128k/",
                             encoding_id=encoding.id,
                             stream_id=audio_stream.id,
                             muxing_id=audio_muxing.id,
                             language='en',
                             uri='audiomedia.m3u8',
                             autoselect=False)

    audio_media = bitmovin.manifests.HLS.AudioMedia.create(
        manifest_id=hls_manifest.id, object_=audio_media).resource

    variant_stream_1080p = VariantStream(audio=audio_media.groupId,
                                         closed_captions='NONE',
                                         segment_path="video/1080p/",
                                         uri='video_1080p.m3u8',
                                         encoding_id=encoding.id,
                                         stream_id=video_stream_1080p.id,
                                         muxing_id=video_muxing_1080p.id)

    variant_stream_1080p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_1080p)

    variant_stream_720p = VariantStream(audio=audio_media.groupId,
                                        closed_captions='NONE',
                                        segment_path="video/720p/",
                                        uri='video_720p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_720p.id,
                                        muxing_id=video_muxing_720p.id)

    variant_stream_720p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_720p)

    variant_stream_360p = VariantStream(audio=audio_media.groupId,
                                        closed_captions='NONE',
                                        segment_path="video/360p/",
                                        uri='video_360p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_360p.id,
                                        muxing_id=video_muxing_360p.id)

    variant_stream_360p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_360p)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    ###################################################################################################################

    live_hls_manifest = LiveHlsManifest(manifest_id=hls_manifest.id,
                                        time_shift=60)

    live_stream_configuration = LiveStreamConfiguration(
        stream_key=STREAM_KEY,
        live_hls_manifests=[live_hls_manifest],
    )

    resource_response = bitmovin.encodings.Encoding.start_live(
        encoding_id=encoding.id,
        live_stream_configuration=live_stream_configuration)

    bitmovin.encodings.Encoding.wait_until_running(
        encoding_id=resource_response.resource.id)

    live_details = None
    retry = 0

    while retry < LIVE_STREAM_INFORMATION_FETCH_MAX_RETRIES:
        try:
            live_details = bitmovin.encodings.Encoding.retrieve_live(
                encoding_id=resource_response.resource.id)
            break
        except BitmovinApiError as bitmovin_api_error:
            if bitmovin_api_error.response.data.code != ERROR_CODE_LIVE_STREAM_NOT_READY:
                sys.exit(2)
            print(
                "Live stream is not ready yet. Retrying to fetch live stream information in {} seconds..."
                .format(LIVE_STREAM_INFORMATION_FETCH_RETRY_INTERVAL))
            retry += 1
            time.sleep(LIVE_STREAM_INFORMATION_FETCH_RETRY_INTERVAL)

    if live_details is not None:
        print_live_stream_details(encoding_id=encoding.id,
                                  live_stream_details=live_details.resource)
    else:
        print("Unable to fetch live stream details!")
        sys.exit(1)
예제 #7
0
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    output = S3Output(access_key=S3_OUTPUT_ACCESS_KEY,
                      secret_key=S3_OUTPUT_SECRET_KEY,
                      bucket_name=S3_OUTPUT_BUCKET_NAME,
                      name='Sample S3 Output')
    output = bitmovin.outputs.S3.create(output).resource

    manifest_output = EncodingOutput(
        output_id=output.id,
        output_path=OUTPUT_BASE_PATH,
        acl=[ACLEntry(permission=ACLPermission.PUBLIC_READ)])

    # Create a DASH manifest
    dash_manifest = DashManifest(manifest_name='stream_vod.mpd',
                                 outputs=[manifest_output],
                                 name='stream_vod.mpd')
    dash_manifest = bitmovin.manifests.DASH.create(dash_manifest).resource

    period = Period()
    period = bitmovin.manifests.DASH.add_period(
        object_=period, manifest_id=dash_manifest.id).resource

    video_adaptation_set = VideoAdaptationSet()
    video_adaptation_set = bitmovin.manifests.DASH.add_video_adaptation_set(
        object_=video_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    audio_adaptation_set = AudioAdaptationSet(lang='en')
    audio_adaptation_set = bitmovin.manifests.DASH.add_audio_adaptation_set(
        object_=audio_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    for representation in AUDIO_REPRESENTATIONS:
        audio_representation = FMP4Representation(
            type=FMP4RepresentationType.TEMPLATE,
            encoding_id=ENCODING_ID,
            muxing_id=representation['fmp4_muxing_id'],
            segment_path=representation['dash_segment_path'],
            start_segment_number=START_SEGMENT,
            end_segment_number=END_SEGMENT)

        bitmovin.manifests.DASH.add_fmp4_representation(
            object_=audio_representation,
            manifest_id=dash_manifest.id,
            period_id=period.id,
            adaptationset_id=audio_adaptation_set.id)

    for representation in VIDEO_REPRESENTATIONS:
        video_representation = FMP4Representation(
            type=FMP4RepresentationType.TEMPLATE,
            encoding_id=ENCODING_ID,
            muxing_id=representation['fmp4_muxing_id'],
            segment_path=representation['dash_segment_path'],
            start_segment_number=START_SEGMENT,
            end_segment_number=END_SEGMENT)

        bitmovin.manifests.DASH.add_fmp4_representation(
            object_=video_representation,
            manifest_id=dash_manifest.id,
            period_id=period.id,
            adaptationset_id=video_adaptation_set.id)

    # Create a HLS manifest
    hls_manifest = HlsManifest(manifest_name='stream_vod.m3u8',
                               outputs=[manifest_output],
                               name='stream_vod.m3u8')
    hls_manifest = bitmovin.manifests.HLS.create(object_=hls_manifest).resource

    for representation in AUDIO_REPRESENTATIONS:
        hls_audio_media = AudioMedia(
            name='en',
            group_id='audio_group',
            segment_path=representation['hls_segment_path'],
            encoding_id=ENCODING_ID,
            stream_id=representation['stream_id'],
            muxing_id=representation['ts_muxing_id'],
            language='en',
            uri=representation['hls_variant_uri'],
            start_segment_number=START_SEGMENT,
            end_segment_number=END_SEGMENT)

        bitmovin.manifests.HLS.AudioMedia.create(manifest_id=hls_manifest.id,
                                                 object_=hls_audio_media)

    for representation in VIDEO_REPRESENTATIONS:
        hls_variant_stream = VariantStream(
            audio="audio_group",
            segment_path=representation['hls_segment_path'],
            encoding_id=ENCODING_ID,
            stream_id=representation['stream_id'],
            muxing_id=representation['ts_muxing_id'],
            uri=representation['hls_variant_uri'],
            start_segment_number=START_SEGMENT,
            end_segment_number=END_SEGMENT)

        bitmovin.manifests.HLS.VariantStream.create(
            manifest_id=hls_manifest.id, object_=hls_variant_stream)

    # start manifest creation.
    bitmovin.manifests.DASH.start(manifest_id=dash_manifest.id)
    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)
예제 #8
0
def main():
    s3_input = S3Input(access_key=S3_INPUT_ACCESSKEY,
                       secret_key=S3_INPUT_SECRETKEY,
                       bucket_name=S3_INPUT_BUCKETNAME,
                       name='Sample S3 Output')
    s3_input = bitmovin.inputs.S3.create(s3_input).resource

    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='Sample S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    encoding = Encoding(
        name='hls fairplay example encoding - {}'.format(date_component))
    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    video_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)

    audio_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)

    video_details = {}
    for profile in VIDEO_PROFILES:
        codec_config = H265CodecConfiguration(
            name="h265 configuration @ {}".format(profile['bitrate']),
            bitrate=profile['bitrate'],
            rate=profile['fps'],
            height=profile['height'],
            profile=H265Profile.main)

        codec_config = bitmovin.codecConfigurations.H265.create(
            codec_config).resource

        stream = Stream(codec_configuration_id=codec_config.id,
                        input_streams=[video_input_stream],
                        name='Sample Stream - {}bps'.format(
                            profile['bitrate']))
        stream = bitmovin.encodings.Stream.create(
            object_=stream, encoding_id=encoding.id).resource

        muxing = create_fmp4_muxing(encoding, stream)

        cenc = create_cenc_drm(encoding=encoding,
                               muxing=muxing,
                               output=s3_output,
                               path='{}fmp4/video_{}p'.format(
                                   OUTPUT_BASE_PATH, profile['height']))

        muxing_key = 'video_{}'.format(profile['bitrate'])

        video_details[muxing_key] = dict(muxing=muxing, drm=cenc)

    audio_codec_config = AACCodecConfiguration(
        name='example_audio_codec_configuration_stereo',
        bitrate=128000,
        rate=48000)

    audio_codec_config = bitmovin.codecConfigurations.AAC.create(
        audio_codec_config).resource

    audio_stream = Stream(codec_configuration_id=audio_codec_config.id,
                          input_streams=[audio_input_stream],
                          name='Sample Audio Stream EN Stereo')

    audio_stream = bitmovin.encodings.Stream.create(
        object_=audio_stream, encoding_id=encoding.id).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    audio_muxing = create_fmp4_muxing(encoding=encoding, stream=audio_stream)

    cenc_audio = create_cenc_drm(encoding=encoding,
                                 muxing=audio_muxing,
                                 output=s3_output,
                                 path='{}fmp4/audio_{}'.format(
                                     OUTPUT_BASE_PATH, 128000))

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(
            encoding_id=encoding.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for encoding to finish: {}".
              format(bitmovin_error))

    # Manifest ##

    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])
    hls_manifest = HlsManifest(manifest_name='example_manifest_hls.m3u8',
                               outputs=[manifest_output],
                               name='Sample HLS FairPlay Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(hls_manifest).resource

    audio_media = AudioMedia(
        name='Sample Audio Media',
        group_id='audio_group',
        segment_path=cenc_audio.outputs[0].outputPath.replace(
            OUTPUT_BASE_PATH, ''),
        encoding_id=encoding.id,
        stream_id=audio_stream.id,
        muxing_id=audio_muxing.id,
        drm_id=cenc_audio.id,
        language='en',
        uri='audiomedia.m3u8')

    audio_media = bitmovin.manifests.HLS.AudioMedia.create(
        manifest_id=hls_manifest.id, object_=audio_media).resource

    for key, video_detail in video_details.items():
        muxing = video_detail['muxing']
        drm = video_detail['drm']
        variant_stream = VariantStream(
            audio=audio_media.groupId,
            closed_captions='NONE',
            segment_path=drm.outputs[0].outputPath.replace(
                OUTPUT_BASE_PATH, ''),
            uri='{}.m3u8'.format(key),
            encoding_id=encoding.id,
            stream_id=muxing.streams[0].streamId,
            muxing_id=muxing.id,
            drm_id=drm.id)

        bitmovin.manifests.HLS.VariantStream.create(
            manifest_id=hls_manifest.id, object_=variant_stream)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id)
    except BitmovinError as bitmovin_error:
        print(
            "Exception occurred while waiting for HLS manifest creation to finish: {}"
            .format(bitmovin_error))
예제 #9
0
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    https_input = HTTPSInput(name='create_simple_encoding HTTPS input',
                             host=HTTPS_INPUT_HOST)
    https_input = bitmovin.inputs.HTTPS.create(https_input).resource

    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='Sample S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    encoding = Encoding(name='example hls fmp4 fairplay encoding',
                        cloud_region=CloudRegion.GOOGLE_EUROPE_WEST_1)
    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    video_codec_configuration_1080p = H264CodecConfiguration(
        name='example_video_codec_configuration_1080p',
        bitrate=4800000,
        rate=25.0,
        width=1920,
        height=1080,
        profile=H264Profile.HIGH)
    video_codec_configuration_1080p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_1080p).resource

    video_codec_configuration_720p = H264CodecConfiguration(
        name='example_video_codec_configuration_720p',
        bitrate=2400000,
        rate=25.0,
        width=1280,
        height=720,
        profile=H264Profile.HIGH)
    video_codec_configuration_720p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_720p).resource

    audio_codec_configuration = AACCodecConfiguration(
        name='example_audio_codec_configuration_english',
        bitrate=128000,
        rate=48000)
    audio_codec_configuration = bitmovin.codecConfigurations.AAC.create(
        audio_codec_configuration).resource

    video_input_stream = StreamInput(input_id=https_input.id,
                                     input_path=HTTPS_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)
    audio_input_stream = StreamInput(input_id=https_input.id,
                                     input_path=HTTPS_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)

    video_stream_1080p = Stream(
        codec_configuration_id=video_codec_configuration_1080p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 1080p')
    video_stream_1080p = bitmovin.encodings.Stream.create(
        object_=video_stream_1080p, encoding_id=encoding.id).resource

    video_stream_720p = Stream(
        codec_configuration_id=video_codec_configuration_720p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 720p')
    video_stream_720p = bitmovin.encodings.Stream.create(
        object_=video_stream_720p, encoding_id=encoding.id).resource

    audio_stream = Stream(codec_configuration_id=audio_codec_configuration.id,
                          input_streams=[audio_input_stream],
                          name='Sample Stream AUDIO')
    audio_stream = bitmovin.encodings.Stream.create(
        object_=audio_stream, encoding_id=encoding.id).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    video_muxing_stream_1080p = MuxingStream(video_stream_1080p.id)
    video_muxing_stream_720p = MuxingStream(video_stream_720p.id)
    audio_muxing_stream = MuxingStream(audio_stream.id)

    video_muxing_1080p_output = EncodingOutput(output_id=s3_output.id,
                                               output_path=OUTPUT_BASE_PATH +
                                               'video/1080p/',
                                               acl=[acl_entry])
    video_muxing_1080p = FMP4Muxing(segment_length=4,
                                    segment_naming='seg_%number%.m4s',
                                    init_segment_name='init.mp4',
                                    streams=[video_muxing_stream_1080p],
                                    outputs=[video_muxing_1080p_output],
                                    name='Sample Muxing 1080p')
    video_muxing_1080p = bitmovin.encodings.Muxing.FMP4.create(
        object_=video_muxing_1080p, encoding_id=encoding.id).resource
    video_muxing_720p_output = EncodingOutput(output_id=s3_output.id,
                                              output_path=OUTPUT_BASE_PATH +
                                              'video/720p/',
                                              acl=[acl_entry])
    video_muxing_720p = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[video_muxing_stream_720p],
                                   outputs=[video_muxing_720p_output],
                                   name='Sample Muxing 720p')
    video_muxing_720p = bitmovin.encodings.Muxing.FMP4.create(
        object_=video_muxing_720p, encoding_id=encoding.id).resource
    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH +
                                         'audio/',
                                         acl=[acl_entry])
    audio_muxing = FMP4Muxing(segment_length=4,
                              segment_naming='seg_%number%.m4s',
                              init_segment_name='init.mp4',
                              streams=[audio_muxing_stream],
                              outputs=[audio_muxing_output],
                              name='Sample Muxing AUDIO')
    audio_muxing = bitmovin.encodings.Muxing.FMP4.create(
        object_=audio_muxing, encoding_id=encoding.id).resource

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(
            encoding_id=encoding.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for encoding to finish: {}".
              format(bitmovin_error))

    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])

    hls_manifest = HlsManifest(manifest_name='example_manifest_hls.m3u8',
                               outputs=[manifest_output],
                               name='Sample HLS Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(object_=hls_manifest).resource

    audio_media = AudioMedia(name='Sample Audio Media',
                             group_id='audio_group',
                             segment_path=audio_muxing_output.outputPath,
                             encoding_id=encoding.id,
                             stream_id=audio_stream.id,
                             muxing_id=audio_muxing.id,
                             language='en',
                             uri='audiomedia.m3u8')
    audio_media = bitmovin.manifests.HLS.AudioMedia.create(
        manifest_id=hls_manifest.id, object_=audio_media).resource

    variant_stream_1080p = VariantStream(
        audio=audio_media.groupId,
        closed_captions='NONE',
        segment_path=video_muxing_1080p_output.outputPath,
        uri='video_1080p.m3u8',
        encoding_id=encoding.id,
        stream_id=video_stream_1080p.id,
        muxing_id=video_muxing_1080p.id)
    variant_stream_1080p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_1080p)

    variant_stream_720p = VariantStream(
        audio=audio_media.groupId,
        closed_captions='NONE',
        segment_path=video_muxing_720p_output.outputPath,
        uri='video_720p.m3u8',
        encoding_id=encoding.id,
        stream_id=video_stream_720p.id,
        muxing_id=video_muxing_720p.id)
    variant_stream_720p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_720p)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id)
    except BitmovinError as bitmovin_error:
        print(
            "Exception occurred while waiting for HLS manifest creation to finish: {}"
            .format(bitmovin_error))
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    s3_input = S3Input(access_key=S3_INPUT_ACCESSKEY,
                       secret_key=S3_INPUT_SECRETKEY,
                       bucket_name=S3_INPUT_BUCKETNAME,
                       name='Sample S3 Output')
    s3_input = bitmovin.inputs.S3.create(s3_input).resource

    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='Sample S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    encoding = Encoding(name='example hls fmp4 fairplay encoding',
                        cloud_region=CloudRegion.GOOGLE_EUROPE_WEST_1)
    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    video_codec_configuration_1080p = H264CodecConfiguration(
        name='example_video_codec_configuration_1080p',
        bitrate=4800000,
        rate=25.0,
        width=1920,
        height=1080,
        profile=H264Profile.HIGH)
    video_codec_configuration_1080p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_1080p).resource

    video_codec_configuration_720p = H264CodecConfiguration(
        name='example_video_codec_configuration_720p',
        bitrate=2400000,
        rate=25.0,
        width=1280,
        height=720,
        profile=H264Profile.HIGH)
    video_codec_configuration_720p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_720p).resource

    video_codec_configuration_480p = H264CodecConfiguration(
        name='example_video_codec_configuration_480p',
        bitrate=1200000,
        rate=25.0,
        width=854,
        height=480,
        profile=H264Profile.HIGH)
    video_codec_configuration_480p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_480p).resource

    video_codec_configuration_360p = H264CodecConfiguration(
        name='example_video_codec_configuration_360p',
        bitrate=800000,
        rate=25.0,
        width=640,
        height=360,
        profile=H264Profile.HIGH)
    video_codec_configuration_360p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_360p).resource

    video_codec_configuration_240p = H264CodecConfiguration(
        name='example_video_codec_configuration_240p',
        bitrate=400000,
        rate=25.0,
        width=426,
        height=240,
        profile=H264Profile.HIGH)
    video_codec_configuration_240p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_240p).resource

    audio_codec_configuration = AACCodecConfiguration(
        name='example_audio_codec_configuration_english',
        bitrate=128000,
        rate=48000)
    audio_codec_configuration = bitmovin.codecConfigurations.AAC.create(
        audio_codec_configuration).resource

    video_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)
    audio_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)

    video_stream_1080p = Stream(
        codec_configuration_id=video_codec_configuration_1080p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 1080p')
    video_stream_1080p = bitmovin.encodings.Stream.create(
        object_=video_stream_1080p, encoding_id=encoding.id).resource

    video_stream_720p = Stream(
        codec_configuration_id=video_codec_configuration_720p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 720p')
    video_stream_720p = bitmovin.encodings.Stream.create(
        object_=video_stream_720p, encoding_id=encoding.id).resource

    video_stream_480p = Stream(
        codec_configuration_id=video_codec_configuration_480p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 480p')
    video_stream_480p = bitmovin.encodings.Stream.create(
        object_=video_stream_480p, encoding_id=encoding.id).resource

    video_stream_360p = Stream(
        codec_configuration_id=video_codec_configuration_360p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 360p')
    video_stream_360p = bitmovin.encodings.Stream.create(
        object_=video_stream_360p, encoding_id=encoding.id).resource

    video_stream_240p = Stream(
        codec_configuration_id=video_codec_configuration_240p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 240p')
    video_stream_240p = bitmovin.encodings.Stream.create(
        object_=video_stream_240p, encoding_id=encoding.id).resource

    audio_stream = Stream(codec_configuration_id=audio_codec_configuration.id,
                          input_streams=[audio_input_stream],
                          name='Sample Stream AUDIO')
    audio_stream = bitmovin.encodings.Stream.create(
        object_=audio_stream, encoding_id=encoding.id).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    video_muxing_stream_1080p = MuxingStream(video_stream_1080p.id)
    video_muxing_stream_720p = MuxingStream(video_stream_720p.id)
    video_muxing_stream_480p = MuxingStream(video_stream_480p.id)
    video_muxing_stream_360p = MuxingStream(video_stream_360p.id)
    video_muxing_stream_240p = MuxingStream(video_stream_240p.id)
    audio_muxing_stream = MuxingStream(audio_stream.id)

    video_muxing_1080p_output = EncodingOutput(output_id=s3_output.id,
                                               output_path=OUTPUT_BASE_PATH +
                                               'video/1080p/',
                                               acl=[acl_entry])
    video_muxing_1080p = FMP4Muxing(segment_length=4,
                                    segment_naming='seg_%number%.m4s',
                                    init_segment_name='init.mp4',
                                    streams=[video_muxing_stream_1080p],
                                    outputs=[video_muxing_1080p_output],
                                    name='Sample Muxing 1080p')
    video_muxing_1080p = bitmovin.encodings.Muxing.FMP4.create(
        object_=video_muxing_1080p, encoding_id=encoding.id).resource

    video_muxing_720p_output = EncodingOutput(output_id=s3_output.id,
                                              output_path=OUTPUT_BASE_PATH +
                                              'video/720p/',
                                              acl=[acl_entry])
    video_muxing_720p = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[video_muxing_stream_720p],
                                   outputs=[video_muxing_720p_output],
                                   name='Sample Muxing 720p')
    video_muxing_720p = bitmovin.encodings.Muxing.FMP4.create(
        object_=video_muxing_720p, encoding_id=encoding.id).resource

    video_muxing_480p_output = EncodingOutput(output_id=s3_output.id,
                                              output_path=OUTPUT_BASE_PATH +
                                              'video/480p/',
                                              acl=[acl_entry])
    video_muxing_480p = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[video_muxing_stream_480p],
                                   outputs=[video_muxing_480p_output],
                                   name='Sample Muxing 480p')
    video_muxing_480p = bitmovin.encodings.Muxing.FMP4.create(
        object_=video_muxing_480p, encoding_id=encoding.id).resource

    video_muxing_360p_output = EncodingOutput(output_id=s3_output.id,
                                              output_path=OUTPUT_BASE_PATH +
                                              'video/360p/',
                                              acl=[acl_entry])
    video_muxing_360p = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[video_muxing_stream_360p],
                                   outputs=[video_muxing_360p_output],
                                   name='Sample Muxing 360p')
    video_muxing_360p = bitmovin.encodings.Muxing.FMP4.create(
        object_=video_muxing_360p, encoding_id=encoding.id).resource

    video_muxing_240p_output = EncodingOutput(output_id=s3_output.id,
                                              output_path=OUTPUT_BASE_PATH +
                                              'video/240p/',
                                              acl=[acl_entry])
    video_muxing_240p = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[video_muxing_stream_240p],
                                   outputs=[video_muxing_240p_output],
                                   name='Sample Muxing 240p')
    video_muxing_240p = bitmovin.encodings.Muxing.FMP4.create(
        object_=video_muxing_240p, encoding_id=encoding.id).resource

    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH +
                                         'audio/',
                                         acl=[acl_entry])
    audio_muxing = FMP4Muxing(segment_length=4,
                              segment_naming='seg_%number%.m4s',
                              init_segment_name='init.mp4',
                              streams=[audio_muxing_stream],
                              outputs=[audio_muxing_output],
                              name='Sample Muxing AUDIO')
    audio_muxing = bitmovin.encodings.Muxing.FMP4.create(
        object_=audio_muxing, encoding_id=encoding.id).resource

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(
            encoding_id=encoding.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for encoding to finish: {}".
              format(bitmovin_error))

    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])

    hls_manifest = HlsManifest(manifest_name='example_manifest_hls.m3u8',
                               outputs=[manifest_output],
                               name='Sample HLS Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(object_=hls_manifest).resource

    audio_media = AudioMedia(name='Sample Audio Media',
                             group_id='audio_group',
                             segment_path='audio/',
                             encoding_id=encoding.id,
                             stream_id=audio_stream.id,
                             muxing_id=audio_muxing.id,
                             language='en',
                             uri='audiomedia.m3u8')
    audio_media = bitmovin.manifests.HLS.AudioMedia.create(
        manifest_id=hls_manifest.id, object_=audio_media).resource

    variant_stream_1080p = VariantStream(audio=audio_media.groupId,
                                         closed_captions='NONE',
                                         segment_path='video/1080p/',
                                         uri='video_1080p.m3u8',
                                         encoding_id=encoding.id,
                                         stream_id=video_stream_1080p.id,
                                         muxing_id=video_muxing_1080p.id)
    variant_stream_1080p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_1080p)

    variant_stream_720p = VariantStream(audio=audio_media.groupId,
                                        closed_captions='NONE',
                                        segment_path='video/720p/',
                                        uri='video_720p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_720p.id,
                                        muxing_id=video_muxing_720p.id)
    variant_stream_720p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_720p)

    variant_stream_480p = VariantStream(audio=audio_media.groupId,
                                        closed_captions='NONE',
                                        segment_path='video/480p/',
                                        uri='video_480p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_480p.id,
                                        muxing_id=video_muxing_480p.id)
    variant_stream_480p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_480p)

    variant_stream_360p = VariantStream(audio=audio_media.groupId,
                                        closed_captions='NONE',
                                        segment_path='video/360p/',
                                        uri='video_360p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_360p.id,
                                        muxing_id=video_muxing_360p.id)
    variant_stream_360p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_360p)

    variant_stream_240p = VariantStream(audio=audio_media.groupId,
                                        closed_captions='NONE',
                                        segment_path='video/240p/',
                                        uri='video_240p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_240p.id,
                                        muxing_id=video_muxing_240p.id)
    variant_stream_240p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_240p)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    dash_manifest = DashManifest(manifest_name='example_manifest_dash.mpd',
                                 outputs=[manifest_output],
                                 name='Sample DASH Manifest')
    dash_manifest = bitmovin.manifests.DASH.create(dash_manifest).resource
    period = Period()
    period = bitmovin.manifests.DASH.add_period(
        object_=period, manifest_id=dash_manifest.id).resource
    video_adaptation_set = VideoAdaptationSet()
    video_adaptation_set = bitmovin.manifests.DASH.add_video_adaptation_set(
        object_=video_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource
    audio_adaptation_set = AudioAdaptationSet(lang='en')
    audio_adaptation_set = bitmovin.manifests.DASH.add_audio_adaptation_set(
        object_=audio_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    fmp4_representation_1080p = FMP4Representation(
        FMP4RepresentationType.TEMPLATE,
        encoding_id=encoding.id,
        muxing_id=video_muxing_1080p.id,
        segment_path='video/1080p/')
    fmp4_representation_1080p = bitmovin.manifests.DASH.add_fmp4_representation(
        object_=fmp4_representation_1080p,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=video_adaptation_set.id).resource

    fmp4_representation_720p = FMP4Representation(
        FMP4RepresentationType.TEMPLATE,
        encoding_id=encoding.id,
        muxing_id=video_muxing_720p.id,
        segment_path='video/720p/')
    fmp4_representation_720p = bitmovin.manifests.DASH.add_fmp4_representation(
        object_=fmp4_representation_720p,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=video_adaptation_set.id).resource

    fmp4_representation_480p = FMP4Representation(
        FMP4RepresentationType.TEMPLATE,
        encoding_id=encoding.id,
        muxing_id=video_muxing_480p.id,
        segment_path='video/480p/')
    fmp4_representation_480p = bitmovin.manifests.DASH.add_fmp4_representation(
        object_=fmp4_representation_480p,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=video_adaptation_set.id).resource

    fmp4_representation_360p = FMP4Representation(
        FMP4RepresentationType.TEMPLATE,
        encoding_id=encoding.id,
        muxing_id=video_muxing_360p.id,
        segment_path='video/360p/')
    fmp4_representation_360p = bitmovin.manifests.DASH.add_fmp4_representation(
        object_=fmp4_representation_360p,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=video_adaptation_set.id).resource

    fmp4_representation_240p = FMP4Representation(
        FMP4RepresentationType.TEMPLATE,
        encoding_id=encoding.id,
        muxing_id=video_muxing_240p.id,
        segment_path='video/240p/')
    fmp4_representation_240p = bitmovin.manifests.DASH.add_fmp4_representation(
        object_=fmp4_representation_240p,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=video_adaptation_set.id).resource

    fmp4_representation_audio = FMP4Representation(
        FMP4RepresentationType.TEMPLATE,
        encoding_id=encoding.id,
        muxing_id=audio_muxing.id,
        segment_path='audio/')
    fmp4_representation_audio = bitmovin.manifests.DASH.add_fmp4_representation(
        object_=fmp4_representation_audio,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=audio_adaptation_set.id).resource

    bitmovin.manifests.DASH.start(manifest_id=dash_manifest.id)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id)
    except BitmovinError as bitmovin_error:
        print(
            "Exception occurred while waiting for HLS manifest creation to finish: {}"
            .format(bitmovin_error))

    try:
        bitmovin.manifests.DASH.wait_until_finished(
            manifest_id=dash_manifest.id)
    except BitmovinError as bitmovin_error:
        print(
            "Exception occurred while waiting for DASH manifest creation to finish: {}"
            .format(bitmovin_error))
예제 #11
0
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    s3_input = S3Input(access_key=S3_INPUT_ACCESSKEY,
                       secret_key=S3_INPUT_SECRETKEY,
                       bucket_name=S3_INPUT_BUCKETNAME,
                       name='Sample S3 Input')
    s3_input = bitmovin.inputs.S3.create(s3_input).resource

    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='Sample S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    encoding = Encoding(name='Python Encoding with DASH CENC and Fairplay')

    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    video_codec_configuration_480p = H264CodecConfiguration(name='example_video_codec_configuration_480p',
                                                            bitrate=1200000,
                                                            rate=None,
                                                            height=480,
                                                            profile=H264Profile.HIGH)
    video_codec_configuration_480p = bitmovin.codecConfigurations.H264.create(video_codec_configuration_480p).resource

    video_codec_configuration_360p = H264CodecConfiguration(name='example_video_codec_configuration_360p',
                                                            bitrate=800000,
                                                            rate=None,
                                                            height=360,
                                                            profile=H264Profile.HIGH)
    video_codec_configuration_360p = bitmovin.codecConfigurations.H264.create(video_codec_configuration_360p).resource

    video_codec_configuration_240p = H264CodecConfiguration(name='example_video_codec_configuration_240p',
                                                            bitrate=400000,
                                                            rate=None,
                                                            height=240,
                                                            profile=H264Profile.HIGH)
    video_codec_configuration_240p = bitmovin.codecConfigurations.H264.create(video_codec_configuration_240p).resource

    audio_codec_configuration_stereo = AACCodecConfiguration(name='example_audio_codec_configuration_stereo',
                                                             bitrate=128000,
                                                             rate=48000)
    audio_codec_configuration_stereo = \
        bitmovin.codecConfigurations.AAC.create(audio_codec_configuration_stereo).resource

    video_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)

    audio_input_stream_en_stereo = StreamInput(input_id=s3_input.id,
                                               input_path=S3_INPUT_PATH,
                                               selection_mode=SelectionMode.AUTO)

    video_stream_480p = Stream(codec_configuration_id=video_codec_configuration_480p.id,
                               input_streams=[video_input_stream],
                               name='Sample Stream 480p')
    video_stream_480p = bitmovin.encodings.Stream.create(object_=video_stream_480p,
                                                         encoding_id=encoding.id).resource

    video_stream_360p = Stream(codec_configuration_id=video_codec_configuration_360p.id,
                               input_streams=[video_input_stream],
                               name='Sample Stream 360p')
    video_stream_360p = bitmovin.encodings.Stream.create(object_=video_stream_360p,
                                                         encoding_id=encoding.id).resource

    video_stream_240p = Stream(codec_configuration_id=video_codec_configuration_240p.id,
                               input_streams=[video_input_stream],
                               name='Sample Stream 240p')
    video_stream_240p = bitmovin.encodings.Stream.create(object_=video_stream_240p,
                                                         encoding_id=encoding.id).resource

    audio_stream_en_stereo = Stream(codec_configuration_id=audio_codec_configuration_stereo.id,
                                    input_streams=[audio_input_stream_en_stereo],
                                    name='Sample Audio Stream EN Stereo')
    audio_stream_en_stereo = bitmovin.encodings.Stream.create(object_=audio_stream_en_stereo,
                                                              encoding_id=encoding.id).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    video_muxing_stream_480p = MuxingStream(video_stream_480p.id)
    video_muxing_stream_360p = MuxingStream(video_stream_360p.id)
    video_muxing_stream_240p = MuxingStream(video_stream_240p.id)

    audio_muxing_stream_en_stereo = MuxingStream(audio_stream_en_stereo.id)

    widevine_drm = CENCWidevineEntry(pssh=CENC_WIDEVINE_PSSH)
    play_ready_drm = CENCPlayReadyEntry(la_url=CENC_PLAYREADY_LA_URL)

    video_muxing_480p_dash_output = EncodingOutput(output_id=s3_output.id,
                                                   output_path=OUTPUT_BASE_PATH + 'video/dash/480p/',
                                                   acl=[acl_entry])
    video_muxing_480p = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[video_muxing_stream_480p],
                                   name='FMP4 Muxing 480p')
    video_muxing_480p = bitmovin.encodings.Muxing.FMP4.create(object_=video_muxing_480p,
                                                              encoding_id=encoding.id).resource
    cenc_480p = CENCDRMResource(key=CENC_KEY,
                                kid=CENC_KID,
                                widevine=widevine_drm,
                                playReady=play_ready_drm,
                                marlin=CENCMarlinEntry(),
                                outputs=[video_muxing_480p_dash_output],
                                name='Cenc')
    cenc_480p = bitmovin.encodings.Muxing.FMP4.DRM.CENC.create(object_=cenc_480p,
                                                               encoding_id=encoding.id,
                                                               muxing_id=video_muxing_480p.id).resource
    video_muxing_480p_ts = TSMuxing(segment_length=4,
                                    segment_naming='seg_%number%.ts',
                                    streams=[video_muxing_stream_480p],
                                    name='TS Muxing 480p')
    video_muxing_480p_ts = bitmovin.encodings.Muxing.TS.create(object_=video_muxing_480p_ts,
                                                               encoding_id=encoding.id).resource

    video_muxing_480p_hls_output = EncodingOutput(output_id=s3_output.id,
                                                  output_path=OUTPUT_BASE_PATH + 'video/hls/480p/',
                                                  acl=[acl_entry])
    fair_play_480p = FairPlayDRM(key=FAIRPLAY_KEY,
                                 iv=FAIRPLAY_IV,
                                 uri=FAIRPLAY_URI,
                                 outputs=[video_muxing_480p_hls_output],
                                 name='FairPlay 480p')
    fair_play_480p = bitmovin.encodings.Muxing.TS.DRM.FairPlay.create(object_=fair_play_480p,
                                                                      encoding_id=encoding.id,
                                                                      muxing_id=video_muxing_480p_ts.id).resource

    video_muxing_360p_dash_output = EncodingOutput(output_id=s3_output.id,
                                                   output_path=OUTPUT_BASE_PATH + 'video/dash/360p/',
                                                   acl=[acl_entry])
    video_muxing_360p = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[video_muxing_stream_360p],
                                   name='FMP4 Muxing 360p')
    video_muxing_360p = bitmovin.encodings.Muxing.FMP4.create(object_=video_muxing_360p,
                                                              encoding_id=encoding.id).resource
    cenc_360p = CENCDRMResource(key=CENC_KEY,
                                kid=CENC_KID,
                                widevine=widevine_drm,
                                playReady=play_ready_drm,
                                marlin=CENCMarlinEntry(),
                                outputs=[video_muxing_360p_dash_output],
                                name='Cenc')
    cenc_360p = bitmovin.encodings.Muxing.FMP4.DRM.CENC.create(object_=cenc_360p,
                                                               encoding_id=encoding.id,
                                                               muxing_id=video_muxing_360p.id).resource

    video_muxing_360p_hls_output = EncodingOutput(output_id=s3_output.id,
                                                  output_path=OUTPUT_BASE_PATH + 'video/hls/360p/',
                                                  acl=[acl_entry])
    video_muxing_360p_ts = TSMuxing(segment_length=4,
                                    segment_naming='seg_%number%.ts',
                                    streams=[video_muxing_stream_360p],
                                    name='TS Muxing 360p')
    video_muxing_360p_ts = bitmovin.encodings.Muxing.TS.create(object_=video_muxing_360p_ts,
                                                               encoding_id=encoding.id).resource
    fair_play_360p = FairPlayDRM(key=FAIRPLAY_KEY,
                                 iv=FAIRPLAY_IV,
                                 uri=FAIRPLAY_URI,
                                 outputs=[video_muxing_360p_hls_output],
                                 name='FairPlay 360p')
    fair_play_360p = bitmovin.encodings.Muxing.TS.DRM.FairPlay.create(object_=fair_play_360p,
                                                                      encoding_id=encoding.id,
                                                                      muxing_id=video_muxing_360p_ts.id).resource

    video_muxing_240p_dash_output = EncodingOutput(output_id=s3_output.id,
                                                   output_path=OUTPUT_BASE_PATH + 'video/dash/240p/',
                                                   acl=[acl_entry])
    video_muxing_240p = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[video_muxing_stream_240p],
                                   name='FMP4 Muxing 240p')
    video_muxing_240p = bitmovin.encodings.Muxing.FMP4.create(object_=video_muxing_240p,
                                                              encoding_id=encoding.id).resource
    cenc_240p = CENCDRMResource(key=CENC_KEY,
                                kid=CENC_KID,
                                widevine=widevine_drm,
                                playReady=play_ready_drm,
                                marlin=CENCMarlinEntry(),
                                outputs=[video_muxing_240p_dash_output],
                                name='Cenc')
    cenc_240p = bitmovin.encodings.Muxing.FMP4.DRM.CENC.create(object_=cenc_240p,
                                                               encoding_id=encoding.id,
                                                               muxing_id=video_muxing_240p.id).resource

    video_muxing_240p_hls_output = EncodingOutput(output_id=s3_output.id,
                                                  output_path=OUTPUT_BASE_PATH + 'video/hls/240p/',
                                                  acl=[acl_entry])
    video_muxing_240p_ts = TSMuxing(segment_length=4,
                                    segment_naming='seg_%number%.ts',
                                    streams=[video_muxing_stream_240p],
                                    name='TS Muxing 240p')
    video_muxing_240p_ts = bitmovin.encodings.Muxing.TS.create(object_=video_muxing_240p_ts,
                                                               encoding_id=encoding.id).resource

    fair_play_240p = FairPlayDRM(key=FAIRPLAY_KEY,
                                 iv=FAIRPLAY_IV,
                                 uri=FAIRPLAY_URI,
                                 outputs=[video_muxing_240p_hls_output],
                                 name='FairPlay 240p')
    fair_play_240p = bitmovin.encodings.Muxing.TS.DRM.FairPlay.create(object_=fair_play_240p,
                                                                      encoding_id=encoding.id,
                                                                      muxing_id=video_muxing_240p_ts.id).resource

    audio_muxing_dash_output = EncodingOutput(output_id=s3_output.id,
                                              output_path=OUTPUT_BASE_PATH + 'audio/dash/en/',
                                              acl=[acl_entry])
    audio_muxing_en_stereo = FMP4Muxing(segment_length=4,
                                        segment_naming='seg_%number%.m4s',
                                        init_segment_name='init.mp4',
                                        streams=[audio_muxing_stream_en_stereo],
                                        name='Sample Audio Muxing EN Stereo')
    audio_muxing_en_stereo = bitmovin.encodings.Muxing.FMP4.create(object_=audio_muxing_en_stereo,
                                                                   encoding_id=encoding.id).resource

    cenc_audio = CENCDRMResource(key=CENC_KEY,
                                 kid=CENC_KID,
                                 widevine=widevine_drm,
                                 playReady=play_ready_drm,
                                 marlin=CENCMarlinEntry(),
                                 outputs=[audio_muxing_dash_output],
                                 name='Cenc')
    cenc_audio = bitmovin.encodings.Muxing.FMP4.DRM.CENC.create(object_=cenc_audio,
                                                                encoding_id=encoding.id,
                                                                muxing_id=audio_muxing_en_stereo.id).resource

    audio_muxing_hls_output = EncodingOutput(output_id=s3_output.id,
                                             output_path=OUTPUT_BASE_PATH + 'audio/hls/en/',
                                             acl=[acl_entry])
    audio_muxing_en_stereo_ts = TSMuxing(segment_length=4,
                                         segment_naming='seg_%number%.m4s',
                                         streams=[audio_muxing_stream_en_stereo],
                                         name='Sample TS Audio Muxing EN Stereo')
    audio_muxing_en_stereo_ts = bitmovin.encodings.Muxing.TS.create(object_=audio_muxing_en_stereo_ts,
                                                                    encoding_id=encoding.id).resource

    fair_play_audio = FairPlayDRM(key=FAIRPLAY_KEY,
                                  iv=FAIRPLAY_IV,
                                  uri=FAIRPLAY_URI,
                                  outputs=[audio_muxing_hls_output],
                                  name='FairPlay Audio')
    fair_play_audio = bitmovin.encodings.Muxing.TS.DRM.FairPlay.create(object_=fair_play_audio,
                                                                       encoding_id=encoding.id,
                                                                       muxing_id=audio_muxing_en_stereo_ts.id).resource

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(encoding_id=encoding.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for encoding to finish: {}".format(bitmovin_error))

    ###################################################################################################################

    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])
    dash_manifest = DashManifest(manifest_name='stream.mpd',
                                 outputs=[manifest_output],
                                 name='Sample DASH Manifest')
    dash_manifest = bitmovin.manifests.DASH.create(dash_manifest).resource

    period = Period()
    period = bitmovin.manifests.DASH.add_period(object_=period, manifest_id=dash_manifest.id).resource

    video_adaptation_set = VideoAdaptationSet()
    video_adaptation_set = bitmovin.manifests.DASH.add_video_adaptation_set(object_=video_adaptation_set,
                                                                            manifest_id=dash_manifest.id,
                                                                            period_id=period.id).resource

    video_content_protection = ContentProtection(encoding_id=encoding.id,
                                                 muxing_id=video_muxing_480p.id,
                                                 drm_id=cenc_480p.id)
    bitmovin.manifests.DASH.add_content_protection_to_adaptionset(object_=video_content_protection,
                                                                  manifest_id=dash_manifest.id,
                                                                  period_id=period.id,
                                                                  adaptationset_id=video_adaptation_set.id)
    fmp4_representation_480p = DRMFMP4Representation(type=FMP4RepresentationType.TEMPLATE,
                                                     encoding_id=encoding.id,
                                                     muxing_id=video_muxing_480p.id,
                                                     drm_id=cenc_480p.id,
                                                     segment_path='video/dash/480p/')
    fmp4_representation_480p = bitmovin.manifests.DASH.add_drm_fmp4_representation(
        object_=fmp4_representation_480p,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=video_adaptation_set.id
    ).resource

    fmp4_representation_360p = DRMFMP4Representation(type=FMP4RepresentationType.TEMPLATE,
                                                     encoding_id=encoding.id,
                                                     muxing_id=video_muxing_360p.id,
                                                     drm_id=cenc_360p.id,
                                                     segment_path='video/dash/360p/')
    fmp4_representation_360p = bitmovin.manifests.DASH.add_drm_fmp4_representation(
        object_=fmp4_representation_360p,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=video_adaptation_set.id
    ).resource

    fmp4_representation_240p = DRMFMP4Representation(type=FMP4RepresentationType.TEMPLATE,
                                                     encoding_id=encoding.id,
                                                     muxing_id=video_muxing_240p.id,
                                                     drm_id=cenc_240p.id,
                                                     segment_path='video/dash/240p/')
    fmp4_representation_240p = bitmovin.manifests.DASH.add_drm_fmp4_representation(
        object_=fmp4_representation_240p,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=video_adaptation_set.id
    ).resource

    audio_adaptation_set = AudioAdaptationSet(lang='EN')
    audio_adaptation_set = bitmovin.manifests.DASH.add_audio_adaptation_set(object_=audio_adaptation_set,
                                                                            manifest_id=dash_manifest.id,
                                                                            period_id=period.id).resource

    audio_content_protection = ContentProtection(encoding_id=encoding.id,
                                                 muxing_id=audio_muxing_en_stereo.id,
                                                 drm_id=cenc_audio.id)
    bitmovin.manifests.DASH.add_content_protection_to_adaptionset(object_=audio_content_protection,
                                                                  manifest_id=dash_manifest.id,
                                                                  period_id=period.id,
                                                                  adaptationset_id=audio_adaptation_set.id)
    drm_cenc_fmp4_representation_audio = DRMFMP4Representation(type=FMP4RepresentationType.TEMPLATE,
                                                               encoding_id=encoding.id,
                                                               muxing_id=audio_muxing_en_stereo.id,
                                                               drm_id=cenc_audio.id,
                                                               segment_path='audio/dash/en/')
    drm_cenc_fmp4_representation_audio = bitmovin.manifests.DASH.add_drm_fmp4_representation(
        object_=drm_cenc_fmp4_representation_audio,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=audio_adaptation_set.id
    ).resource

    bitmovin.manifests.DASH.start(manifest_id=dash_manifest.id)

    ###################################################################################################################

    hls_manifest = HlsManifest(manifest_name='stream.m3u8',
                               outputs=[manifest_output],
                               name='Sample HLS FairPlay Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(hls_manifest).resource

    audio_media = AudioMedia(name='English',
                             group_id='audio_group',
                             segment_path='audio/hls/en/',
                             encoding_id=encoding.id,
                             stream_id=audio_stream_en_stereo.id,
                             muxing_id=audio_muxing_en_stereo_ts.id,
                             drm_id=fair_play_audio.id,
                             language='en',
                             uri='audio.m3u8')

    audio_media = bitmovin.manifests.HLS.AudioMedia.create(manifest_id=hls_manifest.id,
                                                           object_=audio_media).resource

    variant_stream_480p = VariantStream(audio=audio_media.groupId,
                                        segment_path='video/hls/480p/',
                                        uri='video_480p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_480p.id,
                                        muxing_id=video_muxing_480p_ts.id,
                                        drm_id=fair_play_480p.id)

    variant_stream_480p = bitmovin.manifests.HLS.VariantStream.create(manifest_id=hls_manifest.id,
                                                                      object_=variant_stream_480p)

    variant_stream_360p = VariantStream(audio=audio_media.groupId,
                                        segment_path='video/hls/360p/',
                                        uri='video_360p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_360p.id,
                                        muxing_id=video_muxing_360p_ts.id,
                                        drm_id=fair_play_360p.id)

    variant_stream_360p = bitmovin.manifests.HLS.VariantStream.create(manifest_id=hls_manifest.id,
                                                                      object_=variant_stream_360p)

    variant_stream_240p = VariantStream(audio=audio_media.groupId,
                                        segment_path='video/hls/240p/',
                                        uri='video_240p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_240p.id,
                                        muxing_id=video_muxing_240p_ts.id,
                                        drm_id=fair_play_240p.id)

    variant_stream_240p = bitmovin.manifests.HLS.VariantStream.create(manifest_id=hls_manifest.id,
                                                                      object_=variant_stream_240p)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    ###################################################################################################################

    try:
        bitmovin.manifests.DASH.wait_until_finished(manifest_id=dash_manifest.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for manifest creation to finish: {}".format(bitmovin_error))

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for HLS manifest creation to finish: {}".format(bitmovin_error))
예제 #12
0
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    # Create an S3 input. This resource is then used as base bucket for the input file.
    s3_input = S3Input(access_key=S3_INPUT_ACCESSKEY,
                       secret_key=S3_INPUT_SECRETKEY,
                       bucket_name=S3_INPUT_BUCKETNAME,
                       name='S3 Input')
    s3_input = bitmovin.inputs.S3.create(s3_input).resource

    # Create an S3 Output. This will be used as target bucket for the muxings, sprites and manifests
    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    video_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_FILEPATH,
                                     selection_mode=SelectionMode.AUTO)
    audio_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_FILEPATH,
                                     selection_mode=SelectionMode.AUTO)

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    # Create an Encoding.
    encoding = Encoding(
        name='Encoding sample with HLS and DASH, and VTT subtitles',
        cloud_region=CloudRegion.AUTO)

    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    encoding_configs = []

    # Iterate over all encoding profiles and create the H264 configuration with the defined height and bitrate.
    for encoding_profile in encoding_profiles:
        encoding_config = dict(profile=encoding_profile)
        codec = H264CodecConfiguration(
            name='H264 Codec {}p {}k Configuration'.format(
                encoding_profile.get('height'),
                encoding_profile.get('bitrate')),
            bitrate=encoding_profile.get('bitrate'),
            height=encoding_profile.get('height'),
            rate=encoding_profile.get('fps'),
            profile=H264Profile.HIGH)
        encoding_config['codec'] = bitmovin.codecConfigurations.H264.create(
            codec).resource
        encoding_configs.append(encoding_config)

    # Also the AAC configuration has to be created, which will be later on used to create the streams.
    audio_codec_configuration = AACCodecConfiguration(
        name='AAC Codec Configuration', bitrate=128000, rate=48000)
    audio_codec_configuration = bitmovin.codecConfigurations.AAC.create(
        audio_codec_configuration).resource

    # With the configurations and the input file streams are now created and muxed later on.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        video_stream = Stream(
            codec_configuration_id=encoding_config.get('codec').id,
            input_streams=[video_input_stream],
            name='Stream {}p_{}k'.format(encoding_profile.get('height'),
                                         encoding_profile.get('bitrate')))
        encoding_config['stream'] = bitmovin.encodings.Stream.create(
            object_=video_stream, encoding_id=encoding.id).resource

    audio_stream = Stream(codec_configuration_id=audio_codec_configuration.id,
                          input_streams=[audio_input_stream],
                          name='Audio Stream')
    audio_stream = bitmovin.encodings.Stream.create(
        object_=audio_stream, encoding_id=encoding.id).resource

    # Create FMP4 muxings which are later used for the DASH manifest. The current settings will set a segment length
    # of 4 seconds.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        video_muxing_stream = MuxingStream(encoding_config.get('stream').id)
        video_muxing_output = EncodingOutput(
            output_id=s3_output.id,
            output_path=OUTPUT_BASE_PATH +
            'video/dash/{}p_{}k/'.format(encoding_profile.get('height'),
                                         encoding_profile.get('bitrate')),
            acl=[acl_entry])
        video_muxing = FMP4Muxing(segment_length=4,
                                  segment_naming='seg_%number%.m4s',
                                  init_segment_name='init.mp4',
                                  streams=[video_muxing_stream],
                                  outputs=[video_muxing_output],
                                  name='FMP4 Muxing {}p_{}k'.format(
                                      encoding_profile.get('height'),
                                      encoding_profile.get('bitrate')))
        encoding_config['fmp4_muxing'] = bitmovin.encodings.Muxing.FMP4.create(
            object_=video_muxing, encoding_id=encoding.id).resource

    audio_muxing_stream = MuxingStream(audio_stream.id)
    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH +
                                         'audio_dash/',
                                         acl=[acl_entry])
    audio_fmp4_muxing = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[audio_muxing_stream],
                                   outputs=[audio_muxing_output],
                                   name='Audio FMP4 Muxing')
    audio_fmp4_muxing = bitmovin.encodings.Muxing.FMP4.create(
        object_=audio_fmp4_muxing, encoding_id=encoding.id).resource

    # Create TS muxings which are later used for the HLS manifest. The current settings will set a segment length
    # of 4 seconds.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        video_muxing_stream = MuxingStream(encoding_config.get('stream').id)
        video_muxing_output = EncodingOutput(
            output_id=s3_output.id,
            output_path=OUTPUT_BASE_PATH +
            'video/hls/{}p_{}k/'.format(encoding_profile.get('height'),
                                        encoding_profile.get('bitrate')),
            acl=[acl_entry])
        video_muxing = TSMuxing(segment_length=4,
                                segment_naming='seg_%number%.ts',
                                streams=[video_muxing_stream],
                                outputs=[video_muxing_output],
                                name='TS Muxing {}p_{}k'.format(
                                    encoding_profile.get('height'),
                                    encoding_profile.get('bitrate')))
        encoding_config['ts_muxing'] = bitmovin.encodings.Muxing.TS.create(
            object_=video_muxing, encoding_id=encoding.id).resource

    audio_muxing_stream = MuxingStream(audio_stream.id)
    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH +
                                         'audio_hls/',
                                         acl=[acl_entry])
    audio_ts_muxing = TSMuxing(segment_length=4,
                               segment_naming='seg_%number%.ts',
                               streams=[audio_muxing_stream],
                               outputs=[audio_muxing_output],
                               name='Audio TS Muxing')
    audio_ts_muxing = bitmovin.encodings.Muxing.TS.create(
        object_=audio_ts_muxing, encoding_id=encoding.id).resource

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(
            encoding_id=encoding.id, check_interval=5)
    except BitmovinError as bitmovin_error:
        print('Exception occurred while waiting for encoding to finish: {}'.
              format(bitmovin_error))
        exit(-1)

    # Specify the output for manifest which will be in the OUTPUT_BASE_PATH.
    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])
    # Create a DASH manifest and add one period with an adapation set for audio and video
    dash_manifest = DashManifest(manifest_name='stream.mpd',
                                 outputs=[manifest_output],
                                 name='DASH Manifest')
    dash_manifest = bitmovin.manifests.DASH.create(dash_manifest).resource
    period = Period()
    period = bitmovin.manifests.DASH.add_period(
        object_=period, manifest_id=dash_manifest.id).resource
    video_adaptation_set = VideoAdaptationSet()
    video_adaptation_set = bitmovin.manifests.DASH.add_video_adaptation_set(
        object_=video_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    audio_adaptation_set = AudioAdaptationSet(lang='en')
    audio_adaptation_set = bitmovin.manifests.DASH.add_audio_adaptation_set(
        object_=audio_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    subtitle_adaptation_set = SubtitleAdaptationSet(lang='en')
    subtitle_adaptation_set = bitmovin.manifests.DASH.add_subtitle_adaptation_set(
        object_=subtitle_adaptation_set,
        manifest_id=dash_manifest.id,
        period_id=period.id).resource

    # Add all representation to the video adaption set
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        muxing = encoding_config.get('fmp4_muxing')
        fmp4_representation_1080p = FMP4Representation(
            FMP4RepresentationType.TEMPLATE,
            encoding_id=encoding.id,
            muxing_id=muxing.id,
            segment_path='video/dash/{}p_{}k/'.format(
                encoding_profile.get('height'),
                encoding_profile.get('bitrate')))
        encoding_config[
            'dash'] = bitmovin.manifests.DASH.add_fmp4_representation(
                object_=fmp4_representation_1080p,
                manifest_id=dash_manifest.id,
                period_id=period.id,
                adaptationset_id=video_adaptation_set.id).resource

    fmp4_representation_audio = FMP4Representation(
        FMP4RepresentationType.TEMPLATE,
        encoding_id=encoding.id,
        muxing_id=audio_fmp4_muxing.id,
        segment_path='audio_dash/')
    bitmovin.manifests.DASH.add_fmp4_representation(
        object_=fmp4_representation_audio,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=audio_adaptation_set.id)

    vtt_representation = VttRepresentation(vtt_url=VTT_URL)
    bitmovin.manifests.DASH.add_vtt_representation(
        object_=vtt_representation,
        manifest_id=dash_manifest.id,
        period_id=period.id,
        adaptationset_id=subtitle_adaptation_set.id)

    bitmovin.manifests.DASH.start(manifest_id=dash_manifest.id)

    # Create a HLS manifest and add one period with an adapation set for audio and video
    hls_manifest = HlsManifest(manifest_name='stream.m3u8',
                               outputs=[manifest_output],
                               name='HLS Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(hls_manifest).resource

    audio_media = AudioMedia(name='HLS Audio Media',
                             group_id='audio',
                             segment_path='audio_hls/',
                             encoding_id=encoding.id,
                             stream_id=audio_stream.id,
                             muxing_id=audio_ts_muxing.id,
                             language='en',
                             uri='audio.m3u8')
    audio_media = bitmovin.manifests.HLS.AudioMedia.create(
        manifest_id=hls_manifest.id, object_=audio_media).resource

    vtt_media = VttMedia(name='English subtitle',
                         group_id='subs',
                         vtt_url=VTT_URL,
                         uri="subtitles_en.m3u8",
                         language='en',
                         is_default=True)
    vtt_media = bitmovin.manifests.HLS.VttMedia.create(
        manifest_id=hls_manifest.id, object_=vtt_media).resource

    # Add all representation to the video adaption set
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile')
        stream = encoding_config.get('stream')
        muxing = encoding_config.get('ts_muxing')
        variant_stream = VariantStream(
            audio='audio',
            closed_captions='NONE',
            subtitles='subs',
            segment_path='video/hls/{}p_{}k/'.format(
                encoding_profile.get('height'),
                encoding_profile.get('bitrate')),
            uri='video_{}p_{}k.m3u8'.format(encoding_profile.get('height'),
                                            encoding_profile.get('bitrate')),
            encoding_id=encoding.id,
            stream_id=stream.id,
            muxing_id=muxing.id)
        variant_stream = bitmovin.manifests.HLS.VariantStream.create(
            manifest_id=hls_manifest.id, object_=variant_stream).resource

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.DASH.wait_until_finished(
            manifest_id=dash_manifest.id, check_interval=1)
    except BitmovinError as bitmovin_error:
        print(
            'Exception occurred while waiting for manifest creation to finish: {}'
            .format(bitmovin_error))
        exit(-1)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id,
                                                   check_interval=1)
    except BitmovinError as bitmovin_error:
        print(
            'Exception occurred while waiting for manifest creation to finish: {}'
            .format(bitmovin_error))
        exit(-1)
def generate_hls_manifest(output,
                          output_path,
                          encoding_configs,
                          encoding,
                          keyframes=None):
    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    # Specify the output for manifest.
    manifest_output = EncodingOutput(output_id=output.id,
                                     output_path=output_path,
                                     acl=[acl_entry])

    # Create a HLS manifest
    hls_manifest = HlsManifest(manifest_name='stream.m3u8',
                               outputs=[manifest_output],
                               name='HLS Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(hls_manifest).resource

    # Add all streams into the manifest
    for encoding_config in encoding_configs:
        encoding_type = encoding_config.get("type")
        encoding_profile = encoding_config.get("profile")
        muxing = encoding_config.get('muxing')
        stream = encoding_config.get('stream')
        segment_path = remove_output_base_path(muxing.outputs[0].outputPath,
                                               output_path)

        hls_media = None
        if encoding_type == 'audio':
            audio_media = AudioMedia(name='HLS Audio Media',
                                     group_id='audio',
                                     segment_path=segment_path,
                                     encoding_id=encoding.id,
                                     stream_id=stream.id,
                                     muxing_id=muxing.id,
                                     language='en',
                                     uri='audio.m3u8')
            hls_media = bitmovin.manifests.HLS.AudioMedia.create(
                manifest_id=hls_manifest.id, object_=audio_media).resource

        if encoding_type == 'video':
            variant_stream = VariantStream(
                audio='audio',
                closed_captions='NONE',
                segment_path=segment_path,
                uri='video_{}p_{}k.m3u8'.format(
                    encoding_profile.get('height'),
                    encoding_profile.get('bitrate')),
                encoding_id=encoding.id,
                stream_id=stream.id,
                muxing_id=muxing.id)
            hls_media = bitmovin.manifests.HLS.VariantStream.create(
                manifest_id=hls_manifest.id, object_=variant_stream).resource

        if keyframes:
            for keyframe in keyframes:
                insert_discontinuity(stream_type=encoding_type,
                                     manifest_id=hls_manifest.id,
                                     stream_or_media_id=hls_media.id,
                                     keyframe=keyframe)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id,
                                                   check_interval=1)
    except BitmovinError as bitmovin_error:
        print(
            'Exception occurred while waiting for manifest creation to finish: {}'
            .format(bitmovin_error))
        exit(-1)
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    s3_input = S3Input(access_key=S3_INPUT_ACCESSKEY,
                       secret_key=S3_INPUT_SECRETKEY,
                       bucket_name=S3_INPUT_BUCKETNAME,
                       name='Sample S3 Output')
    s3_input = bitmovin.inputs.S3.create(s3_input).resource

    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='Sample S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    encoding = Encoding(name='hls fairplay example encoding - {}'.format(date_component))
    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    video_codec_configuration_480p = H264CodecConfiguration(name='example_video_codec_configuration_480p',
                                                            bitrate=1200000,
                                                            rate=None,
                                                            height=480,
                                                            profile=H264Profile.HIGH)
    video_codec_configuration_480p = bitmovin.codecConfigurations.H264.create(video_codec_configuration_480p).resource

    video_codec_configuration_360p = H264CodecConfiguration(name='example_video_codec_configuration_360p',
                                                            bitrate=800000,
                                                            rate=None,
                                                            height=360,
                                                            profile=H264Profile.HIGH)
    video_codec_configuration_360p = bitmovin.codecConfigurations.H264.create(video_codec_configuration_360p).resource

    video_codec_configuration_240p = H264CodecConfiguration(name='example_video_codec_configuration_240p',
                                                            bitrate=400000,
                                                            rate=None,
                                                            height=240,
                                                            profile=H264Profile.HIGH)
    video_codec_configuration_240p = bitmovin.codecConfigurations.H264.create(video_codec_configuration_240p).resource

    audio_codec_configuration_stereo = AACCodecConfiguration(name='example_audio_codec_configuration_stereo',
                                                             bitrate=128000,
                                                             rate=48000)
    audio_codec_configuration_stereo = bitmovin.codecConfigurations.AAC.create(
        audio_codec_configuration_stereo).resource

    video_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)

    audio_input_stream_en_stereo = StreamInput(input_id=s3_input.id,
                                               input_path=S3_INPUT_PATH,
                                               selection_mode=SelectionMode.AUTO)

    video_stream_480p = Stream(codec_configuration_id=video_codec_configuration_480p.id,
                               input_streams=[video_input_stream],
                               name='Sample Stream 480p')
    video_stream_480p = bitmovin.encodings.Stream.create(object_=video_stream_480p,
                                                         encoding_id=encoding.id).resource

    video_stream_360p = Stream(codec_configuration_id=video_codec_configuration_360p.id,
                               input_streams=[video_input_stream],
                               name='Sample Stream 360p')
    video_stream_360p = bitmovin.encodings.Stream.create(object_=video_stream_360p,
                                                         encoding_id=encoding.id).resource

    video_stream_240p = Stream(codec_configuration_id=video_codec_configuration_240p.id,
                               input_streams=[video_input_stream],
                               name='Sample Stream 240p')
    video_stream_240p = bitmovin.encodings.Stream.create(object_=video_stream_240p,
                                                         encoding_id=encoding.id).resource

    audio_stream_en_stereo = Stream(codec_configuration_id=audio_codec_configuration_stereo.id,
                                    input_streams=[audio_input_stream_en_stereo],
                                    name='Sample Audio Stream EN Stereo')
    audio_stream_en_stereo = bitmovin.encodings.Stream.create(object_=audio_stream_en_stereo,
                                                              encoding_id=encoding.id).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    video_muxing_stream_480p = MuxingStream(video_stream_480p.id)
    video_muxing_stream_360p = MuxingStream(video_stream_360p.id)
    video_muxing_stream_240p = MuxingStream(video_stream_240p.id)

    audio_muxing_stream_en_stereo = MuxingStream(audio_stream_en_stereo.id)

    video_muxing_480p_output = EncodingOutput(output_id=s3_output.id,
                                              output_path=OUTPUT_BASE_PATH + 'video/hls/480p',
                                              acl=[acl_entry])
    video_muxing_480p = TSMuxing(segment_length=4,
                                 segment_naming='seg_%number%.ts',
                                 streams=[video_muxing_stream_480p],
                                 name='Sample Muxing 480p')
    video_muxing_480p = bitmovin.encodings.Muxing.TS.create(object_=video_muxing_480p,
                                                            encoding_id=encoding.id).resource

    fair_play_480p = FairPlayDRM(key=FAIRPLAY_KEY,
                                 iv=FAIRPLAY_IV,
                                 uri=FAIRPLAY_URI,
                                 outputs=[video_muxing_480p_output],
                                 name='FairPlay 480p')
    fair_play_480p = bitmovin.encodings.Muxing.TS.DRM.FairPlay.create(object_=fair_play_480p,
                                                                      encoding_id=encoding.id,
                                                                      muxing_id=video_muxing_480p.id).resource

    video_muxing_360p_output = EncodingOutput(output_id=s3_output.id,
                                              output_path=OUTPUT_BASE_PATH + 'video/hls/360p',
                                              acl=[acl_entry])
    video_muxing_360p = TSMuxing(segment_length=4,
                                 segment_naming='seg_%number%.ts',
                                 streams=[video_muxing_stream_360p],
                                 name='Sample Muxing 360p')
    video_muxing_360p = bitmovin.encodings.Muxing.TS.create(object_=video_muxing_360p,
                                                            encoding_id=encoding.id).resource
    fair_play_360p = FairPlayDRM(key=FAIRPLAY_KEY,
                                 iv=FAIRPLAY_IV,
                                 uri=FAIRPLAY_URI,
                                 outputs=[video_muxing_360p_output],
                                 name='FairPlay 360p')
    fair_play_360p = bitmovin.encodings.Muxing.TS.DRM.FairPlay.create(object_=fair_play_360p,
                                                                      encoding_id=encoding.id,
                                                                      muxing_id=video_muxing_360p.id).resource

    video_muxing_240p_output = EncodingOutput(output_id=s3_output.id,
                                              output_path=OUTPUT_BASE_PATH + 'video/hls/240p',
                                              acl=[acl_entry])
    video_muxing_240p = TSMuxing(segment_length=4,
                                 segment_naming='seg_%number%.ts',
                                 streams=[video_muxing_stream_240p],
                                 name='Sample Muxing 240p')
    video_muxing_240p = bitmovin.encodings.Muxing.TS.create(object_=video_muxing_240p,
                                                            encoding_id=encoding.id).resource

    fair_play_240p = FairPlayDRM(key=FAIRPLAY_KEY,
                                 iv=FAIRPLAY_IV,
                                 uri=FAIRPLAY_URI,
                                 outputs=[video_muxing_240p_output],
                                 name='FairPlay 240p')
    fair_play_240p = bitmovin.encodings.Muxing.TS.DRM.FairPlay.create(object_=fair_play_240p,
                                                                      encoding_id=encoding.id,
                                                                      muxing_id=video_muxing_240p.id).resource

    audio_muxing_output_en_stereo = EncodingOutput(output_id=s3_output.id,
                                                   output_path=OUTPUT_BASE_PATH + 'audio/hls/en_2_0',
                                                   acl=[acl_entry])
    audio_muxing_en_stereo = TSMuxing(segment_length=4,
                                      segment_naming='seg_%number%.ts',
                                      streams=[audio_muxing_stream_en_stereo],
                                      name='Sample Audio Muxing EN Stereo')
    audio_muxing_en_stereo = bitmovin.encodings.Muxing.TS.create(object_=audio_muxing_en_stereo,
                                                                 encoding_id=encoding.id).resource
    fair_play_audio = FairPlayDRM(key=FAIRPLAY_KEY,
                                  iv=FAIRPLAY_IV,
                                  uri=FAIRPLAY_URI,
                                  outputs=[audio_muxing_output_en_stereo],
                                  name='FairPlay Audio')

    fair_play_audio = bitmovin.encodings.Muxing.TS.DRM.FairPlay.create(object_=fair_play_audio,
                                                                       encoding_id=encoding.id,
                                                                       muxing_id=audio_muxing_en_stereo.id).resource

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(encoding_id=encoding.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for encoding to finish: {}".format(bitmovin_error))

    # Manifest ##

    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])
    hls_manifest = HlsManifest(manifest_name='example_manifest_hls.m3u8',
                               outputs=[manifest_output],
                               name='Sample HLS FairPlay Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(hls_manifest).resource

    audio_media = AudioMedia(name='Sample Audio Media',
                             group_id='audio_group',
                             segment_path=audio_muxing_output_en_stereo.outputPath,
                             encoding_id=encoding.id,
                             stream_id=audio_stream_en_stereo.id,
                             muxing_id=audio_muxing_en_stereo.id,
                             drm_id=fair_play_audio.id,
                             language='en',
                             uri='audiomedia.m3u8')

    audio_media = bitmovin.manifests.HLS.AudioMedia.create(manifest_id=hls_manifest.id, object_=audio_media).resource

    variant_stream_480p = VariantStream(audio=audio_media.groupId,
                                        closed_captions='NONE',
                                        segment_path=video_muxing_480p_output.outputPath,
                                        uri='video_480p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_480p.id,
                                        muxing_id=video_muxing_480p.id,
                                        drm_id=fair_play_480p.id)

    bitmovin.manifests.HLS.VariantStream.create(manifest_id=hls_manifest.id,
                                                object_=variant_stream_480p)

    variant_stream_360p = VariantStream(audio=audio_media.groupId,
                                        closed_captions='NONE',
                                        segment_path=video_muxing_360p_output.outputPath,
                                        uri='video_360p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_360p.id,
                                        muxing_id=video_muxing_360p.id,
                                        drm_id=fair_play_360p.id)

    bitmovin.manifests.HLS.VariantStream.create(manifest_id=hls_manifest.id,
                                                object_=variant_stream_360p)

    variant_stream_240p = VariantStream(audio=audio_media.groupId,
                                        closed_captions='NONE',
                                        segment_path=video_muxing_240p_output.outputPath,
                                        uri='video_240p.m3u8',
                                        encoding_id=encoding.id,
                                        stream_id=video_stream_240p.id,
                                        muxing_id=video_muxing_240p.id,
                                        drm_id=fair_play_240p.id)

    bitmovin.manifests.HLS.VariantStream.create(manifest_id=hls_manifest.id,
                                                object_=variant_stream_240p)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for HLS manifest creation to finish: {}".format(bitmovin_error))
def make_hls_manifest(bitmovin, manifest_spec, encoding, output,
                      video_encoding_configs, audio_encoding_configs,
                      number_of_audio_streams, audio_stream_languages):
    """
    Makes the HLS manifes. Adds all audio groups and stream variants.
    """
    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)
    manifest_output = EncodingOutput(output_id=output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])

    # Create a HLS H264 manifest and add one period with an adaptation set for audio and video
    hls_manifest = HlsManifest(manifest_name='stream.m3u8',
                               outputs=[manifest_output],
                               name='HLS H264 Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(object_=hls_manifest).resource

    audio_groups = []

    audio_profiles_for_manifest = get_audio_profiles_from_codecs(
        codecs=manifest_spec['audio_codecs'])

    for audio_group_index, audio_profie_spec in enumerate(
            audio_profiles_for_manifest):
        audio_codec = audio_profie_spec['codec']

        audio_group_id = 'audio_group_{}_{}'.format(audio_group_index,
                                                    audio_codec)
        audio_groups.append(audio_group_id)

        for stream_number in range(number_of_audio_streams):
            audio_stream_language = audio_stream_languages[stream_number]

            lang = audio_stream_language['lang']

            muxings = get_audio_muxings_from_configs(
                configs=audio_encoding_configs,
                stream_number=stream_number,
                manifest_type=HLS)

            for muxing_spec in muxings:
                muxing = muxing_spec['object_']

                segment_path = get_segment_output_path(
                    output_path=OUTPUT_BASE_PATH,
                    muxing_output_path=muxing.outputs[0].outputPath)

                hls_audio_media = AudioMedia(
                    name=lang,
                    group_id=audio_group_id,
                    segment_path=segment_path,
                    encoding_id=encoding.id,
                    stream_id=muxing.streams[0].streamId,
                    muxing_id=muxing.id,
                    language=lang,
                    uri="audio_{}_{}_{}.m3u8".format(audio_group_index,
                                                     stream_number, lang))

                bitmovin.manifests.HLS.AudioMedia.create(
                    manifest_id=hls_manifest.id, object_=hls_audio_media)

    for audio_group_id in audio_groups:
        for manifest_video_codec in manifest_spec['video_codecs']:
            muxings = get_video_muxings_from_configs(
                configs=video_encoding_configs,
                codec=manifest_video_codec,
                manifest_type=HLS)

            for muxing_spec in muxings:
                muxing = muxing_spec['object_']
                encoding_profile = muxing_spec['encoding_profile']

                segment_path = get_segment_output_path(
                    output_path=OUTPUT_BASE_PATH,
                    muxing_output_path=muxing.outputs[0].outputPath)

                # append another variant stream for this video quality to our hls renditions.
                hls_variant_stream = VariantStream(
                    audio=audio_group_id,
                    segment_path=segment_path,
                    uri='video_{}_{}.m3u8'.format(
                        encoding_profile.get('width'),
                        encoding_profile.get('bitrate')),
                    encoding_id=encoding.id,
                    stream_id=muxing.streams[0].streamId,
                    muxing_id=muxing.id)

                bitmovin.manifests.HLS.VariantStream.create(
                    manifest_id=hls_manifest.id, object_=hls_variant_stream)

    return hls_manifest
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    https_input = HTTPSInput(name='create_simple_encoding HTTPS input',
                             host=HTTPS_INPUT_HOST)
    https_input = bitmovin.inputs.HTTPS.create(https_input).resource

    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='Sample S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    encoding = Encoding(
        name='example hls progressive ts encoding with various id3 tags',
        cloud_region=CloudRegion.GOOGLE_EUROPE_WEST_1)

    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    video_codec_configuration_480p = H264CodecConfiguration(
        name='example_video_codec_configuration_480p',
        bitrate=1200000,
        height=480,
        profile=H264Profile.MAIN,
        rate=None)
    video_codec_configuration_480p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_480p).resource

    video_codec_configuration_360p = H264CodecConfiguration(
        name='example_video_codec_configuration_360p',
        bitrate=800000,
        height=360,
        profile=H264Profile.MAIN,
        rate=None)
    video_codec_configuration_360p = bitmovin.codecConfigurations.H264.create(
        video_codec_configuration_360p).resource

    audio_codec_configuration = AACCodecConfiguration(
        name='example_audio_codec_configuration_english',
        bitrate=128000,
        rate=44100)
    audio_codec_configuration = bitmovin.codecConfigurations.AAC.create(
        audio_codec_configuration).resource

    video_input_stream = StreamInput(input_id=https_input.id,
                                     input_path=HTTPS_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)
    audio_input_stream = StreamInput(input_id=https_input.id,
                                     input_path=HTTPS_INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)

    video_stream_480p = Stream(
        codec_configuration_id=video_codec_configuration_480p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 480p')
    video_stream_480p = bitmovin.encodings.Stream.create(
        object_=video_stream_480p, encoding_id=encoding.id).resource

    video_stream_360p = Stream(
        codec_configuration_id=video_codec_configuration_360p.id,
        input_streams=[video_input_stream],
        name='Sample Stream 360p')
    video_stream_360p = bitmovin.encodings.Stream.create(
        object_=video_stream_360p, encoding_id=encoding.id).resource

    audio_stream = Stream(codec_configuration_id=audio_codec_configuration.id,
                          input_streams=[audio_input_stream],
                          name='Sample Stream AUDIO')
    audio_stream = bitmovin.encodings.Stream.create(
        object_=audio_stream, encoding_id=encoding.id).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    video_muxing_stream_480p = MuxingStream(video_stream_480p.id)
    video_muxing_stream_360p = MuxingStream(video_stream_360p.id)
    audio_muxing_stream = MuxingStream(audio_stream.id)

    muxing_480p_path = '480p'
    muxing_480p_output = EncodingOutput(output_id=s3_output.id,
                                        output_path=OUTPUT_BASE_PATH +
                                        muxing_480p_path,
                                        acl=[acl_entry])
    muxing_480p = ProgressiveTSMuxing(
        segment_length=4,
        filename='progressive.ts',
        streams=[video_muxing_stream_480p, audio_muxing_stream],
        outputs=[muxing_480p_output],
        name='Sample Muxing 480p')
    muxing_480p = bitmovin.encodings.Muxing.ProgressiveTS.create(
        object_=muxing_480p, encoding_id=encoding.id).resource

    muxing_360p_path = '360p'
    muxing_360p_output = EncodingOutput(output_id=s3_output.id,
                                        output_path=OUTPUT_BASE_PATH +
                                        muxing_360p_path,
                                        acl=[acl_entry])
    muxing_360p = ProgressiveTSMuxing(
        segment_length=4,
        filename='progressive.ts',
        streams=[video_muxing_stream_360p, audio_muxing_stream],
        outputs=[muxing_360p_output],
        name='Sample Muxing 360p')
    muxing_360p = bitmovin.encodings.Muxing.ProgressiveTS.create(
        object_=muxing_360p, encoding_id=encoding.id).resource

    raw_id3_tag_1 = RawID3Tag(
        position_mode=ID3TagPositionMode.TIME,
        time=1.0,
        bytes_=base64.b64encode(b'My awesome Raw ID3 Tag #1').decode('utf-8'),
        name='Raw ID3 #1',
        description='Just some descriptive information')

    raw_id3_tag_2 = RawID3Tag(
        position_mode=ID3TagPositionMode.TIME,
        time=2.0,
        bytes_=base64.b64encode(b'My awesome Raw ID3 Tag #2').decode('utf-8'),
        name='Raw ID3 #2',
        description='Just some descriptive information')

    frame_id_id3_tag_1 = FrameIdID3Tag(
        position_mode=ID3TagPositionMode.TIME,
        time=5.12,
        frame_id='ABCD',
        bytes_=base64.b64encode(b'My awesome FrameId ID3 Tag #1').decode(
            'utf-8'),
        name='FrameId ID3 #1',
        description='Just some descriptive information')

    frame_id_id3_tag_2 = FrameIdID3Tag(
        position_mode=ID3TagPositionMode.TIME,
        time=6.3422172,
        frame_id='EFGH',
        bytes_=base64.b64encode(b'My awesome FrameId ID3 Tag #2').decode(
            'utf-8'),
        name='FrameId ID3 #2',
        description='Just some descriptive information')

    plain_text_id3_tag_1 = PlainTextID3Tag(
        position_mode=ID3TagPositionMode.TIME,
        time=8.34,
        frame_id='IJKL',
        text='My awesome PlainText ID3 Tag #1',
        name='PlainText ID3 #1',
        description='Just some descriptive information')

    plain_text_id3_tag_2 = PlainTextID3Tag(
        position_mode=ID3TagPositionMode.TIME,
        time=9.013,
        frame_id='MNOP',
        text='My awesome PlainText ID3 Tag #2',
        name='PlainText ID3 #2',
        description='Just some descriptive information')

    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.Raw.create(
        object_=raw_id3_tag_1,
        encoding_id=encoding.id,
        muxing_id=muxing_360p.id)
    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.Raw.create(
        object_=raw_id3_tag_1,
        encoding_id=encoding.id,
        muxing_id=muxing_480p.id)
    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.Raw.create(
        object_=raw_id3_tag_2,
        encoding_id=encoding.id,
        muxing_id=muxing_360p.id)
    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.Raw.create(
        object_=raw_id3_tag_2,
        encoding_id=encoding.id,
        muxing_id=muxing_480p.id)

    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.FrameId.create(
        object_=frame_id_id3_tag_1,
        encoding_id=encoding.id,
        muxing_id=muxing_360p.id)
    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.FrameId.create(
        object_=frame_id_id3_tag_1,
        encoding_id=encoding.id,
        muxing_id=muxing_480p.id)
    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.FrameId.create(
        object_=frame_id_id3_tag_2,
        encoding_id=encoding.id,
        muxing_id=muxing_360p.id)
    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.FrameId.create(
        object_=frame_id_id3_tag_2,
        encoding_id=encoding.id,
        muxing_id=muxing_480p.id)

    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.PlainText.create(
        object_=plain_text_id3_tag_1,
        encoding_id=encoding.id,
        muxing_id=muxing_360p.id)
    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.PlainText.create(
        object_=plain_text_id3_tag_1,
        encoding_id=encoding.id,
        muxing_id=muxing_480p.id)
    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.PlainText.create(
        object_=plain_text_id3_tag_2,
        encoding_id=encoding.id,
        muxing_id=muxing_360p.id)
    bitmovin.encodings.Muxing.ProgressiveTS.ID3Tags.PlainText.create(
        object_=plain_text_id3_tag_2,
        encoding_id=encoding.id,
        muxing_id=muxing_480p.id)

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(
            encoding_id=encoding.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for encoding to finish: {}".
              format(bitmovin_error))

    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])

    hls_manifest = HlsManifest(
        manifest_name='master.m3u8',
        outputs=[manifest_output],
        name='Sample HLS Manifest - Master - ProgressiveTS+ID3')
    hls_manifest = bitmovin.manifests.HLS.create(object_=hls_manifest).resource

    variant_stream_480p = VariantStream(
        closed_captions='NONE',
        segment_path='{}/'.format(muxing_480p_path),
        uri='480p.m3u8',
        encoding_id=encoding.id,
        stream_id=video_stream_480p.id,
        muxing_id=muxing_480p.id)

    variant_stream_480p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_480p)

    variant_stream_360p = VariantStream(
        closed_captions='NONE',
        segment_path='{}/'.format(muxing_360p_path),
        uri='360p.m3u8',
        encoding_id=encoding.id,
        stream_id=video_stream_360p.id,
        muxing_id=muxing_360p.id)

    variant_stream_360p = bitmovin.manifests.HLS.VariantStream.create(
        manifest_id=hls_manifest.id, object_=variant_stream_360p)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id)
    except BitmovinError as bitmovin_error:
        print(
            "Exception occurred while waiting for HLS manifest creation to finish: {}"
            .format(bitmovin_error))
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    # Create an S3 input. This resource is then used as base bucket for the input file.
    s3_input = S3Input(access_key=S3_INPUT_ACCESSKEY,
                       secret_key=S3_INPUT_SECRETKEY,
                       bucket_name=S3_INPUT_BUCKETNAME,
                       name='S3 Input')
    s3_input = bitmovin.inputs.S3.create(s3_input).resource

    # Create an S3 Output. This will be used as target bucket for the muxings, sprites and manifests
    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    # Create an Encoding. This will run in AWS_EU_WEST_1. This is the base entity used to configure the encoding.
    encoding = Encoding(name='Encoding with text filter',
                        cloud_region=CloudRegion.AWS_EU_WEST_1)

    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    encoding_configs = []

    # Iterate over all encoding profiles and create the H264 configuration with the defined height and bitrate.
    for idx, _ in enumerate(encoding_profiles_h264):
        profile_h264 = encoding_profiles_h264[idx]
        encoding_config = dict(profile_h264=profile_h264)
        h264_codec = H264CodecConfiguration(
            name='H264 Codec {}p {}k Configuration'.format(
                profile_h264.get('height'), profile_h264.get('bitrate')),
            bitrate=profile_h264.get('bitrate') * 1000,
            height=profile_h264.get('height'),
            profile=profile_h264.get('profile'),
            rate=profile_h264.get('fps'))
        encoding_config[
            'h264_codec'] = bitmovin.codecConfigurations.H264.create(
                h264_codec).resource
        encoding_configs.append(encoding_config)

    # Also the AAC configuration has to be created, which will be later on used to create the streams.
    audio_codec_configuration = AACCodecConfiguration(
        name='AAC Codec Configuration', bitrate=128000, rate=48000)
    audio_codec_configuration = bitmovin.codecConfigurations.AAC.create(
        audio_codec_configuration).resource

    video_input_stream = StreamInput(
        input_id=s3_input.id,
        input_path=S3_INPUT_PATH,
        selection_mode=SelectionMode.VIDEO_RELATIVE,
        position=0)

    audio_input_stream = StreamInput(
        input_id=s3_input.id,
        input_path=S3_INPUT_PATH,
        selection_mode=SelectionMode.AUDIO_RELATIVE,
        position=0)

    # Configure text filter here
    text_filter = TextFilter(name='Text Filter',
                             text='Bitmovin is great!',
                             x='main_w/2-text_w/2',
                             y='10',
                             font_color='#FFFFFF',
                             font_size=48,
                             box=True,
                             box_color='#32A9E1',
                             shadow_color='#218ECD',
                             shadow_x=5,
                             shadow_y=5,
                             font=Font.DEJAVUSANS)

    text_filter = bitmovin.filters.Text.create(object_=text_filter).resource

    stream_filter = [StreamFilter(id=text_filter.id, position=0)]

    # With the configurations and the input file streams are now created and muxed later on.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile_h264')

        video_stream_h264 = Stream(
            codec_configuration_id=encoding_config.get('h264_codec').id,
            input_streams=[video_input_stream],
            name='Stream H264 {}p_{}k'.format(encoding_profile.get('height'),
                                              encoding_profile.get('bitrate')))

        encoding_config['h264_stream'] = bitmovin.encodings.Stream.create(
            object_=video_stream_h264, encoding_id=encoding.id).resource

        bitmovin.encodings.Stream.Filter.create(
            encoding_id=encoding.id,
            stream_id=encoding_config['h264_stream'].id,
            stream_filter=stream_filter)

    audio_stream = Stream(codec_configuration_id=audio_codec_configuration.id,
                          input_streams=[audio_input_stream],
                          name='Audio Stream')
    audio_stream = bitmovin.encodings.Stream.create(
        object_=audio_stream, encoding_id=encoding.id).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    # Create TS and FMP4 muxings which are later used for the HLS and DASH manifest. The current settings will set a
    # segment length of 4 seconds.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile_h264')
        video_muxing_stream_h264 = MuxingStream(
            encoding_config.get('h264_stream').id)
        video_muxing_output_h264 = EncodingOutput(
            output_id=s3_output.id,
            output_path=OUTPUT_BASE_PATH +
            'video/h264/dash/{}p_{}k/'.format(encoding_profile.get('height'),
                                              encoding_profile.get('bitrate')),
            acl=[acl_entry])
        video_muxing_h264 = FMP4Muxing(segment_length=4,
                                       segment_naming='seg_%number%.m4s',
                                       init_segment_name='init.mp4',
                                       streams=[video_muxing_stream_h264],
                                       outputs=[video_muxing_output_h264],
                                       name='FMP4 H264 Muxing {}p_{}k'.format(
                                           encoding_profile.get('height'),
                                           encoding_profile.get('bitrate')))
        encoding_config['h264_muxing'] = bitmovin.encodings.Muxing.FMP4.create(
            object_=video_muxing_h264, encoding_id=encoding.id).resource

        video_ts_muxing_output_h264 = EncodingOutput(
            output_id=s3_output.id,
            output_path=OUTPUT_BASE_PATH +
            'video/h264/hls/{}p_{}k/'.format(encoding_profile.get('height'),
                                             encoding_profile.get('bitrate')),
            acl=[acl_entry])
        video_ts_muxing_h264 = TSMuxing(segment_length=4,
                                        segment_naming='seg_%number%.ts',
                                        streams=[video_muxing_stream_h264],
                                        outputs=[video_ts_muxing_output_h264],
                                        name='FMP4 H264 Muxing {}p_{}k'.format(
                                            encoding_profile.get('height'),
                                            encoding_profile.get('bitrate')))
        encoding_config[
            'h264_ts_muxing'] = bitmovin.encodings.Muxing.TS.create(
                object_=video_ts_muxing_h264, encoding_id=encoding.id).resource

    audio_muxing_stream = MuxingStream(audio_stream.id)

    # mp4 audio muxing
    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH +
                                         'audio/dash/',
                                         acl=[acl_entry])
    audio_muxing = FMP4Muxing(segment_length=4,
                              segment_naming='seg_%number%.m4s',
                              init_segment_name='init.mp4',
                              streams=[audio_muxing_stream],
                              outputs=[audio_muxing_output],
                              name='Audio Dash Muxing')
    audio_muxing = bitmovin.encodings.Muxing.FMP4.create(
        object_=audio_muxing, encoding_id=encoding.id).resource

    # TS audio muxing
    hls_audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                             output_path=OUTPUT_BASE_PATH +
                                             'audio/hls/',
                                             acl=[acl_entry])
    hls_audio_muxing = TSMuxing(segment_length=4,
                                segment_naming='seg_%number%.ts',
                                streams=[audio_muxing_stream],
                                outputs=[hls_audio_muxing_output],
                                name='Audio TS Muxing')
    hls_audio_muxing = bitmovin.encodings.Muxing.TS.create(
        object_=hls_audio_muxing, encoding_id=encoding.id).resource

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(
            encoding_id=encoding.id)
    except BitmovinError as bitmovin_error:
        print('Exception occurred while waiting for encoding to finish:')
        pprint(bitmovin_error)
        exit(-1)

    # Specify the output for manifest which will be in the OUTPUT_BASE_PATH.
    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])

    # Create a DASH H264 manifest and add one period with an adaptation set for audio and video
    dash_manifest_h264 = DashManifest(manifest_name='stream.mpd',
                                      outputs=[manifest_output],
                                      name='DASH H264 Manifest')
    dash_manifest_h264 = bitmovin.manifests.DASH.create(
        dash_manifest_h264).resource
    period_h264 = Period()
    period_h264 = bitmovin.manifests.DASH.add_period(
        object_=period_h264, manifest_id=dash_manifest_h264.id).resource
    video_adaptation_set_h264 = VideoAdaptationSet()
    video_adaptation_set_h264 = bitmovin.manifests.DASH.add_video_adaptation_set(
        object_=video_adaptation_set_h264,
        manifest_id=dash_manifest_h264.id,
        period_id=period_h264.id).resource

    audio_adaptation_set_h264 = AudioAdaptationSet(lang='en')
    audio_adaptation_set_h264 = bitmovin.manifests.DASH.add_audio_adaptation_set(
        object_=audio_adaptation_set_h264,
        manifest_id=dash_manifest_h264.id,
        period_id=period_h264.id).resource

    fmp4_representation_audio = FMP4Representation(
        FMP4RepresentationType.TEMPLATE,
        encoding_id=encoding.id,
        muxing_id=audio_muxing.id,
        segment_path='audio/dash/')

    bitmovin.manifests.DASH.add_fmp4_representation(
        object_=fmp4_representation_audio,
        manifest_id=dash_manifest_h264.id,
        period_id=period_h264.id,
        adaptationset_id=audio_adaptation_set_h264.id)

    # Add all representation to the video adaption set
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile_h264')
        muxing = encoding_config.get('h264_muxing')
        fmp4_representation = FMP4Representation(
            FMP4RepresentationType.TEMPLATE,
            encoding_id=encoding.id,
            muxing_id=muxing.id,
            segment_path='video/h264/dash/{}p_{}k/'.format(
                encoding_profile.get('height'),
                encoding_profile.get('bitrate')))
        encoding_config[
            'h264_dash'] = bitmovin.manifests.DASH.add_fmp4_representation(
                object_=fmp4_representation,
                manifest_id=dash_manifest_h264.id,
                period_id=period_h264.id,
                adaptationset_id=video_adaptation_set_h264.id).resource

    bitmovin.manifests.DASH.start(manifest_id=dash_manifest_h264.id)

    # Create a HLS H264 manifest and add one period with an adaptation set for audio and video
    hls_manifest = HlsManifest(manifest_name='stream.m3u8',
                               outputs=[manifest_output],
                               name='HLS H264 Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(object_=hls_manifest).resource

    hls_audio_media = AudioMedia(name='en',
                                 group_id='audio_group',
                                 segment_path='audio/hls/',
                                 encoding_id=encoding.id,
                                 stream_id=audio_stream.id,
                                 muxing_id=hls_audio_muxing.id,
                                 language='en',
                                 uri='audio.m3u8')

    bitmovin.manifests.HLS.AudioMedia.create(manifest_id=hls_manifest.id,
                                             object_=hls_audio_media)

    # Add all representation to the video adaption set
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile_h264')
        video_muxing_stream_h264 = encoding_config.get('h264_stream')
        ts_muxing = encoding_config.get('h264_ts_muxing')

        # append another variant stream for this video quality to our hls renditions.
        hls_variant_stream = VariantStream(
            audio='audio_group',
            segment_path='video/h264/hls/{}p_{}k/'.format(
                encoding_profile.get('height'),
                encoding_profile.get('bitrate')),
            uri='video_{}p_{}.m3u8'.format(encoding_profile.get('height'),
                                           encoding_profile.get('bitrate')),
            encoding_id=encoding.id,
            stream_id=video_muxing_stream_h264.id,
            muxing_id=ts_muxing.id)

        bitmovin.manifests.HLS.VariantStream.create(
            manifest_id=hls_manifest.id, object_=hls_variant_stream)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.DASH.wait_until_finished(
            manifest_id=dash_manifest_h264.id)
    except BitmovinError as bitmovin_error:
        print(
            'Exception occurred while waiting for manifest creation to finish: {}'
            .format(bitmovin_error))
        exit(-1)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id)
    except BitmovinError as bitmovin_error:
        print(
            'Exception occurred while waiting for manifest creation to finish: {}'
            .format(bitmovin_error))
        exit(-1)
def main():
    bitmovin = Bitmovin(api_key=API_KEY)

    # Create an S3 input. This resource is then used as base bucket for the input file.
    s3_input = S3Input(access_key=S3_INPUT_ACCESSKEY,
                       secret_key=S3_INPUT_SECRETKEY,
                       bucket_name=S3_INPUT_BUCKETNAME,
                       name='S3 Input')
    s3_input = bitmovin.inputs.S3.create(s3_input).resource

    # Create an S3 Output. This will be used as target bucket for the muxings, sprites and manifests
    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    # Create an Encoding. This will run in AWS_EU_WEST_1. This is the base entity used to configure the encoding.
    encoding = Encoding(name='Encoding with video/audio and stream condition',
                        cloud_region=CloudRegion.AWS_EU_WEST_1)

    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    encoding_configs = []

    # Iterate over all encoding profiles and create the H264 configuration with the defined height and bitrate.
    for idx, _ in enumerate(encoding_profiles_h264):
        profile_h264 = encoding_profiles_h264[idx]
        encoding_config = dict(profile_h264=profile_h264)
        h264_codec_height = H264CodecConfiguration(
            name='H264 Codec {}p {}k Configuration'.format(profile_h264.get('height'),
                                                           profile_h264.get('bitrate')),
            bitrate=profile_h264.get('bitrate') * 1000,
            height=profile_h264.get('height'),
            profile=profile_h264.get('profile'),
            rate=profile_h264.get("fps"))
        encoding_config['h264_codec_ar_gt_1'] = bitmovin.codecConfigurations.H264.create(h264_codec_height).resource
        h264_codec_height_landscape = H264CodecConfiguration(
            name='H264 Codec {}p {}k Configuration'.format(profile_h264.get('height'),
                                                           profile_h264.get('bitrate')),
            bitrate=profile_h264.get('bitrate') * 1000,
            height=profile_h264.get('height_landscape'),
            profile=profile_h264.get('profile'),
            rate=profile_h264.get("fps"))
        encoding_config['h264_codec_ar_lt_1'] = bitmovin.codecConfigurations.H264.create(h264_codec_height_landscape).resource
        encoding_configs.append(encoding_config)

    # Also the AAC configuration has to be created, which will be later on used to create the streams.
    audio_codec_configuration = AACCodecConfiguration(name='AAC Codec Configuration',
                                                      bitrate=128000,
                                                      rate=48000)
    audio_codec_configuration = bitmovin.codecConfigurations.AAC.create(audio_codec_configuration).resource

    video_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_PATH,
                                     selection_mode=SelectionMode.VIDEO_RELATIVE,
                                     position=0)

    audio_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=S3_INPUT_PATH,
                                     selection_mode=SelectionMode.AUDIO_RELATIVE,
                                     position=0)

    # With the configurations and the input file streams are now created and muxed later on.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get("profile_h264")
        video_stream_condition_ar_gt_1 = Condition(attribute="ASPECTRATIO", operator=">=", value="1")
        video_stream_h264 = Stream(codec_configuration_id=encoding_config.get("h264_codec_ar_gt_1").id,
                                   input_streams=[video_input_stream],
                                   conditions=video_stream_condition_ar_gt_1,
                                   name='Stream H264 {}p_{}k'.format(encoding_profile.get('height'),
                                                                     encoding_profile.get('bitrate')))
        encoding_config['h264_stream_ar_gt_1'] = bitmovin.encodings.Stream.create(object_=video_stream_h264,
                                                                                  encoding_id=encoding.id).resource
        video_stream_condition_ar_lt_1 = Condition(attribute="ASPECTRATIO", operator="<", value="1")
        video_stream_h264 = Stream(codec_configuration_id=encoding_config.get("h264_codec_ar_lt_1").id,
                                   input_streams=[video_input_stream],
                                   conditions=video_stream_condition_ar_lt_1,
                                   name='Stream H264 {}p_{}k'.format(encoding_profile.get('height'),
                                                                     encoding_profile.get('bitrate')))
        encoding_config['h264_stream_ar_lt_1'] = bitmovin.encodings.Stream.create(object_=video_stream_h264,
                                                                                  encoding_id=encoding.id).resource

    audio_stream_condition = Condition(attribute="INPUTSTREAM", operator="==", value="TRUE")
    audio_stream = Stream(codec_configuration_id=audio_codec_configuration.id,
                          input_streams=[audio_input_stream],
                          conditions=audio_stream_condition,
                          name='Audio Stream')
    audio_stream = bitmovin.encodings.Stream.create(object_=audio_stream, encoding_id=encoding.id).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    # Create FMP4 muxings which are later used for the DASH manifest. The current settings will set a segment length
    # of 4 seconds.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get("profile_h264")
        video_muxing_stream_h264_ar_gt_1 = MuxingStream(encoding_config.get("h264_stream_ar_gt_1").id)
        video_muxing_output_h264 = EncodingOutput(output_id=s3_output.id,
                                                  output_path=OUTPUT_BASE_PATH + 'video/h264/dash/{}p_{}k/'.format(
                                                      encoding_profile.get('height'),
                                                      encoding_profile.get('bitrate')),
                                                  acl=[acl_entry])
        video_muxing_h264_ar_gt_1 = FMP4Muxing(segment_length=4,
                                               segment_naming='seg_%number%.m4s',
                                               init_segment_name='init.mp4',
                                               streams=[video_muxing_stream_h264_ar_gt_1],
                                               outputs=[video_muxing_output_h264],
                                               name='FMP4 H264 Muxing {}p_{}k'.format(encoding_profile.get('height'),
                                                                                      encoding_profile.get('bitrate')))
        encoding_config['h264_muxing_ar_gt_1'] = bitmovin.encodings.Muxing.FMP4.create(
            object_=video_muxing_h264_ar_gt_1,
            encoding_id=encoding.id).resource

        video_ts_muxing_output_h264 = EncodingOutput(output_id=s3_output.id,
                                                     output_path=OUTPUT_BASE_PATH + 'video/h264/hls/{}p_{}k/'.format(
                                                         encoding_profile.get('height'),
                                                         encoding_profile.get('bitrate')),
                                                     acl=[acl_entry])
        video_ts_muxing_h264_ar_gt_1 = TSMuxing(segment_length=4,
                                                segment_naming='seg_%number%.ts',
                                                streams=[video_muxing_stream_h264_ar_gt_1],
                                                outputs=[video_ts_muxing_output_h264],
                                                name='FMP4 H264 Muxing {}p_{}k'.format(encoding_profile.get('height'),
                                                                                       encoding_profile.get('bitrate')))
        encoding_config['h264_ts_muxing_ar_gt_1'] = bitmovin.encodings.Muxing.TS.create(
            object_=video_ts_muxing_h264_ar_gt_1,
            encoding_id=encoding.id).resource

        video_muxing_stream_h264_ar_lt_1 = MuxingStream(encoding_config.get("h264_stream_ar_lt_1").id)
        video_muxing_output_h264 = EncodingOutput(output_id=s3_output.id,
                                                  output_path=OUTPUT_BASE_PATH + 'video/h264/dash/{}p_{}k/'.format(
                                                      encoding_profile.get('height'),
                                                      encoding_profile.get('bitrate')),
                                                  acl=[acl_entry])
        video_muxing_h264_ar_lt_1 = FMP4Muxing(segment_length=4,
                                               segment_naming='seg_%number%.m4s',
                                               init_segment_name='init.mp4',
                                               streams=[video_muxing_stream_h264_ar_lt_1],
                                               outputs=[video_muxing_output_h264],
                                               name='FMP4 H264 Muxing {}p_{}k'.format(encoding_profile.get('height'),
                                                                                      encoding_profile.get('bitrate')))
        encoding_config['h264_muxing_ar_lt_1'] = bitmovin.encodings.Muxing.FMP4.create(
            object_=video_muxing_h264_ar_lt_1,
            encoding_id=encoding.id).resource

        video_ts_muxing_output_h264 = EncodingOutput(output_id=s3_output.id,
                                                     output_path=OUTPUT_BASE_PATH + 'video/h264/hls/{}p_{}k/'.format(
                                                         encoding_profile.get('height'),
                                                         encoding_profile.get('bitrate')),
                                                     acl=[acl_entry])
        video_ts_muxing_h264_ar_lt_1 = TSMuxing(segment_length=4,
                                                segment_naming='seg_%number%.ts',
                                                streams=[video_muxing_stream_h264_ar_lt_1],
                                                outputs=[video_ts_muxing_output_h264],
                                                name='FMP4 H264 Muxing {}p_{}k'.format(encoding_profile.get('height'),
                                                                                       encoding_profile.get('bitrate')))
        encoding_config['h264_ts_muxing_ar_lt_1'] = bitmovin.encodings.Muxing.TS.create(
            object_=video_ts_muxing_h264_ar_lt_1,
            encoding_id=encoding.id).resource

    audio_muxing_stream = MuxingStream(audio_stream.id)

    # mp4 audio muxing
    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH + "audio/dash/",
                                         acl=[acl_entry])
    audio_muxing = FMP4Muxing(segment_length=4,
                              segment_naming='seg_%number%.m4s',
                              init_segment_name='init.mp4',
                              streams=[audio_muxing_stream],
                              outputs=[audio_muxing_output],
                              name='Audio Dash Muxing')
    audio_muxing = bitmovin.encodings.Muxing.FMP4.create(object_=audio_muxing,
                                                         encoding_id=encoding.id).resource

    # TS audio muxing
    hls_audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                             output_path=OUTPUT_BASE_PATH + "audio/hls/",
                                             acl=[acl_entry])
    hls_audio_muxing = TSMuxing(segment_length=4,
                                segment_naming='seg_%number%.ts',
                                streams=[audio_muxing_stream],
                                outputs=[hls_audio_muxing_output],
                                name='Audio TS Muxing')
    hls_audio_muxing = bitmovin.encodings.Muxing.TS.create(object_=hls_audio_muxing,
                                                           encoding_id=encoding.id).resource

    bitmovin.encodings.Encoding.start(encoding_id=encoding.id)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(encoding_id=encoding.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for encoding to finish:")
        pprint(bitmovin_error)
        exit(-1)

    # Specify the output for manifest which will be in the OUTPUT_BASE_PATH.
    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])

    # Create a DASH H264 manifest and add one period with an adaptation set for audio and video
    dash_manifest_h264 = DashManifest(manifest_name='stream.mpd',
                                      outputs=[manifest_output],
                                      name='DASH H264 Manifest')
    dash_manifest_h264 = bitmovin.manifests.DASH.create(dash_manifest_h264).resource
    period_h264 = Period()
    period_h264 = bitmovin.manifests.DASH.add_period(object_=period_h264, manifest_id=dash_manifest_h264.id).resource
    video_adaptation_set_h264 = VideoAdaptationSet()
    video_adaptation_set_h264 = bitmovin.manifests.DASH.add_video_adaptation_set(object_=video_adaptation_set_h264,
                                                                                 manifest_id=dash_manifest_h264.id,
                                                                                 period_id=period_h264.id).resource

    audio_adaptation_set_h264 = AudioAdaptationSet(lang='en')
    audio_adaptation_set_h264 = bitmovin.manifests.DASH.add_audio_adaptation_set(object_=audio_adaptation_set_h264,
                                                                                 manifest_id=dash_manifest_h264.id,
                                                                                 period_id=period_h264.id).resource

    fmp4_representation_audio = FMP4Representation(FMP4RepresentationType.TEMPLATE,
                                                   encoding_id=encoding.id,
                                                   muxing_id=audio_muxing.id,
                                                   segment_path="audio/dash/")

    bitmovin.manifests.DASH.add_fmp4_representation(object_=fmp4_representation_audio,
                                                    manifest_id=dash_manifest_h264.id,
                                                    period_id=period_h264.id,
                                                    adaptationset_id=audio_adaptation_set_h264.id)

    # Add all representation to the video adaption set
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get("profile_h264")
        h264_muxing_ar_gt_1 = encoding_config.get('h264_muxing_ar_gt_1')
        fmp4_representation = FMP4Representation(FMP4RepresentationType.TEMPLATE,
                                                 encoding_id=encoding.id,
                                                 muxing_id=h264_muxing_ar_gt_1.id,
                                                 segment_path='video/h264/dash/{}p_{}k/'.format(
                                                     encoding_profile.get('height'),
                                                     encoding_profile.get('bitrate')))
        encoding_config['h264_dash'] = bitmovin.manifests.DASH.add_fmp4_representation(
            object_=fmp4_representation,
            manifest_id=dash_manifest_h264.id,
            period_id=period_h264.id,
            adaptationset_id=video_adaptation_set_h264.id
        ).resource
        h264_muxing_ar_lt_1 = encoding_config.get('h264_muxing_ar_lt_1')
        fmp4_representation = FMP4Representation(FMP4RepresentationType.TEMPLATE,
                                                 encoding_id=encoding.id,
                                                 muxing_id=h264_muxing_ar_lt_1.id,
                                                 segment_path='video/h264/dash/{}p_{}k/'.format(
                                                     encoding_profile.get('height'),
                                                     encoding_profile.get('bitrate')))
        encoding_config['h264_dash'] = bitmovin.manifests.DASH.add_fmp4_representation(
            object_=fmp4_representation,
            manifest_id=dash_manifest_h264.id,
            period_id=period_h264.id,
            adaptationset_id=video_adaptation_set_h264.id
        ).resource

    bitmovin.manifests.DASH.start(manifest_id=dash_manifest_h264.id)

    # Create a HLS H264 manifest and add one period with an adaptation set for audio and video
    hls_manifest = HlsManifest(manifest_name='stream.m3u8',
                               outputs=[manifest_output],
                               name='HLS H264 Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(object_=hls_manifest).resource

    hls_audio_media = AudioMedia(name='en', group_id='audio_group',
                                 segment_path="audio/hls/",
                                 encoding_id=encoding.id,
                                 stream_id=audio_stream.id,
                                 muxing_id=hls_audio_muxing.id,
                                 language='en',
                                 uri="audio.m3u8")

    bitmovin.manifests.HLS.AudioMedia.create(manifest_id=hls_manifest.id,
                                             object_=hls_audio_media)

    # Add all representation to the video adaption set
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get("profile_h264")
        video_muxing_stream_h264_ar_gt_1 = encoding_config.get("h264_stream_ar_gt_1")
        ts_muxing_ar_gt_1 = encoding_config.get('h264_ts_muxing_ar_gt_1')

        # append another variant stream for this video quality to our hls renditions.
        hls_variant_stream = VariantStream(audio="audio_group",
                                           segment_path='video/h264/hls/{}p_{}k/'.format(
                                               encoding_profile.get('height'),
                                               encoding_profile.get('bitrate')),
                                           uri='video_{}p_{}.m3u8'.format(
                                               encoding_profile.get('height'),
                                               encoding_profile.get('bitrate')),
                                           encoding_id=encoding.id,
                                           stream_id=video_muxing_stream_h264_ar_gt_1.id,
                                           muxing_id=ts_muxing_ar_gt_1.id)

        bitmovin.manifests.HLS.VariantStream.create(manifest_id=hls_manifest.id,
                                                    object_=hls_variant_stream)
        
        video_muxing_stream_h264_ar_lt_1 = encoding_config.get("h264_stream_ar_lt_1")
        ts_muxing_ar_lt_1 = encoding_config.get('h264_ts_muxing_ar_lt_1')

        # append another variant stream for this video quality to our hls renditions.
        hls_variant_stream = VariantStream(audio="audio_group",
                                           segment_path='video/h264/hls/{}p_{}k/'.format(
                                               encoding_profile.get('height'),
                                               encoding_profile.get('bitrate')),
                                           uri='video_{}p_{}.m3u8'.format(
                                               encoding_profile.get('height'),
                                               encoding_profile.get('bitrate')),
                                           encoding_id=encoding.id,
                                           stream_id=video_muxing_stream_h264_ar_lt_1.id,
                                           muxing_id=ts_muxing_ar_lt_1.id)

        bitmovin.manifests.HLS.VariantStream.create(manifest_id=hls_manifest.id,
                                                    object_=hls_variant_stream)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.DASH.wait_until_finished(manifest_id=dash_manifest_h264.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for manifest creation to finish: {}".format(bitmovin_error))
        exit(-1)

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for manifest creation to finish: {}".format(bitmovin_error))
        exit(-1)
예제 #19
0
def main():
    # Create an S3 input. This resource is then used as base to acquire input files.
    s3_input = S3Input(access_key=S3_INPUT_ACCESS_KEY,
                       secret_key=S3_INPUT_SECRET_KEY,
                       bucket_name=S3_INPUT_BUCKET_NAME,
                       name='Test S3 Input')

    s3_input = bitmovin.inputs.S3.create(s3_input).resource

    # Create an S3 Output. This will be used as target bucket for the muxings, sprites and manifests
    s3_output = S3Output(access_key=S3_OUTPUT_ACCESSKEY,
                         secret_key=S3_OUTPUT_SECRETKEY,
                         bucket_name=S3_OUTPUT_BUCKETNAME,
                         name='Test S3 Output')
    s3_output = bitmovin.outputs.S3.create(s3_output).resource

    acl_entry = ACLEntry(permission=ACLPermission.PUBLIC_READ)

    # Create DRM resources
    widevine_drm = CENCWidevineEntry(pssh=CENC_WIDEVINE_PSSH)
    playready_drm = CENCPlayReadyEntry(la_url=CENC_PLAYREADY_LA_URL)

    # Create an Encoding. This is the base entity used to configure the encoding.
    encoding = Encoding(name='Constrained Per-title encoding test',
                        cloud_region=CloudRegion.AUTO,
                        encoder_version=EncoderVersion.BETA)

    encoding = bitmovin.encodings.Encoding.create(encoding).resource

    encoding_configs = []

    # Iterate over all encoding profiles and create the H264 configuration.
    # As we are using per-title, we do not define bitrates, instead just providing the target height as indicator
    for idx, _ in enumerate(encoding_profiles_h264):
        profile_h264 = encoding_profiles_h264[idx]
        encoding_config = dict(profile_h264=profile_h264)
        h264_codec = H264CodecConfiguration(
            name='Sample video codec configuration',
            profile=H264Profile.HIGH,
            height=profile_h264.get("height")
        )
        encoding_config['h264_codec'] = bitmovin.codecConfigurations.H264.create(h264_codec).resource
        encoding_configs.append(encoding_config)

    # Also the AAC configuration has to be created, which will be later on used to create the streams.
    audio_codec_configuration = AACCodecConfiguration(name='AAC Codec Configuration',
                                                      bitrate=128000,
                                                      rate=48000)

    audio_codec_configuration = bitmovin.codecConfigurations.AAC.create(audio_codec_configuration).resource

    # create the input stream resources
    video_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)
    audio_input_stream = StreamInput(input_id=s3_input.id,
                                     input_path=INPUT_PATH,
                                     selection_mode=SelectionMode.AUTO)

    # With the configurations and the input file, streams are now created that will be muxed later on.
    # As we use per-title, the streams are used as templates
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get("profile_h264")
        video_stream_condition = Condition(attribute="HEIGHT", operator=">=", value=str(encoding_profile.get('height')))
        video_stream = Stream(codec_configuration_id=encoding_config.get("h264_codec").id,
                              input_streams=[video_input_stream],
                              conditions=video_stream_condition,
                              name='Stream H264 {}p'.format(encoding_profile.get('height')),
                              mode=StreamMode.PER_TITLE_TEMPLATE)

        encoding_config['h264_stream'] = bitmovin.encodings.Stream.create(object_=video_stream,
                                                                          encoding_id=encoding.id).resource

    # create the stream for the audio
    audio_stream = Stream(codec_configuration_id=audio_codec_configuration.id,
                          input_streams=[audio_input_stream],
                          name='Audio Stream')
    audio_stream = bitmovin.encodings.Stream.create(object_=audio_stream,
                                                    encoding_id=encoding.id).resource

    # === FMP4 Muxings ===
    # Create FMP4 muxings which are later used for the DASH manifest. The current settings will set a segment length
    # of 4 seconds.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get("profile_h264")
        video_muxing_stream = MuxingStream(encoding_config['h264_stream'].id)
        video_muxing_output = EncodingOutput(output_id=s3_output.id,
                                             output_path=OUTPUT_BASE_PATH + "video/dash/{height}p_{bitrate}_{uuid}/",
                                             acl=[acl_entry])
        video_muxing = FMP4Muxing(segment_length=4,
                                  segment_naming='seg_%number%.m4s',
                                  init_segment_name='init.mp4',
                                  streams=[video_muxing_stream],
                                  name="Video FMP4 Muxing {}p".format(encoding_profile.get('height')))

        encoding_config['fmp4_muxing'] = bitmovin.encodings.Muxing.FMP4.create(object_=video_muxing,
                                                                               encoding_id=encoding.id).resource
        video_cenc = CENCDRM(key=CENC_KEY,
                             kid=CENC_KID,
                             widevine=widevine_drm,
                             playReady=playready_drm,
                             outputs=[video_muxing_output],
                             name="Video FMP4 CENC")

        encoding_config['fmp4_cenc'] = bitmovin.encodings.Muxing.FMP4.DRM.CENC.create(
            object_=video_cenc,
            encoding_id=encoding.id,
            muxing_id=encoding_config['fmp4_muxing'].id).resource

    audio_muxing_stream = MuxingStream(audio_stream.id)
    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH + 'audio/dash/',
                                         acl=[acl_entry])
    audio_fmp4_muxing = FMP4Muxing(segment_length=4,
                                   segment_naming='seg_%number%.m4s',
                                   init_segment_name='init.mp4',
                                   streams=[audio_muxing_stream],
                                   name='Audio FMP4 Muxing')
    audio_fmp4_muxing = bitmovin.encodings.Muxing.FMP4.create(object_=audio_fmp4_muxing,
                                                              encoding_id=encoding.id).resource
    audio_cenc = CENCDRM(key=CENC_KEY,
                         kid=CENC_KID,
                         widevine=widevine_drm,
                         playReady=playready_drm,
                         outputs=[audio_muxing_output],
                         name='Audio FMP4 CENC')
    audio_cenc = bitmovin.encodings.Muxing.FMP4.DRM.CENC.create(object_=audio_cenc,
                                                                encoding_id=encoding.id,
                                                                muxing_id=audio_fmp4_muxing.id).resource

    # === TS Muxings ===
    # Create TS muxings which are later used for the HLS manifest. The current settings will set a segment length
    # of 4 seconds.
    for encoding_config in encoding_configs:
        encoding_profile = encoding_config.get('profile_h264')
        video_muxing_stream = MuxingStream(encoding_config['h264_stream'].id)
        video_muxing_output = EncodingOutput(output_id=s3_output.id,
                                             output_path=OUTPUT_BASE_PATH + 'video/hls/{height}p_{bitrate}_{uuid}/',
                                             acl=[acl_entry])
        video_muxing = TSMuxing(segment_length=4,
                                segment_naming='seg_%number%.ts',
                                streams=[video_muxing_stream],
                                name='Video TS Muxing {}p'.format(encoding_profile.get('height')))
        encoding_config['ts_muxing'] = bitmovin.encodings.Muxing.TS.create(object_=video_muxing,
                                                                           encoding_id=encoding.id).resource
        video_fairplay = FairPlayDRM(key=FAIRPLAY_KEY,
                                     iv=FAIRPLAY_IV,
                                     uri=FAIRPLAY_URI,
                                     outputs=[video_muxing_output],
                                     name='Video TS FairPlay')

        encoding_config['ts_fairplay'] = bitmovin.encodings.Muxing.TS.DRM.FairPlay.create(
            object_=video_fairplay,
            encoding_id=encoding.id,
            muxing_id=encoding_config['ts_muxing'].id).resource

    audio_muxing_stream = MuxingStream(audio_stream.id)
    audio_muxing_output = EncodingOutput(output_id=s3_output.id,
                                         output_path=OUTPUT_BASE_PATH + 'audio/hls/',
                                         acl=[acl_entry])
    audio_ts_muxing = TSMuxing(segment_length=4,
                               segment_naming='seg_%number%.ts',
                               streams=[audio_muxing_stream],
                               name='Audio TS Muxing')
    audio_ts_muxing = bitmovin.encodings.Muxing.TS.create(object_=audio_ts_muxing,
                                                          encoding_id=encoding.id).resource
    audio_fairplay = FairPlayDRM(key=FAIRPLAY_KEY,
                                 iv=FAIRPLAY_IV,
                                 uri=FAIRPLAY_URI,
                                 outputs=[audio_muxing_output],
                                 name='Audio FairPlay')
    audio_fairplay = bitmovin.encodings.Muxing.TS.DRM.FairPlay.create(object_=audio_fairplay,
                                                                      encoding_id=encoding.id,
                                                                      muxing_id=audio_ts_muxing.id).resource

    # Keep the audio info together
    audio_representation_info = dict(
        fmp4_muxing=audio_fmp4_muxing,
        ts_muxing=audio_ts_muxing,
        stream=audio_stream,
        ts_fairplay=audio_fairplay,
        fmp4_cenc=audio_cenc
    )

    # Finally create the per-title configuration to pass to the encoding
    auto_representations = AutoRepresentation(adopt_configuration_threshold=0.5)
    h264_per_title_configuration = H264PerTitleConfiguration(auto_representations=auto_representations)
    per_title = PerTitle(h264_configuration=h264_per_title_configuration)

    # And start the encoding
    start_encoding_request = StartEncodingRequest(per_title=per_title, encoding_mode=EncodingMode.THREE_PASS)
    bitmovin.encodings.Encoding.start(encoding_id=encoding.id, start_encoding_request=start_encoding_request)

    try:
        bitmovin.encodings.Encoding.wait_until_finished(encoding_id=encoding.id)
    except BitmovinError as bitmovin_error:
        print("Exception occurred while waiting for encoding to finish: {}".format(bitmovin_error))

    # Specify the output for manifest which will be in the OUTPUT_BASE_PATH.
    manifest_output = EncodingOutput(output_id=s3_output.id,
                                     output_path=OUTPUT_BASE_PATH,
                                     acl=[acl_entry])

    # === DASH MANIFEST ===
    muxing_for_contentprotection = None
    drm_for_contentprotection = None
    # Create a DASH manifest and add one period with an adapation set for audio and video
    dash_manifest = DashManifest(manifest_name='stream.mpd',
                                 outputs=[manifest_output],
                                 name='DASH Manifest')
    dash_manifest = bitmovin.manifests.DASH.create(dash_manifest).resource
    period = Period()
    period = bitmovin.manifests.DASH.add_period(object_=period, manifest_id=dash_manifest.id).resource

    video_adaptation_set = VideoAdaptationSet()
    video_adaptation_set = bitmovin.manifests.DASH.add_video_adaptation_set(object_=video_adaptation_set,
                                                                            manifest_id=dash_manifest.id,
                                                                            period_id=period.id).resource

    audio_adaptation_set = AudioAdaptationSet(lang='en')
    audio_adaptation_set = bitmovin.manifests.DASH.add_audio_adaptation_set(object_=audio_adaptation_set,
                                                                            manifest_id=dash_manifest.id,
                                                                            period_id=period.id).resource

    # Add the audio representation
    segment_path = audio_representation_info.get('fmp4_cenc').outputs[0].outputPath
    segment_path = remove_output_base_path(segment_path)

    fmp4_representation_audio = DRMFMP4Representation(FMP4RepresentationType.TEMPLATE,
                                                      encoding_id=encoding.id,
                                                      muxing_id=audio_representation_info.get('fmp4_muxing').id,
                                                      drm_id=audio_representation_info.get('fmp4_cenc').id,
                                                      segment_path=segment_path)
    bitmovin.manifests.DASH.add_drm_fmp4_representation(object_=fmp4_representation_audio,
                                                        manifest_id=dash_manifest.id,
                                                        period_id=period.id,
                                                        adaptationset_id=audio_adaptation_set.id)

    # Add all video representations to the video adaption set
    muxings = bitmovin.encodings.Muxing.FMP4.list(encoding_id=encoding.id).resource
    for muxing in muxings:
        drm = bitmovin.encodings.Muxing.FMP4.DRM.CENC.list(encoding.id, muxing.id).resource

        segment_path = drm[0].outputs[0].outputPath
        if 'audio' in segment_path:
            # we ignore the audio muxing
            continue
        if '{uuid}' in segment_path:
            # we ignore any muxing with placeholders in the path - they are the template muxings, not the result muxings
            continue
        segment_path = remove_output_base_path(segment_path)

        muxing_for_contentprotection = muxing
        drm_for_contentprotection = drm[0]

        fmp4_representation = DRMFMP4Representation(
            type=FMP4RepresentationType.TEMPLATE,
            encoding_id=encoding.id,
            muxing_id=muxing.id,
            segment_path=segment_path,
            drm_id=drm[0].id
        )

        bitmovin.manifests.DASH.add_drm_fmp4_representation(
            object_=fmp4_representation,
            manifest_id=dash_manifest.id,
            period_id=period.id,
            adaptationset_id=video_adaptation_set.id)

    # add content protection to the adaptation set
    video_content_protection = ContentProtection(encoding_id=encoding.id,
                                                 muxing_id=muxing_for_contentprotection.id,
                                                 drm_id=drm_for_contentprotection.id)
    bitmovin.manifests.DASH.add_content_protection_to_adaptionset(object_=video_content_protection,
                                                                  manifest_id=dash_manifest.id,
                                                                  period_id=period.id,
                                                                  adaptationset_id=video_adaptation_set.id)

    bitmovin.manifests.DASH.start(manifest_id=dash_manifest.id)

    # === HLS MANIFEST ===
    # Create a HLS manifest and add one period with an adapation set for audio and video
    hls_manifest = HlsManifest(manifest_name='stream.m3u8',
                               outputs=[manifest_output],
                               name='HLS Manifest')
    hls_manifest = bitmovin.manifests.HLS.create(hls_manifest).resource

    segment_path = audio_representation_info.get('ts_fairplay').outputs[0].outputPath
    segment_path = remove_output_base_path(segment_path)

    audio_media = AudioMedia(name='HLS Audio Media',
                             group_id='audio',
                             segment_path=segment_path,
                             encoding_id=encoding.id,
                             stream_id=audio_representation_info.get('stream').id,
                             muxing_id=audio_representation_info.get('ts_muxing').id,
                             drm_id=audio_representation_info.get('ts_fairplay').id,
                             language='en',
                             uri='audio.m3u8')
    audio_media = bitmovin.manifests.HLS.AudioMedia.create(manifest_id=hls_manifest.id, object_=audio_media).resource

    # Add all video representations to the video adaption set
    muxings = bitmovin.encodings.Muxing.TS.list(encoding_id=encoding.id).resource
    for muxing in muxings:
        drm = bitmovin.encodings.Muxing.TS.DRM.FairPlay.list(encoding.id, muxing.id).resource

        segment_path = drm[0].outputs[0].outputPath
        if 'audio' in segment_path:
            # we ignore the audio muxing
            continue
        if '{uuid}' in segment_path:
            # we ignore any muxing with placeholders in the path - they are the template muxings, not the result muxings
            continue
        segment_path = remove_output_base_path(segment_path)

        variant_stream = VariantStream(audio=audio_media.groupId,
                                       closed_captions='NONE',
                                       segment_path=segment_path,
                                       uri='video_{}.m3u8'.format(muxing.avgBitrate),
                                       encoding_id=encoding.id,
                                       stream_id=muxing.streams[0].streamId,
                                       muxing_id=muxing.id,
                                       drm_id=drm[0].id)

        bitmovin.manifests.HLS.VariantStream.create(manifest_id=hls_manifest.id,
                                                    object_=variant_stream)

    bitmovin.manifests.HLS.start(manifest_id=hls_manifest.id)

    try:
        bitmovin.manifests.DASH.wait_until_finished(manifest_id=dash_manifest.id, check_interval=1)
    except BitmovinError as bitmovin_error:
        print('Exception occurred while waiting for manifest creation to finish: {}'.format(bitmovin_error))

    try:
        bitmovin.manifests.HLS.wait_until_finished(manifest_id=hls_manifest.id, check_interval=1)
    except BitmovinError as bitmovin_error:
        print('Exception occurred while waiting for manifest creation to finish: {}'.format(bitmovin_error))
        exit(-1)