ffmpeg学习笔记-多线程音视频解码

之前的视频解码仍然存在问题，那就是是在主线程中去完成解码的，会造成线程阻塞，这里将其改为多线程解码，使其主线程不被阻塞

前面介绍了音视频的主线程解码，那样会阻塞主线程，在前面学习了多线程以后，就可以对音频和视频分离开来在子线程里解析了，但这样存在音视频同步的问题了，这里贴出代码，只是提供一种思路，其运行存在大量问题，还需要慢慢解决。例如，退出发生异常，音视频不同步

#include <android/log.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <android/native_window.h>
#include <android/native_window_jni.h>

#include "com_cj5785_ffmpegvideothread_VideoPlayer.h"

#include "include/ffmpeg/libavformat/avformat.h"
#include "include/ffmpeg/libavcodec/avcodec.h"
#include "include/ffmpeg/libswscale/swscale.h"
#include "include/ffmpeg/libswresample/swresample.h"
#include "include/libyuv/libyuv.h"

#define LOGI(FORMAT,...) __android_log_print(4,"cj5785",FORMAT,##__VA_ARGS__);
#define LOGE(FORMAT,...) __android_log_print(6,"cj5785",FORMAT,##__VA_ARGS__);

#define MAX_STREAM 2
#define VIDEO_STREAM_TYPE 0
#define AUDIO_STREAM_TYPE 1
#define MAX_AUDIO_FRME_SIZE 48000 * 4

typedef struct _Player
{
	JavaVM *javaVM;
	AVFormatContext *input_format_ctx;
	int video_stream_index;
	int audio_stream_index;
	AVCodecContext *input_codec_ctx[MAX_STREAM];
	pthread_t decode_threads[MAX_STREAM];
	ANativeWindow* nativeWindow;
	SwrContext *swr_ctx;
	enum AVSampleFormat in_sample_fmt;
	enum AVSampleFormat out_sample_fmt;
	int in_sample_rate;
	int out_sample_rate;
	int out_channel_nb;
	jobject audio_track;
	jmethodID audio_track_write_mid;
}Player;

void init_input_format_ctx(Player *player, const char *input)
{
	//注册组件
	av_register_all();

	AVFormatContext *format_ctx = avformat_alloc_context();
	//打开视频文件
	if(avformat_open_input(&format_ctx, input, NULL, NULL) != 0)
	{
		LOGE("%s", "打开文件失败!");
		return;
	}

	//获取视频相关信息
	if(avformat_find_stream_info(format_ctx, NULL) < 0)
	{
		LOGE("%s", "获取视频信息失败!");
		return;
	}

	//判断输入流的类型
	int i = 0;
	for (i = 0; i < format_ctx->nb_streams; i++)
	{
		if(format_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
		{
			player->video_stream_index = i;
		}
		else if(format_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
		{
			player->audio_stream_index = i;
		}
	}

	player->input_format_ctx = format_ctx;

}

void init_codec_context(Player *player,int stream_idx){
	AVFormatContext *format_ctx = player->input_format_ctx;
	//获取解码器
	AVCodecContext *codec_ctx = format_ctx->streams[stream_idx]->codec;
	AVCodec *codec = avcodec_find_decoder(codec_ctx->codec_id);
	if(codec == NULL){
		LOGE("%s","无法解码");
		return;
	}
	//打开解码器
	if(avcodec_open2(codec_ctx, codec, NULL) < 0){
		LOGE("%s","解码器无法打开");
		return;
	}
	player->input_codec_ctx[stream_idx] = codec_ctx;
}

void decode_video_prepare(JNIEnv *env,Player *player,jobject surface){
	player->nativeWindow = ANativeWindow_fromSurface(env, surface);
}

void decode_video(Player *player,AVPacket *packet)
{
	//像素数据（解码数据）
	AVFrame *yuv_frame = av_frame_alloc();
	AVFrame *rgb_frame = av_frame_alloc();
	//绘制时的缓冲区
	ANativeWindow_Buffer outBuffer;
	AVCodecContext *codec_ctx = player->input_codec_ctx[player->video_stream_index];
	int got_frame;
	//解码AVPacket->AVFrame
	avcodec_decode_video2(codec_ctx, yuv_frame, &got_frame, packet);
	//Zero if no frame could be decompressed
	//非零，正在解码
	if(got_frame){
		//lock
		//设置缓冲区的属性（宽、高、像素格式）
		ANativeWindow_setBuffersGeometry(player->nativeWindow, codec_ctx->width, codec_ctx->height,WINDOW_FORMAT_RGBA_8888);
		ANativeWindow_lock(player->nativeWindow,&outBuffer,NULL);

		//设置rgb_frame的属性（像素格式、宽高）和缓冲区
		//rgb_frame缓冲区与outBuffer.bits是同一块内存
		avpicture_fill((AVPicture *)rgb_frame, outBuffer.bits, AV_PIX_FMT_RGBA, codec_ctx->width, codec_ctx->height);

		//YUV->RGBA_8888
		I420ToARGB(yuv_frame->data[0],yuv_frame->linesize[0],
				yuv_frame->data[2],yuv_frame->linesize[2],
				yuv_frame->data[1],yuv_frame->linesize[1],
				rgb_frame->data[0], rgb_frame->linesize[0],
				codec_ctx->width,codec_ctx->height);

		//unlock
		ANativeWindow_unlockAndPost(player->nativeWindow);

		usleep(1000 * 16);
	}

	av_frame_free(&yuv_frame);
	av_frame_free(&rgb_frame);
}

void decode_audio_prepare(Player *player){
	SwrContext *swr_ctx = swr_alloc();
	AVCodecContext *codec_ctx = player->input_codec_ctx[player->audio_stream_index];
	enum AVSampleFormat in_sample_fmt = codec_ctx->sample_fmt;
	enum AVSampleFormat out_sample_fmt = AV_SAMPLE_FMT_S16;
	int in_sample_rate = codec_ctx->sample_rate;
	int out_sample_rate = in_sample_rate;
	uint64_t in_ch_layout = codec_ctx->channel_layout;
	uint64_t out_ch_layout = AV_CH_LAYOUT_STEREO;
	swr_alloc_set_opts(swr_ctx,
			out_ch_layout, out_sample_fmt, out_sample_rate,
			in_ch_layout, in_sample_fmt, in_sample_rate,
			0, NULL);
	swr_init(swr_ctx);
	int out_channel_nb = av_get_channel_layout_nb_channels(out_ch_layout);

	player->in_sample_fmt = in_sample_fmt;
	player->out_sample_fmt = out_sample_fmt;
	player->in_sample_rate = in_sample_rate;
	player->out_sample_rate = out_sample_rate;
	player->out_channel_nb = out_channel_nb;
	player->swr_ctx = swr_ctx;
}

void jni_audio_prepare(JNIEnv *env, jobject jobj, Player *player)
{
	jclass player_class = (*env)->GetObjectClass(env, jobj);
	jmethodID create_audio_track_mid = (*env)->GetMethodID(env, player_class, "createAudioTrack", "(II)Landroid/media/AudioTrack;");
	jobject audio_track = (*env)->CallObjectMethod(env, jobj, create_audio_track_mid, player->out_sample_rate, player->out_channel_nb);
	jclass audio_track_class = (*env)->GetObjectClass(env, audio_track);
	jmethodID audio_track_play_mid = (*env)->GetMethodID(env, audio_track_class, "play", "()V");
	(*env)->CallVoidMethod(env, audio_track, audio_track_play_mid);
	jmethodID audio_track_write_mid = (*env)->GetMethodID(env, audio_track_class, "write", "([BII)I");

	player->audio_track = (*env)->NewGlobalRef(env, audio_track);
	player->audio_track_write_mid = audio_track_write_mid;
}

void decode_audio(Player *player, AVPacket *packet)
{
	JNIEnv *env = NULL;
	JavaVM *javaVM = player->javaVM;
	(*javaVM)->AttachCurrentThread(javaVM, &env, NULL);
	uint8_t *out_buffer = (uint8_t *)av_malloc(MAX_AUDIO_FRME_SIZE);
	AVCodecContext *codec_ctx = player->input_codec_ctx[player->audio_stream_index];
	AVFrame *frame = av_frame_alloc();
	int got_frame = 0;
	avcodec_decode_audio4(codec_ctx, frame, &got_frame, packet);
	if(got_frame)
	{
		swr_convert(player->swr_ctx, &out_buffer, MAX_AUDIO_FRME_SIZE,
				(const uint8_t **)frame->data, frame->nb_samples);
		int out_buffer_size = av_samples_get_buffer_size(NULL, player->out_channel_nb,
				frame->nb_samples ,player->out_sample_fmt, 1);
		jbyteArray audio_sample_array = (*env)->NewByteArray(env, out_buffer_size);
		jbyte *sample_byte = (*env)->GetByteArrayElements(env, audio_sample_array, NULL);
		memcpy(sample_byte, out_buffer, out_buffer_size);
		(*env)->ReleaseByteArrayElements(env, audio_sample_array, sample_byte, 0);
		(*env)->CallIntMethod(env, player->audio_track, player->audio_track_write_mid,
				audio_sample_array, 0, out_buffer_size);
		(*env)->DeleteLocalRef(env,audio_sample_array);
		(*javaVM)->DetachCurrentThread(javaVM);
		usleep(16 * 1000);
	}
	av_frame_free(&frame);
}

void* decode_data(void* arg){
	Player *player = (struct Player*)arg;
	AVFormatContext *format_ctx = player->input_format_ctx;
	//编码数据
	AVPacket *packet = (AVPacket *)av_malloc(sizeof(AVPacket));
	//6.一阵一阵读取压缩的视频数据AVPacket
	int video_frame_count = 0;
	while(av_read_frame(format_ctx,packet) >= 0){
		if(packet->stream_index == player->video_stream_index)
		{
			//decode_video(player,packet);
		}else if(packet->stream_index == player->audio_stream_index)
		{
			decode_audio(player,packet);
		}
		av_free_packet(packet);
	}
}

JNIEXPORT void JNICALL Java_com_cj5785_ffmpegvideothread_VideoPlayer_play
  (JNIEnv *env, jobject jobj, jstring jstr_path, jobject obj_surface)
{
	LOGE("%s", "开始");

	const char *input_cstr = (*env)->GetStringUTFChars(env, jstr_path, NULL);
	Player *player = (Player *)calloc(sizeof(Player), 1);

	(*env)->GetJavaVM(env,&(player->javaVM));

	//初始化封装格式上下文
	init_input_format_ctx(player,input_cstr);
	int video_stream_index = player->video_stream_index;
	int audio_stream_index = player->audio_stream_index;
	//获取音视频解码器，并打开
	init_codec_context(player,video_stream_index);
	init_codec_context(player,audio_stream_index);

	decode_video_prepare(env, player, obj_surface);
	decode_audio_prepare(player);
	jni_audio_prepare(env,jobj,player);

	//创建子线程解码
	pthread_create(&(player->decode_threads[video_stream_index]),NULL,decode_data,(void*)player);
	pthread_create(&(player->decode_threads[audio_stream_index]),NULL,decode_data,(void*)player);

	/*ANativeWindow_release(nativeWindow);
	av_frame_free(&yuv_frame);
	avcodec_close(pCodeCtx);
	avformat_free_context(pFormatCtx);

	(*env)->ReleaseStringUTFChars(env,input_jstr,input_cstr);

	free(player);*/

}