Potential Bug: moov atom missing in terminated RSTP feed recorded video files

[UltimateCodeWarrior]

Hi All,

So there's a good chance when recording A/V from a RSTP stream that the stream will go down. Either the Network Connection, Router, Camera... Chain is only as strong as the weakest link. Problem is, the PyAV doesn't handle the error effectively, and just blows up somewhere deep in the bowels and doesn't allow for the finishing out of the output mp4 file gracefully and leaves it in an unplayable state. This corrupted mp4 file is missing something called a : moov atom. Would be nice if it would put one in there somewhere that could be moved to the beginning with a ffmpeg command such as:

ffmpeg -i corrupted_1738018839.561.mp4 -vcodec copy -acodec copy -movflags faststart fixed_video_file.mp4

There aren't many tools that can add the atom or fix the issue, or they are windows based tools. I need an automated way of fixing it or just fix the pyav so it never happens. It's a real hassle otherwise. Seems that for anything that needs to lock onto a RSTP feed, there should be some thought given to disaster recovery.

I've created a little python script that will alternate recording video with a slight overlap. I've also included a script that can stitch these sections back together with ffmpeg concat. It will calculate the overlap and shave off the front of the next file to try and keep the timeline correct. (Any improvements welcome, it's not perfect).

I did this method because trying to do a split recording with a/v with pyAV was a terrible experience. Fooling around with packet timings...really? I've included at the very end my version of some borrowed code to try and do this.

Smaller .mp4 files will result in more playable clips and better disaster recovery. Rather than recording to an hour long .mp4 file only to have it corrupted somewhere isn't a good idea. I mean if a vandal smashes your camera, good luck in trying to figure out what happened to it from the video logs. If you are recording in smaller chunks, you got a better chance of quickly identifying the perp from stored video. I'm actually locking on feed with opencv as well and saving the a bunch of jpeg frames to a disaster bin just in case of this.

So the code:

First Code writes out alternating video files with a slight overlap that gets cut out on ffmpeg concat code.

`import threading
import time
import av

rtsp_url = "rtsp://admin:admin@192.168.0.109:554/cam/realmonitor?channel=1&subtype=0"

def record_video(start_time, duration=60):
try:
source = av.open(rtsp_url, metadata_encoding='utf-8')
except OSError as e:
print(f"Error opening RTSP feed: {e}")
return

filename = f"data/output_{start_time:.3f}.mp4"
print("Writing:", filename)
output = av.open(filename, mode='w')

in_to_out = {}
for stream in source.streams:
    if stream.type in ('audio', 'video'):
        in_to_out[stream] = output.add_stream_from_template(stream)

start_time = time.time()
end_time = start_time + duration
last_packet_time = time.time()
timeout = 5  # Timeout in seconds

try:
    for packet in source.demux():
        current_time = time.time()
        if current_time >= end_time:
            break

        if current_time - last_packet_time > timeout:
            print(f"Timeout: No packets received for {timeout} seconds")
            break

        if packet.stream in in_to_out:
            packet.stream = in_to_out[packet.stream]
            output.mux(packet)
            last_packet_time = current_time  # Reset the timeout

except Exception as e:
    print(f"An error occurred during demuxing/muxing: {e}")

finally:
    try:
        output.close()
    except Exception as e:
        print(f"Error closing output file: {e}")
    try:
        source.close()
    except Exception as e:
        print(f"Error closing source file: {e}")
    print(f"Finished recording: {filename}")

def schedule_recordings():
while True:
start_time = time.time()
threading.Thread(target=record_video, args=(start_time, 60)).start()
time.sleep(55) # Wait 55 seconds before starting the next recording

if name == "main":
schedule_recordings()`

FFMPEG MP4 Concat Code, will create a concatenated file ignoring overlaps from the files generated above.

`
import time
import os
import re
import subprocess

def get_timestamps(file):
# Extract the timestamp from the filename
match = re.search(r'output_(\d+.\d{3}).mp4', file)
if match:
file_timestamp = float(match.group(1))
else:
raise ValueError(f"Filename {file} does not contain a valid timestamp")

# Use ffprobe to get the start and end timestamps of the file
result = subprocess.run(
    ["ffprobe", "-v", "error", "-show_entries", "format=start_time,duration", "-of", "default=noprint_wrappers=1:nokey=1", file],
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    text=True
)
start_time, duration = map(float, result.stdout.split())
start_time += file_timestamp
end_time = start_time + duration
return start_time, end_time

def merge():
# Get the current directory
current_directory = os.getcwd()

# Find all .mp4 files in the current directory and sort them alphabetically
files_to_concatenate = sorted([f for f in os.listdir(current_directory) if f.endswith('.mp4')])

# List start and end timestamps
timestamps = []
for file in files_to_concatenate:
    start_time, end_time = get_timestamps(file)
    timestamps.append((file, start_time, end_time))
    print(f"{file}: start_time={start_time}, end_time={end_time}")

# Find overlaps and create trimmed files
trimmed_files = []
for i in range(len(timestamps)):
    file, start_time, end_time = timestamps[i]
    if i > 0:
        prev_file, prev_start, prev_end = timestamps[i-1]
        if start_time < prev_end:
            overlap = (prev_end - start_time) 
            trimmed_file = f"trimmed_{file}"
            subprocess.run(
                ["ffmpeg", "-y", "-i", file, "-ss", str(overlap), "-c", "copy", trimmed_file],
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True
            )
            trimmed_files.append(trimmed_file)
            continue
    trimmed_files.append(file)

# Create the concat_list.txt file
concat_file = "concat_list.txt"
with open(concat_file, 'w') as f:
    for file in trimmed_files:
        f.write(f"file '{file}'\n")

# Use ffmpeg to concatenate the files
os.system(f"ffmpeg -y -f concat -safe 0 -i {concat_file} -c copy output.mp4")

# Optionally remove the concat_list.txt file and trimmed files
# os.remove(concat_file)
# for file in trimmed_files:
#     if file.startswith("trimmed_"):
#         os.remove(file)

print(f"Concatenated file saved as output.mp4")

Call the merge function

ts = time.time()
merge()
print(time.time() - ts)
`

Here is some Code Tweaked from some other people on this forum, but enhanced with Audio Recording, works for first 10 seconds video clip, but audio fails for each successive. The first video has some sort of green screen artifact for 2 seconds, don't know what that's all about, but if you are feeling adventurous in adjusting packet timings....be my guest to work your magic.

`
import time
from os import path
import av

ts= time.time()

source = av.open('rtsp://admin:admin@192.168.0.109:554/cam/realmonitor?channel=1&subtype=0', metadata_encoding='utf-8')
v_stream = source.streams.video[0]
a_stream = source.streams.audio[0]

av_options = {'avoid_negative_ts': '1'}
packet = None
frag_offset = 0.0 # secs
frag_length = 10.0 # secs
frag_pts = 0

while True:
videoFilePath = f"out4_{frag_offset:.0f}.mp4"
with av.open(f"{videoFilePath}", "w") as mp4_output:
v_out_stream = mp4_output.add_stream_from_template(v_stream)
a_out_stream = mp4_output.add_stream_from_template(a_stream)

    print('stream_cc:',v_out_stream.codec_context.time_base)
    # print(outputContainer.flags)
    # break
    mp4_output.container_options.update(av_options)
	##presentation time stamp and decode time stamp
    if packet:

    

        packet.dts = packet.dts - frag_pts
        packet.pts = packet.pts - frag_pts
        if packet.stream == v_stream:
            packet.stream = v_out_stream
        elif packet.stream == a_stream:
            packet.stream = a_out_stream
        print('init :',packet,frag_offset)
        mp4_output.mux(packet)

    for packet in source.demux():

            if packet.dts is None:
                continue
            #print(f"delta {time.time()-ts}")
        
            cur_time = float(packet.pts * packet.time_base)
            orig_pts = packet.pts
            print('cont:',orig_pts, packet.time_base, cur_time)

            if(packet.stream == v_stream):
                if cur_time >= frag_offset+frag_length and packet.is_keyframe:
                    frag_offset = cur_time
                    frag_pts = orig_pts
                    break
                else:
                    packet.dts = packet.dts - frag_pts
                    packet.pts = packet.pts - frag_pts
                    if packet.stream == v_stream:
                        packet.stream = v_out_stream
                    
            else:
                #packet.dts = packet.dts - frag_pts
                #packet.pts = packet.pts - frag_pts
                packet.stream = a_out_stream
        
            mp4_output.mux(packet)

`