def get_file_hashcode(path): video = get_video_properties(path) # video = video.__dict__ # video.pop('_filehandler') video = str(video).encode('utf-8') hashcode = sha1(video) return hashcode.hexdigest()
def main(path): if path.endswith('.mp4'): mp4file = MP4File(path) # The 8 boxes required to parse is lacking some information like codec # ... hence, a library that uses ffprobe is used... vedioProps = get_video_properties(path) audioProps = get_audio_properties(path) print('..................Summary..................') print('The file has a size of: ', mp4file.fsize) print('Major Brand: ', mp4file.boxes['ftyp'].box_info['major_brand']) print('Compatible Brands: ', mp4file.boxes['ftyp'].box_info['compatible_brands']) duration = mp4file.boxes['moov'].child_boxes['mvhd'].box_info['duration']/mp4file.boxes['moov'].child_boxes['mvhd'].box_info['timescale'] print('Duration is (in seconds): ', duration) print('Appoximate bitrate is: ', mp4file.fsize*8/duration) print('...................Video...................') print('The codec for video: ' + vedioProps['codec_name']) if 'trak0' in mp4file.boxes['moov'].child_boxes: if mp4file.boxes['moov'].child_boxes['trak0'].child_boxes['tkhd'].box_info['volume'] == 0: print('The width for video: ' + str(mp4file.boxes['moov'].child_boxes['trak0'].child_boxes['tkhd'].box_info['width'])) print('The height for video: ' + str(mp4file.boxes['moov'].child_boxes['trak0'].child_boxes['tkhd'].box_info['height'])) else: print('The width for video: ' + str(mp4file.boxes['moov'].child_boxes['trak1'].child_boxes['tkhd'].box_info['width'])) print('The height for video: ' + str(mp4file.boxes['moov'].child_boxes['trak1'].child_boxes['tkhd'].box_info['height'])) print('The avg_frame_rate for video: ' + str(eval(vedioProps['avg_frame_rate']))) print('...................Audio...................') print('The codec for audio: ' + audioProps['codec_name']) print('The sample rate for audio: ' + audioProps['sample_rate']) print('The number of channels for audio: ' + str(audioProps['channels'])) print('The bit_rate for audio: ' + audioProps['bit_rate']) else: logging.error('File format not supported')
def audio_matching(audio, folder): '''find matching video files for audio and define the video resolution''' ### Get Values ### values = 'static/audioClips' + folder + '/values.txt' with open(values) as f: duration = f.readline().strip() arousal_string = f.readline().strip() valence_string = f.readline().strip() arousal = [float(value.strip()) for value in arousal_string.split(', ')] valence = [float(value.strip()) for value in valence_string.split(', ')] ########## Matching ########## matching_method = session['files']['matching'] if "approx" in matching_method: mode = "standard" if matching_method == "approx" else "mse" if matching_method == "approx_w": mode = "weighted" matching_files, matching_indexes = approximation_matching( folder, "audio", mode) elif "offline" in matching_method: mode = "standard" if matching_method == "offline" else "mse" if matching_method == "offline_w": mode = "weighted" matching_files, matching_indexes = offline_matching( folder, "audio", mode) else: matching_files, matching_indexes = random_matching(folder, "audio") for i in range(0, len(matching_files)): matching_files[i] = encode(matching_files[i]) session['files'] = { 'matching_files': matching_files, 'matching_indexes': matching_indexes } ########## Get video resolution ########## max_width = 0.0 max_height = 0.0 for video in session['files']['matching_files']: props = get_video_properties('static/datasets/video/' + decode(video) + '.mp4') if props['width'] > max_width: max_width = props['width'] if props['height'] > max_height: max_height = props['height'] resolution = {"width": max_width, "height": max_height} return merge_audio_result(audio, resolution)
async def get_properties(self): """Get the video properties like codec, resolution.Returns Video properties saved in a Dictionary.""" """ NamedTemporaryFile is too hard to use portably when you need to open the file by name after writing it. On posix you can open the file for reading by name without closing it first. But on Windows, To do that you need to close the file first, which means you have to pass delete=False, which in turn means that you get no help in cleaning up the actual file resource. """ fbytes = await self.get_file_bytes() # get bytes of file temp_vid = tempfile.NamedTemporaryFile( prefix="opsdroid_vid_", delete=False) # create a file to store the bytes temp_vid.write(fbytes) temp_vid.close() try: vid_details = get_video_properties(temp_vid.name) os.remove(temp_vid.name) # delete the temp file return vid_details except RuntimeError as error: if "ffmpeg" in str(error).lower(): _LOGGER.warning( _("Video events are not supported unless ffmpeg is installed. Install FFMPEG on your system. Here is the error: " )) _LOGGER.warning(_(error)) os.remove(temp_vid.name) # delete the temp file
def check_video_validation(total_parts, source_folder): """ combine a chunked file to check validation of proRes video. """ dest = os.path.join(source_folder, 'video_chunk') with open(dest, 'wb+') as destination: if int(sys.version[:1]) >= 3: for i in range(int(total_parts)): part = os.path.join(source_folder, str(i)) with open(part, 'rb') as source: destination.write(source.read()) else: for i in xrange(int(total_parts)): part = os.path.join(source_folder, str(i)) with open(part, 'rb') as source: destination.write(source.read()) try: props = get_video_properties(dest) print (props) if props['codec_name'] == 'proRes': return True except Exception as e: print(e) return False
def get_new_vid_name(video): extension = filetype.guess_extension(video) properties = videoprops.get_video_properties(video) vid_date = properties['tags']['creation_time'] formated_vid_date = vid_date.replace("-", "").replace("T", "").replace(":", "") new_name = f"vid_{formated_vid_date[:8]}_{formated_vid_date[8:14]}.{extension}" return new_name
def get_max_size(videos): max_width = 0 max_height = 0 for v in videos: props = get_video_properties(v) max_width = max(max_width, props['width']) max_height = max(max_height, props['height']) return max_width, max_height
def get_video_data(filename): if os.path.exists(filename): props = videoprops.get_video_properties(filename) else: raise FileNotFoundError( errno.ENOENT, os.strerror(errno.ENOENT), filename) fields = ['codec_name', 'width', 'height'] result = {prop: props[prop] for prop in fields} return result
def convert_video_thumbnail(data, context): print(data) if data['contentType'].startswith('video/'): bucket = client.get_bucket(data['bucket']) name = data['name'] file_name = '/tmp/' + name print(file_name) thumbnail_file_name = '/tmp/' + name.split('.')[0] + '.png' print(thumbnail_file_name) try: os.remove(file_name) except OSError: pass try: os.remove(thumbnail_file_name) except OSError: pass print("File has been removed") # Downloading the video to the cloud functions blob = bucket.get_blob(name) blob.download_to_filename(file_name) print("Video Downloaded") props = get_video_properties(file_name) if os.path.exists(file_name): print("NEW MP4 EXISTS") check_output('ffmpeg -itsoffset -4 -i ' + file_name + ' -vcodec mjpeg -vframes 1 -an -f rawvideo -s ' + str(props['width']) + 'x' + str(props['height']) + ' ' + thumbnail_file_name, shell=True) thumbnail_blob = bucket.blob(name.split('.')[0] + '.png') thumbnail_blob.upload_from_filename(thumbnail_file_name) else: print("MP4 not created") print("uploaded") else: print("Not a Video")
def get_quality(file): video = get_video_properties(file) if video['width'] >=3800 : video_quality = "4K" elif video['width'] >= 2000 and video['width'] < 3800: video_quality = "2K" elif video['width'] >= 1700 and video['width'] < 2000: video_quality = "FullHD" elif video['width'] >= 1000 and video['width'] < 1700: video_quality = "HD" elif video['width'] < 1000: video_quality = "SD" return video_quality
def resize(videos, maxw, maxh): PAD_OPTIONS = { 'width': '{}'.format(maxw), 'height': '{}'.format(maxh), 'x': '(ow-iw)/2', 'y': '(oh-ih)/2', } for v in videos: props = get_video_properties(v) (ffmpeg.input(v).filter( "scale", size="{}:{}".format(maxw, maxh), force_original_aspect_ratio='decrease').filter_( "pad", **PAD_OPTIONS).filter("setsar", 1).output('{}m.mp4'.format( v[:v.find(".mp4")])).global_args('-y').run())
import subprocess import time input_path = 'input/Test_Set/' output_path = 'output/Test_Set/' files = [f for f in listdir(input_path) if isfile(join(input_path, f))] for file in files: input_full_path = input_path + file output_full_path = output_path + file[:-4] props = get_video_properties(input_full_path) print(f'''Resolution: {props['width']}×{props['height']}''') new_w = 346 new_h = math.ceil((new_w * props['height'])/props['width']) print(f'''New resolution: {new_w}×{new_h}''') start_time = time.time() subprocess.call('./run_v2e.sh ' + input_full_path + ' ' + output_full_path + ' ' + str(new_w) + ' ' + str(new_h), shell=True) print("--- %s seconds ---" % (time.time() - start_time)) print('\n')
def video_info(video_path): video_properties = get_video_properties(video_path) audio_properties = get_audio_properties(video_path) return video_properties, audio_properties
def post(self, request, format=None): print("Entered Here") print((request.data)) destination_bucket = 'video-streaming-project-bucket' data = { "status_code": 200, "message": "Request is accepted", "result": {} } storage_client = storage.Client() file_serializer = FileSerializer(data=request.data) if file_serializer.is_valid(): file_serializer.save() video_id = uuid.uuid4() video_id_str = str(video_id).replace("-", "") mypath = os.path.join(os.getcwd(), "media") onlyfiles = [f for f in listdir(mypath) if isfile(join(mypath, f))] filename = onlyfiles[0] if ((os.path.exists( os.path.join(os.getcwd(), "media", onlyfiles[0].split(".")[0] + ".mp4"))) == False): mp4_conversion_cmd = 'ffmpeg -i ' + '"' + os.path.join( os.getcwd(), "media", onlyfiles[0]) + '"' + " " + '"' + os.path.join( os.getcwd(), "media", onlyfiles[0].split(".")[0] + ".mp4") + '"' filename = filename.split(".")[0] + ".mp4" p = subprocess.Popen(mp4_conversion_cmd, stdout=subprocess.PIPE, shell=True) p.wait() out, err = p.communicate() video_description = 'file uploaded' result = subprocess.run([ "ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", os.path.join(os.getcwd(), "media", filename) ], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) if (result.stdout != 'N/A\n'): video_duration = float(result.stdout) else: video_duration = 0 props = get_video_properties( os.path.join(os.getcwd(), "media", filename)) video_resolution = str(props['width']) + "X" + str(props['height']) video_encoding = str(props['codec_name']) video_size = os.path.getsize( os.path.join(os.getcwd(), "media", filename)) thumbnail_command = 'ffmpeg -i ' + '"' + os.path.join( os.getcwd(), "media", filename ) + '"' + ' -ss 00:00:01.000 -vframes 1 ' + '"' + os.path.join( os.getcwd(), "media", video_id_str + '.png') + '"' video_thumbnail = subprocess.Popen(thumbnail_command, shell=True, stdout=subprocess.PIPE) out, err = video_thumbnail.communicate() bucket = storage_client.bucket(destination_bucket) destination_blob_name = video_id_str + '/video/' + filename blob = bucket.blob(destination_blob_name) blob.upload_from_filename( os.path.join(os.getcwd(), "media", filename)) destination_blob_name_thumbnail = 'thumbnail/' + video_id_str + ".png" blob = bucket.blob(destination_blob_name_thumbnail) blob.upload_from_filename( os.path.join(os.getcwd(), "media", video_id_str + '.png')) blob.make_public() video_clip_command = 'ffmpeg -ss 00:00:05 -i ' + '"' + os.path.join( os.getcwd(), "media", filename ) + '"' + ' -t 00:00:05 -vcodec copy -acodec copy ' + '"' + os.path.join( os.getcwd(), "media", video_id_str + '.mp4') + '"' video_clip = subprocess.Popen(video_clip_command, shell=True, stdout=subprocess.PIPE) out, err = video_clip.communicate() destination_blob_name_clip = 'clip/' + video_id_str + ".mp4" blob1 = bucket.blob(destination_blob_name_clip) blob1.upload_from_filename( os.path.join(os.getcwd(), "media", video_id_str + '.mp4')) blob1.make_public() print("Blob {} is publicly accessible at {}".format( blob.name, blob.public_url)) print(video_resolution) data['result']['video_id'] = video_id VideoDetails.objects.create(video_id=video_id, video_name=filename, video_description=video_description, thumbnail_url=blob.public_url, video_duration=video_duration, video_encoding=video_encoding, video_path="gs://" + destination_bucket + "/" + destination_blob_name, video_size=video_size, video_category=video_description, video_resolution=video_resolution, clip_url=blob1.public_url) cmd = 'rmdir /s/q ' + '"' + os.path.join(os.getcwd(), "media") + '"' delete_folder = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE) out, err = delete_folder.communicate() hostname = socket.gethostname() IPAddr = socket.gethostbyname(hostname) response = requests.post('http://192.168.0.22:8000/encoding', data={'video_id': str(video_id)}) try: os.mkdir(os.path.join(os.getcwd(), "media")) except OSError: print("Creation of the directory %s failed" % path) if response.status_code == 200: return Response(data, status=status.HTTP_201_CREATED) else: data['status_code'] = 400 data['message'] = "Upload failed" return Response(data, status=status.HTTP_400_BAD_REQUEST) else: return Response(file_serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None): try: data = {"status_code": 200, "message": "Requested Accepted"} video_id = request.data['video_id'] video_download_directory = '/tmp' os.mkdir(os.path.join(video_download_directory, video_id)) object_download_path = os.path.join(video_download_directory, video_id, "original_video.mp4") storage_client = storage.Client() video_path = list( VideoDetails.objects.filter( video_id=video_id).values('video_path'))[0]['video_path'] print(video_path) bucket_name = video_path.split("/")[2] object_path = "/".join(video_path.split("/")[3:]) bucket = storage_client.bucket(bucket_name) blob = bucket.blob(object_path) blob.download_to_filename(object_download_path) video_resolution_list = list( VideoEncodingFormat.objects.filter().values( 'resolution'))[0:15] width_list = [] height_list = [] for i in range(len(video_resolution_list)): width, height = video_resolution_list[i]['resolution'].split( "X") width_list.append(int(width)) height_list.append(int(height)) min_w = 3360 min_h = 2100 index = 0 props = get_video_properties( os.path.join(video_download_directory, str(video_id), 'original_video.mp4')) print(str(props['width']) + "X" + str(props['height'])) for i in range(len(width_list)): if ((int(props['width']) - width_list[i]) >= 0 and (int(props['width']) - width_list[i]) <= min_w and (int(props['height']) - height_list[i]) >= 0 and (int(props['height']) - height_list[i]) <= min_h): min_h = (props['height'] - height_list[i]) min_w = (props['width'] - width_list[i]) index = i os.mkdir( os.path.join(video_download_directory, video_id, 'encoding')) for i in range(0, index + 1): cmd = 'ffmpeg -i ' + '"' + os.path.join( video_download_directory, str(video_id), 'original_video.mp4' ) + '"' + ' -s ' + str(width_list[i]) + 'x' + str( height_list[i]) + ' -c:a copy ' + '"' + os.path.join( video_download_directory, video_id, 'encoding', str(i + 1) + '.mp4') + '"' cmd_output = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE) cmd_output.wait() out, err = cmd_output.communicate(input=None, timeout=None) webm_cmd = 'ffmpeg -i ' + '"' + os.path.join( video_download_directory, str(video_id), 'original_video.mp4' ) + '"' + ' -s ' + str(width_list[i]) + 'x' + str( height_list[i] ) + ' -c:v libvpx-vp9 -crf 30 -b:v 0 ' + '"' + os.path.join( video_download_directory, video_id, 'encoding', str(i + 1) + '.webm') + '"' webm_cmd_output = subprocess.Popen(webm_cmd, shell=True, stdout=subprocess.PIPE) out, err = webm_cmd_output.communicate(input=None, timeout=None) ogg_cmd = 'ffmpeg -i ' + '"' + os.path.join( video_download_directory, video_id, 'encoding', str(i + 1) + '.mp4' ) + '"' + ' -c:v libtheora -q:v 7 -c:a libvorbis -q:a 4 ' + '"' + os.path.join( video_download_directory, video_id, 'encoding', str(i + 1) + '.ogv') + '"' ogg_cmd_output = subprocess.Popen(ogg_cmd, shell=True, stdout=subprocess.PIPE) out, err = ogg_cmd_output.communicate(input=None, timeout=None) bucket = storage_client.bucket(bucket_name) mp4_destination_blob_name = str(video_id).replace( "-", "") + "/encoding/" + str(i + 1) + '.mp4' mp4_blob = bucket.blob(mp4_destination_blob_name) mp4_blob.upload_from_filename( os.path.join(video_download_directory, video_id, 'encoding', str(i + 1) + '.mp4')) web_destination_blob_name = str(video_id).replace( "-", "") + "/encoding/" + str(i + 1) + '.webm' web_blob = bucket.blob(web_destination_blob_name) web_blob.upload_from_filename( os.path.join(video_download_directory, video_id, 'encoding', str(i + 1) + '.webm')) ogg_destination_blob_name = str(video_id).replace( "-", "") + "/encoding/" + str(i + 1) + '.ogv' ogg_blob = bucket.blob(ogg_destination_blob_name) ogg_blob.upload_from_filename( os.path.join(video_download_directory, video_id, 'encoding', str(i + 1) + '.ogv')) video_id_object = VideoDetails.objects.get(video_id=video_id) mp4_encoding_id_object = VideoEncodingFormat.objects.get(id=i + 1) web_encoding_id_object = VideoEncodingFormat.objects.get(id=i + 16) ogv_encoding_id_object = VideoEncodingFormat.objects.get(id=i + 31) VideoEncodingDetails.objects.create( video_id=video_id_object, encoding_id=mp4_encoding_id_object, video_path='gs://' + bucket_name + "/" + str(video_id).replace("-", "") + "/encoding/" + str(i + 1) + '.mp4') VideoEncodingDetails.objects.create( video_id=video_id_object, encoding_id=web_encoding_id_object, video_path='gs://' + bucket_name + "/" + str(video_id).replace("-", "") + "/encoding/" + str(i + 1) + '.webm') VideoEncodingDetails.objects.create( video_id=video_id_object, encoding_id=ogv_encoding_id_object, video_path='gs://' + bucket_name + "/" + str(video_id).replace("-", "") + "/encoding/" + str(i + 1) + '.ogv') cmd = 'rmdir /s/q ' + '"' + os.path.join(video_download_directory, video_id) + '"' delete_folder = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE) out, err = delete_folder.communicate() return Response(data, status=status.HTTP_200_OK, headers=None) except Exception as e: print("****************************************************") print(e) print("****************************************************") data['status_code'] = 400 data['message'] = str(e) return Response(data, status=status.HTTP_200_OK, headers=None)
def post(self, request, format=None): """ @param: request = Input Request for extracting video details @returns: The request accepted message and video details extracted and stored in the database """ print("Entered Here1234") destination_bucket = 'video-streaming-project-bucket' try: data = { "status_code": 200, "message": "Request is accepted", "video_id": "" } video_download_directory = '/tmp' try: if path.exists(video_download_directory): pass except Exception as e: os.mkdir(video_download_directory) print(request.data) video_request_serializer = VideoUploadRequestSerializer( data=request.data) if (video_request_serializer.is_valid()): print("Entered Here too") is_bucket_path = request.data['is_bucket_path'] if (is_bucket_path): bucket_path = request.data['path'] storage_client = storage.Client() bucket_name = bucket_path.split("/")[2] prefix = "/".join(bucket_path.split("/")[3:]) filename = bucket_path.split("/")[-1] blobs = storage_client.list_blobs(bucket_name, prefix=prefix) list_of_files = [] for blob in blobs: if str(blob.name).endswith("/"): pass else: list_of_files.append(str(blob.name)) print(list_of_files) for i in range(len(list_of_files)): video_id = uuid.uuid4() video_id_str = str(video_id).replace("-", "") video_name = ".".join( list_of_files[i].split("/")[-1]).split(".")[:-1] video_description = list_of_files[i].split("/")[1] if (path.exists( os.path.join(video_download_directory, str(video_id_str), 'video'))): pass else: print("Entered Here too") os.mkdir( os.path.join(video_download_directory, str(video_id_str))) os.mkdir( os.path.join(video_download_directory, str(video_id_str), 'video')) try: cmd = (' '.join([ 'gsutil', '-m', 'cp', 'gs://' + bucket_name + '/' + list_of_files[i], "\"" + os.path.join(video_download_directory, str(video_id_str), 'video') + "\"" ])) p = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True) p.wait() out, err = p.communicate() except Exception as e: print("Entered Here1111") print(e) mp4_conversion_cmd = 'ffmpeg -i ' + '"' + os.path.join( video_download_directory, str(video_id_str), 'video', filename) + '"' + " " + '"' + os.path.join( video_download_directory, str(video_id_str), 'video', filename.split(".")[0] + ".mp4") + '"' print(mp4_conversion_cmd) filename = filename.split(".")[0] + ".mp4" p = subprocess.Popen(mp4_conversion_cmd, stdout=subprocess.PIPE, shell=True) p.wait() out, err = p.communicate() result = subprocess.run([ "ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", os.path.join(video_download_directory, str(video_id_str), 'video', filename) ], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) if (result.stdout != 'N/A\n'): video_duration = float(result.stdout) else: video_duration = 0 props = get_video_properties( os.path.join(video_download_directory, str(video_id_str), 'video', filename)) video_resolution = str(props['width']) + "X" + str( props['height']) video_encoding = str(props['codec_name']) video_size = os.path.getsize( os.path.join(video_download_directory, str(video_id_str), 'video', filename)) thumbnail_command = 'ffmpeg -i ' + '"' + os.path.join( video_download_directory, str(video_id_str), "video", filename ) + '"' + ' -ss 00:00:01.000 -vframes 1 ' + '"' + os.path.join( video_download_directory, str(video_id_str), 'thumbnail.png') + '"' video_thumbnail = subprocess.Popen( thumbnail_command, shell=True, stdout=subprocess.PIPE) out, err = video_thumbnail.communicate() video_clip_command = 'ffmpeg -ss 00:00:05 -i ' + '"' + os.path.join( video_download_directory, str(video_id_str), "video", filename ) + '"' + ' -t 00:00:05 -vcodec copy -acodec copy ' + '"' + os.path.join( video_download_directory, str(video_id_str), 'clip.mp4') + '"' video_clip = subprocess.Popen(video_clip_command, shell=True, stdout=subprocess.PIPE) out, err = video_clip.communicate() bucket = storage_client.bucket(destination_bucket) destination_blob_name = video_id_str + '/video/' + filename blob = bucket.blob(destination_blob_name) blob.upload_from_filename( os.path.join(video_download_directory, str(video_id_str), 'video', filename)) destination_blob_name_thumbnail = 'thumbnail/' + video_id_str + ".png" blob = bucket.blob(destination_blob_name_thumbnail) blob.upload_from_filename( os.path.join(video_download_directory, str(video_id_str), 'thumbnail.png')) blob.make_public() destination_blob_name_clip = 'clip/' + video_id_str + ".mp4" blob1 = bucket.blob(destination_blob_name_clip) blob1.upload_from_filename( os.path.join(video_download_directory, str(video_id_str), 'clip.mp4')) blob1.make_public() cmd = 'rmdir /s/q ' + '"' + os.path.join( video_download_directory, video_id_str) + '"' delete_folder = subprocess.Popen( cmd, shell=True, stdout=subprocess.PIPE) out, err = delete_folder.communicate() VideoDetails.objects.create( video_id=video_id, video_name=filename, video_description=video_description, thumbnail_url=blob.public_url, video_duration=video_duration, video_encoding=video_encoding, video_path="gs://" + destination_bucket + "/" + destination_blob_name, video_size=video_size, video_category=video_description, video_resolution=video_resolution, clip_url=blob1.public_url) else: data['status_code'] = 400 data['message'] = 'Bad Request' return Response(data, status=status.HTTP_200_OK, headers=None) except Exception as e: print(e) data['message'] = str(e) return Response(data, status=status.HTTP_200_OK, headers=None)
def send_telegram(input, type, bot=telegram_bot_token, notification=False): notification = not notification if type == "text": r = requests.post( "https://api.telegram.org/" + bot + "/sendMessage", params={ "chat_id": "1024110161", "text": input, "disable_notification": notification, }, ) elif type == "voice": r = requests.post( "https://api.telegram.org/" + bot + "/sendVoice", params={ "chat_id": "1024110161", "disable_notification": notification }, files={"voice": open(input, "rb")}, ) elif type == "animation": r = requests.post( "https://api.telegram.org/" + bot + "/sendAnimation", params={ "chat_id": "1024110161", "disable_notification": notification }, files={"animation": open(input, "rb")}, ) elif type == "photo": r = requests.post( "https://api.telegram.org/" + bot + "/sendPhoto", params={ "chat_id": "1024110161", "photo": input, "disable_notification": notification, }, ) elif type == "video_file": width = get_video_properties(input)["width"] height = get_video_properties(input)["height"] r = requests.post( "https://api.telegram.org/" + bot + "/sendVideo", params={ "chat_id": "1024110161", "width": width, "height": height, "disable_notification": notification, }, files={"video": open(input, "rb")}, ) elif type == "video_url": r = requests.post( "https://api.telegram.org/" + bot + "/sendVideo", params={ "chat_id": "1024110161", "video": input, "disable_notification": notification, }, ) return r
def resolution(item): vProp = get_video_properties(item) x = vProp['width'] y = vProp['height'] return x, y
import os from PIL import Image from datetime import datetime from videoprops import get_video_properties folder = 'video/' # folder_success='video_success/' for subdir, dirs, files in os.walk(folder): for file in files: path_video = os.path.join(folder, file) # path_move = os.path.join(folder_success,file) # filevideo='P_one2.mov' # # path_video='video/IMG_9556.MOV' # path_video=os.path.join(folder,filevideo) props_2 = get_video_properties(path_video) def cal_resolution(props_2): rotate = False width = props_2['width'] height = props_2['height'] if width < height: reso = width / height else: reso = height / width rotate = True if reso == 0.5625: resize_v = 576 else: resize_v = 768
def set_meta_mp4(filepath: str) -> None: stinfo = os.stat(filepath) file_name = os.path.basename(filepath) actual_time = get_ntime(file_name) base_time = '' if not actual_time: actual_time = get_mtime(filepath) base_time = timestamp_to_name(actual_time) vid_props = get_video_properties(filepath) try: aud_props = get_audio_properties(filepath) channels = aud_props["channels"] except RuntimeError as ex: log.warning(ex) channels = 0 #print(vid_props['tags']['creation_time']) bitrate = int(vid_props["bit_rate"]) // 1024 log.debug(f'{bitrate=}kBs {channels=}') if bitrate > 400: flags = '-ac 1 -vcodec libx264 -vf "scale=iw/2:ih/2" -crf 25' t = 'compress' else: if channels == 0: flags = '-codec copy' t = 'copy' elif channels == 1: flags = '-codec copy' t = 'copy' elif channels == 2: flags = '-ac 1 -c:v copy' t = 'audio' else: raise RuntimeError(f'Strange channels count: {channels}') ctime = dt.datetime.fromtimestamp(actual_time) #if override: # ctime.replace(year=2018, month=6, day=30) cmd = f'ffmpeg -i "{filepath}" -metadata creation_time="{ctime}" {flags} -y tmp.mp4' log.debug(' '*12 + f'Call: {cmd}') completed = subprocess.run(cmd, capture_output=True) if completed.returncode != 0: log.error(f'Problem retcode={completed.returncode} with: {cmd}') if t == 'compress': for line in completed.stderr.decode("utf-8").splitlines(): log.debug(' '*12 + 'stderr>' + line) for line in completed.stdout.decode("utf-8").splitlines(): log.debug(' '*12 + 'stdout>' + line) if base_time: directory = os.path.dirname(filepath) file_name = base_time + " " + file_name new_filepath = os.path.join(directory, file_name) else: new_filepath = filepath new_filepath = new_filepath.replace('.avi', '.mp4') # TODO: Add _crf25 if not '_crf25' in new_filepath: new_filepath = new_filepath.replace('.mp4', '_crf25.mp4') #if override: # new_filepath = override_filepath(new_filepath) shutil.move('tmp.mp4', new_filepath) # Keep accesstime, change modifiedtime os.utime(filepath, (stinfo.st_atime, actual_time))
def predict_video(model, input_video, output_video, output_file, frame_rate=2): # start # args = get_arguments() # input_video = args.input_video # output_video = args.output_video # output_file = args.output_file # input_video = "sample_video/IMG_0119.MOV" # output_video = "output/output_IMG_0119.MOV" # video_size = (540, 960) # video_size = (1080, 1920) # video_size = (1920, 1080) # video_size=(960, 540) # remove existed output video if os.path.exists(output_video): os.remove(output_video) print("Removed {}".format(output_video)) print("input_video: ", input_video) # video path cap = cv2.VideoCapture(input_video) video_info = get_video_properties(input_video) width = cap.get(cv2.CAP_PROP_FRAME_WIDTH) # float height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT) # float print("Video actual size: w={} h={}".format(width, height)) video_size = (int(width), int(height)) output_video_size = (960, 540) need_rotate = False rotate_side = 0 if "rotate" in video_info["tags"]: if video_info["tags"]["rotate"] == '90' or video_info["tags"][ "rotate"] == '-90': video_size = (int(height), int(width)) output_video_size = (540, 960) if video_info["tags"]["rotate"] == '90': rotate_side = cv2.ROTATE_90_CLOCKWISE elif video_info["tags"]["rotate"] == '-90': rotate_side = cv2.ROTATE_90_COUNTERCLOCKWISE elif video_info["tags"]["rotate"] == '180': rotate_side = cv2.ROTATE_180_CLOCKWISE need_rotate = True # fourcc = cv2.VideoWriter_fourcc(*'vp80') fourcc = cv2.VideoWriter_fourcc(*'XVID') out = cv2.VideoWriter(output_video, fourcc, 20.0, output_video_size) # load model frame_count = 0 next_frame = 0 license_list = [] while cap.isOpened(): ret, frame = cap.read() if frame is None: print("[INFO] End of Video") break frame_count += 1 if need_rotate: frame = cv2.rotate(frame, rotate_side) frame = cv2.resize(frame, output_video_size) # skip frame for faster processing if frame_count < next_frame: out.write(frame) continue next_frame = frame_count + frame_rate print("frame_count: ", frame_count) # frame = cv2.resize(frame, video_size) try: processed_frame, all_license_plates, total_cars = predict_one_image( frame, model, name="frame_{}".format(frame_count)) license_list.append(all_license_plates) if total_cars == 0: next_frame = frame_count + frame_rate * 5 except Exception as ex: print("=======> Error: ", ex) print(traceback.format_exc()) # or print(sys.exc_info()[2]) processed_frame = frame # cv2.imshow('video', processed_frame) # cv2.imwrite("/src/output/images/frame_{}.jpeg".format(frame_count), processed_frame) out.write(processed_frame) if cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() cv2.destroyAllWindows() # choose license plate selected_license_plates = select_license_plate(license_list, queue_size=5, match_size=3) print("selected_license_plates: ", selected_license_plates) # write to result file writer = open(output_file, "w") for cur_license in selected_license_plates: if cur_license is not None: writer.write(cur_license + "\n") writer.close() print("Finished processing video")