122 lines
3.8 KiB
Python
Executable file
122 lines
3.8 KiB
Python
Executable file
import logging
|
|
import re
|
|
import asyncio
|
|
|
|
class Process:
|
|
def __init__(self, obj_websocket):
|
|
self.obj_websocket = obj_websocket
|
|
self.line_empty = 0
|
|
|
|
# Data
|
|
self.id = None
|
|
self.fps: float = 0.0
|
|
self.speed: float = 0.0
|
|
|
|
self.quantizer: int = 0
|
|
self.bitrate: list = [0, "kbits/s"]
|
|
self.size: list = [0, "KiB"]
|
|
|
|
self.time: int = 0
|
|
self.time_remaining = 0
|
|
self.loading = 0
|
|
self.frames: int = 0
|
|
|
|
|
|
async def read_out(self, obj):
|
|
self.id = obj.id
|
|
self.line_empty = 0
|
|
i = 100
|
|
|
|
while True:
|
|
line = await obj.process.stderr.read(1024)
|
|
line_decoded = line.decode()
|
|
|
|
self.process_line_extract(obj, line_decoded)
|
|
#logging.info(line_decoded)
|
|
|
|
self.loading = (self.frames / obj.source_frames_total) * 100
|
|
|
|
await self.obj_websocket.send_websocket(self.to_dict(obj))
|
|
|
|
if self.line_empty > 30:
|
|
break
|
|
elif not line:
|
|
self.line_empty += 1
|
|
await asyncio.sleep(2)
|
|
continue
|
|
elif line:
|
|
self.line_empty = 0
|
|
|
|
if i == 100 or i == 200 or i == 300 or i == 400 or i == 500:
|
|
logging.info(self.to_dict(obj))
|
|
self.save_stat_value(obj)
|
|
elif i == 101 or i == 501:
|
|
i = 0
|
|
time = self.time_remaining
|
|
if time != " ":
|
|
logging.info(f"Time remaining: {time}")
|
|
|
|
i += 1
|
|
|
|
def process_line_extract(self, obj, line:str):
|
|
# FPS
|
|
fps = re.findall(r"fps=\s*(\d+.\d*)", line)
|
|
self.fps = float(fps[0]) if fps else 0.0
|
|
|
|
# Quantizer
|
|
q = re.findall(r"q=\s*(\d+).\d+", line)
|
|
self.quantizer = int(q[0]) if q else 0
|
|
|
|
# Bitrate
|
|
bitrate = re.findall(r"bitrate=\s*(\d+)", line)
|
|
self.bitrate[0] = int(bitrate[0]) if bitrate else 0
|
|
|
|
# Speed
|
|
speed = re.findall(r"speed=\s*(\d+\.\d+)", line)
|
|
self.speed = float(speed[0]) if speed else 0.0
|
|
|
|
# File Size
|
|
size = re.findall(r"size=\s*(\d+)", line)
|
|
if size and int(size[0]) > self.size[0]:
|
|
self.size = obj.size_convert("KiB", None, "storage", int(size[0]))
|
|
obj.process_size = self.size
|
|
|
|
# Time
|
|
media_time = re.findall(r"time=\s*(\d+:\d+:\d+)", line)
|
|
time_v = media_time[0] if media_time else "00:00:00"
|
|
if self.time < obj.time_in_sec(time_v):
|
|
self.time = obj.time_in_sec(time_v)
|
|
obj.process_time = self.time
|
|
|
|
# Frames
|
|
frame = re.findall(r"frame=\s*(\d+)", line)
|
|
if frame and int(frame[0]) > self.frames:
|
|
self.frames = int(frame[0])
|
|
obj.process_frames = self.frames
|
|
|
|
def save_stat_value(self, obj):
|
|
if self.fps:
|
|
obj.stat_fps = [obj.stat_fps[0] + self.fps, obj.stat_fps[1] + 1]
|
|
|
|
if self.quantizer:
|
|
obj.stat_quantizer = [obj.stat_quantizer[0] + self.quantizer, obj.stat_quantizer[1] + 1]
|
|
|
|
if self.bitrate[0]:
|
|
obj.stat_bitrate = [obj.stat_bitrate[0] + self.bitrate[0], obj.stat_bitrate[1] + 1]
|
|
|
|
if self.speed:
|
|
obj.stat_speed = [obj.stat_speed[0] + self.speed, obj.stat_speed[1] + 1]
|
|
|
|
def to_dict(self, obj):
|
|
return {"data_flow": {
|
|
"id": self.id,
|
|
"frames": self.frames,
|
|
"fps": self.fps,
|
|
"quantizer": self.quantizer,
|
|
"size": self.size,
|
|
"time": obj.format_time(self.time, "Tage", "Std", "Min", None),
|
|
"time_remaining": obj.format_time(obj.time_remaining(), None, "Std", "Min", None),
|
|
"loading": self.loading,
|
|
"bitrate": self.bitrate,
|
|
"speed": self.speed
|
|
}}
|