Quellcode

import osimport stat
import shutil
import sys
import boto3
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

# clean out /tmp
folder = '/tmp'
for the_file in os.listdir(folder):
    file_path = os.path.join(folder, the_file)
    try:
        if os.path.isfile(file_path):
            os.unlink(file_path)
        elif os.path.isdir(file_path): shutil.rmtree(file_path)
    except Exception as e:
        logger.info("cleanup /tmp exception: " + e)
        print(e)

lambda_tmp_dir = '/tmp'  # Lambda fuction can use this directory.

# ffmpeg loading
ffmpeg = "{0}/ffmpeg".format(lambda_tmp_dir)
shutil.copyfile('/var/task/ffmpeg', ffmpeg)
os.environ['ffmpeg'] = ffmpeg
os.chmod(ffmpeg, os.stat(ffmpeg).st_mode | stat.S_IRWXU)
os.chmod("/tmp", stat.S_IRWXU)

s3 = boto3.client('s3')

# Make sure the target directory exists
def prepare_path(target):
    if os.path.exists(target):
        logger.info("{0} exists".format(target))
        shutil.rmtree(target)

    os.mkdir(target)


# Copy/download the file to local
# standard way of doing things
"""
def copy_object(bucket, source, dest):
    name = source.split('/')[-1]
    local_file = "{0}/{1}".format(dest, name)
    logger.debug("{0} to {1}".format(source, local_file))
    s3.download_file(bucket, source, local_file)
    if os.path.exists(local_file):
        b = open(local_file, "r")
    return local_file
"""

# The following function can be used to upload directory to s3 via boto.
def upload_files(path, bucket, mediaId, fileType):
    logger.info("upload_files() path-> " + path + " | bucket-> " + bucket + " | mediaId-> " + mediaId + " | fileType-> " + fileType)
    for subdir, dirs, files in os.walk(path):
        for file in files:
            full_path = os.path.join(subdir, file)
            with open(full_path, 'rb') as data:
                thisKey = 'media/' + fileType + '/' + mediaId + '/' + full_path[len(path) + 1:]
                logger.info("upload_files() thisKey-> " + thisKey)
                s3.put_object(Bucket=bucket, Key=thisKey, Body=data)


def create_presigned_url(bucket_name, object_name, expiration=3600):
    """Generate a presigned URL to share an S3 object

    :param bucket_name: string
    :param object_name: string
    :param expiration: Time in seconds for the presigned URL to remain valid
    :return: Presigned URL as string. If error, returns None.
    """

    # Generate a presigned URL for the S3 object
    s3_client = boto3.client('s3')
    try:
        response = s3_client.generate_presigned_url('get_object',
                                                    Params={'Bucket': bucket_name,
                                                            'Key': object_name},
                                                    ExpiresIn=expiration)
    except ClientError as e:
        logging.error(e)
        return None

    # The response contains the presigned URL
    return response


def ffmpeg_lambda_handler(event, context):
    # determine the ID
    the_file_path = event['Records'][0]['s3']['object']['key']
    the_bucket = event['Records'][0]['s3']['bucket']['name']




    the_file_path_array = the_file_path.split('/')
    the_file_name = the_file_path_array[-1]
    the_file_name_array = the_file_name.split('.')
    mediaId = str(the_file_name_array[0])
    fileType = the_file_path_array[1]

    # create the local_path
    local_path = "{0}/{1}".format(lambda_tmp_dir, mediaId)
    prepare_path(local_path)





    # copy_object to destination path.
    # localInputFile = copy_object(the_bucket, the_file_path, local_path)
    localInputFile = create_presigned_url(the_bucket, the_file_path, expiration=3600)

    # ++++++++++++++++++++++++++++++++++++++++ FFMPEG ++++++++++++++++++++++++++++++++++++++++++

    audioPath = "{0}/{1}".format(local_path, 'audio_file.mp3')

    if fileType == 'transition':
        # GoPro settings
        brPairs = [[1080, 16000], [1080, 7000], [720, 3000], [540, 1500], [224, 440]]

    else:
        # Spherical Video settings
        brPairs = [[1920, 16000], [720, 3000], [960, 7000], [1440, 16000], [2048, 40000]]


    for p in brPairs:
        # size
        thisKey = str(p[0])

        # get bit-rate
        bitrate = p[1]

        # buffer rate
        bufs = str(bitrate * 0.75)

        # convert num to string
        bitstring = str(bitrate)

        # final file path
        final_file = thisKey + '_' + bitstring + '.mp4'

        localOutputPath = "{0}/{1}".format(local_path, final_file)
        localOutputPath = str(localOutputPath)

        s3Path = 's3://xplorit-media/processor/360video/170968.mp4'
        httpsPath = 'https://s3-us-west-2.amazonaws.com/xplorit-media/processor/360video/170968.mp4'

        buff_temp_name = str('temp_' + mediaId + '_' + thisKey + '_' + bitstring)
        localTempPath = "{0}/{1}".format(local_path, buff_temp_name)
        localTempPath = str(localTempPath)
        myPassLogFile = folder + '/my_passlog_' + mediaId + '_' + thisKey + '_' + bitstring

        # Pass Commands
        # pass_one_command = ffmpeg + ' -y -i ' + localInputFile + ' -c:v libx264 -strict -2 -b:v ' + bitstring + 'k -maxrate ' + bitstring + 'k -bufsize ' + bufs + 'k -vf scale=-2:' + thisKey + ' -an -pass 1 -passlogfile ' + myPassLogFile + ' -f mp4 ' + localTempPath
        # pass_two_command = ffmpeg + ' -y -i ' + localInputFile + ' -c:v libx264 -strict -2 -b:v ' + bitstring + 'k -maxrate ' + bitstring + 'k -bufsize ' + bufs + 'k -vf scale=-2:' + thisKey + ' -c:a aac -b:a 128k -pass 2 -passlogfile ' + myPassLogFile + ' -movflags +faststart -f mp4 ' + localOutputPath

        pass_one_command = ffmpeg + ' -y -i "' + localInputFile + '" -c:v libx264 -strict -2 -b:v ' + bitstring + 'k -maxrate ' + bitstring + 'k -bufsize ' + bufs + 'k -vf scale=-2:' + thisKey + ' -an -pass 1 -passlogfile ' + myPassLogFile + ' -f mp4 /dev/null'
        pass_two_command = ffmpeg + ' -y -i "' + localInputFile + '" -c:v libx264 -strict -2 -b:v ' + bitstring + 'k -maxrate ' + bitstring + 'k -bufsize ' + bufs + 'k -vf scale=-2:' + thisKey + ' -c:a aac -b:a 128k -pass 2 -passlogfile ' + myPassLogFile + ' -movflags +faststart -f mp4 ' + localOutputPath

        # aws s3 cp - s3: // my - amazing - bucket / geoip_v4_data.csv.gz
        # ffmpeg - re - i in.ts - f hls - method PUT http: // example.com / live / out.m3u8

        # Pass one
        logger.info("Pass One " + pass_one_command)
        os.system(pass_one_command)

        # Pass two
        logger.info("Pass two " + pass_two_command)
        os.system(pass_two_command)

        # delete temp
        os.system('rm -f ' + localTempPath)

        # delete log
        os.system('rm -f ' + myPassLogFile)

        # delete mbtree
        os.system('rm -f ' + myPassLogFile + '-0.log.mbtree')

        logger.info("B -> DONE PROCESSING = " + mediaId + '_' + thisKey + '_' + bitstring)

        # upload file localOutputPath
        key_create = 'media/' + fileType + '/' + mediaId + '/' + final_file
        logger.info("UPLOADING localOutputPath = " + localOutputPath + ' the_bucket = ' + the_bucket + ' key_create = ' + key_create)
        s3.upload_file(localOutputPath, the_bucket, key_create)
        # remove file
        os.system('rm -f ' + localOutputPath)


    # encode audio
    audioCommand = ffmpeg + ' -y -i "' + localInputFile + '" -f mp3 -ab 192000 -vn ' + audioPath
    logger.info("Audio extraction " + audioCommand)
    try:
        os.system(audioCommand)
        key_create = 'media/' + fileType + '/' + mediaId + '/audio_file.mp3'
        logger.info("UPLOADING audioPath = " + audioPath + ' the_bucket = ' + the_bucket + ' key_create = ' + key_create)
        s3.upload_file(audioPath, the_bucket, key_create)
        logger.info("Audio extraction SUCCESS " + audioCommand)
    except:
        logger.info("Audio extraction ERROR" + audioCommand)
    # upload audio file localOutputPath


    # ++++++++++++++++++++++++++++++++++++++++ KRPANOTOOLS ++++++++++++++++++++++++++++++++++++++++++

    # Upload to s3.
    # upload_files(local_path, the_bucket, mediaId, fileType)
    # key_create = 'media/' + fileType + '/' + mediaId + '/' + mediaId + '.mp4'
    # logger.info("UPLOADING localInputFile = " + localInputFile + ' the_bucket = ' + the_bucket + ' key_create = ' + key_create)
    # s3.upload_file(localInputFile, the_bucket, key_create)

    logger.info("OK WE'RE DONE!!!")