def encode():
# Configure objetcts
config = util.Config('config.json')
sl = util.check_system()['sl']
# Create video object and your main folders
video = util.VideoParams(config=config,
yuv=f'..{sl}yuv-full',
hevc_base='hevc',
mp4_base='mp4',
segment_base='segment',
dectime_base='dectime')
# Set basic configuration
video.encoder = 'ffmpeg'
video.project = 'ffmpeg_crf_18videos_60s'
video.factor = 'crf'
# iterate over 3 factors: video (complexity), tiles format, quality
for video.name in config.videos_list:
for video.tile_format in config.tile_list:
for video.quality in getattr(config, f'{video.factor}_list'):
util.encode(video)
# util.encapsule(video)
# util.extract_tile(video)
util.make_segments(video)
def main():
programs = util.check_system()
kvazaar = programs['kvazaar']
sl = programs['sl']
# videos = util.list_videos('input.json')
videos = {"pac_man": 0, "rollercoaster": 0, "lions": 0, "om_non": 0}
videos = {"om_nom": 0}
for name in videos:
for tile in tile_list:
m, n = list(map(int, tile.split('x')))
for rate, qp in list(zip(rate_list, qp_list)):
for tile_count in range(1, (m * n) + 1):
folder = f'{name}_{scale}_{fps}_{tile}'
filename = f'{folder}_tile{tile_count}'
filepath_in = f'yuv{sl}{folder}{sl}{filename}.yuv'
os.makedirs(f'hevc{sl}{folder}', exist_ok=True)
filepath_out_rate = f'hevc{sl}{folder}{sl}{folder}_rate{rate}_tile{tile_count}'
filepath_out_qp = f'hevc{sl}{folder}{sl}{folder}_qp{qp}_tile{tile_count}'
params_common = (f'--input {filepath_in} '
f'--input-res {scale} '
f'--input-fps {fps} '
f'-p {gop} '
'--no-tmvp '
'--no-open-gop')
params_rate = f'{params_common} --bitrate {rate} --output {filepath_out_rate + ".hevc"}'
params_qp = f'{params_common} --qp {qp} --output {filepath_out_qp + ".hevc"}'
if os.path.isfile(filepath_out_rate + '.hevc'):
print(
f'arquivo {filepath_out_rate + ".hevc"} existe. Pulando.'
)
else:
command = f'{kvazaar} {params_rate}'
with open(filepath_out_rate + '.log',
'w',
encoding='utf-8') as f:
print(command)
subprocess.run(command,
shell=True,
stdout=f,
stderr=subprocess.STDOUT)
if os.path.isfile(filepath_out_qp + '.hevc'):
print(
f'arquivo {filepath_out_qp + ".hevc"} existe. Pulando.'
)
else:
command = f'{kvazaar} {params_qp}'
with open(filepath_out_qp + '.log',
'w',
encoding='utf-8') as f:
print(command)
subprocess.run(command,
shell=True,
stdout=f,
stderr=subprocess.STDOUT)
def main():
programs = util.check_system()
sl = programs['sl']
mp4client = programs['mp4client']
qp_list = [20, 25, 30, 35, 40]
rate_list = [2000000, 4000000, 8000000, 16000000, 24000000]
# rate_list = [8000000]
tile_list = ['1x1', '6x4', '12x8']
# tile_list = ['12x8']
# videos = util.list_videos('input.json')
# videos = {"pac_man": 0,
# "rollercoaster": 0,
# "lions": 0,
# "om_nom": 0}
videos = {'rollercoaster': 0, 'lions': 0}
for i in range(1):
for name in videos:
for tile in tile_list:
m, n = list(map(int, tile.split('x')))
for rate, qp in list(zip(rate_list, qp_list)):
out_folder = f'dectime{sl}{name}_{tile}_rate{rate}'
os.makedirs(out_folder, exist_ok=True)
for t in range(1, m * n + 1):
for chunk in range(1, duration + 1):
video_path = f'dash{sl}{name}_{scale}_{fps}_{tile}_rate{rate}{sl}segments{sl}{name}_tile{t}_track{t + 1}_{chunk:03}'
log_path = f'{out_folder}{sl}{name}_tile{t}_{chunk:03}'
command = f'start /b /wait /affinity 0x800 {mp4client} -bench {video_path}.mp4'
print('\n' + command)
while True:
with open('temp.tmp', 'w',
encoding='utf-8') as f1:
p = subprocess.run(
command,
shell=True,
stdout=f1,
stderr=subprocess.STDOUT)
print(f'returncode = {p.returncode}')
if p.returncode == 0:
with open('temp.tmp', 'r', encoding='utf-8') as f1, \
open(f'{log_path}.log', 'a', encoding='utf-8') as f2:
f2.write(f1.read())
break
else:
print(
f'Algum erro. Exitcode == {p.returncode}. Tentando novamente.'
)
def main():
programs = util.check_system()
mp4box = programs['mp4box']
sl = programs['sl']
# videos = util.list_videos('input.json')
videos = {"pac_man": 0}
# "rollercoaster": 0,
# "lions": 0,
# "om-non": 0}
for name in videos:
for tile in tile_list:
m, n = list(map(int, tile.split('x')))
for rate, qp in list(zip(rate_list, qp_list)):
for tile_count in range(1, (m * n) + 1):
basename = f'{name}_{scale}_{fps}_{tile}'
mp4_folder = f'mp4{sl}{basename}'
rate_name = f'{basename}_rate{rate}_tile{tile_count}'
qp_name = f'{basename}_rate{rate}_tile{tile_count}'
rate_dash_folder = f'{mp4_folder}{sl}rate_dash'
qp_dash_folder = f'{mp4_folder}{sl}qp_dash'
rate_ini_name = f'{rate_name}_dashinit.mp4'
qp_ini_name = f'{qp_name}_dashinit.mp4'
with open(f'{rate_dash_folder}{sl}{rate_ini_name}', 'rb') as f_rate_ini, \
open(f'{qp_dash_folder}{sl}{qp_ini_name}', 'rb') as f_qp_ini:
for chunk in range(1, duration + 1):
dash_rate_name = f'{basename}_rate{rate}_tile{tile_count}_dash{chunk}'
with open(f'{rate_dash_folder}{sl}{dash_rate_name}.m4s', 'rb') as f_rate_chunk, \
open(f'{rate_dash_folder}{sl}{dash_rate_name}.mp4', 'wb') as f_rate_chunk_mp4:
f_rate_chunk_mp4.write(f_rate_ini.read())
f_rate_chunk_mp4.write(f_rate_chunk.read())
dash_qp_name = f'{basename}_rate{rate}_tile{tile_count}_dash{chunk}'
with open(f'{qp_dash_folder}{sl}{dash_qp_name}.m4s', 'rb') as f_qp_chunk, \
open(f'{qp_dash_folder}{sl}{dash_qp_name}.mp4', 'wb') as f_qp_chunk_mp4:
f_qp_chunk_mp4.write(f_rate_ini.read())
f_qp_chunk_mp4.write(f_qp_chunk.read())
if __name__ == '__main__':
main()
def main():
programs = util.check_system()
sl = programs['sl']
ffmpeg = programs['ffmpeg']
with open('input.json', 'r') as f:
video_list = json.load(f)
p_count = 0
proc = []
for name in video_list:
ss = video_list[name]
base_name = f'{name}_{scale}_{fps}'
folder_in = f'original{sl}'
folder_out = f'yuv{sl}'
filepath_in = f'{folder_in}{name}.mp4'
filepath_out = f'{folder_out}{base_name}.yuv'
os.makedirs(folder_out, exist_ok=True)
par_in = ('-n -hide_banner ' f'-ss {ss} ' f'-i {filepath_in}')
par_out = (f'-t {duration} '
f'-r {fps} '
f'-vf scale={scale} '
'-map 0:0 '
f'{filepath_out}')
command = f'{ffmpeg} {par_in} {par_out}'
print(command + '\n')
p = subprocess.Popen([command], shell=True, stderr=subprocess.DEVNULL)
proc.append(p)
p_count += 1
while p_count >= 3:
time.sleep(1)
print('.', end='', flush=True)
for p in proc:
if p.poll() is not None:
print('\nConcluindo processo :')
proc.remove(p)
p_count -= 1
break
for p in proc:
p.wait()
def main():
sl = util.check_system()['sl']
# videos = util.list_videos('input.json')
videos = {"rollercoaster": 0, "lions": 0}
for name in videos:
for tile in tile_list:
for rate, qp in list(zip(rate_list, qp_list)):
# ----------------------------------------------
# Encode
# ----------------------------------------------
yuv_video_name = f'yuv{sl}{name}_{scale}_{fps}'
hevc_video = util.encode(name=name,
scale=scale,
gop=gop,
fps=fps,
tile=tile,
yuv_video_name=yuv_video_name,
quality=rate,
factor='rate')
# ----------------------------------------------
# Encapsule
# ----------------------------------------------
mp4_video = util.encapsule(name=name,
scale=scale,
fps=fps,
tile=tile,
hevc_video=hevc_video,
quality=rate,
factor='rate')
# ----------------------------------------------
# Extract and segment Tiles
# ----------------------------------------------
util.extract_segment(name=name,
scale=scale,
fps=fps,
tile=tile,
mp4_video=mp4_video,
quality=rate,
factor='rate')
def encode():
config = util.Config('config.json')
sl = util.check_system()['sl']
video = util.VideoParams(config=config,
yuv=f'..{sl}yuv-full',
hevc_base='hevc',
mp4_base='mp4',
segment_base='segment',
dectime_base='dectime',
project='ffmpeg-60s-qp',
encoder='ffmpeg',
factor='crf')
# for video.name in config.videos_list:
for video.name in ['om_nom', 'rollercoaster']:
for video.tile_format in config.tile_list:
for video.quality in getattr(config, f'{video.factor}_list'):
util.encode(video)
def main():
programs = util.check_system()
sl = programs['sl']
siti = programs['siti']
with open('input.json', 'r') as f:
video_list = json.load(f)
for name in video_list:
base_name = f'{name}_{scale}_{fps}'
folder_in = f'yuv{sl}'
filepath_in = f'{folder_in}{base_name}.yuv'
filepath_out = f'{folder_in}{base_name}.log'
params = (f'-w {w} ' f'-h {h} ' '-f 1 ' '-s ' f'-i {filepath_in}')
command = f'{siti} {params}'
print(command)
with open(filepath_out, 'w') as f:
subprocess.run(command,
stdout=f,
stderr=subprocess.STDOUT,
encoding='utf-8')
#!/bin/python3
import itertools
import os
import json
import numpy as np
import matplotlib.pyplot as plt
from utils import util
from utils import util_stats
programs = util.check_system()
sl = programs['sl']
duration = 10
scale = '4320x2160'
w = 4320
h = 2160
fps = 30
gop = 30
qp_list = [20, 25, 30, 35, 40]
rate_list = [2000000, 4000000, 8000000, 16000000, 24000000]
tile_list = ['1x1', '6x4', '12x8']
# videos = {"pac_man": 0,
# "rollercoaster": 0,
# "lions": 0,
# "om_nom": 0}
# videos = {"rollercoaster": 0,
# "lions": 0,
# "om_nom": 0}
videos = {"rollercoaster": 0, "lions": 0}
def main():
programs = util.check_system()
mp4box = programs['mp4box']
sl = programs['sl']
# videos = util.list_videos('input.json')
videos = {"pac_man": 0, "rollercoaster": 0}
#"lions": 0,
#"om_non": 0}
for name in videos:
for tile in tile_list:
m, n = list(map(int, tile.split('x')))
for rate, qp in list(zip(rate_list, qp_list)):
for tile_count in range(1, (m * n) + 1):
folder = f'{name}_{scale}_{fps}_{tile}'
filepath_in_rate = f'hevc{sl}{folder}{sl}{folder}_rate{rate}_tile{tile_count}'
filepath_in_qp = f'hevc{sl}{folder}{sl}{folder}_qp{qp}_tile{tile_count}'
os.makedirs(f'mp4{sl}{folder}', exist_ok=True)
filepath_out_rate = f'mp4{sl}{folder}{sl}{folder}_rate{rate}_tile{tile_count}'
filepath_out_qp = f'mp4{sl}{folder}{sl}{folder}_qp{qp}_tile{tile_count}'
if os.path.isfile(filepath_out_rate + '.mp4'):
print(
f'arquivo {filepath_out_rate + ".hevc"} existe. Pulando.'
)
else:
command = f'{mp4box} -add {filepath_in_rate}.hevc:split_tiles -new {filepath_out_rate}.mp4'
print(command)
with open(filepath_out_rate + '.log',
'w',
encoding='utf-8') as f:
subprocess.run(command,
shell=True,
stdout=f,
stderr=subprocess.STDOUT)
if os.path.isfile(filepath_out_qp + '.mp4'):
print(
f'arquivo {filepath_out_qp + ".hevc"} existe. Pulando.'
)
else:
command = f'{mp4box} -add {filepath_in_qp}.hevc:split_tiles -new {filepath_out_qp}.mp4'
print(command)
with open(filepath_out_qp + '.log',
'w',
encoding='utf-8') as f:
subprocess.run(command,
shell=True,
stdout=f,
stderr=subprocess.STDOUT)
filepath_in_rate = f'mp4{sl}{folder}{sl}{folder}_rate{rate}_tile{tile_count}'
filepath_in_qp = f'mp4{sl}{folder}{sl}{folder}_qp{qp}_tile{tile_count}'
os.makedirs(f'mp4{sl}{folder}{sl}rate_dash', exist_ok=True)
os.makedirs(f'mp4{sl}{folder}{sl}qp_dash', exist_ok=True)
filepath_out_rate = f'mp4{sl}{folder}{sl}rate_dash{sl}{folder}_rate{rate}_tile{tile_count}'
filepath_out_qp = f'mp4{sl}{folder}{sl}qp_dash{sl}{folder}_qp{qp}_tile{tile_count}'
if os.path.isfile(filepath_out_rate + '.mpd'):
print(
f'arquivo {filepath_out_rate + ".mpd"} existe. Pulando.'
)
else:
command = f'{mp4box} -dash 1000 -profile live -out {filepath_out_rate}.mpd {filepath_in_rate}.mp4'
print(command)
with open(filepath_out_rate + '.log',
'w',
encoding='utf-8') as f:
subprocess.run(command,
shell=True,
stdout=f,
stderr=subprocess.STDOUT)
if os.path.isfile(filepath_out_qp + '.mpd'):
print(
f'arquivo {filepath_out_qp + ".mpd"} existe. Pulando.'
)
else:
command = f'{mp4box} -dash 1000 -profile live -out {filepath_out_qp}.mpd {filepath_in_qp}.mp4'
print(command)
with open(filepath_out_qp + '.log',
'w',
encoding='utf-8') as f:
subprocess.run(command,
shell=True,
stdout=f,
stderr=subprocess.STDOUT)
import matplotlib.pyplot as plt
from utils import util
duration = 10
scale = '4320x2160'
w, h = list(map(int, scale.split('x')))
fps = 30
gop = 30
proc_num = 4
qp_list = [20, 30, 40]
rate_list = [2000000, 8000000, 24000000]
tile_list = ['1x1', '2x2', '3x3', '6x3']
sl = util.check_system()['sl']
videos = {'rollercoaster': 0,
'lions': 0}
def main():
collect_data()
# grafico do tamanho do tiles pelo tempo
graph1()
graph2()
# graph3()
def graph1():
decode_time = _load_data('times.json')
def main():
programs = util.check_system()
kvazaar = programs['kvazaar']
mp4box = programs['mp4box']
sl = programs['sl']
# videos = util.list_videos('input.json')
videos = {"pac_man": 0,
"rollercoaster": 0,
"lions": 0,
"om_nom": 0}
yuv_folder = 'yuv'
hevc_base_folder = 'hevc'
mp4_base_folder = 'mp4'
dash_folder = 'dash'
for name in videos:
for tile in tile_list:
m, n = list(map(int, tile.split('x')))
for rate, qp in list(zip(rate_list, qp_list)):
basename = f'{name}_{scale}_{fps}_{tile}'
# ----------------------------------------------
# Encode
# ----------------------------------------------
yuv_video_name = f'{yuv_folder}{sl}{name}_{scale}_{fps}'
hevc_folder = f'{hevc_base_folder}{sl}{basename}'
hevc_video_qp = f'{hevc_folder}{sl}{basename}_qp{qp}'
hevc_video_rate = f'{hevc_folder}{sl}{basename}_rate{rate}'
os.makedirs(f'{hevc_folder}', exist_ok=True)
params_common = (f'--input {yuv_video_name}.yuv '
f'--input-res {scale} '
f'--input-fps {fps} '
f'-p {gop} '
'--no-tmvp '
'--no-open-gop')
params_qp = f'{params_common} --qp {qp} --output {hevc_video_qp}.hevc'
params_rate = f'{params_common} --bitrate {rate} --output {hevc_video_rate}.hevc'
if tile is not '1x1':
tile_params = f' --tiles {tile} --slices tiles --mv-constraint frametilemargin'
params_qp += tile_params
params_rate += tile_params
# command = f'{kvazaar} {params_qp}'
# util.run(command, hevc_video_qp, 'hevc')
# command = f'{kvazaar} {params_rate}'
# util.run(command, hevc_video_rate, 'hevc')
# ----------------------------------------------
# Encapsule
# ----------------------------------------------
mp4_folder = f'{mp4_base_folder}{sl}{basename}'
mp4_video_qp = f'{mp4_folder}{sl}{basename}_qp{qp}'
mp4_video_rate = f'{mp4_folder}{sl}{basename}_rate{rate}'
os.makedirs(f'{mp4_folder}', exist_ok=True)
# command = f'{mp4box} -add {hevc_video_qp}.hevc:split_tiles -new {mp4_video_qp}.mp4'
# util.run(command, mp4_video_qp, 'mp4')
#
# command = f'{mp4box} -add {hevc_video_rate}.hevc:split_tiles -new {mp4_video_rate}.mp4'
# util.run(command, mp4_video_rate, 'mp4')
# # ----------------------------------------------
# # Extract Tiles
# # ----------------------------------------------
for tile_count in range(1, m * n + 1):
track = tile_count + 1
mp4_tile_video_qp_folder = f'{dash_folder}{sl}{basename}_qp{qp}'
mp4_tile_video_rate_folder = f'{dash_folder}{sl}{basename}_rate{rate}'
os.makedirs(f'{mp4_tile_video_qp_folder}', exist_ok=True)
os.makedirs(f'{mp4_tile_video_rate_folder}', exist_ok=True)
mp4_video_tile_qp = f'{mp4_tile_video_qp_folder}{sl}{name}_tile{tile_count}'
mp4_video_tile_rate = f'{mp4_tile_video_rate_folder}{sl}{name}_tile{tile_count}'
mp4_video_segment_qp_folder = f'{mp4_tile_video_qp_folder}{sl}segments'
mp4_video_segment_rate_folder = f'{mp4_tile_video_rate_folder}{sl}segments'
os.makedirs(f'{mp4_video_segment_qp_folder}', exist_ok=True)
os.makedirs(f'{mp4_video_segment_rate_folder}', exist_ok=True)
mp4_video_segment_qp = f'{mp4_video_segment_qp_folder}{sl}{name}_tile{tile_count}_track{track}_001'
mp4_video_segment_rate = f'{mp4_video_segment_rate_folder}{sl}{name}_tile{tile_count}_track{track}_001'
mp4_video_tile_track_qp = f'{mp4_video_tile_qp}_track{track}'
mp4_video_tile_track_rate = f'{mp4_video_tile_rate}_track{track}'
# Se tile == 1x1 (pois não tem base track) apenas copiar arquivo para destino
if tile in '1x1':
# mp4_video_segment_qp = f'{mp4_video_segment_qp_folder}{sl}{name}_tile{tile_count}_001'
# mp4_video_segment_rate = f'{mp4_video_segment_rate_folder}{sl}{name}_tile{tile_count}_001'
if os.path.isfile(f'{mp4_video_tile_track_qp}.mp4'):
print(f'O arquivo {mp4_video_tile_track_qp}.mp4 existe. Pulando.')
else:
shutil.copyfile(f'{mp4_video_qp}.mp4', f'{mp4_video_tile_track_qp}.mp4')
if os.path.isfile(f'{mp4_video_tile_track_rate}.mp4'):
print(f'O arquivo {mp4_video_tile_track_rate}.mp4 existe. Pulando.')
else:
shutil.copyfile(f'{mp4_video_rate}.mp4', f'{mp4_video_tile_track_rate}.mp4')
# Segment track
command = f'{mp4box} -split 1 {mp4_video_tile_track_qp}.mp4 -out {mp4_video_segment_qp_folder}{sl}'
util.run(command, mp4_video_segment_qp, 'mp4', overwrite=False)
command = f'{mp4box} -split 1 {mp4_video_tile_track_rate}.mp4 -out {mp4_video_segment_rate_folder}{sl}'
util.run(command, mp4_video_segment_rate, 'mp4', overwrite=False)
else:
# Remove undesired track
rem_option = ''
for tile_removed in range(2, (m * n) + 2):
if tile_removed == track:
continue
rem_option += f'-rem {tile_removed} '
command = f'{mp4box} {rem_option} {mp4_video_qp}.mp4 -out {mp4_video_tile_qp}.mp4'
print(command)
util.run(command, mp4_video_tile_qp, 'mp4')
command = f'{mp4box} {rem_option} {mp4_video_rate}.mp4 -out {mp4_video_tile_rate}.mp4'
util.run(command, mp4_video_tile_rate, 'mp4')
# Extract track desired (track) only for stats, and track 1, the resulting track.
# command = f'{mp4box} -raw {track} -raw 1 {mp4_video_tile_qp}.mp4'
command = f'{mp4box} -raw {track} {mp4_video_tile_qp}.mp4'
util.run(command, mp4_video_tile_track_qp, 'hvc')
# command = f'{mp4box} -raw {track} -raw 1 {mp4_video_tile_rate}.mp4'
command = f'{mp4box} -raw {track} {mp4_video_tile_rate}.mp4'
util.run(command, mp4_video_tile_track_rate, 'hvc')
# Add resulting track in new mp4
command = f'{mp4box} -add {mp4_video_tile_track_qp}.hvc -new {mp4_video_tile_track_qp}.mp4'
util.run(command, mp4_video_tile_track_qp, 'mp4', overwrite=False)
command = f'{mp4box} -add {mp4_video_tile_track_rate}.hvc -new {mp4_video_tile_track_rate}.mp4'
util.run(command, mp4_video_tile_track_rate, 'mp4', overwrite=False)
# Segment track
command = f'{mp4box} -split 1 {mp4_video_tile_track_qp}.mp4 -out {mp4_video_segment_qp_folder}{sl}'
util.run(command, f'{mp4_video_segment_qp}', 'mp4')
command = f'{mp4box} -split 1 {mp4_video_tile_track_rate}.mp4 -out {mp4_video_segment_rate_folder}{sl}'
util.run(command, f'{mp4_video_segment_rate}', 'mp4')
def main():
programs = util.check_system()
sl = programs['sl']
ffmpeg = programs['ffmpeg']
cp = programs['cp']
with open('input.json', 'r') as f:
video_list = json.load(f)
p_count = 0
proc = []
video_list = dict(maldives=0)
for name in video_list:
ss = video_list[name]
folder_in = f'yuv{sl}'
in_name = f'{name}_{scale}_{fps}'
filepath_in = f'{folder_in}{in_name}.yuv'
for tile in tile_list:
m, n = list(map(int, tile.split('x')))
tile_w = int(w / m)
tile_h = int(h / n)
folder_name = f'{in_name}_{tile}'
folder_out = f'yuv{sl}{folder_name}'
os.makedirs(folder_out, exist_ok=True)
tile_count = 0
for y in range(0, h, tile_h):
for x in range(0, w, tile_w):
tile_count += 1
out_name = f'{folder_name}_tile{tile_count}'
filepath_out = f'{folder_out}{sl}{out_name}.yuv'
# Encode params
input_params = ('-hide_banner -n '
f'-s {scale} '
f'-framerate {fps} '
f'-i {filepath_in}')
filter_params = f'-vf "crop=w={tile_w}:h={tile_h}:x={x}:y={y}"'
command = f'{ffmpeg} {input_params} {filter_params} {filepath_out}'
print('Processando: ' + command)
p = subprocess.Popen(command,
shell=True,
stderr=subprocess.DEVNULL)
proc.append(p)
p_count += 1
while p_count >= 1:
time.sleep(1)
print('.', end='', flush=True)
for p in proc:
if p.poll() is not None:
p_count -= 1
proc.remove(p)
print('\n\nConcluido:' + p.args + '\n\n')
break
for p in proc:
p.wait()
