Есть ли способ рассчитать размеры выходного кадра при сжатии видео и извлечения его кадров с помощью ffmpeg

Question

Я использую следующий код для сжатия видео и извлечения его кадров. Обратите внимание, что я не хочу сохранять полученное видео.

        output_args = {
            "vcodec": "libx265",
            "crf": 24,
        }
        out, err = (
            ffmpeg
            .input(in_filename)
            .output('pipe:', format='rawvideo', pix_fmt='rgb24',**output_args)
            .run(capture_stdout=True)
        )
        frames = np.frombuffer(out, np.uint8).reshape(-1,width,height,3)

Когда я пытаюсь преобразовать выходной буфер в исходные размеры видео, я получаю следующую ошибку: cannot reshape array of size 436567 into shape (1920,1080,3) Это ожидается, потому что полученное видео имеет меньшие размеры. Есть ли способ рассчитать количество кадров, ширину и высоту сжатого видео, чтобы изменить форму кадров из буфера?

Кроме того, если я сохраню сжатое видео вместо загрузки его кадров, и затем я загружаю видеокадры из сжатого видео, они будут иметь те же размеры, что и оригинал. Я подозреваю, что под капотом происходит какая-то интерполяция. Есть ли способ применить его без сохранения видео?

Answer 1

Я нашел решение, используя ffmpeg- python.

Допущения:

• out содержит весь закодированный поток h265 в буфере памяти.
• Вы не хотите записывать поток в файл.

Решение использует следующее:

• Выполнение FFmpeg в подпроцессе с sdtin в качестве ввода pipe и stdout в качестве вывода pipe.
  На входе будет видеопоток (буфер памяти).
  Выходной формат - необработанные видеокадры в формате пикселей BGR.
• Запись потокового содержимого в pipe (в stdin).
• Чтение декодированного видео (кадр за кадром) и отображение каждого кадра (используя cv2.imshow)

Для тестирования решения я создал образец видеофайла и прочитал его в буфер памяти (закодированный как H.265).
Я использовал буфер памяти в качестве входных данных для вышеуказанного кода (ваш out буфер).

Вот полный код, включая код тестирования:

import ffmpeg
import numpy as np
import cv2
import io

in_filename = 'in.mp4'

# Build synthetic video, for testing begins:
###############################################
# ffmpeg -y -r 10 -f lavfi -i testsrc=size=192x108:rate=1 -c:v libx265 -crf 24 -t 5 in.mp4

width, height = 192, 108

(
    ffmpeg
    .input('testsrc=size={}x{}:rate=1'.format(width, height), r=10, f='lavfi')
    .output(in_filename, vcodec='libx265', crf=24, t=5)
    .overwrite_output()
    .run()
)
###############################################


# Use ffprobe to get video frames resolution
###############################################
p = ffmpeg.probe(in_filename, select_streams='v');
width = p['streams'][0]['width']
height = p['streams'][0]['height']
n_frames = int(p['streams'][0]['nb_frames'])
###############################################


# Stream the entire video as one large array of bytes
###############################################
# https://github.com/kkroening/ffmpeg-python/blob/master/examples/README.md
in_bytes, _ = (
    ffmpeg
    .input(in_filename)
    .video # Video only (no audio).
    .output('pipe:', format='hevc', crf=24)
    .run(capture_stdout=True) # Run asynchronous, and stream to stdout
)
###############################################


# Open In-memory binary streams
stream = io.BytesIO(in_bytes)

# Execute FFmpeg in a subprocess with sdtin as input pipe and stdout as output pipe
# The input is going to be the video stream (memory buffer)
# The output format is raw video frames in BGR pixel format.
# https://github.com/kkroening/ffmpeg-python/blob/master/examples/README.md
# https://github.com/kkroening/ffmpeg-python/issues/156
# http://zulko.github.io/blog/2013/09/27/read-and-write-video-frames-in-python-using-ffmpeg/
process = (
    ffmpeg
    .input('pipe:', format='hevc')
    .video
    .output('pipe:', format='rawvideo', pix_fmt='bgr24')
    .run_async(pipe_stdin=True, pipe_stdout=True)
)


# https://stackoverflow.com/questions/20321116/can-i-pipe-a-io-bytesio-stream-to-subprocess-popen-in-python
# https://gist.github.com/waylan/2353749
process.stdin.write(stream.getvalue())  # Write stream content to the pipe
process.stdin.close()  # close stdin (flush and send EOF)


# Read decoded video (frame by frame), and display each frame (using cv2.imshow)
while(True):
    # Read raw video frame from stdout as bytes array.
    in_bytes = process.stdout.read(width * height * 3)

    if not in_bytes:
        break

    # transform the byte read into a numpy array
    in_frame = (
        np
        .frombuffer(in_bytes, np.uint8)
        .reshape([height, width, 3])
    )

    # Display the frame
    cv2.imshow('in_frame', in_frame)

    if cv2.waitKey(100) & 0xFF == ord('q'):
        break

process.wait()
cv2.destroyAllWindows()

Примечание: я использовал stdin и stdout вместо каналов имен, потому что я хотел, чтобы код работал как в Windows и Linux.