Как получить кадр за кадром из MP4? (Медиакодек)

Я понимаю, почему может показаться, что хранить все текстуры в одном файле просто, но это действительно очень плохая идея.

MP4 — это видеокодек, оптимизированный для списка кадров, которые имеют высокий уровень сходства с соседними кадрами, т. е. с движением. Он также оптимизирован для распаковки в последовательном порядке, поэтому использование подхода «произвольного доступа» будет очень неэффективным.

Чтобы дать немного больше деталей, видеокодеки хранят ключевые кадры (один в секунду, но скорость меняется) и дельта-кадры в остальное время. Ключевые кадры сжимаются независимо, как отдельные изображения, но дельта-кадры сохраняются как отличие от одного или нескольких других кадров. Алгоритм предполагает, что эта разница будет минимальной после того, как будет выполнена компенсация движения.

Поэтому, если вы хотите получить доступ к одному дельта-кадру, ваш код должен будет распаковать соседний ключевой кадр и все дельта-кадры, которые соединяют его с нужным вам кадром, это будет намного медленнее, чем просто использование однокадрового JPEG.

Короче говоря, используйте JPEG или PNG для сжатия текстур и добавляйте их все в один файл архива, чтобы он оставался аккуратным.

Решение будет выглядеть примерно как ИзвлечьMpegFramesTest, в котором MediaCodec используется для генерации «внешних» текстур из видеокадров. В тестовом коде кадры рендерятся во внеэкранный буфер, а затем сохраняются в формате PNG. Вы бы просто визуализировали их напрямую.

С этим есть несколько проблем:

1. Видео MPEG не предназначено для работы в качестве базы данных с произвольным доступом. Обычная структура GOP (группы изображений) имеет один «ключевой кадр» (по сути, изображение JPEG), за которым следуют 14 дельта-кадров, которые просто содержат отличие от предыдущего декодированного кадра. Поэтому, если вам нужен кадр N, вам, возможно, придется сначала декодировать кадры с N-14 по N-1. Не проблема, если вы всегда двигаетесь вперед (воспроизводите фильм на текстуре) или сохраняете только ключевые кадры (в этот момент вы изобрели неуклюжую базу данных изображений JPEG).
2. Как упоминалось в комментариях и ответах, вы, вероятно, получите некоторые визуальные артефакты. Насколько плохо они выглядят, зависит от материала и вашей степени сжатия. Поскольку вы генерируете кадры, вы можете уменьшить это, гарантируя, что всякий раз, когда происходит большое изменение, первый кадр всегда будет ключевым кадром.
3. Микропрограмме, с которой взаимодействует MediaCodec, может потребоваться несколько кадров, прежде чем она начнет производить вывод, даже если вы начнете с ключевого кадра. Поиск в потоке требует затрат времени на задержку. См., например. эта почта. (Вы когда-нибудь задумывались, почему цифровые видеорегистраторы имеют плавную перемотку вперед, но не плавную перемотку назад?)
4. Кадры MediaCodec, прошедшие через SurfaceTexture, становятся «внешними» текстурами. У них есть некоторые ограничения по сравнению с обычными текстурами — производительность может быть хуже, нельзя использовать в качестве цветового буфера в FBO и т. д. Если вы просто рендерите его один раз за кадр со скоростью 30 кадров в секунду, это не должно иметь значения.
5. Метод MediaMetadataRetriever getFrameAtTime() имеет менее чем желаемую производительность по причинам, указанным выше. Вы вряд ли получите лучшие результаты, написав его самостоятельно, хотя вы можете сэкономить немного времени, пропустив шаг, на котором создается объект Bitmap. Кроме того, вы передали OPTION_CLOSEST_SYNC, но это даст желаемые результаты только в том случае, если все ваши кадры являются кадрами синхронизации (опять же, неуклюжая база данных изображений JPEG). Вам нужно использовать OPTION_CLOSEST.

Если вы просто пытаетесь воспроизвести фильм на текстуре (или ваша проблема может быть сведена к этому), в Графика есть несколько примеров. Один из них, который может быть уместным, — это TextureFromCamera, который визуализирует видеопоток камеры в прямоугольнике GLES, который можно масштабировать и вращать. Вы можете заменить вход камеры кодом воспроизведения MP4 из одной из других демонстраций. Это будет хорошо работать, если вы играете только вперед, но если вы хотите пропустить или вернуться назад, у вас возникнут проблемы.

Проблема, которую вы описываете, очень похожа на ту, с которой имеют дело разработчики 2D-игр. Делать то, что они делают, вероятно, лучший подход.

Да, есть способ извлечь отдельные кадры из видео mp4.

В принципе, вы, кажется, ищете альтернативный способ загрузки текстур, вместо обычного способа GLUtils.texImage2D (который заполняет текстуру из Bitmap).

Во-первых, вы должны учитывать то, что советуют другие, и ожидать визуальных артефактов от сжатия. Но предполагая, что ваши текстуры формируют связанные текстуры (например, взрыв), получение их из видеопотока имеет смысл. Для несвязанных изображений вы получите лучшие результаты, используя JPG или PNG. И обратите внимание, что видео mp4 не имеет альфа-канала, часто используемого в текстурах.

Для задачи вы не можете использовать MediaMetadataRetriever, это не даст вам необходимой точности для извлечения всех кадров.

Вам придется работать с классами Медиакодек и MediaExtractor. Подробная документация Android для MediaCodec.

На самом деле вам нужно реализовать своего рода настраиваемый видеоплеер и добавить одну ключевую функцию: шаг кадра.

Близким к этому является Android Проигрыватель медиа, который является полноценным проигрывателем, но 1) не имеет покадрового шага и 2) имеет довольно закрытый исходный код, поскольку он реализован множеством собственных библиотек C++, которые невозможно расширить и трудно изучить.

Я советую это с опытом создания покадрового видеоплеера, и я сделал это, приняв MediaPlayer-Extended, который написан на простой java (без собственного кода), поэтому вы можете включить это в свой проект и добавить функцию, которая вам нужна . Он работает с Android MediaCodec и MediaExtractor.
Где-то в классе MediaPlayer вы бы добавили функцию для frameStep и добавили еще один сигнал + функцию в PlaybackThread для декодирования только одного следующего кадра (в режиме паузы). Однако реализация этого будет зависеть от вас. Результатом будет то, что вы позволите декодеру получить и обработать один кадр, использовать кадр, а затем повторить со следующим кадром. Я так делал, поэтому знаю, что этот подход работает.

Другая половина задачи – получение результата. Видеоплеер (с MediaCodec) выводит кадры в файл Surface. Ваша задача будет получить пиксели. Я знаю, как читать растровое изображение RGB с такой поверхности: вам нужно создать OpenGL Pbuffer EGLSurface, позволить MediaCodec выполнить рендеринг в эту поверхность (Android SurfaceTexture), а затем прочитать пиксели с этой поверхности. Это еще одна нетривиальная задача, вам нужно создать шейдер для рендеринга текстуры EOS (поверхности) и использовать GLES20.glReadPixels для получения пикселей RGB в ByteBuffer. Затем вы загрузите эти растровые изображения RGB в свои текстуры. Однако, поскольку вы хотите загрузить текстуры, вы можете найти оптимизированный способ рендеринга видеокадра непосредственно в ваши текстуры и избежать перемещения пикселей.

Надеюсь, это поможет, и удачи в реализации.

На самом деле я хочу опубликовать свою реализацию на текущее время.

Вот h файл

#include <jni.h>
#include <memory>

#include <opencv2/opencv.hpp>

#include "looper.h"
#include "media/NdkMediaCodec.h"
#include "media/NdkMediaExtractor.h"

#ifndef NATIVE_CODEC_NATIVECODECC_H
#define NATIVE_CODEC_NATIVECODECC_H

//Originally took from here https://github.com/googlesamples/android- 
ndk/tree/master/native-codec
//Convert took from here 
https://github.com/kueblert/AndroidMediaCodec/blob/master/nativecodecvideo.cpp

class NativeCodec
{
public:
NativeCodec() = default;

~NativeCodec() = default;

void DecodeDone();

void Pause();

void Resume();

bool createStreamingMediaPlayer(const std::string &filename);

void setPlayingStreamingMediaPlayer(bool isPlaying);

void shutdown();

void rewindStreamingMediaPlayer();

int getFrameWidth() const
{
    return m_frameWidth;
}

int getFrameHeight() const
{
    return m_frameHeight;
}

void getNextFrame(std::vector<unsigned char> &imageData);

private:
struct Workerdata
{
    AMediaExtractor *ex;
    AMediaCodec *codec;
    bool sawInputEOS;
    bool sawOutputEOS;
    bool isPlaying;
    bool renderonce;
};

void Seek();

ssize_t m_bufidx = -1;
int m_frameWidth = -1;
int m_frameHeight = -1;
cv::Size m_frameSize;

Workerdata m_data = {nullptr, nullptr, false, false, false, false};
};

#endif //NATIVE_CODEC_NATIVECODECC_H

Здесь cc файл

#include "native_codec.h"

#include <cassert>
#include "native_codec.h"
#include <jni.h>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <cerrno>
#include <climits>
#include "util.h"
#include <android/log.h>
#include <string>
#include <chrono>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>

#include <android/log.h>
#include <string>
#include <chrono>

// for native window JNI
#include <android/native_window_jni.h>
#include <android/asset_manager.h>
#include <android/asset_manager_jni.h>

using namespace std;
using namespace std::chrono;

bool NativeCodec::createStreamingMediaPlayer(const std::string &filename)
{
AMediaExtractor *ex = AMediaExtractor_new();
media_status_t err = AMediaExtractor_setDataSource(ex, filename.c_str());;

if (err != AMEDIA_OK)
{
    return false;
}

size_t numtracks = AMediaExtractor_getTrackCount(ex);

AMediaCodec *codec = nullptr;

for (int i = 0; i < numtracks; i++)
{
    AMediaFormat *format = AMediaExtractor_getTrackFormat(ex, i);

    int format_color;

    AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_COLOR_FORMAT, &format_color);
    bool ok = AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_WIDTH, &m_frameWidth);
    ok = ok && AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_HEIGHT, 
 &m_frameHeight);

    if (ok)
    {
        m_frameSize = cv::Size(m_frameWidth, m_frameHeight);
    } else
    {
        //Asking format for frame width / height failed.
    }

    const char *mime;

    if (!AMediaFormat_getString(format, AMEDIAFORMAT_KEY_MIME, &mime))
    {
        return false;
    } else if (!strncmp(mime, "video/", 6))
    {
        // Omitting most error handling for clarity.
        // Production code should check for errors.
        AMediaExtractor_selectTrack(ex, i);
        codec = AMediaCodec_createDecoderByType(mime);
        AMediaCodec_configure(codec, format, nullptr, nullptr, 0);
        m_data.ex = ex;
        m_data.codec = codec;
        m_data.sawInputEOS = false;
        m_data.sawOutputEOS = false;
        m_data.isPlaying = false;
        m_data.renderonce = true;
        AMediaCodec_start(codec);
    }

    AMediaFormat_delete(format);
}

return true;
}

void NativeCodec::getNextFrame(std::vector<unsigned char> &imageData)
{
if (!m_data.sawInputEOS)
{
    m_bufidx = AMediaCodec_dequeueInputBuffer(m_data.codec, 2000);

    if (m_bufidx >= 0)
    {
        size_t bufsize;
        auto buf = AMediaCodec_getInputBuffer(m_data.codec, m_bufidx, &bufsize);
        auto sampleSize = AMediaExtractor_readSampleData(m_data.ex, buf, bufsize);

        if (sampleSize < 0)
        {
            sampleSize = 0;
            m_data.sawInputEOS = true;
        }

        auto presentationTimeUs = AMediaExtractor_getSampleTime(m_data.ex);

        AMediaCodec_queueInputBuffer(m_data.codec, m_bufidx, 0, sampleSize, 
presentationTimeUs,
                                     m_data.sawInputEOS ? 
AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM : 0);

        AMediaExtractor_advance(m_data.ex);
    }
}

if (!m_data.sawOutputEOS)
{
    AMediaCodecBufferInfo info;
    auto status = AMediaCodec_dequeueOutputBuffer(m_data.codec, &info, 0);

    if (status >= 0)
    {
        if (info.flags & AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM)
        {
            __android_log_print(ANDROID_LOG_ERROR, 
 "AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM", "AMEDIACODEC_BUFFER_FLAG_END_OF_STREAM :: %s", 
//
                                "output EOS");

            m_data.sawOutputEOS = true;
        }

        if (info.size > 0)
        {
//                size_t bufsize;
            uint8_t *buf = AMediaCodec_getOutputBuffer(m_data.codec, 
  static_cast<size_t>(status), /*bufsize*/nullptr);
            cv::Mat YUVframe(cv::Size(m_frameSize.width, static_cast<int> 
  (m_frameSize.height * 1.5)), CV_8UC1, buf);

            cv::Mat colImg(m_frameSize, CV_8UC3);
            cv::cvtColor(YUVframe, colImg, CV_YUV420sp2BGR, 3);
            auto dataSize = colImg.rows * colImg.cols * colImg.channels();
            imageData.assign(colImg.data, colImg.data + dataSize);
        }

        AMediaCodec_releaseOutputBuffer(m_data.codec, static_cast<size_t>(status), 
 info.size != 0);

        if (m_data.renderonce)
        {
            m_data.renderonce = false;
            return;
        }
    } else if (status < 0)
    {
        getNextFrame(imageData);
    } else if (status == AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED)
    {
        __android_log_print(ANDROID_LOG_ERROR, 
"AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED", "AMEDIACODEC_INFO_OUTPUT_BUFFERS_CHANGED :: %s", //
                            "output buffers changed");
    } else if (status == AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED)
    {
        auto format = AMediaCodec_getOutputFormat(m_data.codec);

        __android_log_print(ANDROID_LOG_ERROR, 
"AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED", "AMEDIACODEC_INFO_OUTPUT_FORMAT_CHANGED :: %s", 
 //
                            AMediaFormat_toString(format));

        AMediaFormat_delete(format);
    } else if (status == AMEDIACODEC_INFO_TRY_AGAIN_LATER)
    {
        __android_log_print(ANDROID_LOG_ERROR, "AMEDIACODEC_INFO_TRY_AGAIN_LATER", 
  "AMEDIACODEC_INFO_TRY_AGAIN_LATER :: %s", //
                            "no output buffer right now");
    } else
    {
        __android_log_print(ANDROID_LOG_ERROR, "UNEXPECTED INFO CODE", "UNEXPECTED 
 INFO CODE :: %zd", //
                            status);
    }
}
}

void NativeCodec::DecodeDone()
{
if (m_data.codec != nullptr)
{
    AMediaCodec_stop(m_data.codec);
    AMediaCodec_delete(m_data.codec);
    AMediaExtractor_delete(m_data.ex);
    m_data.sawInputEOS = true;
    m_data.sawOutputEOS = true;
}
}

void NativeCodec::Seek()
{
AMediaExtractor_seekTo(m_data.ex, 0, AMEDIAEXTRACTOR_SEEK_CLOSEST_SYNC);
AMediaCodec_flush(m_data.codec);
m_data.sawInputEOS = false;
m_data.sawOutputEOS = false;

if (!m_data.isPlaying)
{
    m_data.renderonce = true;
}
}

void NativeCodec::Pause()
{
if (m_data.isPlaying)
{
    // flush all outstanding codecbuffer messages with a no-op message
    m_data.isPlaying = false;
}
}

void NativeCodec::Resume()
{
if (!m_data.isPlaying)
{
    m_data.isPlaying = true;
}
}

void NativeCodec::setPlayingStreamingMediaPlayer(bool isPlaying)
{
if (isPlaying)
{
    Resume();
} else
{
    Pause();
}
}

void NativeCodec::shutdown()
{
m_bufidx = -1;
DecodeDone();
}

void NativeCodec::rewindStreamingMediaPlayer()
{
Seek();
}

Итак, согласно этой реализации для преобразования формата (в моем случае из YUV в BGR) нужно настроить OpenCV, для понимания как это сделать проверьте эти два источника

https://thewikihow.com/video_jN9Bv5LHXMk

https://thewikihow.com/video_0fdIiOqCz3o

А также для пробы оставляю здесь свой CMakeLists.txt файл

#For add OpenCV take a look at this video
#https://thewikihow.com/video_jN9Bv5LHXMk
#https://thewikihow.com/video_0fdIiOqCz3o
#Look at the video than compare with this file and make the same

set(pathToProject
    C:/Users/tetavi/Downloads/Buffer/OneMoreArNew/arcore-android- 
sdk/samples/hello_ar_c)
set(pathToOpenCv C:/OpenCV-android-sdk)

cmake_minimum_required(VERSION 3.4.1)

set(CMAKE VERBOSE MAKEFILE on)
set(CMAKE CXX FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")

include_directories(${pathToOpenCv}/sdk/native/jni/include)

# Import the ARCore library.
add_library(arcore SHARED IMPORTED)
set_target_properties(arcore PROPERTIES IMPORTED_LOCATION
    ${ARCORE_LIBPATH}/${ANDROID_ABI}/libarcore_sdk_c.so
    INTERFACE_INCLUDE_DIRECTORIES ${ARCORE_INCLUDE}
    )

# Import the glm header file from the NDK.
add_library(glm INTERFACE)
set_target_properties(glm PROPERTIES
    INTERFACE_INCLUDE_DIRECTORIES 
${ANDROID_NDK}/sources/third_party/vulkan/src/libs/glm
    )

# This is the main app library.
add_library(hello_ar_native SHARED
     src/main/cpp/background_renderer.cc
    src/main/cpp/hello_ar_application.cc
    src/main/cpp/jni_interface.cc
    src/main/cpp/video_render.cc
    src/main/cpp/geometry_loader.cc
    src/main/cpp/plane_renderer.cc
    src/main/cpp/native_codec.cc
    src/main/cpp/point_cloud_renderer.cc
    src/main/cpp/frame_manager.cc
    src/main/cpp/safe_queue.cc
    src/main/cpp/stb_image.h
    src/main/cpp/util.cc)

add_library(lib_opencv SHARED IMPORTED)
set_target_properties(lib_opencv PROPERTIES IMPORTED_LOCATION

${pathToProject}/app/src/main/jniLibs/${CMAKE_ANDROID_ARCH_ABI}/libopencv_java3.so)

target_include_directories(hello_ar_native PRIVATE
    src/main/cpp)

target_link_libraries(hello_ar_native $\{log-lib} lib_opencv
    android
    log
    GLESv2
    glm
    mediandk
    arcore)

Применение:

Вам нужно создать потоковый медиаплеер с помощью этого метода

NaviteCodec::createStreamingMediaPlayer(pathToYourMP4file);

а затем просто используйте

NativeCodec::getNextFrame(imageData);

Не стесняйтесь спрашивать