eFusion 05 сентября 2020

🎞️ Параллельная обработка видео с помощью OpenCV

Задача: взять видео, выполнить распознавание лица, записать видеофайл с рамкой вокруг лица обратно на диск. А чтобы сделать это быстрее, запустим процесс в нескольких потоках.

Установка необходимых библиотек

Для работы понадобится установить следующие пакеты:

OpenCV – cамая популярная библиотека компьютерного зрения – её мы будем использовать для чтения и записи видеофайлов. Пример использования недавно публиковался в Библиотеке программиста. Чтобы установить OpenCV, используйте pip:

        pip3 install opencv-python
    

FFmpeg – кроссплатформенное ПО для записи, конвертации и стриминга аудио и видео. Мы будем использовать FFmpeg для объединения нескольких видеофайлов. Страница загрузки.

Импорт библиотек в Python

Давайте импортируем необходимые библиотеки:

        import cv2 as cv
import time
import subprocess as sp
import multiprocessing as mp
from os import remove
from xailient import dnn
    

Подробная информация об используемых библиотеках:

  • cv2: библиотека OpenCV, чтобы читать и писать видеофайлы;
  • time: получаем текущее время для расчета времени выполнения кода;
  • subprocess: запускаем новые процессы, подключаемся к их каналам input/output/error и забираем их коды возврата.
  • multiprocessing: распараллеливаем выполнение функции для нескольких входных значений и распределяем входные данные между процессами;
  • xailient: библиотека для распознавания лиц. Вы можете использовать для этой цели любую библиотеку, например face_recognition, но в нашем примере используется эта.

Конвейер обработки видео в одном процессе

Начнем с метода обработки видео в одном процессе. Именно так мы обычно читаем видеофайл, обрабатываем каждый кадр и записываем выходные кадры обратно на диск.

        def process_video():
    # Читаем файл с видео
    cap = cv.VideoCapture(file_name)

    # Получаем высоту, ширину и количество кадров в видео
    width, height = (
            int(cap.get(cv.CAP_PROP_FRAME_WIDTH)),
            int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
        )
    fps = int(cap.get(cv.CAP_PROP_FPS))

    # Определяем кодек и создаем объект VideoWriter
    fourcc = cv.VideoWriter_fourcc('m', 'p', '4', 'v')
    out = cv.VideoWriter()
    output_file_name = "output_single.mp4"
    out.open(output_file_name, fourcc, fps, (width, height), True)

    try:
        while cap.isOpened():
            ret, frame = cap.read()
            if not ret:
                break
            
            im = frame
            # Выполняем распознавание лиц в кадре
            _, bboxes = detectum.process_frame(im, THRESHOLD)

            # Цикл по списку (если он пуст, то это пропускаем) и наложение зеленых полей            for i in bboxes:
                cv.rectangle(im, (i[0], i[1]), (i[2], i[3]), (0, 255, 0), 3)
            
            # Рисуем рамку
            out.write(im)
    except:
        # Высвобождаем ресурсы
        cap.release()
        out.release()
        

    # Высвобождаем ресурсы
    cap.release()
    out.release()
    

Давайте создадим еще одну функцию, которая вызывает видеопроцессор, фиксирует время начала и конца, вычисляет время, необходимое для выполнения обработки и количество обработанных кадров в секунду.

        def single_process():
    print("Обработка видео с использованием одного процесса...")
    start_time = time.time()
    process_video()
    end_time = time.time()
    total_processing_time = end_time - start_time
    print("Время: {}".format(total_processing_time))
    print("FPS : {}".format(frame_count/total_processing_time))
    
file_name = "input_video.mp4"
output_file_name = "output.mp4"
width, height, frame_count = get_video_frame_details(file_name)
print("Количество кадров = {}".format(frame_count))
print("Ширина = {}, Длина = {}".format(width, height))
single_process()
    

Обработка видео с использованием нескольких процессов

Теперь определим другую функцию, использующую многопроцессорную обработку:

        def process_video_multiprocessing(group_number):
    # Читаем файл с видео
    cap = cv.VideoCapture(file_name)

    cap.set(cv.CAP_PROP_POS_FRAMES, frame_jump_unit * group_number)

    # Получаем высоту, ширину и количество кадров в видео
    width, height = (
            int(cap.get(cv.CAP_PROP_FRAME_WIDTH)),
            int(cap.get(cv.CAP_PROP_FRAME_HEIGHT))
        )
    no_of_frames = int(cap.get(cv.CAP_PROP_FRAME_COUNT))
    fps = int(cap.get(cv.CAP_PROP_FPS))
    proc_frames = 0

    # Определяем кодек и создаем объект VideoWriter
    fourcc = cv.VideoWriter_fourcc('m', 'p', '4', 'v')
    out = cv.VideoWriter()
    output_file_name = "output_multi.mp4"
    out.open("output_{}.mp4".format(group_number), fourcc, fps, (width, height), True)
    try:
        while proc_frames < frame_jump_unit:
            ret, frame = cap.read()
            if not ret:
                break

            im = frame
            # Выполняем распознавание лиц в каждом кадре
            _, bboxes = detectum.process_frame(im, THRESHOLD)

            # Цикл по списку (если он пуст, то это пропускаем) и наложение зеленых полей 
            for i in bboxes:
                cv.rectangle(im, (i[0], i[1]), (i[2], i[3]), (0, 255, 0), 3)
            
            # Рисуем рамку
            out.write(im)

            proc_frames += 1
    except:
        # Высвобождаем ресурсы
        cap.release()
        out.release()

    # Высвобождаем ресурсы
    cap.release()
    out.release()
    

В приведенной функции описана обработка, которая обычно выполняется с помощью одного процесса, но теперь она делится поровну между общим количеством процессоров, доступных на исполняющем устройстве.

Если существует 4 процесса, а общее количество кадров в обрабатываемом видео равно 1000, то каждый процесс получает 250 кадров для обработки, которые выполняются параллельно. В итоге каждый процесс создаст отдельный выходной файл с видео. Чтобы объединить эти файлики мы будем использовать ffmpeg.

        def combine_output_files(num_processes):
    # Создаем список выходных файлов и складываем имена файлов в текстовый файл
    list_of_output_files = ["output_{}.mp4".format(i) for i in range(num_processes)]
    with open("list_of_output_files.txt", "w") as f:
        for t in list_of_output_files:
            f.write("file {} \n".format(t))

    # Используем ffmpeg для объединения выходных видеофайлов
    ffmpeg_cmd = "ffmpeg -y -loglevel error -f concat -safe 0 -i list_of_output_files.txt -vcodec copy " + output_file_name
    sp.Popen(ffmpeg_cmd, shell=True).wait()

    # Удаляем временные файлы
    for f in list_of_output_files:
        remove(f)
    remove("list_of_output_files.txt")
    

Теперь создаем конвейер для запуска многопроцессорной обработки видео, расчета времени выполнения и кадров, обрабатываемых в секунду.

        def multi_process():
    print("Обработка видео с использованием {} процессов...".format(num_processes))
    start_time = time.time()

    # Параллельное выполнение функции с несколькими входными значениями
    p = mp.Pool(num_processes)
    p.map(process_video_multiprocessing, range(num_processes))

    combine_output_files(num_processes)

    end_time = time.time()

    total_processing_time = end_time - start_time
    print("Время: {}".format(total_processing_time))
    print("FPS : {}".format(frame_count/total_processing_time))

file_name = "input.mp4"
output_file_name = "output.mp4"
width, height, frame_count = get_video_frame_details(file_name)
print("Количество кадров = {}".format(frame_count))
print("Ширина= {}, Высота = {}".format(width, height))
num_processes = mp.cpu_count()
print("Количество процессоров: " + str(num_processes))
frame_jump_unit =  frame_count// num_processes
multi_process()
    

Результаты

Эксперимент проводился на Lenovo Yoga 920 с Ubuntu18.04. Количество доступных на устройстве логических процессоров – 8шт.

Из этого эксперимента мы можем сделать вывод, что при использовании всех ядер обрабатывается в 2 раза больше кадров в секунду. Чем больше процессоров на тестовой машине, тем больше можно реализовать процессов, и тем быстрее пройдет процесс обработки.

Источники

РУБРИКИ В СТАТЬЕ

МЕРОПРИЯТИЯ

Комментарии 0

ВАКАНСИИ

ЛУЧШИЕ СТАТЬИ ПО ТЕМЕ

BUG