声明：本文章原创，禁止转载。分享出来，主要是在csdn上收获了这么多，该贡献点了
说实话移植ffmpeg 到mac ox 和 模拟器 上基本没啥难度，基本就是config && make && make install,也没有遇到啥难度，在模拟器上 运行没啥问题，问题的重点在移植到ios 平台上。
以前也知道交叉编译是怎么一回事，但是没有实战过，ide 用多了，对gcc 那一套选项根本就动不了，对ffmpeg 的 编译选项也是动不了，怎么办呢，慢慢啃吧，这是咋程序员的命。
那么就要对这些知识温故一下才有法了，要不然 编译的时候copy人家得脚本，然后一出问题就找不到 南北了。精简版 支持 mp4 + m3u8 的编译脚本如下，我的imac 不是i386处理器，是x86_64, 这个也是个坑，网上都说模拟器是 i386 处理器，尼玛我的就怎么不一样，编译脚本如下，如果你懂原理 基本没啥难度。
#!/bin/sh
# FFMpeg，SDK版本号
VERSION="2.1"
SDKVERSION="8.2"
#最低支持的SDK版本号
MINSDKVERSION="7.0"
# 源文件路径
SRCDIR="$(pwd)"
BUILDDIR="${SRCDIR}/build"
mkdir -p $BUILDDIR
# 获取xcode开发环境安装路径
DEVELOPER=`xcode-select -print-path`
# 要编译的架构列表
ARCHS="x86_64,armv7,arm64"
for ARCH in ${ARCHS}
do
if [ "${ARCH}" == "x86_64" ];
then
PLATFORM="iPhoneSimulator"
EXTRA_CFLAGS="-arch x86_64"
EXTRA_LDFLAGS="-arch x86_64 -mfpu=neon"
EXTRA_CONFIG="--arch=x86_64 --cpu=x86_64"
else
PLATFORM="iPhoneOS"
EXTRA_CFLAGS="-arch ${ARCH} -mfloat-abi=softfp"
EXTRA_LDFLAGS="-arch ${ARCH} -mfpu=neon -mfloat-abi=softfp"
EXTRA_CONFIG="--arch=${ARCH} --disable-armv5te"
fi
make clean
# 根据需要裁减
./configure --prefix="${BUILDDIR}/${ARCH}" \
--disable-doc \
--disable-ffprobe \
--disable-ffmpeg \
--disable-ffplay \
--disable-ffserver \
--disable-debug \
--disable-zlib \
--disable-encoders \
--disable-muxers \
--disable-devices \
--disable-filters \
--disable-bsfs \
--disable-demuxers \
--enable-demuxer=hls \
--enable-demuxer=mpegts \
--enable-demuxer=mpegtsraw \
--enable-demuxer=h264 \
--enable-demuxer=m4v \
--enable-demuxer=mov \
--enable-demuxer=mpegvideo \
--enable-demuxer=yuv4mpegpipe \
--disable-protocols \
--enable-protocol=file \
--enable-protocol=http \
--enable-protocol=hls \
--disable-decoders \
--enable-decoder=h264 \
--enable-decoder=h264_crystalhd \
--enable-decoder=h264_vda \
--enable-decoder=h264_vdpau \
--enable-decoder=aac \
--enable-decoder=aac_latm \
--enable-decoder=tscc \
--enable-decoder=tscc2 \
--enable-decoder=mts2 \
--disable-parsers \
--enable-parser=aac \
--enable-parser=aac_latm \
--enable-parser=h264 \
--enable-parser=mpeg4video \
--enable-cross-compile \
--enable-pic \
--disable-asm \
--target-os=darwin \
--enable-small \
${EXTRA_CONFIG} \
--cc="${DEVELOPER}/Platforms/${PLATFORM}.platform/Developer/usr/bin/gcc" \
--as="/usr/bin/gas-preprocessor.pl" \
--sysroot="${DEVELOPER}/Platforms/${PLATFORM}.platform/Developer/SDKs/${PLATFORM}${SDKVERSION}.sdk" \
--extra-cflags="-miphoneos-version-min=${MINSDKVERSION} ${EXTRA_CFLAGS}" \
--extra-ldflags="-miphoneos-version-min=${MINSDKVERSION} ${EXTRA_LDFLAGS} -isysroot ${DEVELOPER}/Platforms/${PLATFORM}.platform/Developer/SDKs/${PLATFORM}${SDKVERSION}.sdk"
make && make install && make clean
done好吧，好人做到底，贴上测试 播放器代码 opengl + openal。也可以用苹果的CoreGraphics + audioqueuf，这个你随意。
//
// CorePlayer.c
// player
//
// Created by KuaiyuIOS on 15/4/16.
// Copyright (c) 2015年 KuaiyuD. All rights reserved.
//
#include "CorePlayer.h"
#include <stdlib.h>
#include <string.h>
#include <pthread/pthread.h>
#include <OpenAL/al.h>
#include <OpenAL/alc.h>
#include <unistd.h>
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswresample/swresample.h"
#include "libswscale/swscale.h"
#include "libavutil/time.h"
#define kTwoConverImgThread 0
#define QueueSize 26
#define AudioBufferMaxSize 26
#define SYN_PTS 500
#define VideoType PIX_FMT_RGBA
#define AudioType AV_SAMPLE_FMT_S16
#define MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio
//typedef struct videoItem{
// uint8_t *rgbData;
// int width;
// int height;
// int length;
// int64_t pts;
//} VideoItem;
typedef struct rgbVideoItem{
uint8_t *rgbData;
int widht;
int height;
int length;
int64_t pts;
}RGBVideoItem;
typedef struct packetquque {
int size;
int lenght;
void **items; //指向具体的item
void (*free_cb)(void *);
double pts;
pthread_mutex_t mutex;
pthread_cond_t cond;
}PacketQueue;
//openal 无需持有 一旦有的data 马上让 opanal 持有
typedef struct audioQueue{
int inUse[AudioBufferMaxSize];
ALuint alBuffers[AudioBufferMaxSize];
int64_t pts[AudioBufferMaxSize];
int itemIndex;
pthread_mutex_t mutex;
pthread_cond_t cond;
} AudioQueue;
struct CPContext {
//base
char url[256];
double duratioin;
double progress;
double volume;
void *userinfo;
void (*dis_callback)(uint8_t *data,int lenght,int width,int height,void *info);
void (*dis_audio_callback)(uint8_t *audioDta,int lenght,void *info);
void (*init_callback)(int width,int height,void *info);
void (*finish_callback)(int flag,void *info);
CPContex **p_ref;
int eof;
int seek;
int seekPos;
PacketQueue *video_q;
PacketQueue *picture_q;
AudioQueue *audio_q;
pthread_t read_t;
pthread_t decode_audio_t;
pthread_t decode_video_t;
pthread_t decode_video_other_t;
pthread_t display_picture_t;
pthread_mutex_t lock_muxt;
pthread_cond_t lock_cond;
int play;
int last_play;
int quit;
//时钟
int64_t audio_pts_curr;
//openal
ALCcontext *al_ctx;
ALCdevice *al_device;
ALuint al_source;
int videoLength;
int audioLength;
struct SwsContext *img_convert_ctx;
struct SwrContext *aud_convert_ctx;
AVCodecContext *decode_video_ctx;
AVCodecContext *decode_audio_ctx;
};
void seconds_sleep(unsigned seconds){
struct timeval tv = {seconds,0};
int err;
do{
err = select(0, NULL, NULL, NULL, &tv);
}while (err < 0 && errno == EINTR);
}
void suseconds_sleep(double suseconds){
struct timeval tv = {0,(int)(suseconds * 1000)};
int err;
do{
err = select(0, NULL, NULL, NULL, &tv);
}while (err < 0 && errno == EINTR);
}
#pragma mark ==============================
#pragma mark ==[quque item free callback]==
#pragma mark ==============================
void packet_quque_free_callback(void *item)
{
AVPacket *packet = (AVPacket *)item;
av_free_packet(packet);
}
void frame_queue_free_callback(void *item){
AVFrame *frame = (AVFrame *)item;
av_frame_free(&frame);
}
void rgb_video_quque_free_callback(void *item)
{
RGBVideoItem *videoitem = (RGBVideoItem *)item;
av_free(videoitem->rgbData);
av_free(item);
}
#pragma mark =========================
#pragma mark ==[quque operation]==
#pragma mark =========================
int queue_init(PacketQueue **q,void (*free_cb)(void *)){
PacketQueue *tempq = av_mallocz(sizeof(PacketQueue));
tempq->size = QueueSize;
tempq->items = (void **)av_mallocz(sizeof(void *) * QueueSize);
tempq->free_cb = free_cb;
pthread_mutex_init(&tempq->mutex, NULL);
pthread_cond_init(&tempq->cond, NULL);
*q = tempq;
return 0;
}
int queue_flush(PacketQueue *q)
{
pthread_mutex_lock(&q->mutex);
for(int i = 0;i < q->lenght;i++)
{
q->free_cb(q->items[i]);
}
q->lenght = 0;
pthread_mutex_unlock(&q->mutex);
return 0;
}
int queue_uninit(PacketQueue **q){
PacketQueue *tempq = *q;
pthread_cond_broadcast(&tempq->cond);
queue_flush(tempq);
av_free((void *)tempq->items);
pthread_mutex_destroy(&tempq->mutex);
pthread_cond_destroy(&tempq->cond);
av_free(tempq);
*q = NULL;
return 0;
}
int queue_push(PacketQueue *q,void *item)
{
pthread_mutex_lock(&q->mutex);
while (q->lenght + 1 >= q->size)
{
pthread_cond_wait(&q->cond, &q->mutex);
}
q->items[q->lenght] = item;
q->lenght ++;
pthread_mutex_unlock(&q->mutex);
pthread_cond_signal(&q->cond);
return 0;
}
int queue_get(PacketQueue *q,void **item ,void *info){
CPContex *ctx = (CPContex *)info;
pthread_mutex_lock(&q->mutex);
while (q->lenght <= 0) {
pthread_cond_wait(&q->cond, &q->mutex);
if(ctx->quit || ctx->eof)
{
*item = NULL;
pthread_mutex_unlock(&q->mutex);
return -1;
}
}
q->lenght --;
*item = q->items[0];
if(q->lenght > 0) //前移动
{
memcpy(&q->items[0], &q->items[1], sizeof(void *) * q->lenght);
}
q->items[q->lenght] = NULL;
pthread_mutex_unlock(&q->mutex);
pthread_cond_signal(&q->cond);
return 0;
}
int audio_queue_init(AudioQueue **q){
AudioQueue *tempq = av_mallocz(sizeof(AudioQueue));
pthread_mutex_init(&tempq->mutex, NULL);
pthread_cond_init(&tempq->cond, NULL);
*q = tempq;
return 0;
}
int audio_queue_uninit(AudioQueue **q){
AudioQueue *tempq = *q;
pthread_cond_broadcast(&tempq->cond);
pthread_mutex_lock(&tempq->mutex);
for(int i = 0;i < AudioBufferMaxSize;i++){
if(tempq->alBuffers[i] != 0)
{
alDeleteBuffers(1, &tempq->alBuffers[i]);
}
}
pthread_mutex_unlock(&tempq->mutex);
pthread_mutex_destroy(&tempq->mutex);
pthread_cond_destroy(&tempq->cond);
*q = NULL;
return 0;
}
int audio_queue_put(AudioQueue *q,uint8_t *audioData,int length,int64_t pts,void *info){
CPContex *ctx = (CPContex *)info;
pthread_mutex_lock(&q->mutex);
while (q->inUse[q->itemIndex]) {
pthread_cond_wait(&q->cond, &q->mutex);
if(ctx->quit || ctx->eof)
{
pthread_mutex_unlock(&q->mutex);
return -1;
}
}
q->inUse[q->itemIndex] = 1;
pthread_mutex_unlock(&q->mutex);
ALuint buffid = q->alBuffers[q->itemIndex];
if(buffid <= 0){
alGenBuffers(1, &buffid);
q->alBuffers[q->itemIndex] = buffid;
}
alBufferData(buffid, AL_FORMAT_STEREO16, audioData, length, ctx ->decode_audio_ctx->sample_rate);
alSourceQueueBuffers(ctx->al_source, 1, &buffid);
q->pts[q->itemIndex] = pts;
// ctx->audio_pts_curr = pts;
if(ctx->dis_audio_callback)
{
ctx->dis_audio_callback(audioData,length,ctx->userinfo);
}
q->itemIndex ++;
if(q->itemIndex >= AudioBufferMaxSize) q->itemIndex = 0;
return 0;
}
int audio_queue_flush(AudioQueue *q){
return 0;
}
#pragma mark =========================
#pragma mark ==[three thread]==
#pragma mark =========================
static const char * read_thread_name = "com.CorePlayer.read";
static const char * decode_audio_thread_name = "com.CorePlayer.decodeAudio";
static const char * decode_video_thread_name = "com.CorePlayer.decodeVideo";
static const char * display_picture_thread_name = "com.CorePlayer.displayPicture";
void * decode_audio_thread(void *info)
{
pthread_setname_np(decode_audio_thread_name);
CPContex *ctx = (CPContex *)info;
while (ctx->quit == 0 && ctx->eof == 0) {
pthread_mutex_lock(&ctx->lock_muxt);
while (!ctx->play) {
pthread_cond_wait(&ctx->lock_cond, &ctx->lock_muxt);
}
pthread_mutex_unlock(&ctx->lock_muxt);
if(ctx->quit || ctx->eof) break;
//暂停
suseconds_sleep(0.75);
if(ctx->quit || ctx->eof) break;
if(!ctx->play) continue;
//清空
ALint stateValue;
int processed,queued;
ALfloat sec_off;
alGetSourcei(ctx->al_source, AL_BUFFERS_PROCESSED, &processed);
alGetSourcei(ctx->al_source, AL_BUFFERS_QUEUED, &queued);
alGetSourcei(ctx->al_source, AL_SOURCE_STATE, &stateValue);
alGetSourcef(ctx->al_source, AL_SEC_OFFSET, &sec_off);
ctx->progress += sec_off;
while (processed)
{
ALuint buffId;
alSourceUnqueueBuffers(ctx->al_source, 1, &buffId);
processed --;
int buffIndex = -1;
for (int i = 0; i < AudioBufferMaxSize;i ++)
{
if(buffId == ctx->audio_q->alBuffers[i])
{
buffIndex = i;
break;
}
}
if(buffIndex != -1)
{
ctx->audio_pts_curr = ctx->audio_q->pts[buffIndex];
pthread_mutex_lock(&ctx->audio_q->mutex);
ctx->audio_q->inUse[buffIndex] = 0;
pthread_cond_signal(&ctx->audio_q->cond);
pthread_mutex_unlock(&ctx->audio_q->mutex);
}
}
if(stateValue != AL_PLAYING && queued >= 5){
alSourcePlay(ctx->al_source);
}
else if(stateValue == AL_PLAYING && queued < 5){
alSourcePause(ctx->al_source);
}
}
return NULL;
}
void * display_picture_thread(void *info)
{
pthread_setname_np(display_picture_thread_name);
CPContex *ctx = (CPContex *)info;
while (ctx->quit == 0 && ctx->eof == 0) {
pthread_mutex_lock(&ctx->lock_muxt);
while (!ctx->play) {
pthread_cond_wait(&ctx->lock_cond, &ctx->lock_muxt);
}
pthread_mutex_unlock(&ctx->lock_muxt);
if(ctx->quit || ctx->eof) break;
void *item = NULL;
queue_get(ctx->picture_q, (void **)&item,info);
if(item != NULL)
{
RGBVideoItem *newItem = (RGBVideoItem *)item;
if(ctx->dis_callback /*&& newItem->pts != AV_NOPTS_VALUE*/ ) ctx->dis_callback(newItem->rgbData ,newItem->length,newItem->widht,newItem->height,ctx->userinfo);
ctx->picture_q->free_cb(item);
}
}
return NULL;
}
void decode_video_inline(void *info){
CPContex *ctx = (CPContex *)info;
AVFrame *pframeRGB = av_frame_alloc();
while (ctx->quit == 0 && ctx->eof == 0) {
pthread_mutex_lock(&ctx->lock_muxt);
while (!ctx->play) {
pthread_cond_wait(&ctx->lock_cond, &ctx->lock_muxt);
}
pthread_mutex_unlock(&ctx->lock_muxt);
if(ctx->quit || ctx->eof) break;
while (ctx->seek){ //等待清空完毕
suseconds_sleep(0.2);
}
if(ctx->quit || ctx->eof) break;
AVFrame *pframe = NULL;
queue_get(ctx->video_q, (void **)&pframe,info);
if(pframe != NULL){
uint8_t *buff = (uint8_t *)av_mallocz(ctx->videoLength);
avpicture_fill((AVPicture *)pframeRGB, buff, VideoType, ctx->decode_video_ctx->width, ctx->decode_video_ctx->height);
sws_scale(ctx->img_convert_ctx, (const uint8_t * const *)pframe->data, pframe->linesize, 0, ctx->decode_video_ctx->height, pframeRGB->data, pframeRGB->linesize);
RGBVideoItem *item = av_mallocz(sizeof(RGBVideoItem));
item->rgbData = buff;
item->widht = ctx->decode_video_ctx->width;
item->height = ctx->decode_video_ctx->height;
item->length = ctx->videoLength;
item->pts = pframe->pts == AV_NOPTS_VALUE ? (pframe->pkt_pts == AV_NOPTS_VALUE ? pframe->pkt_dts : pframe->pkt_pts) : pframe->pts;
queue_push(ctx->picture_q, item);
ctx->video_q->free_cb(pframe);
}
}
av_frame_free(&pframeRGB);
}
#if kTwoConverImgThread
static const char * decode_video_thread_other = "com.CorePlayer.other.decodeVideo";
void *decode_video_thread_two(void *info){
pthread_setname_np(decode_video_thread_other);
decode_video_inline(info);
return NULL;
}
#endif
void *decode_video_thread(void *info){
pthread_setname_np(decode_video_thread_name);
CPContex *ctx = (CPContex *)info;
#if kTwoConverImgThread
pthread_create(&ctx->decode_video_other_t, NULL, decode_video_thread_two , info);
#endif
queue_init(&ctx->picture_q, rgb_video_quque_free_callback);
pthread_create(&ctx->display_picture_t, NULL, display_picture_thread, info);
decode_video_inline(info);
#if kTwoConverImgThread
pthread_join(ctx->decode_video_other_t, NULL);
#endif
queue_uninit(&ctx->picture_q);
pthread_join(ctx->display_picture_t, NULL);
return NULL;
}
void * read_thread(void *info)
{
pthread_setname_np(read_thread_name);
pthread_detach(pthread_self());
CPContex *ctx = (CPContex *)info;
//完成必要的初始化
ctx->al_device = alcOpenDevice(NULL);
if(ctx->al_device != 0){
ctx->al_ctx = alcCreateContext(ctx->al_device, NULL);
alcMakeContextCurrent(ctx->al_ctx);
}
alGenSources(1, &ctx->al_source);
alSourcei(ctx->al_source, AL_LOOPING, AL_FALSE);
alSourcei(ctx->al_source, AL_GAIN, 1.0f); //声音
alSpeedOfSound(1.0f);
queue_init(&ctx->video_q, frame_queue_free_callback);
audio_queue_init(&ctx->audio_q);
pthread_mutex_init(&ctx->lock_muxt, NULL);
pthread_cond_init(&ctx->lock_cond, NULL);
av_register_all();
avformat_network_init();
int ret = -1,stream_index_a = -1,stream_index_v = -1;
AVFormatContext *fmt_ctx = NULL;
AVCodec *dec_a = NULL,*dec_v = NULL;
AVCodecContext *dec_ctx_a = NULL,*dec_ctx_v = NULL;
AVPacket pkt,*pktptr = &pkt;
AVFrame *pframe = av_frame_alloc(),*pframeRGB = av_frame_alloc();
int frameFinished = 0,audioLength = 0,videoLength = 0;
struct SwsContext *img_convert_ctx = NULL;
struct SwrContext *aud_convert_ctx = NULL;
pthread_mutex_t wait_muxt;
pthread_cond_t wait_cond;
pthread_mutex_init(&wait_muxt, NULL);
pthread_cond_init(&wait_cond, NULL);
if((ret = avformat_open_input(&fmt_ctx, ctx->url, NULL, NULL)) < 0){
printf("open file fail\n");
goto lable;
}
if((ret = avformat_find_stream_info(fmt_ctx, NULL)) < 0){
printf("not more stream info \n");
goto lable;
}
ctx->duratioin = (double)(fmt_ctx->duration / AV_TIME_BASE);
ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec_v, 0);
if(ret != AVERROR_STREAM_NOT_FOUND){
stream_index_v = ret;
dec_ctx_v = fmt_ctx->streams[ret]->codec;
ret = avcodec_open2(dec_ctx_v, dec_v, NULL);
if(ret < 0)
{
printf("open video decode fail\n");
}
}
ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_AUDIO, -1, -1, &dec_a, 0);
if(ret != AVERROR_STREAM_NOT_FOUND){
stream_index_a = ret;
dec_ctx_a = fmt_ctx->streams[ret]->codec;
ret = avcodec_open2(dec_ctx_a, dec_a, NULL);
if(ret < 0){
printf("open audio decode fail\n");
}
}
if(stream_index_v == -1 && stream_index_a == -1)
{
printf("no effect stream \n");
goto lable;
}
if(stream_index_v >= 0){
videoLength = avpicture_get_size(VideoType, dec_ctx_v->width, dec_ctx_v->height);
img_convert_ctx = sws_getContext(dec_ctx_v->width, dec_ctx_v->height, dec_ctx_v->pix_fmt, dec_ctx_v->width, dec_ctx_v->height, VideoType, SWS_FAST_BILINEAR, NULL, NULL, NULL);
ctx->decode_video_ctx = dec_ctx_v;
ctx->videoLength = videoLength;
ctx->img_convert_ctx = img_convert_ctx;
pthread_create(&ctx->decode_video_t, NULL, decode_video_thread, info);
}
if(stream_index_a >= 0){
audioLength = av_samples_get_buffer_size(NULL, av_get_channel_layout_nb_channels(AV_CH_LAYOUT_STEREO), dec_ctx_a->frame_size, AudioType, 1);
aud_convert_ctx = swr_alloc_set_opts(NULL, AV_CH_LAYOUT_STEREO, AudioType, dec_ctx_a->sample_rate, dec_ctx_a->channel_layout, dec_ctx_a->sample_fmt, dec_ctx_a->sample_rate, 0, NULL);
swr_init(aud_convert_ctx);
ctx->aud_convert_ctx = aud_convert_ctx;
ctx->decode_audio_ctx = dec_ctx_a;
ctx->audioLength = audioLength;
pthread_create(&ctx->decode_audio_t, NULL, decode_audio_thread, info);
}
if(/* DISABLES CODE */ (0)){
av_dump_format(fmt_ctx, 0, ctx->url, 0);
}
if(ctx->init_callback){
ctx->init_callback(dec_ctx_v->width,dec_ctx_v->height,ctx->userinfo);
}
pthread_mutex_lock(&ctx->lock_muxt);
while (!ctx->play) {
pthread_cond_wait(&ctx->lock_cond, &ctx->lock_muxt);
}
pthread_mutex_unlock(&ctx->lock_muxt);
while (ctx->quit == 0 && ctx->eof == 0) {
//是否需要暂停网络
if(ctx->play != ctx->last_play)
{
ctx->last_play = ctx->play;
if(ctx->play)
av_read_pause(fmt_ctx);
else
av_read_play(fmt_ctx);
}
//是否暂停
pthread_mutex_lock(&ctx->lock_muxt);
while (!ctx->play) {
pthread_cond_wait(&ctx->lock_cond, &ctx->lock_muxt);
}
pthread_mutex_unlock(&ctx->lock_muxt);
if(ctx->quit && ctx->eof) break;
//是否快进
if(ctx->seek)
{
//new api for seek
int seek_ret = avformat_seek_file(fmt_ctx, -1, (ctx->seekPos - 10) * AV_TIME_BASE, (ctx->seekPos) * AV_TIME_BASE, (ctx->seekPos + 10) *AV_TIME_BASE, AVSEEK_FLAG_ANY);
if(seek_ret < 0){
printf("error while seeking\n");
}else{
if(stream_index_v >= 0)
{
queue_flush(ctx->video_q);
}
if(stream_index_a >= 0)
{
audio_queue_flush(ctx->audio_q);
ctx->progress = ctx->seekPos;
}
//设置 exl clocl
}
ctx->seek = 0;
ctx->eof = 0;
}
frameFinished = 0;
ret = av_read_frame(fmt_ctx, pktptr);
if(ret < 0){
if((ret == AVERROR_EOF || avio_feof(fmt_ctx->pb)) && !ctx->eof){
ctx->eof = 1;
}
if(fmt_ctx->pb && fmt_ctx->pb->error)
break;
/* sleep */
struct timespec tm = {10,0};
pthread_mutex_lock(&wait_muxt);
pthread_cond_timedwait(&wait_cond, &wait_muxt, &tm);
pthread_mutex_unlock(&wait_muxt);
continue;
}
else{
ctx->eof = 0;
}
if(pktptr->stream_index == stream_index_v)
{
ret = avcodec_decode_video2(ctx->decode_video_ctx,pframe, &frameFinished, pktptr);
if(ret < 0)
break;
if(frameFinished)
{
AVFrame *newFrame = av_frame_alloc();
av_frame_copy_props(newFrame, pframe);
newFrame->format = pframe->format;
newFrame->width = dec_ctx_v->width;
newFrame->height = dec_ctx_v->height;
ret = av_frame_get_buffer(newFrame, 1);
av_frame_copy(newFrame, pframe);
queue_push(ctx->video_q, newFrame);
}
}
else if(pktptr->stream_index == stream_index_a)
{
ret = avcodec_decode_audio4(dec_ctx_a, pframe, &frameFinished, pktptr);
if(ret < 0)
break;
if(frameFinished){
uint8_t *buff = (uint8_t *)av_mallocz(MAX_AUDIO_FRAME_SIZE * 2);
swr_convert(aud_convert_ctx, &buff, MAX_AUDIO_FRAME_SIZE, (const uint8_t **)pframe->data, pframe->nb_samples);
int64_t pts = (pframe->pts == AV_NOPTS_VALUE ? pframe->pkt_pts : pframe->pts);
audio_queue_put(ctx->audio_q, buff, audioLength, pts,info);
av_free(buff);
}
}
av_free_packet(pktptr);
}
lable:
avformat_network_deinit();
pthread_mutex_destroy(&wait_muxt);
pthread_cond_destroy(&wait_cond);
av_frame_free(&pframe);
av_frame_free(&pframeRGB);
pthread_mutex_destroy(&ctx->lock_muxt);
pthread_cond_destroy(&ctx->lock_cond);
ctx->eof = 1;
audio_queue_uninit(&ctx->audio_q);
queue_uninit(&ctx->video_q);
if(ctx->decode_video_t != 0) pthread_join(ctx->decode_video_t, NULL);
if(ctx->decode_audio_t != 0) pthread_join(ctx->decode_audio_t, NULL);
if(aud_convert_ctx != NULL) swr_free(&aud_convert_ctx);
if(img_convert_ctx != NULL) sws_freeContext(img_convert_ctx);
if(dec_ctx_a) avcodec_close(dec_ctx_a);
if(dec_ctx_v) avcodec_close(dec_ctx_v);
if(fmt_ctx) avformat_close_input(&fmt_ctx);
alSourceStop(ctx->al_source);
alDeleteSources(1, &ctx->al_source);
if(ctx->al_device){
alcCloseDevice(ctx->al_device);
}
if(ctx->finish_callback){
int quit_flag = (ctx->quit == 1) ? 1 : 0;
ctx->finish_callback(quit_flag,ctx->userinfo);
}
*(ctx->p_ref) = NULL;
av_free(ctx);
return NULL;
}
#pragma mark =========================
#pragma mark ==[out controll method]==
#pragma mark =========================
int CP_start(CPContex *cp_ctx){
if(! cp_ctx ) return -1;
pthread_mutex_lock(&cp_ctx->lock_muxt);
cp_ctx->play = 1;
pthread_cond_broadcast(&cp_ctx->lock_cond);
pthread_mutex_unlock(&cp_ctx->lock_muxt);
alSourcePlay(cp_ctx->al_source);
return 0;
}
int CP_pasue(CPContex *cp_ctx){
if(! cp_ctx ) return -1;
pthread_mutex_lock(&cp_ctx->lock_muxt);
cp_ctx->play = 0;
pthread_mutex_unlock(&cp_ctx->lock_muxt);
alSourcePause(cp_ctx->al_source);
return 0;
}
int CP_stop(CPContex *cp_ctx){
if(! cp_ctx ) return -1;
cp_ctx->quit = 1;
if(cp_ctx->play == 0){
pthread_mutex_lock(&cp_ctx->lock_muxt);
cp_ctx->play = 1;
pthread_cond_broadcast(&cp_ctx->lock_cond);
pthread_mutex_unlock(&cp_ctx->lock_muxt);
}
return 0;
}
int CP_init(CPContex **cp_ctx,
const char *url,
void (*dis_callback)(uint8_t *data,int lenght,int width,int height,void *info),
void (*dis_audio_callback)(uint8_t *audioData,int length,void *info),
void (*init_callback)(int width,int height,void *info),
void *userinfo)
{
// checkurl
CPContex *temp = av_mallocz(sizeof(CPContex));
strcpy(temp->url, url);
temp->userinfo = userinfo;
temp->dis_callback = dis_callback;
temp->dis_audio_callback = dis_audio_callback;
temp->init_callback = init_callback;
temp->p_ref = cp_ctx;
//
pthread_create(&temp->read_t, NULL, read_thread, temp);
*cp_ctx = temp;
return 0;
}
int CP_set_finish_callback(CPContex *cp_ctx,void (*finish_callback)(int flag,void*info)){
if(! cp_ctx ) return -1;
cp_ctx->finish_callback = finish_callback;
return 0;
}
int CP_seek(CPContex *cp_ctx,double pos,int flag)
{
if(! cp_ctx ) return -1;
if(cp_ctx->seek == 1) return -2;
if(flag == 0){
cp_ctx->seek = 1;
cp_ctx->seekPos = pos;
}
return 0;
}
int CP_get_progress(CPContex *cp_ctx,double *progress){
if(! cp_ctx ) return -1;
*progress = cp_ctx->progress;
return 0;
}
int CP_get_duration(CPContex *cp_ctx,double *duration){
if(! cp_ctx ) return -1;
*duration = cp_ctx->duratioin;
return 0;
}以下为真机和模拟器测试图片
模拟器 
扫一扫
786
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
