Android FFmpeg系列——子线程播放音视频

于实现在子线程播放音视频！不多说，直接上码。

代码

// C 层播放器结构体
typedef struct _Player {
    // Env
    JavaVM *java_vm;
    // Java 实例
    jobject instance;
    jobject surface;
    // 上下文
    AVFormatContext *format_context;
    // 视频相关
    int video_stream_index;
    AVCodecContext *video_codec_context;
    ANativeWindow *native_window;
    ANativeWindow_Buffer window_buffer;
    uint8_t *video_out_buffer;
    struct SwsContext *sws_context;
    AVFrame *rgba_frame;
    Queue *video_queue;
    // 音频相关
    int audio_stream_index;
    AVCodecContext *audio_codec_context;
    uint8_t *audio_out_buffer;
    struct SwrContext *swr_context;
    int out_channels;
    jmethodID play_audio_track_method_id;
    Queue *audio_queue;
} Player;

这里主要把音频和视频解码之后播放需要的东西做一下封装，需要注意的是2个队列：音频压缩数据队列和视频压缩数据队列。

初始化播放器：

/**
 * 初始化播放器
 * @param player
 */
void player_init(Player **player, JNIEnv *env, jobject instance, jobject surface) {
    *player = (Player*) malloc(sizeof(Player));
    JavaVM* java_vm;
    env->GetJavaVM(&java_vm);
    (*player)->java_vm = java_vm;
    (*player)->instance = env->NewGlobalRef(instance);
    (*player)->surface = env->NewGlobalRef(surface);
}

我们传入的 Player 的二级指针，主要是为了给 player 分配内存。

这里我们还需要注意一个知识点，因为 instance 和 surface 这两个变量是 jni 方法的参数：

JNIEXPORT void JNICALL
Java_com_johan_player_Player_play(JNIEnv *env, jobject instance, jstring path_, jobject surface){
	...
}

由于我们要在 C 中的子线程使用这个两个变量，所以得使用 env->NewGlobalRef 提升为全局变量。

本文福利， C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部点击领取↓↓

2022年全新音视频流媒体高级开发学习大纲FFmpeg/WebRTC/RTMP/RTSP/HLS/RTP播放器

初始化 AVFormat：

/**
 * 初始化 AVFormat
 * @return
 */
int format_init(Player *player, const char* path) {
    ...
}

（代码不详细贴，要不然篇幅太长，在最后会给出代码地址！！！）

查看和打开解码器：

/**
 * 查找流 index
 * @param player
 * @param type
 * @return
 */
int find_stream_index(Player *player, AVMediaType type) {
    ...
}
/**
 * 初始化解码器
 * @param player
 * @param type
 * @return
 */
int codec_init(Player *player, AVMediaType type) {
    ...
}

准备播放音频和视频：

/**
 * 播放视频准备
 * @param player
 */
int video_prepare(Player *player, JNIEnv *env) {
   ...
}
/**
 * 播放音频准备
 * @param player
 * @return
 */
int audio_prepare(Player *player, JNIEnv* env) {
    ...
}

播放音频和视频：

/**
 * 视频播放
 * @param frame
 */
void video_play(Player* player, AVFrame *frame, JNIEnv *env) {
    ...
}
/**
 * 音频播放
 * @param frame
 */
void audio_play(Player* player, AVFrame *frame, JNIEnv *env) {
    ...
}

释放播放器：

/**
 * 释放播放器
 * @param player
 */
void player_release(Player* player) {
    avformat_close_input(&(player->format_context));
    av_free(player->video_out_buffer);
    av_free(player->audio_out_buffer);
    avcodec_close(player->video_codec_context);
    ANativeWindow_release(player->native_window);
    sws_freeContext(player->sws_context);
    av_frame_free(&(player->rgba_frame));
    avcodec_close(player->audio_codec_context);
    swr_free(&(player->swr_context));
    queue_destroy(player->video_queue);
    queue_destroy(player->audio_queue);
    player->instance = NULL;
    JNIEnv *env;
    int result = player->java_vm->AttachCurrentThread(&env, NULL);
    if (result != JNI_OK) {
        return;
    }
    env->DeleteGlobalRef(player->instance);
    env->DeleteGlobalRef(player->surface);
    player->java_vm->DetachCurrentThread();
}

也就是释放各种资源，这里注意了，我们之前为 instance 和 surface 提升为全局变量，在释放时要 delete 掉。

前面的都是铺垫，接下来才是今天的正题，我们来看看 jni 方法的实现：

/**
 * 同步播放音视频
 */
extern "C"
JNIEXPORT void JNICALL
Java_com_johan_player_Player_play(JNIEnv *env, jobject instance, jstring path_, jobject surface) {
    const char *path = env->GetStringUTFChars(path_, 0);
    int result = 1;
    Player* player;
    player_init(&player, env, instance, surface);
    if (result > 0) {
        result = format_init(player, path);
    }
    if (result > 0) {
        result = codec_init(player, AVMEDIA_TYPE_VIDEO);
    }
    if (result > 0) {
        result = codec_init(player, AVMEDIA_TYPE_AUDIO);
    }
    if (result > 0) {
        play_start(player);
    }
    env->ReleaseStringUTFChars(path_, path);
}

最后调用了 play_start ：

/**
 * 开始播放
 * @param player
 */
void play_start(Player *player) {
    player->video_queue = (Queue*) malloc(sizeof(Queue));
    player->audio_queue = (Queue*) malloc(sizeof(Queue));
    queue_init(player->video_queue);
    queue_init(player->audio_queue);
    thread_init(player);
}

初始化2个队列，然后初始化并启动子线程：

/**
 *  初始化线程
 */
void thread_init(Player* player) {
    pthread_create(&produce_id, NULL, produce, player);
    Consumer* video_consumer = (Consumer*) malloc(sizeof(Consumer));
    video_consumer->player = player;
    video_consumer->stream_index = player->video_stream_index;
    pthread_create(&video_consume_id, NULL, consume, video_consumer);
    Consumer* audio_consumer = (Consumer*) malloc(sizeof(Consumer));
    audio_consumer->player = player;
    audio_consumer->stream_index = player->audio_stream_index;
    pthread_create(&audio_consume_id, NULL, consume, audio_consumer);
}

生产函数：

/**
 * 生产函数
 * 循环读取帧 解码 丢到对应的队列中
 * @param arg
 * @return
 */
void* produce(void* arg) {
    Player *player = (Player*) arg;
    AVPacket *packet = av_packet_alloc();
    while (av_read_frame(player->format_context, packet) >= 0) {
        if (packet->stream_index == player->video_stream_index) {
            queue_in(player->video_queue, packet);
        } else if (packet->stream_index == player->audio_stream_index) {
            queue_in(player->audio_queue, packet);
        }
        packet = av_packet_alloc();
    }
    break_block(player->video_queue);
    break_block(player->audio_queue);
    for (;;) {
        if (queue_is_empty(player->video_queue) && queue_is_empty(player->audio_queue)) {
            break;
        }
        sleep(1);
    }
    LOGE("produce finish ------------------- ");
    player_release(player);
    return NULL;
}

很简单，循环读取没一帧压缩数据，然后放到队列中。

消费函数：

/**
 * 消费函数
 * 从队列获取解码数据 同步播放
 * @param arg
 * @return
 */
void* consume(void* arg) {
    Consumer *consumer = (Consumer*) arg;
    Player *player = consumer->player;
    int index = consumer->stream_index;
    JNIEnv *env;
    int result = player->java_vm->AttachCurrentThread(&env, NULL);
    if (result != JNI_OK) {
        LOGE("Player Error : Can not get current thread env");
        pthread_exit(NULL);
        return NULL;
    }
    AVCodecContext *codec_context;
    Queue *queue;
    if (index == player->video_stream_index) {
        codec_context = player->video_codec_context;
        queue = player->video_queue;
        video_prepare(player, env);
    } else if (index == player->audio_stream_index) {
        codec_context = player->audio_codec_context;
        queue = player->audio_queue;
        audio_prepare(player, env);
    }
    AVFrame *frame = av_frame_alloc();
    for (;;) {
        AVPacket *packet = queue_out(queue);
        if (packet == NULL) {
            break;
        }
        result = avcodec_send_packet(codec_context, packet);
        if (result < 0 && result != AVERROR(EAGAIN) && result != AVERROR_EOF) {
            print_error(result);
            LOGE("Player Error : %d codec step 1 fail", index);
            av_packet_free(&packet);
            continue;
        }
        result = avcodec_receive_frame(codec_context, frame);
        if (result < 0 && result != AVERROR_EOF) {
            print_error(result);
            LOGE("Player Error : %d codec step 2 fail", index);
            av_packet_free(&packet);
            continue;
        }
        if (index == player->video_stream_index) {
            video_play(player, frame, env);
        } else if (index == player->audio_stream_index) {
            audio_play(player, frame, env);
        }
        av_packet_free(&packet);
    }
    player->java_vm->DetachCurrentThread();
    LOGE("consume is finish ------------------------------ ");
    return NULL;
}

消费函数就是从队列中获取压缩数据，然后解码，播放！

虽然看起来很简单，但是我在写的过程中发现很多问题，比如解码出错呀，数据转换失败呀，一大堆，过程挺心累的，但是发现主要的问题是我写的队列有问题，控制不好，当然最主要的原因是对 C 不熟导致的！

最后的解决办法是，把线程锁和条件变量都封装到每一个队列里面，然后再 queue_in 和 queue_out 里面做控制，发现这样简单多了！！

就这样，音频和视频就能同时在子线程播放了，但是还不同步，下一篇将讲解怎么同步播放音视频。

代码地址：https://github.com/JohanMan/Player

 本文福利， C++音视频学习资料包、技术视频，内容包括（音视频开发，面试题，FFmpeg ，webRTC ，rtmp ，hls ，rtsp ，ffplay ，srs）↓↓↓↓↓↓见下面↓↓文章底部点击领取↓↓