When calling the VideoWrite.write method, Segmentation fault occurred

[mujinbao]

@skvark @native-api

This is my code.

import os
import cv2
from vidgear.gears import WriteGear
from concurrent.futures import ThreadPoolExecutor

# init variable
w1, h1, w2, h2 = 1920, 1080, 1920, 1080
fps1, fps2 = 28, 18


def cv_init(channel):
    cap = cv2.VideoCapture(channel)

    # ---------- create avi video out --------------
    code = cv2.VideoWriter_fourcc('X', 'V', 'I', 'D')
    out_avi = cv2.VideoWriter(os.path.join('video','original.avi'), code, 25, (w1, h1), True)
    detection_avi_out = cv2.VideoWriter(os.path.join('video','detection.avi'), code, fps2, (w2, h2), True)

    # ---------- create h264 of mp4 video out ---------------
    output_params = {"-vcodec": "libx264", "-input_framerate": str(fps1), "-crf":28, "-preset":"ultrafast", "-tune":"zerolatency"}
    detection_output_params = {"-vcodec": "libx264", "-input_framerate": str(fps2), "-crf":28, "-preset":"ultrafast", "-tune":"zerolatency"}
    out = WriteGear(output_filename=os.path.join('video', 'original.mp4'),
                compression_mode=True,
                **output_params)
    detection_out = WriteGear(output_filename=os.path.join('video', 'detection.mp4'),
                          compression_mode=True,
                          **detection_output_params)


    return cap, out, detection_out, out_avi, detection_avi_out


def write_video(out, image):

    out.write(image)


if __name__ == '__main__':

    cap, out, detection_out, out_avi, detection_avi_out = cv_init('{{video channel}}')
    # create thread pool
    pool = ThreadPoolExecutor(max_workers=1500)
    while cap.isOpened():

        ret, frame = cap.read()

        # relevant algorithms processing for pictures.....
        # pool.submit(compute_image, frame)

        # deep learning detection target
        # pool.submit(detection, frame)

        pool.submit(write_video, out, frame)
        pool.submit(write_video, out_avi, frame)

        pool.submit(write_video, detection_out, frame)
        pool.submit(write_video, detection_avi_out, frame)

Allow me to explain this function code:
According to the needs of Party A, I need to create four video output objects to save the original image and the image after deep learning recognition, and video formats require both AVI and mp4.
As the latency requirement was minimized, I had to use thread pool to optimize processing speed.
Therefore, in the "write_video" function, the same image is written twice, and then the image is detected by in-depth learning. The new image after detection is also written twice. This code also happens "core dump".

With GDB debugging, this error not seem to occur, but only in the case of fast execution.

About vidgear.WriteGear :
link: https://github.com/abhiTronix/vidgear
WriteGear can call ffmpeg to complete video coding. I used this to create MP4 video and encoding it as H264，After my test, writing only MP4 won't cause a segment fault

Please help me, thank you very much~!

[mujinbao]

This is the GDB information I got in the production environment.

[native-api]

With GDB debugging, this error not seem to occur, but only in the case of fast execution.

This 99,9% means race conditions.
You'll have better luck asking at https://answers.opencv.org, this project only does the packaging.

https://answers.opencv.org/question/32415/thread-safe/ suggests that a Mat object (that wraps an image) cannot be used simultaneously by multiple threads. This may mean that you cannot pass the same frame to multiple threads, you'll need to copy it. Cannot say more than this.

[abhiTronix]

@mujinbao

Problem - 1

Also, According to https://docs.python.org/3/library/concurrent.futures.html#executor-objects

class concurrent.futures.Executor
An abstract class that provides methods to execute calls asynchronously. It should not be used directly, but through its concrete subclasses.

As you can see concurrent.future.Executor is asynchronous process, therefore your function

def write_video(out, image):

    out.write(image)

will be executed asynchonously and therefore prone to data corruption, where at any instant of time incorrect frame number is being written into the pipeline.

Problem - 2

Moreover, as mentioned in their docs, the use of ThreadPoolExecutor can lead to Deadlocks, where when the callable associated with a Future waits on the results of another Future. For example:

import time
def wait_on_b():
    time.sleep(5)
    print(b.result())  # b will never complete because it is waiting on a.
    return 5

def wait_on_a():
    time.sleep(5)
    print(a.result())  # a will never complete because it is waiting on b.
    return 6


executor = ThreadPoolExecutor(max_workers=2)
a = executor.submit(wait_on_b)
b = executor.submit(wait_on_a)

@mujinbao Kindly refrain yourself from using ThreadPoolExecuter in your code and stick to basic inbuilt methods. Goodluck.

[skvark]

Closing as this is a usage question and not really related to this repository.

[mujinbao]

@abhiTronix @native-api
thank you. I'll try to optimize the code in other ways. This is my usage question. Thank you again for your answers.