149 lines
4.6 KiB
Python
149 lines
4.6 KiB
Python
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.frames: int = 0
|
|
|
|
|
|
async def read_out(self, obj):
|
|
self.id = obj.id
|
|
i = 100
|
|
|
|
while True:
|
|
line = await obj.process.stderr.read(1024)
|
|
line_decoded = line.decode()
|
|
|
|
self.process_line_extract(obj, line_decoded)
|
|
|
|
# in json umwandeln
|
|
#await self.obj_websocket.send_websocket(self.to_dict())
|
|
|
|
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())
|
|
self.save_stat_value(obj)
|
|
elif i == 101 or i == 501:
|
|
i = 0
|
|
time = obj.format_time(obj.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[0] = 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):
|
|
return {"data_flow": {self.id: {
|
|
"frames": self.frames,
|
|
"fps": self.fps,
|
|
"quantizer": self.quantizer,
|
|
"size": self.size,
|
|
"time": self.time,
|
|
"bitrate": self.bitrate,
|
|
"speed": self.speed
|
|
}}}
|
|
|
|
@staticmethod
|
|
def size_convert(source: str, target, unit: str, size=0):
|
|
list_unit: list = []
|
|
|
|
if unit == "storage":
|
|
list_unit = ["B", "KiB", "MiB", "GiB", "TiB", "PiB"]
|
|
elif unit == "data_rate":
|
|
list_unit = ["bps", "Kbps", "Mbps", "Gbps", "Tbps", "Pbps"]
|
|
elif unit == "binary_data_rate":
|
|
list_unit = ["b/s", "Kib/s", "Mib/s", "Gib/s", "Tib/s", "Pib/s"]
|
|
|
|
factor = 1024 # Binäre Umrechnung
|
|
|
|
if source not in list_unit:
|
|
raise ValueError("Ungültige Quell-Einheit!")
|
|
|
|
source_index = list_unit.index(source)
|
|
|
|
if target:
|
|
if target not in list_unit:
|
|
raise ValueError("Ungültige Ziel-Einheit!")
|
|
target_index = list_unit.index(target)
|
|
|
|
if source_index < target_index:
|
|
return size / (factor ** (target_index - source_index)), target
|
|
else:
|
|
return size * (factor ** (source_index - target_index)), target
|
|
|
|
# Automatische Umrechnung
|
|
while size >= 1000 and source_index < len(list_unit) - 1:
|
|
size /= factor
|
|
source_index += 1
|
|
|
|
return [round(size,1), list_unit[source_index]]
|