813 lines
26 KiB
Python
813 lines
26 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from distutils.spawn import find_executable
|
|
from glob import glob
|
|
from os.path import exists
|
|
import fractions
|
|
import logging
|
|
import math
|
|
import os
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import tempfile
|
|
import time
|
|
|
|
import numpy as np
|
|
import ox
|
|
import ox.image
|
|
from ox.utils import json
|
|
from django.conf import settings
|
|
from PIL import Image
|
|
|
|
from .chop import Chop, make_keyframe_index
|
|
|
|
|
|
logger = logging.getLogger('pandora.' + __name__)
|
|
|
|
img_extension = 'jpg'
|
|
|
|
MAX_DISTANCE = math.sqrt(3 * pow(255, 2))
|
|
|
|
|
|
class AspectRatio(fractions.Fraction):
|
|
|
|
def __new__(cls, numerator, denominator=None):
|
|
if not denominator:
|
|
ratio = list(map(int, numerator.split(':')))
|
|
if len(ratio) == 1:
|
|
ratio.append(1)
|
|
numerator = ratio[0]
|
|
denominator = ratio[1]
|
|
# if its close enough to the common aspect ratios rather use that
|
|
if abs(numerator/denominator - 4/3) < 0.03:
|
|
numerator = 4
|
|
denominator = 3
|
|
elif abs(numerator/denominator - 16/9) < 0.02:
|
|
numerator = 16
|
|
denominator = 9
|
|
return super(AspectRatio, cls).__new__(cls, numerator, denominator)
|
|
|
|
@property
|
|
def ratio(self):
|
|
return "%d:%d" % (self.numerator, self.denominator)
|
|
|
|
def supported_formats():
|
|
if not find_executable(settings.FFMPEG):
|
|
return None
|
|
p = subprocess.Popen([settings.FFMPEG, '-codecs'],
|
|
stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True)
|
|
stdout, stderr = p.communicate()
|
|
stdout = stdout.decode('utf-8')
|
|
stderr = stderr.decode('utf-8')
|
|
version = stderr.split('\n')[0].split(' ')[2]
|
|
mp4 = 'libx264' in stdout and bool(re.compile('DEA.L. aac').findall(stdout))
|
|
return {
|
|
'version': version.split('.'),
|
|
'ogg': 'libtheora' in stdout and 'libvorbis' in stdout,
|
|
'webm': 'libvpx' in stdout and 'libvorbis' in stdout,
|
|
'vp8': 'libvpx' in stdout and 'libvorbis' in stdout,
|
|
'vp9': 'libvpx-vp9' in stdout and 'libopus' in stdout,
|
|
'mp4': mp4,
|
|
'h264': mp4,
|
|
}
|
|
|
|
def stream(video, target, profile, info, audio_track=0, flags={}):
|
|
if not os.path.exists(target):
|
|
ox.makedirs(os.path.dirname(target))
|
|
|
|
'''
|
|
WebM look into
|
|
lag
|
|
mb_static_threshold
|
|
qmax/qmin
|
|
rc_buf_aggressivity=0.95
|
|
token_partitions=4
|
|
level / speedlevel
|
|
bt?
|
|
H264, should bitrates be a bit lower? other stuff possible?
|
|
'''
|
|
profile, format = profile.split('.')
|
|
bpp = 0.17
|
|
video_codec = 'libvpx'
|
|
audio_codec = 'libvorbis'
|
|
|
|
if 'error' in info:
|
|
return False, "Unsupported Format"
|
|
|
|
if profile == '1080p':
|
|
height = 1080
|
|
|
|
audiorate = 48000
|
|
audioquality = 6
|
|
audiobitrate = None
|
|
audiochannels = None
|
|
elif profile == '720p':
|
|
height = 720
|
|
|
|
audiorate = 48000
|
|
audioquality = 5
|
|
audiobitrate = None
|
|
audiochannels = None
|
|
elif profile == '480p':
|
|
height = 480
|
|
|
|
audiorate = 44100
|
|
audioquality = 3
|
|
audiobitrate = None
|
|
audiochannels = 2
|
|
elif profile == '432p':
|
|
height = 432
|
|
audiorate = 44100
|
|
audioquality = 3
|
|
audiobitrate = None
|
|
audiochannels = 2
|
|
elif profile == '360p':
|
|
height = 360
|
|
|
|
audiorate = 44100
|
|
audioquality = 1
|
|
audiobitrate = None
|
|
audiochannels = 1
|
|
elif profile == '288p':
|
|
height = 288
|
|
|
|
audiorate = 44100
|
|
audioquality = 0
|
|
audiobitrate = None
|
|
audiochannels = 1
|
|
elif profile == '240p':
|
|
height = 240
|
|
|
|
audiorate = 44100
|
|
audioquality = 0
|
|
audiobitrate = None
|
|
audiochannels = 1
|
|
elif profile == '144p':
|
|
height = 144
|
|
|
|
audiorate = 22050
|
|
audioquality = -1
|
|
audiobitrate = '22k'
|
|
audiochannels = 1
|
|
elif profile == '0p':
|
|
info['video'] = []
|
|
audiorate = 48000
|
|
audioquality = 6
|
|
audiobitrate = None
|
|
audiochannels = None
|
|
audio_codec = 'libopus'
|
|
else:
|
|
height = 96
|
|
|
|
if settings.USE_VP9 and settings.FFMPEG_SUPPORTS_VP9:
|
|
audio_codec = 'libopus'
|
|
video_codec = 'libvpx-vp9'
|
|
|
|
audiorate = 22050
|
|
audioquality = -1
|
|
audiobitrate = '22k'
|
|
audiochannels = 1
|
|
|
|
if format == 'webm' and audio_codec == 'libopus':
|
|
audiorate = 48000
|
|
if not audiobitrate:
|
|
audiobitrate = '%sk' % {
|
|
-1: 32, 0: 48, 1: 64, 2: 96, 3: 112, 4: 128,
|
|
5: 144, 6: 160, 7: 192, 8: 256, 9: 320, 10: 512,
|
|
}[audioquality]
|
|
if format == 'webm' and video_codec == 'libvpx-vp9':
|
|
bpp = 0.15
|
|
|
|
if info['video'] and 'display_aspect_ratio' in info['video'][0]:
|
|
# dont make video bigger
|
|
height = min(height, info['video'][0]['height'])
|
|
|
|
fps = AspectRatio(info['video'][0]['framerate'])
|
|
fps = min(30, float(fps))
|
|
|
|
dar = AspectRatio(info['video'][0]['display_aspect_ratio'])
|
|
width = int(dar * height)
|
|
width += width % 2
|
|
|
|
aspect = dar.ratio
|
|
# use 1:1 pixel aspect ratio if dar is close to that
|
|
if abs(width/height - dar) < 0.02:
|
|
aspect = '%s:%s' % (width, height)
|
|
|
|
# parse extra falgs
|
|
if 'crop' in flags:
|
|
h = info['video'][0]['height'] - flags['crop']['top'] - flags['crop']['bottom']
|
|
w = info['video'][0]['width'] - flags['crop']['left'] - flags['crop']['right']
|
|
x = flags['crop']['left']
|
|
y = flags['crop']['top']
|
|
crop = ',crop=w=%s:h=%s:x=%s:y=%s' % (w, h, x, y)
|
|
aspect = dar * (info['video'][0]['width'] / info['video'][0]['height']) * (w/h)
|
|
if abs(w/h - aspect) < 0.02:
|
|
aspect = '%s:%s' % (w, h)
|
|
else:
|
|
crop = ''
|
|
if 'trim' in flags:
|
|
trim = []
|
|
if 'in' in flags['trim']:
|
|
start = flags['trim']['in']
|
|
trim += ['-ss', str(start)]
|
|
if 'out' in flags['trim']:
|
|
t = info['duration'] - flags['trim'].get('in', 0) - flags['trim']['out']
|
|
trim += ['-t', str(t)]
|
|
else:
|
|
trim = []
|
|
if 'aspect' in flags:
|
|
aspect = flags['aspect']
|
|
|
|
bitrate = height*width*fps*bpp/1000
|
|
|
|
video_settings = trim + [
|
|
'-b:v', '%dk' % bitrate,
|
|
'-aspect', aspect,
|
|
# '-vf', 'yadif',
|
|
'-max_muxing_queue_size', '512',
|
|
'-vf', 'hqdn3d%s,scale=%s:%s' % (crop, width, height),
|
|
'-g', '%d' % int(fps*5),
|
|
]
|
|
if format == 'webm':
|
|
video_settings += [
|
|
'-c:v', video_codec,
|
|
'-deadline', 'good',
|
|
'-cpu-used', '1' if video_codec == 'libvpx-vp9' else '0',
|
|
'-lag-in-frames', '25',
|
|
'-auto-alt-ref', '1',
|
|
]
|
|
if video_codec == 'libvpx-vp9':
|
|
video_settings += [
|
|
'-tile-columns', '6',
|
|
'-frame-parallel', '1',
|
|
]
|
|
if format == 'mp4':
|
|
video_settings += [
|
|
'-c:v', 'libx264',
|
|
'-preset:v', 'medium',
|
|
'-profile:v', 'high',
|
|
'-level', '4.0',
|
|
'-pix_fmt', 'yuv420p',
|
|
]
|
|
video_settings += ['-map', '0:%s,0:0' % info['video'][0]['id']]
|
|
audio_only = False
|
|
else:
|
|
video_settings = ['-vn']
|
|
audio_only = True
|
|
|
|
# ignore some unsupported audio codecs
|
|
if info['audio'] and info['audio'][0].get('codec') in ('qdmc', ):
|
|
audio_settings = ['-an']
|
|
elif info['audio']:
|
|
if video_settings == ['-vn'] or not info['video']:
|
|
n = 0
|
|
else:
|
|
n = 1
|
|
audio_settings = []
|
|
# mix 2 mono channels into stereo(common for fcp dv mov files)
|
|
if audio_track == 0 and len(info['audio']) == 2 \
|
|
and len(list(filter(None, [a['channels'] == 1 or None for a in info['audio']]))) == 2:
|
|
audio_settings += [
|
|
'-filter_complex',
|
|
'[0:%s][0:%s] amerge' % (info['audio'][0]['id'], info['audio'][1]['id'])
|
|
]
|
|
mono_mix = True
|
|
else:
|
|
mono_mix = False
|
|
audio_settings += ['-map', '0:%s,0:%s' % (info['audio'][audio_track]['id'], n)]
|
|
audio_settings += ['-ar', str(audiorate)]
|
|
if audio_codec != 'libopus':
|
|
audio_settings += ['-aq', str(audioquality)]
|
|
if mono_mix:
|
|
ac = 2
|
|
else:
|
|
ac = info['audio'][0].get('channels')
|
|
if not ac:
|
|
ac = audiochannels
|
|
if audiochannels:
|
|
ac = min(ac, audiochannels)
|
|
audio_settings += ['-ac', str(ac)]
|
|
if audiobitrate:
|
|
audio_settings += ['-b:a', audiobitrate]
|
|
if format == 'mp4':
|
|
audio_settings += ['-c:a', 'aac', '-strict', '-2']
|
|
elif audio_codec == 'libopus':
|
|
audio_settings += ['-c:a', 'libopus', '-frame_duration', '60']
|
|
else:
|
|
audio_settings += ['-c:a', audio_codec]
|
|
else:
|
|
audio_settings = ['-an']
|
|
|
|
cmds = []
|
|
|
|
base = [settings.FFMPEG,
|
|
'-nostats', '-loglevel', 'error',
|
|
'-y', '-i', video, '-threads', '4', '-map_metadata', '-1', '-sn']
|
|
|
|
if format == 'webm':
|
|
enc_target = target + '.tmp.webm'
|
|
elif format == 'mp4':
|
|
enc_target = target + '.tmp.mp4'
|
|
else:
|
|
enc_target = target
|
|
|
|
if format == 'webm':
|
|
post = ['-f', 'webm', enc_target]
|
|
elif format == 'mp4':
|
|
post = ['-movflags', '+faststart', '-f', 'mp4', enc_target]
|
|
else:
|
|
post = [target]
|
|
if video_settings != ['-vn']:
|
|
pass1_post = post[:]
|
|
pass1_post[-1] = '/dev/null'
|
|
if format == 'webm':
|
|
if video_codec != 'libvpx-vp9':
|
|
pass1_post = ['-speed', '4'] + pass1_post
|
|
post = ['-speed', '1'] + post
|
|
cmds.append(base + ['-pass', '1', '-passlogfile', '%s.log' % target]
|
|
+ video_settings + ['-an'] + pass1_post)
|
|
cmds.append(base + ['-pass', '2', '-passlogfile', '%s.log' % target]
|
|
+ video_settings + audio_settings + post)
|
|
else:
|
|
cmds.append(base + video_settings + audio_settings + post)
|
|
|
|
if settings.FFMPEG_DEBUG:
|
|
print('\n'.join([' '.join(cmd) for cmd in cmds]))
|
|
|
|
n = 0
|
|
for cmd in cmds:
|
|
n += 1
|
|
p = subprocess.Popen(cmd, stdin=subprocess.PIPE,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
close_fds=True)
|
|
stdout, stderr = p.communicate()
|
|
|
|
if p.returncode != 0:
|
|
if os.path.exists(enc_target):
|
|
os.unlink(enc_target)
|
|
if os.path.exists(target):
|
|
os.unlink(target)
|
|
stdout = stdout.decode('utf-8').replace('\r\n', '\n').replace('\r', '\n')
|
|
return False, stdout
|
|
if format == 'webm' and audio_only:
|
|
cmd = ['mkvmerge', '-w', '-o', target, '--cues', '-1:all', enc_target]
|
|
p = subprocess.Popen(cmd, stdin=subprocess.PIPE,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
close_fds=True)
|
|
p.communicate()
|
|
os.unlink(enc_target)
|
|
enc_target = target
|
|
if p.returncode == 0 and enc_target != target:
|
|
shutil.move(enc_target, target)
|
|
for f in glob('%s.log*' % target):
|
|
os.unlink(f)
|
|
if info['video']:
|
|
make_keyframe_index(target)
|
|
return True, None
|
|
|
|
|
|
def run_command(cmd, timeout=10):
|
|
# print(cmd)
|
|
p = subprocess.Popen(cmd, stdout=open('/dev/null', 'w'),
|
|
stderr=subprocess.STDOUT,
|
|
close_fds=True)
|
|
while timeout > 0:
|
|
time.sleep(0.2)
|
|
timeout -= 0.2
|
|
if p.poll() is not None:
|
|
return p.returncode
|
|
if p.poll() is None:
|
|
os.kill(p.pid, 9)
|
|
killedpid, stat = os.waitpid(p.pid, os.WNOHANG)
|
|
return p.returncode
|
|
|
|
|
|
def frame(video, frame, position, height=128, redo=False, info=None):
|
|
'''
|
|
params:
|
|
video input
|
|
frame output
|
|
position as float in seconds
|
|
height of frame
|
|
redo boolean to extract file even if it exists
|
|
'''
|
|
if exists(video):
|
|
folder = os.path.dirname(frame)
|
|
if redo or not exists(frame):
|
|
ox.makedirs(folder)
|
|
if video.endswith('.mp4'):
|
|
cmd = ffmpeg_frame_cmd(video, frame, position, height)
|
|
else:
|
|
cmd = ['oxframe', '-i', video, '-o', frame,
|
|
'-p', str(position), '-y', str(height)]
|
|
run_command(cmd)
|
|
|
|
def ffmpeg_frame_cmd(video, frame, position, height=128):
|
|
cmd = [
|
|
settings.FFMPEG, '-y',
|
|
'-ss', str(position),
|
|
'-i', video,
|
|
'-an', '-frames:v', '1',
|
|
'-vf', 'scale=-1:%s' % height if height else 'scale=iw*sar:ih',
|
|
frame
|
|
]
|
|
return cmd
|
|
|
|
|
|
def ffmpeg_version():
|
|
p = subprocess.Popen([settings.FFMPEG],
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.PIPE, close_fds=True)
|
|
stdout, stderr = p.communicate()
|
|
version = stderr.split(' ')[2].split('-')[0]
|
|
try:
|
|
version = tuple(map(int, version.split('.')))
|
|
except:
|
|
pass
|
|
return version
|
|
|
|
|
|
def frame_direct(video, target, position):
|
|
fdir = os.path.dirname(target)
|
|
if fdir and not os.path.exists(fdir):
|
|
os.makedirs(fdir)
|
|
cmd = ffmpeg_frame_cmd(video, target, position, None)
|
|
r = run_command(cmd)
|
|
return r == 0
|
|
|
|
|
|
def resize_image(image_source, image_output, width=None, size=None):
|
|
if exists(image_source):
|
|
source = Image.open(image_source).convert('RGB')
|
|
source_width = source.size[0]
|
|
source_height = source.size[1]
|
|
if size:
|
|
if source_width > source_height:
|
|
width = size
|
|
height = int(width / (float(source_width) / source_height))
|
|
height = height - height % 2
|
|
else:
|
|
height = size
|
|
width = int(height * (float(source_width) / source_height))
|
|
width = width - width % 2
|
|
|
|
else:
|
|
height = int(width / (float(source_width) / source_height))
|
|
height = height - height % 2
|
|
|
|
width = max(width, 1)
|
|
height = max(height, 1)
|
|
|
|
if width < source_width:
|
|
resize_method = Image.LANCZOS
|
|
else:
|
|
resize_method = Image.BICUBIC
|
|
output = source.resize((width, height), resize_method)
|
|
output.save(image_output)
|
|
|
|
|
|
def timeline(video, prefix, modes=None, size=None):
|
|
if modes is None:
|
|
modes = ['antialias', 'slitscan', 'keyframes', 'audio', 'data']
|
|
if size is None:
|
|
size = [64, 16]
|
|
if isinstance(video, str):
|
|
video = [video]
|
|
cmd = [os.path.normpath(os.path.join(settings.BASE_DIR, '../bin/oxtimelines')),
|
|
'-s', ','.join(map(str, reversed(sorted(size)))),
|
|
'-m', ','.join(modes),
|
|
'-o', prefix,
|
|
'-c', os.path.join(prefix, 'cuts.json'),
|
|
] + video
|
|
# print(cmd)
|
|
p = subprocess.Popen(cmd, stdin=subprocess.PIPE,
|
|
close_fds=True)
|
|
p.wait()
|
|
|
|
|
|
def average_color(prefix, start=0, end=0, mode='antialias'):
|
|
height = 64
|
|
frames = 0
|
|
pixels = []
|
|
color = np.asarray([0, 0, 0], dtype=np.float32)
|
|
|
|
if end:
|
|
start = int(start * 25)
|
|
end = int(end * 25)
|
|
mode = 'timeline' + mode
|
|
timelines = ox.sorted_strings(list(filter(lambda t: t != '%s%s%sp.jpg' % (prefix, mode, height),
|
|
glob("%s%s%sp*.jpg" % (prefix, mode, height)))))
|
|
for image in timelines:
|
|
start_offset = 0
|
|
if start and frames + 1500 <= start:
|
|
frames += 1500
|
|
continue
|
|
timeline = Image.open(image)
|
|
frames += timeline.size[0]
|
|
if start and frames > start > frames-timeline.size[0]:
|
|
start_offset = start - (frames-timeline.size[0])
|
|
box = (start_offset, 0, timeline.size[0], height)
|
|
timeline = timeline.crop(box)
|
|
if end and frames > end:
|
|
end_offset = timeline.size[0] - (frames - end)
|
|
box = (0, 0, end_offset, height)
|
|
timeline = timeline.crop(box)
|
|
|
|
p = np.asarray(timeline.convert('RGB'), dtype=np.float32)
|
|
p = np.sum(p, axis=0) / height # average color per frame
|
|
pixels.append(p)
|
|
if end and frames >= end:
|
|
break
|
|
|
|
if end:
|
|
frames = end - start
|
|
if frames:
|
|
for i in range(0, len(pixels)):
|
|
p = np.sum(pixels[i], axis=0) / frames
|
|
color += p
|
|
color = list(map(float, color))
|
|
return ox.image.getHSL(color)
|
|
|
|
|
|
def average_volume(prefix, start=0, end=0):
|
|
return average_color(prefix, start, end, 'audio')[2]
|
|
|
|
|
|
def get_distance(rgb0, rgb1):
|
|
# rgb distance, normalized so that black/white equals 1
|
|
dst = math.sqrt(pow(rgb0[0] - rgb1[0], 2) + pow(rgb0[1] - rgb1[1], 2) + pow(rgb0[2] - rgb1[2], 2))
|
|
return dst / MAX_DISTANCE
|
|
|
|
|
|
def cuts(prefix):
|
|
fname = os.path.join(prefix, 'cuts.json')
|
|
if not os.path.exists(fname):
|
|
return []
|
|
with open(fname) as f:
|
|
cuts = json.load(f)
|
|
return cuts
|
|
|
|
|
|
def divide(num, by):
|
|
# >>> divide(100, 3)
|
|
# [33, 33, 34]
|
|
arr = []
|
|
div = int(num / by)
|
|
mod = num % by
|
|
for i in range(int(by)):
|
|
arr.append(div + (i > by - 1 - mod))
|
|
return arr
|
|
|
|
|
|
def timeline_strip(item, cuts, info, prefix):
|
|
_debug = False
|
|
duration = info['duration']
|
|
video_height = info['video'][0]['height']
|
|
video_width = info['video'][0]['width']
|
|
video_ratio = video_width / video_height
|
|
|
|
line_image = []
|
|
timeline_height = 64
|
|
timeline_width = 1500
|
|
fps = 25
|
|
frames = int(duration * fps)
|
|
if cuts[0] != 0:
|
|
cuts.insert(0, 0)
|
|
|
|
cuts = list(map(lambda x: int(round(x * fps)), cuts))
|
|
|
|
for frame in range(frames):
|
|
i = int(frame / timeline_width)
|
|
x = frame % timeline_width
|
|
if x == 0:
|
|
timeline_width = min(timeline_width, frames - frame)
|
|
timeline_image = Image.new('RGB', (timeline_width, timeline_height))
|
|
if frame in cuts:
|
|
c = cuts.index(frame)
|
|
if c + 1 < len(cuts):
|
|
duration = cuts[c + 1] - cuts[c]
|
|
frames = math.ceil(duration / (video_width * timeline_height / video_height))
|
|
widths = divide(duration, frames)
|
|
frame = frame
|
|
if _debug:
|
|
print(widths, duration, frames, cuts[c], cuts[c + 1])
|
|
for s in range(int(frames)):
|
|
frame_ratio = widths[s] / timeline_height
|
|
if video_ratio > frame_ratio:
|
|
width = int(round(video_height * frame_ratio))
|
|
left = int((video_width - width) / 2)
|
|
box = (left, 0, left + width, video_height)
|
|
else:
|
|
height = int(round(video_width / frame_ratio))
|
|
top = int((video_height - height) / 2)
|
|
box = (0, top, video_width, top + height)
|
|
if _debug:
|
|
print(frame, 'cut', c, 'frame', s, frame, 'width', widths[s], box)
|
|
# FIXME: why does this have to be frame+1?
|
|
frame_image = Image.open(item.frame((frame+1)/fps))
|
|
frame_image = frame_image.crop(box).resize((widths[s], timeline_height), Image.LANCZOS)
|
|
for x_ in range(widths[s]):
|
|
line_image.append(frame_image.crop((x_, 0, x_ + 1, timeline_height)))
|
|
frame += widths[s]
|
|
if len(line_image) > frame:
|
|
timeline_image.paste(line_image[frame], (x, 0))
|
|
if x == timeline_width - 1:
|
|
timeline_file = '%sStrip64p%04d.png' % (prefix, i)
|
|
if _debug:
|
|
print('writing', timeline_file)
|
|
timeline_image.save(timeline_file)
|
|
|
|
|
|
def chop(video, start, end, subtitles=None, dest=None, encode=False):
|
|
t = end - start
|
|
ext = os.path.splitext(video)[1]
|
|
if dest is None:
|
|
tmp = tempfile.mkdtemp()
|
|
choped_video = '%s/tmp%s' % (tmp, ext)
|
|
else:
|
|
choped_video = dest
|
|
if subtitles and ext == '.mp4':
|
|
subtitles_f = choped_video + '.full.srt'
|
|
with open(subtitles_f, 'wb') as fd:
|
|
fd.write(subtitles)
|
|
else:
|
|
subtitles_f = None
|
|
if False and ext == '.mp4' and settings.CHOP_SUPPORT:
|
|
Chop(video, choped_video, start, end, subtitles_f)
|
|
if subtitles_f:
|
|
os.unlink(subtitles_f)
|
|
else:
|
|
if encode:
|
|
bpp = 0.17
|
|
if ext == '.mp4':
|
|
vcodec = [
|
|
'-c:v', 'libx264',
|
|
'-preset:v', 'medium',
|
|
'-profile:v', 'high',
|
|
'-level', '4.0',
|
|
]
|
|
acodec = [
|
|
'-c:a', 'aac',
|
|
'-aq', '6',
|
|
'-strict', '-2'
|
|
]
|
|
else:
|
|
vcodec = [
|
|
'-c:v', 'libvpx',
|
|
'-deadline', 'good',
|
|
'-cpu-used', '0',
|
|
'-lag-in-frames', '25',
|
|
'-auto-alt-ref', '1',
|
|
]
|
|
acodec = [
|
|
'-c:a', 'libvorbis',
|
|
'-aq', '6',
|
|
]
|
|
info = ox.avinfo(video)
|
|
if not info['audio']:
|
|
acodec = []
|
|
if not info['video']:
|
|
vcodec = []
|
|
else:
|
|
height = info['video'][0]['height']
|
|
width = info['video'][0]['width']
|
|
fps = 30
|
|
bitrate = height*width*fps*bpp/1000
|
|
vcodec += ['-vb', '%dk' % bitrate]
|
|
encoding = vcodec + acodec
|
|
else:
|
|
encoding = [
|
|
'-c:v', 'copy',
|
|
'-c:a', 'copy',
|
|
]
|
|
cmd = [
|
|
settings.FFMPEG,
|
|
'-y',
|
|
'-i', video,
|
|
'-ss', '%.3f' % start,
|
|
'-t', '%.3f' % t,
|
|
] + encoding + [
|
|
'-f', ext[1:],
|
|
choped_video
|
|
]
|
|
print(cmd)
|
|
p = subprocess.Popen(cmd, stdin=subprocess.PIPE,
|
|
stdout=open('/dev/null', 'w'),
|
|
stderr=open('/dev/null', 'w'),
|
|
close_fds=True)
|
|
p.wait()
|
|
if subtitles_f and os.path.exists(subtitles_f):
|
|
os.unlink(subtitles_f)
|
|
if dest is None:
|
|
f = open(choped_video, 'rb')
|
|
os.unlink(choped_video)
|
|
os.rmdir(tmp)
|
|
return f
|
|
else:
|
|
return None
|
|
|
|
def has_faststart(path):
|
|
cmd = [settings.FFPROBE, '-v', 'trace', '-i', path]
|
|
p = subprocess.Popen(cmd, stdin=subprocess.PIPE,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
close_fds=True)
|
|
stdout, stderr = p.communicate()
|
|
moov = "type:'moov'"
|
|
mdat = "type:'mdat'"
|
|
blocks = [b for b in stdout.decode().split('\n') if moov in b or mdat in b]
|
|
if blocks and moov in blocks[0]:
|
|
return True
|
|
return False
|
|
|
|
def remux_stream(src, dst):
|
|
info = ox.avinfo(src)
|
|
if info.get('audio'):
|
|
audio = ['-c:a', 'copy']
|
|
else:
|
|
audio = []
|
|
if info.get('video'):
|
|
video = ['-c:v', 'copy']
|
|
else:
|
|
video = []
|
|
cmd = [
|
|
settings.FFMPEG,
|
|
'-nostats', '-loglevel', 'error',
|
|
'-i', src,
|
|
'-map_metadata', '-1', '-sn',
|
|
] + video + [
|
|
] + audio + [
|
|
'-movflags', '+faststart',
|
|
dst
|
|
]
|
|
print(cmd)
|
|
p = subprocess.Popen(cmd, stdin=subprocess.PIPE,
|
|
stdout=subprocess.PIPE,
|
|
stderr=subprocess.STDOUT,
|
|
close_fds=True)
|
|
stdout, stderr = p.communicate()
|
|
if stderr:
|
|
logger.error("failed to remux %s %s", cmd, stderr)
|
|
return False, stderr
|
|
else:
|
|
return True, None
|
|
|
|
|
|
def ffprobe(path, *args):
|
|
cmd = [settings.FFPROBE, '-loglevel', 'error', '-print_format', 'json', '-i', path] + list(args)
|
|
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True)
|
|
stdout, stderr = p.communicate()
|
|
return json.loads(stdout.decode())
|
|
|
|
|
|
def get_chapters(path):
|
|
info = ffprobe(path, '-show_chapters')
|
|
chapters = []
|
|
n = 0
|
|
for chapter in info.get('chapters', []):
|
|
n += 1
|
|
chapters.append({
|
|
'in': chapter['start_time'],
|
|
'out': chapter['end_time'],
|
|
'value': chapter.get('tags', {}).get('title', 'Chapter %s' % n)
|
|
})
|
|
return chapters
|
|
|
|
def get_text_subtitles(path):
|
|
subtitles = []
|
|
for stream in ffprobe(path, '-show_streams')['streams']:
|
|
if stream.get('codec_name') in ('subrip', 'aas', 'text'):
|
|
subtitles.append({
|
|
'index': stream['index'],
|
|
'language': stream['tags']['language'],
|
|
})
|
|
return subtitles
|
|
|
|
def has_img_subtitles(path):
|
|
subtitles = []
|
|
for stream in ffprobe(path, '-show_streams')['streams']:
|
|
if stream.get('codec_type') == 'subtitle' and stream.get('codec_name') in ('dvbsub', 'pgssub'):
|
|
subtitles.append({
|
|
'index': stream['index'],
|
|
'language': stream['tags']['language'],
|
|
})
|
|
return subtitles
|
|
|
|
def extract_subtitles(path, language=None):
|
|
extra = []
|
|
if language:
|
|
tracks = get_text_subtitles(path)
|
|
track = [t for t in tracks if t['language'] == language]
|
|
if track:
|
|
extra = ['-map', '0:%s' % track[0]['index']]
|
|
else:
|
|
raise Exception("unknown language: %s" % language)
|
|
cmd = ['ffmpeg', '-loglevel', 'error', '-i', path] + extra + ['-f', 'srt', '-']
|
|
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True)
|
|
stdout, stderr = p.communicate()
|
|
return ox.srt.loads(stdout.decode())
|