def trigger_renditions_bucket_event(data, context): """Background Cloud Function to be triggered by Cloud Storage. This function retrieves a source video and triggers the generation of renditions by means of an http asynchronous call to the create_renditions_http function Args: data (dict): The Cloud Functions event payload. context (google.cloud.functions.Context): Metadata of triggering event. Returns: None, the renditions cloud function are triggered asynchronously """ name = data['name'] # Create the folder for the renditions params_folder = '/tmp/{}'.format(os.path.dirname(name)) if not os.path.exists(params_folder): os.makedirs(params_folder) resolutions = [1080, 720, 480, 384, 288, 144] crfs = [45, 40, 32, 25, 21, 18, 14] for resolution in resolutions: for crf in crfs: local_file = '{}/{}-{}-{}.json'.format( params_folder.replace(os.path.dirname(name), ''), name, resolution, crf) remote_file = '{}/{}-{}.json'.format(name, resolution, crf) file_output = open(local_file, "w") file_output.close() gce_utils.upload_blob(PARAMETERS_BUCKET, local_file, remote_file) return 'Renditions triggered for {}'.format(name)
def create_source_http(request): """HTTP Cloud Function. Args: request (flask.Request): The request object. <http://flask.pocoo.org/docs/1.0/api/#flask.Request> Returns: The status message if successful """ request_json = request.get_json(silent=True) request_args = request.args if request_json: playlist_url = request_json['playlist_url'] video_id = request_json['video_id'] extension = request_json['extension'] duration = request_json['duration'] elif request_args: playlist_url = request_args['playlist_url'] video_id = request_args['video_id'] extension = request_args['extension'] duration = request_args['duration'] else: return 'Unable to read request' print(playlist_url, video_id, extension) ffmpeg_installer.install() local_file = '/tmp/{}.{}'.format(video_id, extension) destination_blob_name = '{}.{}'.format(video_id, extension) if not gce_utils.check_blob(SOURCES_BUCKET, destination_blob_name): if download_video_from_url(playlist_url, duration, local_file, extension): gce_utils.upload_blob(SOURCES_BUCKET, local_file, destination_blob_name) else: print('Video already uploaded, skipping') return 'FINISHED Processing source: {}'.format(video_id)
def create_renditions_bucket_event(data, context): """ HTTP Cloud Function to generate video assets. Triggered by files deposited in PARAMETERS_BUCKET Args: data: The triggering object, containing name, resolution and quantization parameter Returns: The status message if successful """ source_name = os.path.dirname(data['name']) params_name = data['name'].replace(source_name, '') resolution = params_name.split('-')[0][1:] crf_value = params_name.split('-')[1].replace('.json', '') print('Processing source: {} at resolution {}'.format( source_name, resolution)) # Locate the ffmpeg binary ffmpeg_installer.install() # Create the folder for the source asset source_folder = '/tmp/source' # Create the folder for the renditions renditions_folder = '/tmp/renditions' if not os.path.exists(renditions_folder): os.makedirs(renditions_folder) # Get the file that has been uploaded to GCS asset_path = {'path': '{}/{}'.format(source_folder, source_name)} # Check if the source is not already in the path if not os.path.exists(asset_path['path']): print('Retrieving video from {}'.format(asset_path['path'])) gce_utils.download_to_local(SOURCES_BUCKET, asset_path['path'], source_name) print('Processing resolution', resolution) # Create folder for each rendition bucket_path = '{}_{}/{}'.format(resolution, crf_value, source_name) print('Bucket path:', bucket_path) if not gce_utils.check_blob(RENDITIONS_BUCKET, bucket_path): crf_path = '{}/{}_{}/{}'.format(renditions_folder, resolution, crf_value, os.path.dirname(source_name)) if not os.path.exists(crf_path): print('Creating rendition folder:', crf_path) os.makedirs(crf_path) # Generate renditions with ffmpeg renditions_worker(asset_path['path'], source_folder, CODEC_TO_USE, resolution, crf_value, renditions_folder) #compute_metrics(asset_path, renditions_paths) # Upload renditions to GCE storage bucket local_path = '{}/{}_{}/{}'.format(renditions_folder, resolution, crf_value, source_name) bucket_path = '{}_{}/{}'.format(resolution, crf_value, source_name) gce_utils.upload_blob(RENDITIONS_BUCKET, local_path, bucket_path) os.remove(local_path) return 'FINISHED Processing source: {} at resolution {}'.format( source_name, resolution)