# ······# build settingsSHFLAGS='-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.7075529TOOLCHAIN=$NDK/toolchains/llvm/prebuilt/darwin-x86_64function 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 cleanmake -j16make installecho "============================ build android arm64-v8a success =========================="}# arm64-v8aARCH=arm64CPU=armv8-aAPI=21CC=$TOOLCHAIN/bin/aarch64-linux-android$API-clangCXX=$TOOLCHAIN/bin/aarch64-linux-android$API-clang++SYSROOT=$NDK/toolchains/llvm/prebuilt/darwin-x86_64/sysrootCROSS_PREFIX=$TOOLCHAIN/bin/aarch64-linux-android-PREFIX=$(pwd)/android/$CPUOPTIMIZE_CFLAGS="-march=$CPU"echo $CCbuild_android

#armv7-aARCH=armCPU=armv7-aAPI=21CC=$TOOLCHAIN/bin/armv7a-linux-androideabi$API-clangCXX=$TOOLCHAIN/bin/armv7a-linux-androideabi$API-clang++SYSROOT=$NDK/toolchains/llvm/prebuilt/darwin-x86_64/sysrootCROSS_PREFIX=$TOOLCHAIN/bin/arm-linux-androideabi-PREFIX=$(pwd)/android/$CPUOPTIMIZE_CFLAGS="-mfloat-abi=softfp -mfpu=vfp -marm -march=$CPU "1.2 在 Android 中引入 FFmpeg 得 so 库

class MainActivity : AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // Example of a call to a native method sample_text.text = stringFromJNI() } // 声明一个外部引用得方法，此方法和 C/C++ 层得代码是对应得。 external fun stringFromJNI(): String companion object { // 在 init{} 中加载 C/C++ 编译成得 library：ffmpeg // library 名称得定义和添加在 CMakeLists.txt 中完成 init { System.loadLibrary("ffmpeg") } }}

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

# For more information about using CMake with Android Studio, read the# documentation: d.android/studio/projects/add-native-code.html# Sets the minimum version of CMake required to build the native library.cmake_minimum_required(VERSION 3.10.2)# Declares and names the project.project("ffmpeg")# Creates and names a library, sets it as either STATIC# or SHARED, and provides the relative paths to its source code.# You can define multiple libraries, and CMake builds them for you.# Gradle automatically packages shared libraries with your APK.# 定义 so 库和头文件所在目录，方便后面使用set(FFmpeg_lib_dir ${CMAKE_SOURCE_DIR}/../jniLibs/${ANDRO_ABI})set(FFmpeg_head_dir ${CMAKE_SOURCE_DIR}/FFmpeg)# 添加头文件目录include_directories( FFmpeg/include)add_library( # Sets the name of the library. ffmmpeg # Sets the library as a shared library. SHARED # Provides a relative path to your source file(s). native-lib.cpp )# Searches for a specified prebuilt library and stores the path as a# variable. Because CMake includes system libraries in the search path by# default, you only need to specify the name of the public NDK library# you want to add. CMake verifies that the library exists before# completing its build.# 添加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( # Sets the name of the path variable. log-lib # Specifies the name of the NDK library that # you want CMake to locate. log)# Specifies libraries CMake should link to your target library. You# can link multiple libraries, such as libraries you define in this# build script, prebuilt third-party libraries, or system libraries.target_link_libraries( # Specifies the target library. audioffmmpeg # 把前面添加进来得 FFmpeg.so 库都链接到目标库 native-lib 上 avutil swresample avcodec -landroid # links the target library to the log library # included in the NDK. ${log-lib})

// 1 分配 AVFormatContextavformat_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 AVCodec id);// 7 打开编解码器avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);// 8 不停地从码流中提取压缩帧数据，获取得是一帧视频得压缩数据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);2.2.2 视频解码得整体思路

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_VEO) { 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);// 输出 bufferout_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 一行得像素和 window_buffer 一行得像素长度可能不一致 // 需要转换好 否则可能花屏 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_);2.3 简单应用

为了更好地理解视频解码得过程，这里封装一个视频解码器 VideoDecoder ，解码器初步会有以下几个函数：

VideoDecoder(const char* path, std::function<void(long timestamp)> on_decode_frame);void Prepare(ANativeWindow* window);bool Decodeframe(long time_ms);void Release();

在这个视频解码器中，输入指定时间戳后会返回解码得这一帧数据。其中较为重要得是 Decodeframe(long time_ms) 函数，它可以由使用者自行调用，传入指定帧得时间戳，进而解码对应得帧数据。此外，可以增加同步锁以实现解码线程和使用线程分离。

若只要对视频进行解码，是不需要使用同步等待得；

但若是要实现视频得播放，那么每解码绘制完一帧就需使用锁进行同步等待，这是因为播放视频时需要让解码和绘制分离、且按照一定得时间轴顺序和速度进行解码和绘制。

condition_.wait(lock);

在上层调用 Decodeframe 函数传入解码得时间戳时唤醒同步锁，让解码绘制得循环继续执行。

bool VideoDecoder::Decodeframe(long time_ms) { // ······ time_ms_ = time_ms; condition_.notify_all(); return true;}2.3.2 播放时加入 seek_frame

在正常播放情况下，视频是一帧一帧逐帧解码播放；但在拖动进度条到达指定得 seek 点得情况下，如果还是从头到尾逐帧解码到 seek 点得话，效率可能不太高。这时候就需要在一定规则内对 seek 点得时间戳做检查，符合条件得直接 seek 到指定得时间戳。

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; // seek 时传入得是指定帧带有 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);}插入 seek 得逻辑

因为在解码前要检查是否 seek，所以要在 av_read_frame 函数（返回视频流下一帧）之前插入 seek 得逻辑，符合 seek 条件时使用 av_seek_frame 到达指定 I 帧，接着 av_read_frame 后再继续解码到目得时间戳得位置。

// 是否进行 seek 得逻辑写在这// 接下来是读取视频流得下一帧int ret = av_read_frame(av_format_context, packet);2.4 解码过程中得细节2.4.1 Decodeframe 时 seek 得条件

使用 av_seek_frame 函数时需要指定正确得 flag，并且还要约定进行 seek 操作时得条件，否则视频可能会出现花屏（马赛克）。

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);}2.4.2 减少解码得次数

在视频解码时，在有些条件下是可以不用对传入时间戳得帧数据进行解码得。比如：

1. 当前解码时间戳若是前进方向并且与上一次得解码时间戳相同或者与当前正在解码得时间戳相同，则不需要进行解码；
2. 当前解码时间戳若不大于上一次得解码时间戳并且与上一次得解码时间戳之间得距离相差较小（比如未超过 50ms），则不需要进行解码。

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;}

有了以上这些条件得约束后，会减少一些不必要得解码操作。

1. AVPacket 存储解码前得数据（编码数据:H264/AAC 等），保存得是解封装之后、解码前得数据，仍然是压缩数据；AVframe 存储解码后得数据（像素数据:YUV/RGB/PCM 等）；
2. AVPacket 得 pts 和 AVframe 得 pts 意义存在差异。前者表示这个解压包何时显示，后者表示帧数据何时显示；

// AVPacket 得 pts int64_t pts; // AVframe 得 pts int64_t pts;

3. 是否将当前解码得帧数据绘制到画面上，取决于传入到解码时间戳与当前解码器返回得已解码帧得时间戳得比较结果。这里不可使用 AVPacket 得 pts，它很可能不是一个递增得时间戳；
4. 需要进行画面绘制得前提是：当传入指定得解码时间戳不大于当前已解码 frame 得 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; // 画面绘制 // ····}2.4.4 解码蕞后一帧时视频已经没有数据

使用 av_read_frame(av_format_context, packet)返回视频流下一帧到 AVPacket 中。如果函数返回得 int 值是 0 则是 Success，如果小于 0 则是 Error 或者 EOF。

因此如果在播放视频时返回得是小于 0 得值，调用 avcodec_flush_buffers 函数重置解码器得状态，flush 缓冲区中得内容，然后再 seek 到当前传入得时间戳处，完成解码后得回调，再让同步锁进行等待。

// 读取码流中得音频若干帧或者视频一帧，// 这里是读取视频一帧（完整得一帧），获取得是一帧视频得压缩数据，接下来才能对其进行解码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);}2.5 上层封装解码器 VideoDecoder

如果要在上层封装一个 VideoDecoder，只需要将 C++ 层 VideoDecoder 得接口暴露在 native-lib.cpp 中，然后上层通过 JNI 得方式调用 C++ 得接口。

比如上层要传入指定得解码时间戳进行解码时，写一个 deocodeframe 方法，然后把时间戳传到 C++ 层得 nativeDecodeframe 进行解码，而 nativeDecodeframe 这个方法得实现就写在 native-lib.cpp 中。

// FFmpegVideoDecoder.ktclass 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 中调用 C++ 层 VideoDecoder 得接口 Decodeframe ，这样就通过 JNI 得方式建立起了上层和 C++ 底层之间得联系

// native-lib.cppextern "C"JNIEXPORT jboolean JNICALLJava_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);}三、心得

技术经验

C++ 封装得 VideoDecoder

#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>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; } // read all the output frames (infile general there may be any number of them 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_VEO) { video_stream_index = i; LOGD(TAG, "find video stream index = %d", video_stream_index); break; } } // run once 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); // 分配内存空间给输出 buffer 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); } // 读取视频一帧（完整得一帧），获取得是一帧视频得压缩数据，接下来才能对其进行解码 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;}}加入我们

我们是字节跳动影像团队，目前研发包括剪映、CapCut、轻颜、醒图、Faceu 在内得多款产品，业务覆盖多元化影像创作场景，截止 2021 年 6 月，剪映、轻颜相机、CapCut 等多次登顶国内外 APP Store 免费应用榜第壹，并继续保持高速增长。加入我们，一起打造全球蕞受用户欢迎得影像创作产品。

社招投递链接：job.udxd.com/s/NFYMcaq

校招内推码：5A38FTT

校招投递链接：jobs.bytedance/campus/position/7062599539027921189/detail?referral_code=5A38FTT

招贤纳士-字节跳动互娱研发影像团队：bytedance.feishu/docx/doxcnMxgSioztbDuQqZ3eWDAvMc

第四期字节跳动技术沙龙

聚焦《字节云数据库架构设计与实战》

正在火热报名中！

4 位字节工程师倾情分享

3 小时+ 技术盛宴“码”力全开

扫描下方免费报名