学习积累

# ······
# build settings
SHFLAGS='-shared -Wl,-soname,$$(@F)'
LIBPREF="lib"
LIBSUF=".a"
FULLNAME='$(NAME)$(BUILDSUF)'
LIBNAME='$(LIBPREF)$(FULLNAME)$(LIBSUF)'
SLIBPREF="lib"
SLIBSUF=".so"
SLIBNAME='$(SLIBPREF)$(FULLNAME)$(SLIBSUF)'
SLIBNAME_WITH_VERSION='$(SLIBNAME).$(LIBVERSION)'

# 変更された設定
SLIBNAME_WITH_MAJOR='$(SLIBNAME)$(FULLNAME)-$(LIBMAJOR)$(SLIBSUF)'
LIB_INSTALL_EXTRA_CMD='$$(RANLIB)"$(LIBDIR)/$(LIBNAME)"'
SLIB_INSTALL_NAME='$(SLIBNAME_WITH_MAJOR)'
SLIB_INSTALL_LINKS='$(SLIBNAME)'
# ······

# 前回のコンパイルをクリア
make clean
# ここでNDKのパスを設定します
export NDK=/Users/bytedance/Library/Android/sdk/ndk/21.4.7075529
TOOLCHAIN=$NDK/toolchains/llvm/prebuilt/darwin-x86_64


function build_android
{

./configure \
--prefix=$PREFIX \
--disable-postproc \
--disable-debug \
--disable-doc \
--enable-FFmpeg \
--disable-doc \
--disable-symver \
--disable-static \
--enable-shared \
--cross-prefix=$CROSS_PREFIX \
--target-os=android \
--arch=$ARCH \
--cpu=$CPU \
--cc=$CC \
--cxx=$CXX \
--enable-cross-compile \
--sysroot=$SYSROOT \
--extra-cflags="-Os -fpic $OPTIMIZE_CFLAGS" \
--extra-ldflags="$ADDI_LDFLAGS"

make clean
make -j16
make install

echo "============================ build android arm64-v8a success =========================="

}

# arm64-v8a
ARCH=arm64
CPU=armv8-a
API=21
CC=$TOOLCHAIN/bin/aarch64-linux-android$API-clang
CXX=$TOOLCHAIN/bin/aarch64-linux-android$API-clang++
SYSROOT=$NDK/toolchains/llvm/prebuilt/darwin-x86_64/sysroot
CROSS_PREFIX=$TOOLCHAIN/bin/aarch64-linux-android-
PREFIX=$(pwd)/android/$CPU
OPTIMIZE_CFLAGS="-march=$CPU"

echo $CC

build_android

#armv7-a
ARCH=arm
CPU=armv7-a
API=21
CC=$TOOLCHAIN/bin/armv7a-linux-androideabi$API-clang
CXX=$TOOLCHAIN/bin/armv7a-linux-androideabi$API-clang++
SYSROOT=$NDK/toolchains/llvm/prebuilt/darwin-x86_64/sysroot
CROSS_PREFIX=$TOOLCHAIN/bin/arm-linux-androideabi-
PREFIX=$(pwd)/android/$CPU
OPTIMIZE_CFLAGS="-mfloat-abi=softfp -mfpu=vfp -marm -march=$CPU "

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // ネイティブメソッドの呼び出しの例
        sample_text.text = stringFromJNI()
    }

    // 外部参照メソッドを宣言します。このメソッドはC/C++層のコードに対応しています。
    external fun stringFromJNI(): String

    companion object {

        // init{}内でC/C++でコンパイルされたライブラリをロードします：ffmpeg
        // ライブラリ名の定義と追加はCMakeLists.txtで行います
        init {
            System.loadLibrary("ffmpeg")
        }
    }
}

#include <jni.h>
#include <string>
extern "C" JNIEXPORT jstring JNICALL
Java_com_bytedance_example_MainActivity_stringFromJNI(
        JNIEnv *env,
        jobject /* this */) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}

# Android StudioでCMakeを使用する方法についての詳細は、ドキュメントを参照してください。
# https://d.android.com/studio/projects/add-native-code.html

# ネイティブライブラリをビルドするために必要なCMakeの最小バージョンを設定します。

cmake_minimum_required(VERSION 3.10.2)

# プロジェクトを宣言し、名前を付けます。

project("ffmpeg")

# ライブラリを作成し、名前を付け、ソースコードへの相対パスを設定します。
# 複数のライブラリを定義でき、CMakeがそれらをビルドします。
# Gradleは自動的に共有ライブラリをAPKにパッケージします。

# soライブラリとヘッダーファイルのディレクトリを定義し、後で使用しやすくします
set(FFmpeg_lib_dir ${CMAKE_SOURCE_DIR}/../jniLibs/${ANDROID_ABI})
set(FFmpeg_head_dir ${CMAKE_SOURCE_DIR}/FFmpeg)

# ヘッダーファイルディレクトリを追加します
include_directories(
        FFmpeg/include
)

add_library( # ライブラリの名前を設定します。
        ffmmpeg

        # ライブラリを共有ライブラリとして設定します。
        SHARED

        # ソースファイルへの相対パスを提供します。
        native-lib.cpp
        )

# 指定されたプリビルドライブラリを検索し、パスを変数として保存します。
# CMakeはデフォルトでシステムライブラリを検索パスに含めるため、追加したい公開NDKライブラリの名前だけを指定すればよいです。
# CMakeはライブラリが存在することを確認してからビルドを完了します。

# FFmpeg関連のsoライブラリを追加します
add_library( avutil
        SHARED
        IMPORTED )
set_target_properties( avutil
        PROPERTIES IMPORTED_LOCATION
        ${FFmpeg_lib_dir}/libavutil.so )
add_library( swresample
        SHARED
        IMPORTED )
set_target_properties( swresample
        PROPERTIES IMPORTED_LOCATION
        ${FFmpeg_lib_dir}/libswresample.so )

add_library( avcodec
        SHARED
        IMPORTED )
set_target_properties( avcodec
        PROPERTIES IMPORTED_LOCATION
        ${FFmpeg_lib_dir}/libavcodec.so )


find_library( # パス変数の名前を設定します。
        log-lib

        # CMakeが見つけるように指定するNDKライブラリの名前を指定します。
        log)

# ターゲットライブラリにリンクするライブラリを指定します。
# このビルドスクリプトで定義したライブラリ、プリビルドのサードパーティライブラリ、またはシステムライブラリを複数リンクできます。

target_link_libraries( # ターゲットライブラリを指定します。
        audioffmmpeg

        # 前に追加したFFmpeg.soライブラリをターゲットライブラリnative-libにリンクします
        avutil
        swresample
        avcodec

        -landroid

        # ターゲットライブラリをNDKに含まれるログライブラリにリンクします。
        ${log-lib})

// 1 AVFormatContextを割り当てる
avformat_alloc_context();
// 2 ファイル入力ストリームを開く
avformat_open_input(AVFormatContext **ps, const char *url,
                        const AVInputFormat *fmt, AVDictionary **options);
// 3 入力ファイルからデータストリーム情報を抽出する
avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);
// 4 コーデックコンテキストを割り当てる
avcodec_alloc_context3(const AVCodec *codec);
// 5 データストリームに関連するコーデックパラメータに基づいてコーデックコンテキストを埋める
avcodec_parameters_to_context(AVCodecContext *codec,
                                  const AVCodecParameters *par);
// 6 登録されたコーデックを検索する
avcodec_find_decoder(enum AVCodecID id);
// 7 コーデックを開く
avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
// 8 ストリームから圧縮フレームデータを抽出し続ける。取得されるのは1フレームのビデオの圧縮データ
av_read_frame(AVFormatContext *s, AVPacket *pkt);
// 9 デコーダに生の圧縮データを送信する（compressed data）
avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt);
// 10 デコーダから出力されたデコードデータを受信する
avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame);

av_register_all();

auto av_format_context = avformat_alloc_context();
avformat_open_input(&av_format_context, path_.c_str(), nullptr, nullptr);
avformat_find_stream_info(av_format_context, nullptr);

int video_stream_index = -1;
for (int i = 0; i < av_format_context->nb_streams; i++) {
    // ビデオメディアストリームのインデックスを見つける
    if (av_format_context->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
        video_stream_index = i;
        LOGD(TAG, "find video stream index = %d", video_stream_index);
        break;
    }
}

// ビデオメディアストリームを取得
auto stream = av_format_context->streams[video_stream_index];
// 登録されたコーデックを見つける
auto codec = avcodec_find_decoder(stream->codecpar->codec_id);
// デコーダコンテキストを取得
AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
// ビデオメディアストリームのパラメータをデコーダコンテキストに設定
auto ret = avcodec_parameters_to_context(codec_ctx, stream->codecpar);

if (ret >= 0) {
    // デコーダを開く
    avcodec_open2(codec_ctx, codec, nullptr);
    // ······
}

video_width_ = codec_ctx->width;
video_height_ = codec_ctx->height;

int buffer_size = av_image_get_buffer_size(AV_PIX_FMT_RGBA,
                                           video_width_, video_height_, 1);
// 出力バッファ
out_buffer_ = (uint8_t*) av_malloc(buffer_size * sizeof(uint8_t));
// 幅と高さを設定してバッファ内のピクセル数を制限します。表示画面のサイズではなく。
// バッファが表示される画面のサイズと一致しない場合、実際に表示されるのは引き伸ばされたり、圧縮された画像になる可能性があります
int result = ANativeWindow_setBuffersGeometry(native_window_, video_width_,
                                              video_height_, WINDOW_FORMAT_RGBA_8888);

auto rgba_frame = av_frame_alloc();
av_image_fill_arrays(rgba_frame->data, rgba_frame->linesize,
                     out_buffer_,
                     AV_PIX_FMT_RGBA,
                     video_width_, video_height_, 1);

struct SwsContext* data_convert_context = sws_getContext(
                    video_width_, video_height_, codec_ctx->pix_fmt,
                    video_width_, video_height_, AV_PIX_FMT_RGBA,
                    SWS_BICUBIC, nullptr, nullptr, nullptr);

auto frame = av_frame_alloc();
auto packet = av_packet_alloc();

ret = av_read_frame(av_format_context, packet);
if (packet->size) {
    Decode(codec_ctx, packet, frame, stream, lock, data_convert_context, rgba_frame);
}

/* 圧縮データを含むパケットをデコーダに送信します */
ret = avcodec_send_packet(codec_ctx, pkt);

while (ret >= 0 && !is_stop_) {
    // デコードされたデータをframeに返します
    ret = avcodec_receive_frame(codec_ctx, frame);
    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
        return;
    } else if (ret < 0) {
        return;
    }
    // 現在デコードされたframeのptsをタイムスタンプに換算し、指定されたタイムスタンプと比較します
    auto decode_time_ms = frame->pts * 1000 / stream->time_base.den;
    if (decode_time_ms >= time_ms_) {
        last_decode_time_ms_ = decode_time_ms;
        is_seeking_ = false;
        // ······
        // 画像データフォーマット変換
        // ······
        // 変換されたデータを画面に描画します
    }
    av_packet_unref(pkt);
}

// 画像データフォーマット変換
int result = sws_scale(
        sws_context,
        (const uint8_t* const*) frame->data, frame->linesize,
        0, video_height_,
        rgba_frame->data, rgba_frame->linesize);

if (result <= 0) {
    LOGE(TAG, "Player Error : data convert fail");
    return;
}

// 再生
result = ANativeWindow_lock(native_window_, &window_buffer_, nullptr);
if (result < 0) {
    LOGE(TAG, "Player Error : Can not lock native window");
} else {
    // 画像を画面に描画します
    // 注意 : ここでrgba_frameの1行のピクセルとwindow_bufferの1行のピクセルの長さは一致しない可能性があります
    // 正しく変換しないと、画面が乱れる可能性があります
    auto bits = (uint8_t*) window_buffer_.bits;
    for (int h = 0; h < video_height_; h++) {
        memcpy(bits + h * window_buffer_.stride * 4,
               out_buffer_ + h * rgba_frame->linesize[0],
               rgba_frame->linesize[0]);
    }
    ANativeWindow_unlockAndPost(native_window_);
}

sws_freeContext(data_convert_context);
av_free(out_buffer_);
av_frame_free(&rgba_frame);
av_frame_free(&frame);
av_packet_free(&packet);

avcodec_close(codec_ctx);
avcodec_free_context(&codec_ctx);

avformat_close_input(&av_format_context);
avformat_free_context(av_format_context);
ANativeWindow_release(native_window_);

VideoDecoder(const char* path, std::function<void(long timestamp)> on_decode_frame);

void Prepare(ANativeWindow* window);

bool DecodeFrame(long time_ms);

void Release();

condition_.wait(lock);

bool VideoDecoder::DecodeFrame(long time_ms) {
    // ······
    time_ms_ = time_ms;
    condition_.notify_all();
    return true;
}

int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp,
                  int flags);

if (!is_seeking_ && (time_ms_ > last_decode_time_ms_ + 1000 ||
                     time_ms_ < last_decode_time_ms_ - 50)) {
    is_seeking_ = true;
    // シーク時に渡すのは指定されたフレームのtime_baseを持つタイムスタンプであるため、times_msを使用して推算する必要があります
    LOGD(TAG, "seek frame time_ms_ = %ld， last_decode_time_ms_ = %ld", time_ms_,
         last_decode_time_ms_);
    av_seek_frame(av_format_context,
                  video_stream_index,
                  time_ms_ * stream->time_base.den / 1000,
                  AVSEEK_FLAG_BACKWARD);
}

// シークのロジックはここに書きます
// 次にビデオストリームの次のフレームを読み取ります
int ret = av_read_frame(av_format_context, packet);

if (!is_seeking_ && (time_ms_ > last_decode_time_ms_ + 1000 ||
                     time_ms_ < last_decode_time_ms_ - 50)) {
    is_seeking_ = true;
    av_seek_frame(···,···,···,AVSEEK_FLAG_BACKWARD);
}

bool VideoDecoder::DecodeFrame(long time_ms) {
    LOGD(TAG, "DecodeFrame time_ms = %ld", time_ms);
    if (last_decode_time_ms_ == time_ms || time_ms_ == time_ms) {
        LOGD(TAG, "DecodeFrame last_decode_time_ms_ == time_ms");
        return false;
    }
    if (time_ms <= last_decode_time_ms_ &&
        time_ms + 50 >= last_decode_time_ms_) {
        return false;
    }
    time_ms_ = time_ms;
    condition_.notify_all();
    return true;
}

// AVPacketのpts
   /**
    * AVStream->time_base単位でのプレゼンテーションタイムスタンプ；デコーディングされたパケットがユーザーに提示される時間。
    * ファイルに保存されていない場合はAV_NOPTS_VALUEになる可能性があります。
    * ptsはdtsより大きいか等しい必要があります。プレゼンテーションはデコーディング前に行うことはできません。
    * 一部のフォーマットは、dtsとpts/ctsの用語を異なる意味で誤用します。これらのタイムスタンプは、AVPacketに保存される前に真のpts/dtsに変換する必要があります。
    */
   int64_t pts;

   // AVFrameのpts
   /**
    * プレゼンテーションタイムスタンプはtime_base単位（フレームがユーザーに表示される時間）です。
    */
   int64_t pts;

auto decode_time_ms = frame->pts * 1000 / stream->time_base.den;
LOGD(TAG, "decode_time_ms = %ld", decode_time_ms);
if (decode_time_ms >= time_ms_) {
    last_decode_time_ms_ = decode_time_ms;
    is_seeking = false;
    // 画面描画
    // ····
}

// 音声のいくつかのフレームまたはビデオの1フレームをストリームから読み取ります。
// ここではビデオの1フレーム（完全なフレーム）を読み取ります。取得されるのは1フレームのビデオの圧縮データであり、次にデコードを行うことができます
ret = av_read_frame(av_format_context, packet);
if (ret < 0) {
    avcodec_flush_buffers(codec_ctx);
    av_seek_frame(av_format_context, video_stream_index,
                  time_ms_ * stream->time_base.den / 1000, AVSEEK_FLAG_BACKWARD);
    LOGD(TAG, "ret < 0, condition_.wait(lock)");
    // デコードの最後のフレームでビデオにデータがないのを防ぎます
    on_decode_frame_(last_decode_time_ms_);
    condition_.wait(lock);
}

// FFmpegVideoDecoder.kt
class FFmpegVideoDecoder(
    path: String,
    val onDecodeFrame: (timestamp: Long, texture: SurfaceTexture, needRender: Boolean) -> Unit
){
    // timeMsフレームを抽出し、syncが同期待機かどうか
    fun decodeFrame(timeMS: Long, sync: Boolean = false) {
        // 現在抽フレームが必要ない場合は待機しません
        if (nativeDecodeFrame(decoderPtr, timeMS) && sync) {
            // ······
    } else {
            // ······
    }
    }

    private external fun nativeDecodeFrame(decoder: Long, timeMS: Long): Boolean

    companion object {
        const val TAG = "FFmpegVideoDecoder"

        init {
            System.loadLibrary("ffmmpeg")

        }
    }
}

// native-lib.cpp
extern "C"
JNIEXPORT jboolean JNICALL
Java_com_example_decoder_video_FFmpegVideoDecoder_nativeDecodeFrame(JNIEnv* env,
                                                               jobject thiz,
                                                               jlong decoder,
                                                               jlong time_ms) {
    auto videoDecoder = (codec::VideoDecoder*)decoder;
    return videoDecoder->DecodeFrame(time_ms);
}

#include <jni.h>
#include <mutex>
#include <android/native_window.h>
#include <android/native_window_jni.h>
#include <time.h>

extern "C" {
#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libswresample/swresample.h>
#include <libswscale/swscale.h>
}
#include <string>
/*
 * VideoDecoderは特定の音声ビデオファイル（例えば.mp4）内のビデオメディアストリームデータをデコードするために使用できます。
 * Java層から指定されたファイルのパスを渡すと、一定のfpsで指定されたタイムスタンプに従ってデコード（フレーム抽出）を行います。この実装はC++が提供するDecodeFrameによって行われます。
 * 各デコード終了時に、デコードされたフレームのタイムスタンプを上層のデコーダにコールバックし、他の操作に使用できるようにします。
 */
namespace codec {
class VideoDecoder {

private:
    std::string path_;
    long time_ms_ = -1;
    long last_decode_time_ms_ = -1;
    bool is_seeking_ = false;
    ANativeWindow* native_window_ = nullptr;
    ANativeWindow_Buffer window_buffer_{};、
    // ビデオの幅と高さの属性
    int video_width_ = 0;
    int video_height_ = 0;
    uint8_t* out_buffer_ = nullptr;
    // on_decode_frameは指定されたフレームのタイムスタンプを上層デコーダにコールバックするために使用されます。
    std::function<void(long timestamp)> on_decode_frame_ = nullptr;
    bool is_stop_ = false;

    // ループ同期時に使用されるロック“std::unique_lock<std::mutex>”と組み合わせて使用されます
    std::mutex work_queue_mtx;
    // 実際に同期待機と解除を行う属性
    std::condition_variable condition_;
    // デコーダが実際にデコードを行う関数
    void Decode(AVCodecContext* codec_ctx, AVPacket* pkt, AVFrame* frame, AVStream* stream,
                std::unique_lock<std::mutex>& lock, SwsContext* sws_context, AVFrame* pFrame);

public:
    // 新しいデコーダを作成する際にメディアファイルパスとデコード後のコールバックon_decode_frameを渡す必要があります。
    VideoDecoder(const char* path, std::function<void(long timestamp)> on_decode_frame);
    // JNI層で上層から渡されたSurfaceをラップして新しいANativeWindowを作成し、後でデコード後にフレームデータを描画する際に使用します
    void Prepare(ANativeWindow* window);
    // 指定されたタイムスタンプのビデオフレームを抽出します。上層から呼び出すことができます
    bool DecodeFrame(long time_ms);
    // デコーダリソースを解放します
    void Release();
    // 現在のシステムミリ秒時間を取得します
    static int64_t GetCurrentMilliTime(void);
};

}

#include "VideoDecoder.h"
#include "../log/Logger.h"
#include <thread>
#include <utility>

extern "C" {
#include <libavutil/imgutils.h>
}

#define TAG "VideoDecoder"
namespace codec {

VideoDecoder::VideoDecoder(const char* path, std::function<void(long timestamp)> on_decode_frame)
        : on_decode_frame_(std::move(on_decode_frame)) {
    path_ = std::string(path);
}

void VideoDecoder::Decode(AVCodecContext* codec_ctx, AVPacket* pkt, AVFrame* frame, AVStream* stream,
                     std::unique_lock<std::mutex>& lock, SwsContext* sws_context,
                     AVFrame* rgba_frame) {

    int ret;
    /* 圧縮データを含むパケットをデコーダに送信します */
    ret = avcodec_send_packet(codec_ctx, pkt);
    if (ret == AVERROR(EAGAIN)) {
        LOGE(TAG,
             "Decode: Receive_frame and send_packet both returned EAGAIN, which is an API violation.");
    } else if (ret < 0) {
        return;
    }

    // すべての出力フレームを読み取ります（一般的に、任意の数のフレームがある可能性があります）
    while (ret >= 0 && !is_stop_) {
        // frameに対して、avcodec_receive_frame内部で毎回呼び出されます
        ret = avcodec_receive_frame(codec_ctx, frame);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
            return;
        } else if (ret < 0) {
            return;
        }
        int64_t startTime = GetCurrentMilliTime();
        LOGD(TAG, "decodeStartTime: %ld", startTime);
        // 現在デコード中のframeのタイムスタンプを換算します
        auto decode_time_ms = frame->pts * 1000 / stream->time_base.den;
        LOGD(TAG, "decode_time_ms = %ld", decode_time_ms);
        if (decode_time_ms >= time_ms_) {
            LOGD(TAG, "decode decode_time_ms = %ld, time_ms_ = %ld", decode_time_ms, time_ms_);
            last_decode_time_ms_ = decode_time_ms;
            is_seeking_ = false;

            // データフォーマット変換
            int result = sws_scale(
                    sws_context,
                    (const uint8_t* const*) frame->data, frame->linesize,
                    0, video_height_,
                    rgba_frame->data, rgba_frame->linesize);

            if (result <= 0) {
                LOGE(TAG, "Player Error : data convert fail");
                return;
            }

            // 再生
            result = ANativeWindow_lock(native_window_, &window_buffer_, nullptr);
            if (result < 0) {
                LOGE(TAG, "Player Error : Can not lock native window");
            } else {
                // 画像を画面に描画します
                auto bits = (uint8_t*) window_buffer_.bits;
                for (int h = 0; h < video_height_; h++) {
                    memcpy(bits + h * window_buffer_.stride * 4,
                           out_buffer_ + h * rgba_frame->linesize[0],
                           rgba_frame->linesize[0]);
                }
                ANativeWindow_unlockAndPost(native_window_);
            }
            on_decode_frame_(decode_time_ms);
            int64_t endTime = GetCurrentMilliTime();
            LOGD(TAG, "decodeEndTime - decodeStartTime: %ld", endTime - startTime);
            LOGD(TAG, "finish decode frame");
            condition_.wait(lock);
        }
        // 主にAVPacket内のすべての空間データをクリアし、クリア後に初期化操作を行い、dataとsizeを0に設定して次回の呼び出しを容易にします。
        // packetの参照を解放します
        av_packet_unref(pkt);
    }
}

void VideoDecoder::Prepare(ANativeWindow* window) {
    native_window_ = window;
    av_register_all();
    auto av_format_context = avformat_alloc_context();
    avformat_open_input(&av_format_context, path_.c_str(), nullptr, nullptr);
    avformat_find_stream_info(av_format_context, nullptr);
    int video_stream_index = -1;
    for (int i = 0; i < av_format_context->nb_streams; i++) {
        // ビデオメディアストリームのインデックスを見つけます
        if (av_format_context->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
            video_stream_index = i;
            LOGD(TAG, "find video stream index = %d", video_stream_index);
            break;
        }
    }

    // 一度実行します
    do {
        if (video_stream_index == -1) {
            codec::LOGE(TAG, "Player Error : Can not find video stream");
            break;
        }
        std::unique_lock<std::mutex> lock(work_queue_mtx);

        // ビデオメディアストリームを取得します
        auto stream = av_format_context->streams[video_stream_index];
        // 登録されたコーデックを見つけます
        auto codec = avcodec_find_decoder(stream->codecpar->codec_id);
        // デコーダコンテキストを取得します
        AVCodecContext* codec_ctx = avcodec_alloc_context3(codec);
        auto ret = avcodec_parameters_to_context(codec_ctx, stream->codecpar);

        if (ret >= 0) {
            // 開きます
            avcodec_open2(codec_ctx, codec, nullptr);
            // デコーダが開かれた後にのみ幅と高さの値があります
            video_width_ = codec_ctx->width;
            video_height_ = codec_ctx->height;

            AVFrame* rgba_frame = av_frame_alloc();
            int buffer_size = av_image_get_buffer_size(AV_PIX_FMT_RGBA, video_width_, video_height_,
                                                       1);
            // 出力バッファにメモリ空間を割り当てます
            out_buffer_ = (uint8_t*) av_malloc(buffer_size * sizeof(uint8_t));
            av_image_fill_arrays(rgba_frame->data, rgba_frame->linesize, out_buffer_,
                                 AV_PIX_FMT_RGBA,
                                 video_width_, video_height_, 1);

            // 幅と高さを設定してバッファ内のピクセル数を制限します。物理的な表示サイズではなく。
            // バッファが物理画面の表示サイズと一致しない場合、実際の表示は引き伸ばされたり、圧縮された画像になる可能性があります
            int result = ANativeWindow_setBuffersGeometry(native_window_, video_width_,
                                                          video_height_, WINDOW_FORMAT_RGBA_8888);
            if (result < 0) {
                LOGE(TAG, "Player Error : Can not set native window buffer");
                avcodec_close(codec_ctx);
                avcodec_free_context(&codec_ctx);
                av_free(out_buffer_);
                break;
            }

            auto frame = av_frame_alloc();
            auto packet = av_packet_alloc();

            struct SwsContext* data_convert_context = sws_getContext(
                    video_width_, video_height_, codec_ctx->pix_fmt,
                    video_width_, video_height_, AV_PIX_FMT_RGBA,
                    SWS_BICUBIC, nullptr, nullptr, nullptr);
            while (!is_stop_) {
                LOGD(TAG, "front seek time_ms_ = %ld, last_decode_time_ms_ = %ld", time_ms_,
                     last_decode_time_ms_);
                if (!is_seeking_ && (time_ms_ > last_decode_time_ms_ + 1000 ||
                                     time_ms_ < last_decode_time_ms_ - 50)) {
                    is_seeking_ = true;
                    LOGD(TAG, "seek frame time_ms_ = %ld， last_decode_time_ms_ = %ld", time_ms_,
                         last_decode_time_ms_);
                    // 渡すのは指定されたフレームのtime_baseを持つタイムスタンプであるため、元のtimes_msを上記で取得した計算方法に従って逆算する必要があります
                    av_seek_frame(av_format_context, video_stream_index,
                                  time_ms_ * stream->time_base.den / 1000, AVSEEK_FLAG_BACKWARD);
                }
                // ビデオの1フレーム（完全なフレーム）を読み取ります。取得されるのは1フレームのビデオの圧縮データであり、次にデコードを行うことができます
                ret = av_read_frame(av_format_context, packet);
                if (ret < 0) {
                    avcodec_flush_buffers(codec_ctx);
                    av_seek_frame(av_format_context, video_stream_index,
                                  time_ms_ * stream->time_base.den / 1000, AVSEEK_FLAG_BACKWARD);
                    LOGD(TAG, "ret < 0, condition_.wait(lock)");
                    // デコードの最後のフレームでビデオにデータがないのを防ぎます
                    on_decode_frame_(last_decode_time_ms_);
                    condition_.wait(lock);
                }
                if (packet->size) {
                    Decode(codec_ctx, packet, frame, stream, lock, data_convert_context,
                           rgba_frame);
                }
            }
            // リソースを解放します
            sws_freeContext(data_convert_context);
            av_free(out_buffer_);
            av_frame_free(&rgba_frame);
            av_frame_free(&frame);
            av_packet_free(&packet);

        }
        avcodec_close(codec_ctx);
        avcodec_free_context(&codec_ctx);

    } while (false);
    avformat_close_input(&av_format_context);
    avformat_free_context(av_format_context);
    ANativeWindow_release(native_window_);
    delete this;
}

bool VideoDecoder::DecodeFrame(long time_ms) {
    LOGD(TAG, "DecodeFrame time_ms = %ld", time_ms);
    if (last_decode_time_ms_ == time_ms || time_ms_ == time_ms) {
        LOGD(TAG, "DecodeFrame last_decode_time_ms_ == time_ms");
        return false;
    }
    if (last_decode_time_ms_ >= time_ms && last_decode_time_ms_ <= time_ms + 50) {
        return false;
    }
    time_ms_ = time_ms;
    condition_.notify_all();
    return true;
}

void VideoDecoder::Release() {
    is_stop_ = true;
    condition_.notify_all();
}

/**
 * 現在のミリ秒単位の時間を取得します
 */
int64_t VideoDecoder::GetCurrentMilliTime(void) {
    struct timeval tv{};
    gettimeofday(&tv, nullptr);
    return tv.tv_sec * 1000.0 + tv.tv_usec / 1000.0;
}

}