[原]零基础学习视频解码之视频线程

在上两篇文章[原]零基础学习视频解码之解码图像和[原]零基础学习视频解码之解码声音我们初步了解如何解码视频图像和视频声音。但是这些都是初步简单的解码出来而已，我们的主要功能是处理非常多：它是通过事件循环中运行，读取数据包，并在视频解码。所以，我们要做的就是拆分这些功能：我们将有一个线程，该线程将负责数据包进行解码;这些数据包将被添加到该队列中，并通过相应的音频和视频解码线程读取。

音频线：我们在上一篇已经建立了我们想要的方式;

视频线：视频线会相对比较麻烦一些，因为我们要自己显示自己的视频画面。我们将实际现实的代码添加到主循环。而不是仅仅显示我们每次循环的视频画面，我们将整合视频现实到事件循环中。我们的想法是对视频进行解码，保存生成到框架中的另一个队列中，然后创建一个自定义事件（FF_REFRESH_EVENT）,我们添加它到事件系统中，那么当我们的事件循环看到这种情况，它会显示在队列的下一帧中。

下面就是正式流程：

首先配置Project相关的依赖库：

Project->Properties->C/C++ General->Path and Symbols->Libraries->Add->SDL、avcode、avutil、avformat、swscale、m

一、创建一个VideoPicture结构体用来保存解码出来的图像。

/*

 ============================================================================

 Name        : VideoDecodeTutorial4_1.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



int main(int argc, char *argv[]) {

    return EXIT_SUCCESS;

}

二、定义一个VideoState结构体用来保存基本信息。

基本信息包含：视频格式的上下文和音频和视频数据流的索引，以及相应的AVStream对象，与音频缓冲器的结构体，有关音频的信息(audio_buf，audio_buf_size等)。我们已经增加了一个队列中的视频，以及一个缓冲的解码帧。我们已经分配的指针两个额外的线程，我们将创建和退出标志和电影的文件名。

/*

 ============================================================================

 Name        : VideoDecodeTutorial4_1.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



typedef struct VideoState {

    AVFormatContext *pFormatCtx;

    int videoStream, audioStream;

    AVStream *audio_st;

    PacketQueue audioq;

    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

    unsigned int audio_buf_size;

    unsigned int audio_buf_index;

    AVPacket audio_pkt;

    uint8_t *audio_pkt_data;

    int audio_pkt_size;

    AVFrame audio_frame;

    AVStream *video_st;

    PacketQueue videoq;



    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;



    SDL_Thread *parse_tid;

    SDL_Thread *video_tid;



    AVIOContext *io_ctx;

    struct SwsContext *sws_ctx;



    char filename[1024];

    int quit;

} VideoState;



int main(int argc, char *argv[]) {

    return EXIT_SUCCESS;

}

三、创建和音频相关的保存队列以及从队列中获取数据、解码音频数据和call_back函数：

/*

 ============================================================================

 Name        : VideoDecodeTutorial4_1.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



typedef struct VideoState {

    AVFormatContext *pFormatCtx;

    int videoStream, audioStream;

    AVStream *audio_st;

    PacketQueue audioq;

    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

    unsigned int audio_buf_size;

    unsigned int audio_buf_index;

    AVPacket audio_pkt;

    uint8_t *audio_pkt_data;

    int audio_pkt_size;

    AVFrame audio_frame;

    AVStream *video_st;

    PacketQueue videoq;



    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;



    SDL_Thread *parse_tid;

    SDL_Thread *video_tid;



    AVIOContext *io_ctx;

    struct SwsContext *sws_ctx;



    char filename[1024];

    int quit;

} VideoState;



SDL_Surface *screen;



/*Since we only hava one decoding thread, the Big Struct can be

 * global in case we need it. */

VideoState *global_video_state;



void packet_queue_init(PacketQueue *q) {

    memset(q, 0, sizeof(PacketQueue));

    q->mutex = SDL_CreateMutex();

    q->cond = SDL_CreateCond();

}



int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

    AVPacketList *pkt1;

    if (av_dup_packet(pkt) < 0) {

        return -1;

    }



    pkt1 = av_malloc(sizeof(AVPacketList));

    if (!pkt1)

        return -1;



    pkt1->pkt = *pkt;

    pkt1->next = NULL;



    SDL_LockMutex(q->mutex);



    if (!q->last_pkt)

        q->first_pkt = pkt1;

    else

        q->last_pkt->next = pkt1;



    q->last_pkt = pkt1;

    q->nb_packets++;

    q->size += pkt1->pkt.size;

    SDL_CondSignal(q->cond);



    SDL_UnlockMutex(q->mutex);

    return 0;

}



static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {

    AVPacketList *pkt1;

    int ret;



    SDL_LockMutex(q->mutex);



    for (;;) {

        if (global_video_state->quit) {

            ret = -1;

            break;

        }



        pkt1 = q->first_pkt;

        if (pkt1) {

            q->first_pkt = pkt1->next;

            if (!q->first_pkt)

                q->last_pkt = NULL;

            q->nb_packets--;

            q->size -= pkt1->pkt.size;

            *pkt = pkt1->pkt;

            av_free(pkt1);

            ret = 1;

            break;

        } else if (!block) {

            ret = 0;

        } else {

            SDL_CondWait(q->cond, q->mutex);

        }

    }



    SDL_UnlockMutex(q->mutex);

    return ret;

}



int audio_decode_frame(VideoState *is) {

    int len1, data_size = 0;

    AVPacket *pkt = &is->audio_pkt;



    for (;;) {

        while (is->audio_pkt_size > 0) {

            int got_frame = 0;

            len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame,

                    &got_frame, pkt);



            if (len1 < 0) {

                /*if error, skip frame*/

                is->audio_pkt_size = 0;

                break;

            }



            if (got_frame) {

                data_size = is->audio_frame.linesize[0];

                /*av_samples_get_buffer_size(NULL,

                 is->audio_st->codec->channels,

                 is->audio_frame.nb_samples,

                 is->audio_st->codec->sample_fmt, 1);*/

                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);

            }



            is->audio_pkt_data += len1;

            is->audio_pkt_size -= len1;



            if (data_size <= 0) {

                /*No data yet, get more frames*/

                continue;

            }

            /* We have data, return it and come back for more later */

            return data_size;

        }

        if (pkt->data)

            av_free_packet(pkt);



        if (is->quit) {

            return -1;

        }



        /* next packet */

        if (packet_queue_get(&is->audioq, pkt, 1) < 0) {

            return -1;

        }

        is->audio_pkt_data = pkt->data;

        is->audio_pkt_size = pkt->size;

    }



    return 0;

}



void audio_callback(void *userdata, Uint8 *stream, int len) {

    VideoState *is = (VideoState *) userdata;

    int len1, audio_size;



    while (len > 0) {

        if (is->audio_buf_index >= is->audio_buf_size) {

            /* We have already sent all out data; get more*/

            audio_size = audio_decode_frame(is);

            if (audio_size < 0) {

                /* If error, output silence */

                is->audio_buf_size = 1024;

                memset(is->audio_buf, 0, is->audio_buf_size);

            } else {

                is->audio_buf_size = audio_size;

            }

            is->audio_buf_index = 0;

        }

        len1 = is->audio_buf_size - is->audio_buf_index;

        if (len1 > len)

            len1 = len;

        memcpy(stream, (uint8_t *) is->audio_buf + is->audio_buf_index, len1);

        len -= len1;

        stream += len1;

        is->audio_buf_index += len1;

    }

}



int main(int argc, char *argv[]) {

    return EXIT_SUCCESS;

}

四、创建视频刷新相关的函数：

schedule_refresh()：它主要的作用是告诉系统指定的毫秒数后推FF_REFRESH_EVENT。当我们看到它在事件队列时，将依次调用视频刷新功能。

/*

 ============================================================================

 Name        : VideoDecodeTutorial4_1.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



typedef struct VideoState {

    AVFormatContext *pFormatCtx;

    int videoStream, audioStream;

    AVStream *audio_st;

    PacketQueue audioq;

    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

    unsigned int audio_buf_size;

    unsigned int audio_buf_index;

    AVPacket audio_pkt;

    uint8_t *audio_pkt_data;

    int audio_pkt_size;

    AVFrame audio_frame;

    AVStream *video_st;

    PacketQueue videoq;



    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;



    SDL_Thread *parse_tid;

    SDL_Thread *video_tid;



    AVIOContext *io_ctx;

    struct SwsContext *sws_ctx;



    char filename[1024];

    int quit;

} VideoState;



SDL_Surface *screen;



/*Since we only hava one decoding thread, the Big Struct can be

 * global in case we need it. */

VideoState *global_video_state;



void packet_queue_init(PacketQueue *q) {

    memset(q, 0, sizeof(PacketQueue));

    q->mutex = SDL_CreateMutex();

    q->cond = SDL_CreateCond();

}



int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

    AVPacketList *pkt1;

    if (av_dup_packet(pkt) < 0) {

        return -1;

    }



    pkt1 = av_malloc(sizeof(AVPacketList));

    if (!pkt1)

        return -1;



    pkt1->pkt = *pkt;

    pkt1->next = NULL;



    SDL_LockMutex(q->mutex);



    if (!q->last_pkt)

        q->first_pkt = pkt1;

    else

        q->last_pkt->next = pkt1;



    q->last_pkt = pkt1;

    q->nb_packets++;

    q->size += pkt1->pkt.size;

    SDL_CondSignal(q->cond);



    SDL_UnlockMutex(q->mutex);

    return 0;

}



static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {

    AVPacketList *pkt1;

    int ret;



    SDL_LockMutex(q->mutex);



    for (;;) {

        if (global_video_state->quit) {

            ret = -1;

            break;

        }



        pkt1 = q->first_pkt;

        if (pkt1) {

            q->first_pkt = pkt1->next;

            if (!q->first_pkt)

                q->last_pkt = NULL;

            q->nb_packets--;

            q->size -= pkt1->pkt.size;

            *pkt = pkt1->pkt;

            av_free(pkt1);

            ret = 1;

            break;

        } else if (!block) {

            ret = 0;

        } else {

            SDL_CondWait(q->cond, q->mutex);

        }

    }



    SDL_UnlockMutex(q->mutex);

    return ret;

}



int audio_decode_frame(VideoState *is) {

    int len1, data_size = 0;

    AVPacket *pkt = &is->audio_pkt;



    for (;;) {

        while (is->audio_pkt_size > 0) {

            int got_frame = 0;

            len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame,

                    &got_frame, pkt);



            if (len1 < 0) {

                /*if error, skip frame*/

                is->audio_pkt_size = 0;

                break;

            }



            if (got_frame) {

                data_size = is->audio_frame.linesize[0];

                /*av_samples_get_buffer_size(NULL,

                 is->audio_st->codec->channels,

                 is->audio_frame.nb_samples,

                 is->audio_st->codec->sample_fmt, 1);*/

                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);

            }



            is->audio_pkt_data += len1;

            is->audio_pkt_size -= len1;



            if (data_size <= 0) {

                /*No data yet, get more frames*/

                continue;

            }

            /* We have data, return it and come back for more later */

            return data_size;

        }

        if (pkt->data)

            av_free_packet(pkt);



        if (is->quit) {

            return -1;

        }



        /* next packet */

        if (packet_queue_get(&is->audioq, pkt, 1) < 0) {

            return -1;

        }

        is->audio_pkt_data = pkt->data;

        is->audio_pkt_size = pkt->size;

    }



    return 0;

}



void audio_callback(void *userdata, Uint8 *stream, int len) {

    VideoState *is = (VideoState *) userdata;

    int len1, audio_size;



    while (len > 0) {

        if (is->audio_buf_index >= is->audio_buf_size) {

            /* We have already sent all out data; get more*/

            audio_size = audio_decode_frame(is);

            if (audio_size < 0) {

                /* If error, output silence */

                is->audio_buf_size = 1024;

                memset(is->audio_buf, 0, is->audio_buf_size);

            } else {

                is->audio_buf_size = audio_size;

            }

            is->audio_buf_index = 0;

        }

        len1 = is->audio_buf_size - is->audio_buf_index;

        if (len1 > len)

            len1 = len;

        memcpy(stream, (uint8_t *) is->audio_buf + is->audio_buf_index, len1);

        len -= len1;

        stream += len1;

        is->audio_buf_index += len1;

    }

}



static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {

    SDL_Event event;

    event.type = FF_REFRESH_EVENT;

    event.user.data1 = opaque;

    SDL_PushEvent(&event);

    return 0;/* 0 means stop timer */

}



/* schedule a video refresh in 'delay' ms*/

static void schedule_refresh(VideoState *is, int delay) {

    SDL_AddTimer(delay, sdl_refresh_timer_cb, is);

}



int main(int argc, char *argv[]) {

    return EXIT_SUCCESS;

}

五、添加视频显示函数：

因为我们的屏幕可以是任意大小（我们设定我们为640×480，并有一些方法来设置它，所以它是由用户调整大小），我们需要动态地计算出我们有多大的矩形。因此，首先我们需要弄清楚我们的电影的显示比例，这仅仅是宽度除以身高。某些编解码器将有一个奇怪的样本纵横比，这简直就是一个像素，或样品的宽度/高度。因为在我们的编解码器的上下文中的高度和宽度值以像素为单位测量，实际的宽高比等于宽高比数倍的样品长宽比。一些编解码器将显示0-5的宽高比，这表示每个像素仅仅是大小1x1的。然后，我们扩展了电影，以适应大在我们的屏幕上，我们可以。在与-3位变换在那里简单地舍入值的4最接近的倍数。

/*

 ============================================================================

 Name        : VideoDecodeTutorial4_1.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



typedef struct VideoState {

    AVFormatContext *pFormatCtx;

    int videoStream, audioStream;

    AVStream *audio_st;

    PacketQueue audioq;

    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

    unsigned int audio_buf_size;

    unsigned int audio_buf_index;

    AVPacket audio_pkt;

    uint8_t *audio_pkt_data;

    int audio_pkt_size;

    AVFrame audio_frame;

    AVStream *video_st;

    PacketQueue videoq;



    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;



    SDL_Thread *parse_tid;

    SDL_Thread *video_tid;



    AVIOContext *io_ctx;

    struct SwsContext *sws_ctx;



    char filename[1024];

    int quit;

} VideoState;



SDL_Surface *screen;



/*Since we only hava one decoding thread, the Big Struct can be

 * global in case we need it. */

VideoState *global_video_state;



void packet_queue_init(PacketQueue *q) {

    memset(q, 0, sizeof(PacketQueue));

    q->mutex = SDL_CreateMutex();

    q->cond = SDL_CreateCond();

}



int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

    AVPacketList *pkt1;

    if (av_dup_packet(pkt) < 0) {

        return -1;

    }



    pkt1 = av_malloc(sizeof(AVPacketList));

    if (!pkt1)

        return -1;



    pkt1->pkt = *pkt;

    pkt1->next = NULL;



    SDL_LockMutex(q->mutex);



    if (!q->last_pkt)

        q->first_pkt = pkt1;

    else

        q->last_pkt->next = pkt1;



    q->last_pkt = pkt1;

    q->nb_packets++;

    q->size += pkt1->pkt.size;

    SDL_CondSignal(q->cond);



    SDL_UnlockMutex(q->mutex);

    return 0;

}



static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {

    AVPacketList *pkt1;

    int ret;



    SDL_LockMutex(q->mutex);



    for (;;) {

        if (global_video_state->quit) {

            ret = -1;

            break;

        }



        pkt1 = q->first_pkt;

        if (pkt1) {

            q->first_pkt = pkt1->next;

            if (!q->first_pkt)

                q->last_pkt = NULL;

            q->nb_packets--;

            q->size -= pkt1->pkt.size;

            *pkt = pkt1->pkt;

            av_free(pkt1);

            ret = 1;

            break;

        } else if (!block) {

            ret = 0;

        } else {

            SDL_CondWait(q->cond, q->mutex);

        }

    }



    SDL_UnlockMutex(q->mutex);

    return ret;

}



int audio_decode_frame(VideoState *is) {

    int len1, data_size = 0;

    AVPacket *pkt = &is->audio_pkt;



    for (;;) {

        while (is->audio_pkt_size > 0) {

            int got_frame = 0;

            len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame,

                    &got_frame, pkt);



            if (len1 < 0) {

                /*if error, skip frame*/

                is->audio_pkt_size = 0;

                break;

            }



            if (got_frame) {

                data_size = is->audio_frame.linesize[0];

                /*av_samples_get_buffer_size(NULL,

                 is->audio_st->codec->channels,

                 is->audio_frame.nb_samples,

                 is->audio_st->codec->sample_fmt, 1);*/

                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);

            }



            is->audio_pkt_data += len1;

            is->audio_pkt_size -= len1;



            if (data_size <= 0) {

                /*No data yet, get more frames*/

                continue;

            }

            /* We have data, return it and come back for more later */

            return data_size;

        }

        if (pkt->data)

            av_free_packet(pkt);



        if (is->quit) {

            return -1;

        }



        /* next packet */

        if (packet_queue_get(&is->audioq, pkt, 1) < 0) {

            return -1;

        }

        is->audio_pkt_data = pkt->data;

        is->audio_pkt_size = pkt->size;

    }



    return 0;

}



void audio_callback(void *userdata, Uint8 *stream, int len) {

    VideoState *is = (VideoState *) userdata;

    int len1, audio_size;



    while (len > 0) {

        if (is->audio_buf_index >= is->audio_buf_size) {

            /* We have already sent all out data; get more*/

            audio_size = audio_decode_frame(is);

            if (audio_size < 0) {

                /* If error, output silence */

                is->audio_buf_size = 1024;

                memset(is->audio_buf, 0, is->audio_buf_size);

            } else {

                is->audio_buf_size = audio_size;

            }

            is->audio_buf_index = 0;

        }

        len1 = is->audio_buf_size - is->audio_buf_index;

        if (len1 > len)

            len1 = len;

        memcpy(stream, (uint8_t *) is->audio_buf + is->audio_buf_index, len1);

        len -= len1;

        stream += len1;

        is->audio_buf_index += len1;

    }

}



static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {

    SDL_Event event;

    event.type = FF_REFRESH_EVENT;

    event.user.data1 = opaque;

    SDL_PushEvent(&event);

    return 0;/* 0 means stop timer */

}



/* schedule a video refresh in 'delay' ms*/

static void schedule_refresh(VideoState *is, int delay) {

    SDL_AddTimer(delay, sdl_refresh_timer_cb, is);

}



void video_display(VideoState *is) {

    SDL_Rect rect;

    VideoPicture *vp;

    float aspect_ratio;

    int w, h, x, y;



    vp = &is->pictq[is->pictq_rindex];

    if (vp->bmp) {

        if (is->video_st->codec->sample_aspect_ratio.num == 0) {

            aspect_ratio = 0;

        } else {

            aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio)

                    * is->video_st->codec->width / is->video_st->codec->height;

        }



        if (aspect_ratio <= 0.0) {

            aspect_ratio = (float) is->video_st->codec->width

                    / (float) is->video_st->codec->height;

        }

        h = screen->h;

        w = ((int) rint(h * aspect_ratio)) & -3;

        if (w > screen->w) {

            w = screen->w;

            h = ((int) rint(w / aspect_ratio)) & -3;

        }



        x = (screen->w - w) / 2;

        y = (screen->h - h) / 2;



        rect.x = x;

        rect.y = y;

        rect.w = w;

        rect.h = h;

        SDL_DisplayYUVOverlay(vp->bmp, &rect);

    }

}



int main(int argc, char *argv[]) {

    return EXIT_SUCCESS;

}

六、分配SDL_Overlay：

然而，我们需要分配SDL_Overlay自己（注意分配的标志，该标志将表明我们是否这样做或不）。要使用此队列中，我们有两个指针 - 写入索引和阅读索引。我们还跟踪实际的照片有多少是在缓冲区中。要写入队列中，我们将首先等待我们的缓冲清除，所以我们足够的空间来存储我们VideoPicture。然后我们检查，看看是否已经分配了覆盖在我们的写作索引。如果没有，我们就必须分配一定的空间。我们也有重新分配的缓冲区，如果窗口的大小发生了变化！而不是在这里分配，但是，为了避免锁定问题。

/*

 ============================================================================

 Name        : VideoDecodeTutorial4_1.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



typedef struct VideoState {

    AVFormatContext *pFormatCtx;

    int videoStream, audioStream;

    AVStream *audio_st;

    PacketQueue audioq;

    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

    unsigned int audio_buf_size;

    unsigned int audio_buf_index;

    AVPacket audio_pkt;

    uint8_t *audio_pkt_data;

    int audio_pkt_size;

    AVFrame audio_frame;

    AVStream *video_st;

    PacketQueue videoq;



    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;



    SDL_Thread *parse_tid;

    SDL_Thread *video_tid;



    AVIOContext *io_ctx;

    struct SwsContext *sws_ctx;



    char filename[1024];

    int quit;

} VideoState;



SDL_Surface *screen;



/*Since we only hava one decoding thread, the Big Struct can be

 * global in case we need it. */

VideoState *global_video_state;



void packet_queue_init(PacketQueue *q) {

    memset(q, 0, sizeof(PacketQueue));

    q->mutex = SDL_CreateMutex();

    q->cond = SDL_CreateCond();

}



int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

    AVPacketList *pkt1;

    if (av_dup_packet(pkt) < 0) {

        return -1;

    }



    pkt1 = av_malloc(sizeof(AVPacketList));

    if (!pkt1)

        return -1;



    pkt1->pkt = *pkt;

    pkt1->next = NULL;



    SDL_LockMutex(q->mutex);



    if (!q->last_pkt)

        q->first_pkt = pkt1;

    else

        q->last_pkt->next = pkt1;



    q->last_pkt = pkt1;

    q->nb_packets++;

    q->size += pkt1->pkt.size;

    SDL_CondSignal(q->cond);



    SDL_UnlockMutex(q->mutex);

    return 0;

}



static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {

    AVPacketList *pkt1;

    int ret;



    SDL_LockMutex(q->mutex);



    for (;;) {

        if (global_video_state->quit) {

            ret = -1;

            break;

        }



        pkt1 = q->first_pkt;

        if (pkt1) {

            q->first_pkt = pkt1->next;

            if (!q->first_pkt)

                q->last_pkt = NULL;

            q->nb_packets--;

            q->size -= pkt1->pkt.size;

            *pkt = pkt1->pkt;

            av_free(pkt1);

            ret = 1;

            break;

        } else if (!block) {

            ret = 0;

        } else {

            SDL_CondWait(q->cond, q->mutex);

        }

    }



    SDL_UnlockMutex(q->mutex);

    return ret;

}



int audio_decode_frame(VideoState *is) {

    int len1, data_size = 0;

    AVPacket *pkt = &is->audio_pkt;



    for (;;) {

        while (is->audio_pkt_size > 0) {

            int got_frame = 0;

            len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame,

                    &got_frame, pkt);



            if (len1 < 0) {

                /*if error, skip frame*/

                is->audio_pkt_size = 0;

                break;

            }



            if (got_frame) {

                data_size = is->audio_frame.linesize[0];

                /*av_samples_get_buffer_size(NULL,

                 is->audio_st->codec->channels,

                 is->audio_frame.nb_samples,

                 is->audio_st->codec->sample_fmt, 1);*/

                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);

            }



            is->audio_pkt_data += len1;

            is->audio_pkt_size -= len1;



            if (data_size <= 0) {

                /*No data yet, get more frames*/

                continue;

            }

            /* We have data, return it and come back for more later */

            return data_size;

        }

        if (pkt->data)

            av_free_packet(pkt);



        if (is->quit) {

            return -1;

        }



        /* next packet */

        if (packet_queue_get(&is->audioq, pkt, 1) < 0) {

            return -1;

        }

        is->audio_pkt_data = pkt->data;

        is->audio_pkt_size = pkt->size;

    }



    return 0;

}



void audio_callback(void *userdata, Uint8 *stream, int len) {

    VideoState *is = (VideoState *) userdata;

    int len1, audio_size;



    while (len > 0) {

        if (is->audio_buf_index >= is->audio_buf_size) {

            /* We have already sent all out data; get more*/

            audio_size = audio_decode_frame(is);

            if (audio_size < 0) {

                /* If error, output silence */

                is->audio_buf_size = 1024;

                memset(is->audio_buf, 0, is->audio_buf_size);

            } else {

                is->audio_buf_size = audio_size;

            }

            is->audio_buf_index = 0;

        }

        len1 = is->audio_buf_size - is->audio_buf_index;

        if (len1 > len)

            len1 = len;

        memcpy(stream, (uint8_t *) is->audio_buf + is->audio_buf_index, len1);

        len -= len1;

        stream += len1;

        is->audio_buf_index += len1;

    }

}



static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {

    SDL_Event event;

    event.type = FF_REFRESH_EVENT;

    event.user.data1 = opaque;

    SDL_PushEvent(&event);

    return 0;/* 0 means stop timer */

}



/* schedule a video refresh in 'delay' ms*/

static void schedule_refresh(VideoState *is, int delay) {

    SDL_AddTimer(delay, sdl_refresh_timer_cb, is);

}



void video_refresh_timer(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    //VideoPicture *vp;

    if (is->video_st) {

        if (is->pictq_size == 0) {

            schedule_refresh(is, 1);

        } else {

            //vp = &is->pictq[is->pictq_rindex];

            /* Now, normally here goes a ton of code

             about timing, etc. we're just going to

             guess at a delay for now. You can

             increase and decrease this value and hard code

             the timing - but I don't suggest that ;)

             We'll learn how to do it for real later.

             */

            schedule_refresh(is, 80);



            /* show the picture! */

            video_display(is);



            /* update queue for next picture! */

            if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) {

                is->pictq_rindex = 0;

            }

            SDL_LockMutex(is->pictq_mutex);

            is->pictq_size--;

            SDL_CondSignal(is->pictq_cond);

            SDL_UnlockMutex(is->pictq_mutex);

        }

    } else {

        schedule_refresh(is, 100);

    }

}



void video_display(VideoState *is) {

    SDL_Rect rect;

    VideoPicture *vp;

    float aspect_ratio;

    int w, h, x, y;



    vp = &is->pictq[is->pictq_rindex];

    if (vp->bmp) {

        if (is->video_st->codec->sample_aspect_ratio.num == 0) {

            aspect_ratio = 0;

        } else {

            aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio)

                    * is->video_st->codec->width / is->video_st->codec->height;

        }



        if (aspect_ratio <= 0.0) {

            aspect_ratio = (float) is->video_st->codec->width

                    / (float) is->video_st->codec->height;

        }

        h = screen->h;

        w = ((int) rint(h * aspect_ratio)) & -3;

        if (w > screen->w) {

            w = screen->w;

            h = ((int) rint(w / aspect_ratio)) & -3;

        }



        x = (screen->w - w) / 2;

        y = (screen->h - h) / 2;



        rect.x = x;

        rect.y = y;

        rect.w = w;

        rect.h = h;

        SDL_DisplayYUVOverlay(vp->bmp, &rect);

    }

}



void alloc_picture(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    VideoPicture *vp;



    vp = &is->pictq[is->pictq_windex];

    if (vp->bmp) {

        // we already have one make another, bigger/smaller

        SDL_FreeYUVOverlay(vp->bmp);

    }

    // Allocate a place to put our YUV image on that screen

    vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,

            is->video_st->codec->height, SDL_YV12_OVERLAY, screen);

    vp->width = is->video_st->codec->width;

    vp->height = is->video_st->codec->height;



    SDL_LockMutex(is->pictq_mutex);

    vp->allocated = 1;

    SDL_CondSignal(is->pictq_cond);

    SDL_UnlockMutex(is->pictq_mutex);

}







int main(int argc, char *argv[]) {

    return EXIT_SUCCESS;

}

七、将解码出来的YUV数据转换成SDL显示的图片并进行排好队：

/*

 ============================================================================

 Name        : VideoDecodeTutorial4_1.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



typedef struct VideoState {

    AVFormatContext *pFormatCtx;

    int videoStream, audioStream;

    AVStream *audio_st;

    PacketQueue audioq;

    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

    unsigned int audio_buf_size;

    unsigned int audio_buf_index;

    AVPacket audio_pkt;

    uint8_t *audio_pkt_data;

    int audio_pkt_size;

    AVFrame audio_frame;

    AVStream *video_st;

    PacketQueue videoq;



    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;



    SDL_Thread *parse_tid;

    SDL_Thread *video_tid;



    AVIOContext *io_ctx;

    struct SwsContext *sws_ctx;



    char filename[1024];

    int quit;

} VideoState;



SDL_Surface *screen;



/*Since we only hava one decoding thread, the Big Struct can be

 * global in case we need it. */

VideoState *global_video_state;



void packet_queue_init(PacketQueue *q) {

    memset(q, 0, sizeof(PacketQueue));

    q->mutex = SDL_CreateMutex();

    q->cond = SDL_CreateCond();

}



int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

    AVPacketList *pkt1;

    if (av_dup_packet(pkt) < 0) {

        return -1;

    }



    pkt1 = av_malloc(sizeof(AVPacketList));

    if (!pkt1)

        return -1;



    pkt1->pkt = *pkt;

    pkt1->next = NULL;



    SDL_LockMutex(q->mutex);



    if (!q->last_pkt)

        q->first_pkt = pkt1;

    else

        q->last_pkt->next = pkt1;



    q->last_pkt = pkt1;

    q->nb_packets++;

    q->size += pkt1->pkt.size;

    SDL_CondSignal(q->cond);



    SDL_UnlockMutex(q->mutex);

    return 0;

}



static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {

    AVPacketList *pkt1;

    int ret;



    SDL_LockMutex(q->mutex);



    for (;;) {

        if (global_video_state->quit) {

            ret = -1;

            break;

        }



        pkt1 = q->first_pkt;

        if (pkt1) {

            q->first_pkt = pkt1->next;

            if (!q->first_pkt)

                q->last_pkt = NULL;

            q->nb_packets--;

            q->size -= pkt1->pkt.size;

            *pkt = pkt1->pkt;

            av_free(pkt1);

            ret = 1;

            break;

        } else if (!block) {

            ret = 0;

        } else {

            SDL_CondWait(q->cond, q->mutex);

        }

    }



    SDL_UnlockMutex(q->mutex);

    return ret;

}



int audio_decode_frame(VideoState *is) {

    int len1, data_size = 0;

    AVPacket *pkt = &is->audio_pkt;



    for (;;) {

        while (is->audio_pkt_size > 0) {

            int got_frame = 0;

            len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame,

                    &got_frame, pkt);



            if (len1 < 0) {

                /*if error, skip frame*/

                is->audio_pkt_size = 0;

                break;

            }



            if (got_frame) {

                data_size = is->audio_frame.linesize[0];

                /*av_samples_get_buffer_size(NULL,

                 is->audio_st->codec->channels,

                 is->audio_frame.nb_samples,

                 is->audio_st->codec->sample_fmt, 1);*/

                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);

            }



            is->audio_pkt_data += len1;

            is->audio_pkt_size -= len1;



            if (data_size <= 0) {

                /*No data yet, get more frames*/

                continue;

            }

            /* We have data, return it and come back for more later */

            return data_size;

        }

        if (pkt->data)

            av_free_packet(pkt);



        if (is->quit) {

            return -1;

        }



        /* next packet */

        if (packet_queue_get(&is->audioq, pkt, 1) < 0) {

            return -1;

        }

        is->audio_pkt_data = pkt->data;

        is->audio_pkt_size = pkt->size;

    }



    return 0;

}



void audio_callback(void *userdata, Uint8 *stream, int len) {

    VideoState *is = (VideoState *) userdata;

    int len1, audio_size;



    while (len > 0) {

        if (is->audio_buf_index >= is->audio_buf_size) {

            /* We have already sent all out data; get more*/

            audio_size = audio_decode_frame(is);

            if (audio_size < 0) {

                /* If error, output silence */

                is->audio_buf_size = 1024;

                memset(is->audio_buf, 0, is->audio_buf_size);

            } else {

                is->audio_buf_size = audio_size;

            }

            is->audio_buf_index = 0;

        }

        len1 = is->audio_buf_size - is->audio_buf_index;

        if (len1 > len)

            len1 = len;

        memcpy(stream, (uint8_t *) is->audio_buf + is->audio_buf_index, len1);

        len -= len1;

        stream += len1;

        is->audio_buf_index += len1;

    }

}



static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {

    SDL_Event event;

    event.type = FF_REFRESH_EVENT;

    event.user.data1 = opaque;

    SDL_PushEvent(&event);

    return 0;/* 0 means stop timer */

}



/* schedule a video refresh in 'delay' ms*/

static void schedule_refresh(VideoState *is, int delay) {

    SDL_AddTimer(delay, sdl_refresh_timer_cb, is);

}



void video_refresh_timer(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    //VideoPicture *vp;

    if (is->video_st) {

        if (is->pictq_size == 0) {

            schedule_refresh(is, 1);

        } else {

            //vp = &is->pictq[is->pictq_rindex];

            /* Now, normally here goes a ton of code

             about timing, etc. we're just going to

             guess at a delay for now. You can

             increase and decrease this value and hard code

             the timing - but I don't suggest that ;)

             We'll learn how to do it for real later.

             */

            schedule_refresh(is, 80);



            /* show the picture! */

            video_display(is);



            /* update queue for next picture! */

            if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) {

                is->pictq_rindex = 0;

            }

            SDL_LockMutex(is->pictq_mutex);

            is->pictq_size--;

            SDL_CondSignal(is->pictq_cond);

            SDL_UnlockMutex(is->pictq_mutex);

        }

    } else {

        schedule_refresh(is, 100);

    }

}



void video_display(VideoState *is) {

    SDL_Rect rect;

    VideoPicture *vp;

    float aspect_ratio;

    int w, h, x, y;



    vp = &is->pictq[is->pictq_rindex];

    if (vp->bmp) {

        if (is->video_st->codec->sample_aspect_ratio.num == 0) {

            aspect_ratio = 0;

        } else {

            aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio)

                    * is->video_st->codec->width / is->video_st->codec->height;

        }



        if (aspect_ratio <= 0.0) {

            aspect_ratio = (float) is->video_st->codec->width

                    / (float) is->video_st->codec->height;

        }

        h = screen->h;

        w = ((int) rint(h * aspect_ratio)) & -3;

        if (w > screen->w) {

            w = screen->w;

            h = ((int) rint(w / aspect_ratio)) & -3;

        }



        x = (screen->w - w) / 2;

        y = (screen->h - h) / 2;



        rect.x = x;

        rect.y = y;

        rect.w = w;

        rect.h = h;

        SDL_DisplayYUVOverlay(vp->bmp, &rect);

    }

}



void alloc_picture(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    VideoPicture *vp;



    vp = &is->pictq[is->pictq_windex];

    if (vp->bmp) {

        // we already have one make another, bigger/smaller

        SDL_FreeYUVOverlay(vp->bmp);

    }

    // Allocate a place to put our YUV image on that screen

    vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,

            is->video_st->codec->height, SDL_YV12_OVERLAY, screen);

    vp->width = is->video_st->codec->width;

    vp->height = is->video_st->codec->height;



    SDL_LockMutex(is->pictq_mutex);

    vp->allocated = 1;

    SDL_CondSignal(is->pictq_cond);

    SDL_UnlockMutex(is->pictq_mutex);

}



int queue_picture(VideoState *is, AVFrame *pFrame) {

    VideoPicture *vp;

    //int dst_pic_fmt

    AVPicture pict;



    /* wait unitl we have space for a new pic */

    SDL_LockMutex(is->pictq_mutex);

    while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && !is->quit) {

        SDL_CondWait(is->pictq_cond, is->pictq_mutex);

    }

    SDL_UnlockMutex(is->pictq_mutex);



    if (is->quit)

        return -1;



    // windex is set to 0 initially

    vp = &is->pictq[is->pictq_windex];



    /* allocate or resize the buffer ! */

    if (!vp->bmp || vp->width != is->video_st->codec->width

            || vp->height != is->video_st->codec->height) {

        SDL_Event event;



        vp->allocated = 0;

        /* we have to do it in the main thread */

        event.type = FF_ALLOC_EVENT;

        event.user.data1 = is;

        SDL_PushEvent(&event);



        /* wait until we have a picture allocated */

        SDL_LockMutex(is->pictq_mutex);

        while (!vp->allocated && !is->quit) {

            SDL_CondWait(is->pictq_cond, is->pictq_mutex);

        }

    }

    SDL_UnlockMutex(is->pictq_mutex);

    if (is->quit) {

        return -1;

    }



    /* We have a place to put our picture on the queue */

    if (vp->bmp) {

        SDL_LockYUVOverlay(vp->bmp);

        //dst_pix_fmt = PIX_FMT_YUV420P;

        /* point pict at the queue */



        pict.data[0] = vp->bmp->pixels[0];

        pict.data[1] = vp->bmp->pixels[2];

        pict.data[2] = vp->bmp->pixels[1];



        pict.linesize[0] = vp->bmp->pitches[0];

        pict.linesize[1] = vp->bmp->pitches[2];

        pict.linesize[2] = vp->bmp->pitches[1];



        // Convert the image into YUV format that SDL uses

        sws_scale(is->sws_ctx, (const uint8_t * const *) pFrame->data,

                pFrame->linesize, 0, is->video_st->codec->height, pict.data,

                pict.linesize);

        SDL_UnlockYUVOverlay(vp->bmp);

        /* now we inform our display thread that we have a pic ready */

        if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE) {

            is->pictq_windex = 0;

        }

        SDL_LockMutex(is->pictq_mutex);

        is->pictq_size++;

        SDL_UnlockMutex(is->pictq_mutex);

    }

    return 0;

}



int main(int argc, char *argv[]) {

    return EXIT_SUCCESS;

}

八、解码视频线程，其实就是一个for循环，不断的去解码图像数据，并且送入queue_picture中排队，等候显示。

/*

 ============================================================================

 Name        : VideoDecodeTutorial4_1.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



typedef struct VideoState {

    AVFormatContext *pFormatCtx;

    int videoStream, audioStream;

    AVStream *audio_st;

    PacketQueue audioq;

    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

    unsigned int audio_buf_size;

    unsigned int audio_buf_index;

    AVPacket audio_pkt;

    uint8_t *audio_pkt_data;

    int audio_pkt_size;

    AVFrame audio_frame;

    AVStream *video_st;

    PacketQueue videoq;



    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;



    SDL_Thread *parse_tid;

    SDL_Thread *video_tid;



    AVIOContext *io_ctx;

    struct SwsContext *sws_ctx;



    char filename[1024];

    int quit;

} VideoState;



SDL_Surface *screen;



/*Since we only hava one decoding thread, the Big Struct can be

 * global in case we need it. */

VideoState *global_video_state;



void packet_queue_init(PacketQueue *q) {

    memset(q, 0, sizeof(PacketQueue));

    q->mutex = SDL_CreateMutex();

    q->cond = SDL_CreateCond();

}



int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

    AVPacketList *pkt1;

    if (av_dup_packet(pkt) < 0) {

        return -1;

    }



    pkt1 = av_malloc(sizeof(AVPacketList));

    if (!pkt1)

        return -1;



    pkt1->pkt = *pkt;

    pkt1->next = NULL;



    SDL_LockMutex(q->mutex);



    if (!q->last_pkt)

        q->first_pkt = pkt1;

    else

        q->last_pkt->next = pkt1;



    q->last_pkt = pkt1;

    q->nb_packets++;

    q->size += pkt1->pkt.size;

    SDL_CondSignal(q->cond);



    SDL_UnlockMutex(q->mutex);

    return 0;

}



static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {

    AVPacketList *pkt1;

    int ret;



    SDL_LockMutex(q->mutex);



    for (;;) {

        if (global_video_state->quit) {

            ret = -1;

            break;

        }



        pkt1 = q->first_pkt;

        if (pkt1) {

            q->first_pkt = pkt1->next;

            if (!q->first_pkt)

                q->last_pkt = NULL;

            q->nb_packets--;

            q->size -= pkt1->pkt.size;

            *pkt = pkt1->pkt;

            av_free(pkt1);

            ret = 1;

            break;

        } else if (!block) {

            ret = 0;

        } else {

            SDL_CondWait(q->cond, q->mutex);

        }

    }



    SDL_UnlockMutex(q->mutex);

    return ret;

}



int audio_decode_frame(VideoState *is) {

    int len1, data_size = 0;

    AVPacket *pkt = &is->audio_pkt;



    for (;;) {

        while (is->audio_pkt_size > 0) {

            int got_frame = 0;

            len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame,

                    &got_frame, pkt);



            if (len1 < 0) {

                /*if error, skip frame*/

                is->audio_pkt_size = 0;

                break;

            }



            if (got_frame) {

                data_size = is->audio_frame.linesize[0];

                /*av_samples_get_buffer_size(NULL,

                 is->audio_st->codec->channels,

                 is->audio_frame.nb_samples,

                 is->audio_st->codec->sample_fmt, 1);*/

                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);

            }



            is->audio_pkt_data += len1;

            is->audio_pkt_size -= len1;



            if (data_size <= 0) {

                /*No data yet, get more frames*/

                continue;

            }

            /* We have data, return it and come back for more later */

            return data_size;

        }

        if (pkt->data)

            av_free_packet(pkt);



        if (is->quit) {

            return -1;

        }



        /* next packet */

        if (packet_queue_get(&is->audioq, pkt, 1) < 0) {

            return -1;

        }

        is->audio_pkt_data = pkt->data;

        is->audio_pkt_size = pkt->size;

    }



    return 0;

}



void audio_callback(void *userdata, Uint8 *stream, int len) {

    VideoState *is = (VideoState *) userdata;

    int len1, audio_size;



    while (len > 0) {

        if (is->audio_buf_index >= is->audio_buf_size) {

            /* We have already sent all out data; get more*/

            audio_size = audio_decode_frame(is);

            if (audio_size < 0) {

                /* If error, output silence */

                is->audio_buf_size = 1024;

                memset(is->audio_buf, 0, is->audio_buf_size);

            } else {

                is->audio_buf_size = audio_size;

            }

            is->audio_buf_index = 0;

        }

        len1 = is->audio_buf_size - is->audio_buf_index;

        if (len1 > len)

            len1 = len;

        memcpy(stream, (uint8_t *) is->audio_buf + is->audio_buf_index, len1);

        len -= len1;

        stream += len1;

        is->audio_buf_index += len1;

    }

}



static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {

    SDL_Event event;

    event.type = FF_REFRESH_EVENT;

    event.user.data1 = opaque;

    SDL_PushEvent(&event);

    return 0;/* 0 means stop timer */

}



/* schedule a video refresh in 'delay' ms*/

static void schedule_refresh(VideoState *is, int delay) {

    SDL_AddTimer(delay, sdl_refresh_timer_cb, is);

}



void video_refresh_timer(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    //VideoPicture *vp;

    if (is->video_st) {

        if (is->pictq_size == 0) {

            schedule_refresh(is, 1);

        } else {

            //vp = &is->pictq[is->pictq_rindex];

            /* Now, normally here goes a ton of code

             about timing, etc. we're just going to

             guess at a delay for now. You can

             increase and decrease this value and hard code

             the timing - but I don't suggest that ;)

             We'll learn how to do it for real later.

             */

            schedule_refresh(is, 80);



            /* show the picture! */

            video_display(is);



            /* update queue for next picture! */

            if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) {

                is->pictq_rindex = 0;

            }

            SDL_LockMutex(is->pictq_mutex);

            is->pictq_size--;

            SDL_CondSignal(is->pictq_cond);

            SDL_UnlockMutex(is->pictq_mutex);

        }

    } else {

        schedule_refresh(is, 100);

    }

}



void video_display(VideoState *is) {

    SDL_Rect rect;

    VideoPicture *vp;

    float aspect_ratio;

    int w, h, x, y;



    vp = &is->pictq[is->pictq_rindex];

    if (vp->bmp) {

        if (is->video_st->codec->sample_aspect_ratio.num == 0) {

            aspect_ratio = 0;

        } else {

            aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio)

                    * is->video_st->codec->width / is->video_st->codec->height;

        }



        if (aspect_ratio <= 0.0) {

            aspect_ratio = (float) is->video_st->codec->width

                    / (float) is->video_st->codec->height;

        }

        h = screen->h;

        w = ((int) rint(h * aspect_ratio)) & -3;

        if (w > screen->w) {

            w = screen->w;

            h = ((int) rint(w / aspect_ratio)) & -3;

        }



        x = (screen->w - w) / 2;

        y = (screen->h - h) / 2;



        rect.x = x;

        rect.y = y;

        rect.w = w;

        rect.h = h;

        SDL_DisplayYUVOverlay(vp->bmp, &rect);

    }

}



void alloc_picture(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    VideoPicture *vp;



    vp = &is->pictq[is->pictq_windex];

    if (vp->bmp) {

        // we already have one make another, bigger/smaller

        SDL_FreeYUVOverlay(vp->bmp);

    }

    // Allocate a place to put our YUV image on that screen

    vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,

            is->video_st->codec->height, SDL_YV12_OVERLAY, screen);

    vp->width = is->video_st->codec->width;

    vp->height = is->video_st->codec->height;



    SDL_LockMutex(is->pictq_mutex);

    vp->allocated = 1;

    SDL_CondSignal(is->pictq_cond);

    SDL_UnlockMutex(is->pictq_mutex);

}



int queue_picture(VideoState *is, AVFrame *pFrame) {

    VideoPicture *vp;

    //int dst_pic_fmt

    AVPicture pict;



    /* wait unitl we have space for a new pic */

    SDL_LockMutex(is->pictq_mutex);

    while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && !is->quit) {

        SDL_CondWait(is->pictq_cond, is->pictq_mutex);

    }

    SDL_UnlockMutex(is->pictq_mutex);



    if (is->quit)

        return -1;



    // windex is set to 0 initially

    vp = &is->pictq[is->pictq_windex];



    /* allocate or resize the buffer ! */

    if (!vp->bmp || vp->width != is->video_st->codec->width

            || vp->height != is->video_st->codec->height) {

        SDL_Event event;



        vp->allocated = 0;

        /* we have to do it in the main thread */

        event.type = FF_ALLOC_EVENT;

        event.user.data1 = is;

        SDL_PushEvent(&event);



        /* wait until we have a picture allocated */

        SDL_LockMutex(is->pictq_mutex);

        while (!vp->allocated && !is->quit) {

            SDL_CondWait(is->pictq_cond, is->pictq_mutex);

        }

    }

    SDL_UnlockMutex(is->pictq_mutex);

    if (is->quit) {

        return -1;

    }



    /* We have a place to put our picture on the queue */

    if (vp->bmp) {

        SDL_LockYUVOverlay(vp->bmp);

        //dst_pix_fmt = PIX_FMT_YUV420P;

        /* point pict at the queue */



        pict.data[0] = vp->bmp->pixels[0];

        pict.data[1] = vp->bmp->pixels[2];

        pict.data[2] = vp->bmp->pixels[1];



        pict.linesize[0] = vp->bmp->pitches[0];

        pict.linesize[1] = vp->bmp->pitches[2];

        pict.linesize[2] = vp->bmp->pitches[1];



        // Convert the image into YUV format that SDL uses

        sws_scale(is->sws_ctx, (const uint8_t * const *) pFrame->data,

                pFrame->linesize, 0, is->video_st->codec->height, pict.data,

                pict.linesize);

        SDL_UnlockYUVOverlay(vp->bmp);

        /* now we inform our display thread that we have a pic ready */

        if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE) {

            is->pictq_windex = 0;

        }

        SDL_LockMutex(is->pictq_mutex);

        is->pictq_size++;

        SDL_UnlockMutex(is->pictq_mutex);

    }

    return 0;

}



int video_thread(void *arg) {

    VideoState *is = (VideoState *) arg;

    AVPacket pkt1, *packet = &pkt1;

    int frameFinished;

    AVFrame *pFrame;



    pFrame = av_frame_alloc();



    for (;;) {

        if (packet_queue_get(&is->videoq, packet, 1) < 0) {

            // means we quit getting packets

            break;

        }



        // Decode video frame

        avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,

                packet);



        // Did we get a video frame?

        if (frameFinished) {

            if (queue_picture(is, pFrame) < 0) {

                break;

            }

        }

        av_free_packet(packet);

    }



    av_free(pFrame);

    return 0;

}



int main(int argc, char *argv[]) {

    return EXIT_SUCCESS;

}

九、将解码器，建立音频选项，保存重要信息到数据结构中，并推出音频视频线，复用一些相同的代码。

/*

 ============================================================================

 Name        : VideoDecodeTutorial4_1.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



typedef struct VideoState {

    AVFormatContext *pFormatCtx;

    int videoStream, audioStream;

    AVStream *audio_st;

    PacketQueue audioq;

    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

    unsigned int audio_buf_size;

    unsigned int audio_buf_index;

    AVPacket audio_pkt;

    uint8_t *audio_pkt_data;

    int audio_pkt_size;

    AVFrame audio_frame;

    AVStream *video_st;

    PacketQueue videoq;



    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;



    SDL_Thread *parse_tid;

    SDL_Thread *video_tid;



    AVIOContext *io_ctx;

    struct SwsContext *sws_ctx;



    char filename[1024];

    int quit;

} VideoState;



SDL_Surface *screen;



/*Since we only hava one decoding thread, the Big Struct can be

 * global in case we need it. */

VideoState *global_video_state;



void packet_queue_init(PacketQueue *q) {

    memset(q, 0, sizeof(PacketQueue));

    q->mutex = SDL_CreateMutex();

    q->cond = SDL_CreateCond();

}



int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

    AVPacketList *pkt1;

    if (av_dup_packet(pkt) < 0) {

        return -1;

    }



    pkt1 = av_malloc(sizeof(AVPacketList));

    if (!pkt1)

        return -1;



    pkt1->pkt = *pkt;

    pkt1->next = NULL;



    SDL_LockMutex(q->mutex);



    if (!q->last_pkt)

        q->first_pkt = pkt1;

    else

        q->last_pkt->next = pkt1;



    q->last_pkt = pkt1;

    q->nb_packets++;

    q->size += pkt1->pkt.size;

    SDL_CondSignal(q->cond);



    SDL_UnlockMutex(q->mutex);

    return 0;

}



static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {

    AVPacketList *pkt1;

    int ret;



    SDL_LockMutex(q->mutex);



    for (;;) {

        if (global_video_state->quit) {

            ret = -1;

            break;

        }



        pkt1 = q->first_pkt;

        if (pkt1) {

            q->first_pkt = pkt1->next;

            if (!q->first_pkt)

                q->last_pkt = NULL;

            q->nb_packets--;

            q->size -= pkt1->pkt.size;

            *pkt = pkt1->pkt;

            av_free(pkt1);

            ret = 1;

            break;

        } else if (!block) {

            ret = 0;

        } else {

            SDL_CondWait(q->cond, q->mutex);

        }

    }



    SDL_UnlockMutex(q->mutex);

    return ret;

}



int audio_decode_frame(VideoState *is) {

    int len1, data_size = 0;

    AVPacket *pkt = &is->audio_pkt;



    for (;;) {

        while (is->audio_pkt_size > 0) {

            int got_frame = 0;

            len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame,

                    &got_frame, pkt);



            if (len1 < 0) {

                /*if error, skip frame*/

                is->audio_pkt_size = 0;

                break;

            }



            if (got_frame) {

                data_size = is->audio_frame.linesize[0];

                /*av_samples_get_buffer_size(NULL,

                 is->audio_st->codec->channels,

                 is->audio_frame.nb_samples,

                 is->audio_st->codec->sample_fmt, 1);*/

                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);

            }



            is->audio_pkt_data += len1;

            is->audio_pkt_size -= len1;



            if (data_size <= 0) {

                /*No data yet, get more frames*/

                continue;

            }

            /* We have data, return it and come back for more later */

            return data_size;

        }

        if (pkt->data)

            av_free_packet(pkt);



        if (is->quit) {

            return -1;

        }



        /* next packet */

        if (packet_queue_get(&is->audioq, pkt, 1) < 0) {

            return -1;

        }

        is->audio_pkt_data = pkt->data;

        is->audio_pkt_size = pkt->size;

    }



    return 0;

}



void audio_callback(void *userdata, Uint8 *stream, int len) {

    VideoState *is = (VideoState *) userdata;

    int len1, audio_size;



    while (len > 0) {

        if (is->audio_buf_index >= is->audio_buf_size) {

            /* We have already sent all out data; get more*/

            audio_size = audio_decode_frame(is);

            if (audio_size < 0) {

                /* If error, output silence */

                is->audio_buf_size = 1024;

                memset(is->audio_buf, 0, is->audio_buf_size);

            } else {

                is->audio_buf_size = audio_size;

            }

            is->audio_buf_index = 0;

        }

        len1 = is->audio_buf_size - is->audio_buf_index;

        if (len1 > len)

            len1 = len;

        memcpy(stream, (uint8_t *) is->audio_buf + is->audio_buf_index, len1);

        len -= len1;

        stream += len1;

        is->audio_buf_index += len1;

    }

}



static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {

    SDL_Event event;

    event.type = FF_REFRESH_EVENT;

    event.user.data1 = opaque;

    SDL_PushEvent(&event);

    return 0;/* 0 means stop timer */

}



/* schedule a video refresh in 'delay' ms*/

static void schedule_refresh(VideoState *is, int delay) {

    SDL_AddTimer(delay, sdl_refresh_timer_cb, is);

}



void video_refresh_timer(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    //VideoPicture *vp;

    if (is->video_st) {

        if (is->pictq_size == 0) {

            schedule_refresh(is, 1);

        } else {

            //vp = &is->pictq[is->pictq_rindex];

            /* Now, normally here goes a ton of code

             about timing, etc. we're just going to

             guess at a delay for now. You can

             increase and decrease this value and hard code

             the timing - but I don't suggest that ;)

             We'll learn how to do it for real later.

             */

            schedule_refresh(is, 80);



            /* show the picture! */

            video_display(is);



            /* update queue for next picture! */

            if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) {

                is->pictq_rindex = 0;

            }

            SDL_LockMutex(is->pictq_mutex);

            is->pictq_size--;

            SDL_CondSignal(is->pictq_cond);

            SDL_UnlockMutex(is->pictq_mutex);

        }

    } else {

        schedule_refresh(is, 100);

    }

}



void video_display(VideoState *is) {

    SDL_Rect rect;

    VideoPicture *vp;

    float aspect_ratio;

    int w, h, x, y;



    vp = &is->pictq[is->pictq_rindex];

    if (vp->bmp) {

        if (is->video_st->codec->sample_aspect_ratio.num == 0) {

            aspect_ratio = 0;

        } else {

            aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio)

                    * is->video_st->codec->width / is->video_st->codec->height;

        }



        if (aspect_ratio <= 0.0) {

            aspect_ratio = (float) is->video_st->codec->width

                    / (float) is->video_st->codec->height;

        }

        h = screen->h;

        w = ((int) rint(h * aspect_ratio)) & -3;

        if (w > screen->w) {

            w = screen->w;

            h = ((int) rint(w / aspect_ratio)) & -3;

        }



        x = (screen->w - w) / 2;

        y = (screen->h - h) / 2;



        rect.x = x;

        rect.y = y;

        rect.w = w;

        rect.h = h;

        SDL_DisplayYUVOverlay(vp->bmp, &rect);

    }

}



void alloc_picture(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    VideoPicture *vp;



    vp = &is->pictq[is->pictq_windex];

    if (vp->bmp) {

        // we already have one make another, bigger/smaller

        SDL_FreeYUVOverlay(vp->bmp);

    }

    // Allocate a place to put our YUV image on that screen

    vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,

            is->video_st->codec->height, SDL_YV12_OVERLAY, screen);

    vp->width = is->video_st->codec->width;

    vp->height = is->video_st->codec->height;



    SDL_LockMutex(is->pictq_mutex);

    vp->allocated = 1;

    SDL_CondSignal(is->pictq_cond);

    SDL_UnlockMutex(is->pictq_mutex);

}



int queue_picture(VideoState *is, AVFrame *pFrame) {

    VideoPicture *vp;

    //int dst_pic_fmt

    AVPicture pict;



    /* wait unitl we have space for a new pic */

    SDL_LockMutex(is->pictq_mutex);

    while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && !is->quit) {

        SDL_CondWait(is->pictq_cond, is->pictq_mutex);

    }

    SDL_UnlockMutex(is->pictq_mutex);



    if (is->quit)

        return -1;



    // windex is set to 0 initially

    vp = &is->pictq[is->pictq_windex];



    /* allocate or resize the buffer ! */

    if (!vp->bmp || vp->width != is->video_st->codec->width

            || vp->height != is->video_st->codec->height) {

        SDL_Event event;



        vp->allocated = 0;

        /* we have to do it in the main thread */

        event.type = FF_ALLOC_EVENT;

        event.user.data1 = is;

        SDL_PushEvent(&event);



        /* wait until we have a picture allocated */

        SDL_LockMutex(is->pictq_mutex);

        while (!vp->allocated && !is->quit) {

            SDL_CondWait(is->pictq_cond, is->pictq_mutex);

        }

    }

    SDL_UnlockMutex(is->pictq_mutex);

    if (is->quit) {

        return -1;

    }



    /* We have a place to put our picture on the queue */

    if (vp->bmp) {

        SDL_LockYUVOverlay(vp->bmp);

        //dst_pix_fmt = PIX_FMT_YUV420P;

        /* point pict at the queue */



        pict.data[0] = vp->bmp->pixels[0];

        pict.data[1] = vp->bmp->pixels[2];

        pict.data[2] = vp->bmp->pixels[1];



        pict.linesize[0] = vp->bmp->pitches[0];

        pict.linesize[1] = vp->bmp->pitches[2];

        pict.linesize[2] = vp->bmp->pitches[1];



        // Convert the image into YUV format that SDL uses

        sws_scale(is->sws_ctx, (const uint8_t * const *) pFrame->data,

                pFrame->linesize, 0, is->video_st->codec->height, pict.data,

                pict.linesize);

        SDL_UnlockYUVOverlay(vp->bmp);

        /* now we inform our display thread that we have a pic ready */

        if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE) {

            is->pictq_windex = 0;

        }

        SDL_LockMutex(is->pictq_mutex);

        is->pictq_size++;

        SDL_UnlockMutex(is->pictq_mutex);

    }

    return 0;

}



int video_thread(void *arg) {

    VideoState *is = (VideoState *) arg;

    AVPacket pkt1, *packet = &pkt1;

    int frameFinished;

    AVFrame *pFrame;



    pFrame = av_frame_alloc();



    for (;;) {

        if (packet_queue_get(&is->videoq, packet, 1) < 0) {

            // means we quit getting packets

            break;

        }



        // Decode video frame

        avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,

                packet);



        // Did we get a video frame?

        if (frameFinished) {

            if (queue_picture(is, pFrame) < 0) {

                break;

            }

        }

        av_free_packet(packet);

    }



    av_free(pFrame);

    return 0;

}



int stream_component_open(VideoState *is, int stream_index) {

    AVFormatContext *pFormatCtx = is->pFormatCtx;

    AVCodecContext *codecCtx;

    AVCodec *codec;

    SDL_AudioSpec wanted_spec, spec;



    if (stream_index < 0 || stream_index >= pFormatCtx->nb_streams) {

        return -1;

    }



    // Get a pointer to the codec context for the video stream

    codecCtx = pFormatCtx->streams[stream_index]->codec;



    if (codecCtx->codec_type == AVMEDIA_TYPE_AUDIO) {

        wanted_spec.freq = codecCtx->sample_rate;

        wanted_spec.format = AUDIO_S16SYS;

        wanted_spec.channels = codecCtx->channels;

        wanted_spec.silence = 0;

        wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;

        wanted_spec.callback = audio_callback;

        wanted_spec.userdata = is;



        if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {

            fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());

            return -1;

        }

    }

    codec = avcodec_find_decoder(codecCtx->codec_id);

    if (!codec || (avcodec_open2(codecCtx, codec, NULL) < 0)) {

        fprintf(stderr, "Unsupported codec!\n");

        return -1;

    }



    switch (codecCtx->codec_type) {

    case AVMEDIA_TYPE_AUDIO:

        is->audioStream = stream_index;

        is->audio_st = pFormatCtx->streams[stream_index];

        is->audio_buf_size = 0;

        is->audio_buf_index = 0;

        memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));

        packet_queue_init(&is->audioq);

        SDL_PauseAudio(0);

        break;



    case AVMEDIA_TYPE_VIDEO:

        is->videoStream = stream_index;

        is->video_st = pFormatCtx->streams[stream_index];

        is->sws_ctx = sws_getContext(is->video_st->codec->width,

                is->video_st->codec->height, is->video_st->codec->pix_fmt,

                is->video_st->codec->width, is->video_st->codec->height,

                AV_PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);

        packet_queue_init(&is->videoq);

        is->video_tid = SDL_CreateThread(video_thread, is);

        break;

    default:

        break;

    }

    return 0;

}



int main(int argc, char *argv[]) {

    return EXIT_SUCCESS;

}

十、将之前获取打开视频、获取视频信息、获取视频音频解码器、以及从packet中循环读取frame的动作放到一个函数中。

/*

 ============================================================================

 Name        : VideoDecodeTutorial4_1.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



typedef struct VideoState {

    AVFormatContext *pFormatCtx;

    int videoStream, audioStream;

    AVStream *audio_st;

    PacketQueue audioq;

    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

    unsigned int audio_buf_size;

    unsigned int audio_buf_index;

    AVPacket audio_pkt;

    uint8_t *audio_pkt_data;

    int audio_pkt_size;

    AVFrame audio_frame;

    AVStream *video_st;

    PacketQueue videoq;



    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;



    SDL_Thread *parse_tid;

    SDL_Thread *video_tid;



    AVIOContext *io_ctx;

    struct SwsContext *sws_ctx;



    char filename[1024];

    int quit;

} VideoState;



SDL_Surface *screen;



/*Since we only hava one decoding thread, the Big Struct can be

 * global in case we need it. */

VideoState *global_video_state;



void packet_queue_init(PacketQueue *q) {

    memset(q, 0, sizeof(PacketQueue));

    q->mutex = SDL_CreateMutex();

    q->cond = SDL_CreateCond();

}



int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

    AVPacketList *pkt1;

    if (av_dup_packet(pkt) < 0) {

        return -1;

    }



    pkt1 = av_malloc(sizeof(AVPacketList));

    if (!pkt1)

        return -1;



    pkt1->pkt = *pkt;

    pkt1->next = NULL;



    SDL_LockMutex(q->mutex);



    if (!q->last_pkt)

        q->first_pkt = pkt1;

    else

        q->last_pkt->next = pkt1;



    q->last_pkt = pkt1;

    q->nb_packets++;

    q->size += pkt1->pkt.size;

    SDL_CondSignal(q->cond);



    SDL_UnlockMutex(q->mutex);

    return 0;

}



static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {

    AVPacketList *pkt1;

    int ret;



    SDL_LockMutex(q->mutex);



    for (;;) {

        if (global_video_state->quit) {

            ret = -1;

            break;

        }



        pkt1 = q->first_pkt;

        if (pkt1) {

            q->first_pkt = pkt1->next;

            if (!q->first_pkt)

                q->last_pkt = NULL;

            q->nb_packets--;

            q->size -= pkt1->pkt.size;

            *pkt = pkt1->pkt;

            av_free(pkt1);

            ret = 1;

            break;

        } else if (!block) {

            ret = 0;

        } else {

            SDL_CondWait(q->cond, q->mutex);

        }

    }



    SDL_UnlockMutex(q->mutex);

    return ret;

}



int audio_decode_frame(VideoState *is) {

    int len1, data_size = 0;

    AVPacket *pkt = &is->audio_pkt;



    for (;;) {

        while (is->audio_pkt_size > 0) {

            int got_frame = 0;

            len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame,

                    &got_frame, pkt);



            if (len1 < 0) {

                /*if error, skip frame*/

                is->audio_pkt_size = 0;

                break;

            }



            if (got_frame) {

                data_size = is->audio_frame.linesize[0];

                /*av_samples_get_buffer_size(NULL,

                 is->audio_st->codec->channels,

                 is->audio_frame.nb_samples,

                 is->audio_st->codec->sample_fmt, 1);*/

                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);

            }



            is->audio_pkt_data += len1;

            is->audio_pkt_size -= len1;



            if (data_size <= 0) {

                /*No data yet, get more frames*/

                continue;

            }

            /* We have data, return it and come back for more later */

            return data_size;

        }

        if (pkt->data)

            av_free_packet(pkt);



        if (is->quit) {

            return -1;

        }



        /* next packet */

        if (packet_queue_get(&is->audioq, pkt, 1) < 0) {

            return -1;

        }

        is->audio_pkt_data = pkt->data;

        is->audio_pkt_size = pkt->size;

    }



    return 0;

}



void audio_callback(void *userdata, Uint8 *stream, int len) {

    VideoState *is = (VideoState *) userdata;

    int len1, audio_size;



    while (len > 0) {

        if (is->audio_buf_index >= is->audio_buf_size) {

            /* We have already sent all out data; get more*/

            audio_size = audio_decode_frame(is);

            if (audio_size < 0) {

                /* If error, output silence */

                is->audio_buf_size = 1024;

                memset(is->audio_buf, 0, is->audio_buf_size);

            } else {

                is->audio_buf_size = audio_size;

            }

            is->audio_buf_index = 0;

        }

        len1 = is->audio_buf_size - is->audio_buf_index;

        if (len1 > len)

            len1 = len;

        memcpy(stream, (uint8_t *) is->audio_buf + is->audio_buf_index, len1);

        len -= len1;

        stream += len1;

        is->audio_buf_index += len1;

    }

}



static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {

    SDL_Event event;

    event.type = FF_REFRESH_EVENT;

    event.user.data1 = opaque;

    SDL_PushEvent(&event);

    return 0;/* 0 means stop timer */

}



/* schedule a video refresh in 'delay' ms*/

static void schedule_refresh(VideoState *is, int delay) {

    SDL_AddTimer(delay, sdl_refresh_timer_cb, is);

}



void video_refresh_timer(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    //VideoPicture *vp;

    if (is->video_st) {

        if (is->pictq_size == 0) {

            schedule_refresh(is, 1);

        } else {

            //vp = &is->pictq[is->pictq_rindex];

            /* Now, normally here goes a ton of code

             about timing, etc. we're just going to

             guess at a delay for now. You can

             increase and decrease this value and hard code

             the timing - but I don't suggest that ;)

             We'll learn how to do it for real later.

             */

            schedule_refresh(is, 80);



            /* show the picture! */

            video_display(is);



            /* update queue for next picture! */

            if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) {

                is->pictq_rindex = 0;

            }

            SDL_LockMutex(is->pictq_mutex);

            is->pictq_size--;

            SDL_CondSignal(is->pictq_cond);

            SDL_UnlockMutex(is->pictq_mutex);

        }

    } else {

        schedule_refresh(is, 100);

    }

}



void video_display(VideoState *is) {

    SDL_Rect rect;

    VideoPicture *vp;

    float aspect_ratio;

    int w, h, x, y;



    vp = &is->pictq[is->pictq_rindex];

    if (vp->bmp) {

        if (is->video_st->codec->sample_aspect_ratio.num == 0) {

            aspect_ratio = 0;

        } else {

            aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio)

                    * is->video_st->codec->width / is->video_st->codec->height;

        }



        if (aspect_ratio <= 0.0) {

            aspect_ratio = (float) is->video_st->codec->width

                    / (float) is->video_st->codec->height;

        }

        h = screen->h;

        w = ((int) rint(h * aspect_ratio)) & -3;

        if (w > screen->w) {

            w = screen->w;

            h = ((int) rint(w / aspect_ratio)) & -3;

        }



        x = (screen->w - w) / 2;

        y = (screen->h - h) / 2;



        rect.x = x;

        rect.y = y;

        rect.w = w;

        rect.h = h;

        SDL_DisplayYUVOverlay(vp->bmp, &rect);

    }

}



void alloc_picture(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    VideoPicture *vp;



    vp = &is->pictq[is->pictq_windex];

    if (vp->bmp) {

        // we already have one make another, bigger/smaller

        SDL_FreeYUVOverlay(vp->bmp);

    }

    // Allocate a place to put our YUV image on that screen

    vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,

            is->video_st->codec->height, SDL_YV12_OVERLAY, screen);

    vp->width = is->video_st->codec->width;

    vp->height = is->video_st->codec->height;



    SDL_LockMutex(is->pictq_mutex);

    vp->allocated = 1;

    SDL_CondSignal(is->pictq_cond);

    SDL_UnlockMutex(is->pictq_mutex);

}



int queue_picture(VideoState *is, AVFrame *pFrame) {

    VideoPicture *vp;

    //int dst_pic_fmt

    AVPicture pict;



    /* wait unitl we have space for a new pic */

    SDL_LockMutex(is->pictq_mutex);

    while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && !is->quit) {

        SDL_CondWait(is->pictq_cond, is->pictq_mutex);

    }

    SDL_UnlockMutex(is->pictq_mutex);



    if (is->quit)

        return -1;



    // windex is set to 0 initially

    vp = &is->pictq[is->pictq_windex];



    /* allocate or resize the buffer ! */

    if (!vp->bmp || vp->width != is->video_st->codec->width

            || vp->height != is->video_st->codec->height) {

        SDL_Event event;



        vp->allocated = 0;

        /* we have to do it in the main thread */

        event.type = FF_ALLOC_EVENT;

        event.user.data1 = is;

        SDL_PushEvent(&event);



        /* wait until we have a picture allocated */

        SDL_LockMutex(is->pictq_mutex);

        while (!vp->allocated && !is->quit) {

            SDL_CondWait(is->pictq_cond, is->pictq_mutex);

        }

    }

    SDL_UnlockMutex(is->pictq_mutex);

    if (is->quit) {

        return -1;

    }



    /* We have a place to put our picture on the queue */

    if (vp->bmp) {

        SDL_LockYUVOverlay(vp->bmp);

        //dst_pix_fmt = PIX_FMT_YUV420P;

        /* point pict at the queue */



        pict.data[0] = vp->bmp->pixels[0];

        pict.data[1] = vp->bmp->pixels[2];

        pict.data[2] = vp->bmp->pixels[1];



        pict.linesize[0] = vp->bmp->pitches[0];

        pict.linesize[1] = vp->bmp->pitches[2];

        pict.linesize[2] = vp->bmp->pitches[1];



        // Convert the image into YUV format that SDL uses

        sws_scale(is->sws_ctx, (const uint8_t * const *) pFrame->data,

                pFrame->linesize, 0, is->video_st->codec->height, pict.data,

                pict.linesize);

        SDL_UnlockYUVOverlay(vp->bmp);

        /* now we inform our display thread that we have a pic ready */

        if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE) {

            is->pictq_windex = 0;

        }

        SDL_LockMutex(is->pictq_mutex);

        is->pictq_size++;

        SDL_UnlockMutex(is->pictq_mutex);

    }

    return 0;

}



int video_thread(void *arg) {

    VideoState *is = (VideoState *) arg;

    AVPacket pkt1, *packet = &pkt1;

    int frameFinished;

    AVFrame *pFrame;



    pFrame = av_frame_alloc();



    for (;;) {

        if (packet_queue_get(&is->videoq, packet, 1) < 0) {

            // means we quit getting packets

            break;

        }



        // Decode video frame

        avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,

                packet);



        // Did we get a video frame?

        if (frameFinished) {

            if (queue_picture(is, pFrame) < 0) {

                break;

            }

        }

        av_free_packet(packet);

    }



    av_free(pFrame);

    return 0;

}



int stream_component_open(VideoState *is, int stream_index) {

    AVFormatContext *pFormatCtx = is->pFormatCtx;

    AVCodecContext *codecCtx;

    AVCodec *codec;

    SDL_AudioSpec wanted_spec, spec;



    if (stream_index < 0 || stream_index >= pFormatCtx->nb_streams) {

        return -1;

    }



    // Get a pointer to the codec context for the video stream

    codecCtx = pFormatCtx->streams[stream_index]->codec;



    if (codecCtx->codec_type == AVMEDIA_TYPE_AUDIO) {

        wanted_spec.freq = codecCtx->sample_rate;

        wanted_spec.format = AUDIO_S16SYS;

        wanted_spec.channels = codecCtx->channels;

        wanted_spec.silence = 0;

        wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;

        wanted_spec.callback = audio_callback;

        wanted_spec.userdata = is;



        if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {

            fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());

            return -1;

        }

    }

    codec = avcodec_find_decoder(codecCtx->codec_id);

    if (!codec || (avcodec_open2(codecCtx, codec, NULL) < 0)) {

        fprintf(stderr, "Unsupported codec!\n");

        return -1;

    }



    switch (codecCtx->codec_type) {

    case AVMEDIA_TYPE_AUDIO:

        is->audioStream = stream_index;

        is->audio_st = pFormatCtx->streams[stream_index];

        is->audio_buf_size = 0;

        is->audio_buf_index = 0;

        memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));

        packet_queue_init(&is->audioq);

        SDL_PauseAudio(0);

        break;



    case AVMEDIA_TYPE_VIDEO:

        is->videoStream = stream_index;

        is->video_st = pFormatCtx->streams[stream_index];

        is->sws_ctx = sws_getContext(is->video_st->codec->width,

                is->video_st->codec->height, is->video_st->codec->pix_fmt,

                is->video_st->codec->width, is->video_st->codec->height,

                AV_PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);

        packet_queue_init(&is->videoq);

        is->video_tid = SDL_CreateThread(video_thread, is);

        break;

    default:

        break;

    }

    return 0;

}



int decode_interrupt_cb(void *opaque) {

    return (global_video_state && global_video_state->quit);

}



int decode_thread(void *arg) {

    VideoState *is = (VideoState *) arg;

    AVFormatContext *pFormatCtx = NULL;

    AVPacket pkt1, *packet = &pkt1;



    int video_index = -1;

    int audio_index = -1;

    int i;



    is->videoStream = -1;

    is->audioStream = -1;



    AVIOInterruptCB interupt_cb;



    global_video_state = is;



    // will interrup blocking functions if we quit!

    interupt_cb.callback = decode_interrupt_cb;

    interupt_cb.opaque = is;



    if (avio_open2(&is->io_ctx, is->filename, 0, &interupt_cb, NULL)) {

        fprintf(stderr, "Cannot open I/O for %s\n", is->filename);

        return -1;

    }



    //Open video file

    if (avformat_open_input(&pFormatCtx, is->filename, NULL, NULL) != 0) {

        return -1; //Couldn't open file

    }



    is->pFormatCtx = pFormatCtx;



    //Retrieve stream infomation

    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {

        return -1; // Couldn't find stream information

    }



    //Dump information about file onto standard error

    av_dump_format(pFormatCtx, 0, is->filename, 0);



    //Find the first video stream

    for (i = 0; i < pFormatCtx->nb_streams; i++) {

        if (pFormatCtx->streams[i]->codec->coder_type == AVMEDIA_TYPE_VIDEO

                && video_index < 0) {

            video_index = i;

        }



        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO

                && audio_index < 0) {

            audio_index = i;

        }

    }



    if (audio_index >= 0) {

        stream_component_open(is, audio_index);

    }



    if (video_index >= 0) {

        stream_component_open(is, video_index);

    }



    if (is->videoStream < 0 || is->audioStream <= 0) {

        fprintf(stderr, "%s: could not open codec\n", is->filename);

        goto fail;

    }



    //main decode loop

    for (;;) {

        if (is->quit) {

            break;

        }



        //seek  stuff goes here

        if (is->audioq.size > MAX_AUDIO_SIZE || is->videoq.size > MAX_VIDEO_SIZE) {

            SDL_Delay(10);

            continue;

        }

        if (av_read_frame(is->pFormatCtx, packet) < 0) {

            if (is->pFormatCtx->pb->error == 0) {

                SDL_Delay(100); /* no error; wait for user input */

                continue;

            } else {

                break;

            }

        }

        // Is this a packet from the video stream?

        if (packet->stream_index == is->videoStream) {

            packet_queue_put(&is->videoq, packet);

        } else if (packet->stream_index == is->audioStream) {

            packet_queue_put(&is->audioq, packet);

        } else {

            av_free_packet(packet);

        }

    }



    /*all done - wait for it*/

    while (!is->quit) {

        SDL_Delay(100);

    }



    fail: if (1) {

        SDL_Event event;

        event.type = FF_QUIT_EVENT;

        event.user.data1 = is;

        SDL_PushEvent(&event);

    }

    return 0;

}



int main(int argc, char *argv[]) {

    return EXIT_SUCCESS;

}

十一、执行相关的调用流程

/*

 ============================================================================

 Name        : player4.c

 Author      : clarck

 Version     :

 Copyright   : Your copyright notice

 Description : Hello World in C, Ansi-style

 ============================================================================

 */



#include <stdio.h>

#include <stdlib.h>

#include <math.h>



#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libavformat/avio.h>

#include <libswscale/swscale.h>

#include <libavutil/avstring.h>

#include <libavutil/rational.h>



#include <SDL/SDL.h>

#include <SDL/SDL_thread.h>



#ifdef __MINGW32__

#undef main /* Prevents SDL from overriding main() */

#endif



#define SDL_AUDIO_BUFFER_SIZE 1024



#define MAX_AUDIO_SIZE (5 * 16 * 1024)

#define MAX_VIDEO_SIZE (5 * 256 * 1024)



#define FF_ALLOC_EVENT (SDL_USEREVENT)

#define FF_REFRESH_EVENT (SDL_USEREVENT + 1)

#define FF_QUIT_EVENT    (SDL_USEREVENT + 2)



#define VIDEO_PICTURE_QUEUE_SIZE 1

#define AVCODEC_MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32bit audio



typedef struct PacketQueue {

    AVPacketList *first_pkt, *last_pkt;

    int nb_packets;

    int size;

    SDL_mutex *mutex;

    SDL_cond *cond;

} PacketQueue;



typedef struct VideoPicture {

    SDL_Overlay *bmp;

    int width, height; /*source height & width*/

    int allocated;

} VideoPicture;



typedef struct VideoState {

    AVFormatContext *pFormatCtx;

    int videoStream, audioStream;

    AVStream *audio_st;

    PacketQueue audioq;

    uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];

    unsigned int audio_buf_size;

    unsigned int audio_buf_index;

    AVPacket audio_pkt;

    uint8_t *audio_pkt_data;

    int audio_pkt_size;

    AVFrame audio_frame;

    AVStream *video_st;

    PacketQueue videoq;



    VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];

    int pictq_size, pictq_rindex, pictq_windex;

    SDL_mutex *pictq_mutex;

    SDL_cond *pictq_cond;



    SDL_Thread *parse_tid;

    SDL_Thread *video_tid;



    AVIOContext *io_ctx;

    struct SwsContext *sws_ctx;



    char filename[1024];

    int quit;

} VideoState;



SDL_Surface *screen;



/*Since we only hava one decoding thread, the Big Struct can be

 * global in case we need it. */

VideoState *global_video_state;



void packet_queue_init(PacketQueue *q) {

    memset(q, 0, sizeof(PacketQueue));

    q->mutex = SDL_CreateMutex();

    q->cond = SDL_CreateCond();

}



int packet_queue_put(PacketQueue *q, AVPacket *pkt) {

    AVPacketList *pkt1;

    if (av_dup_packet(pkt) < 0) {

        return -1;

    }



    pkt1 = av_malloc(sizeof(AVPacketList));

    if (!pkt1)

        return -1;



    pkt1->pkt = *pkt;

    pkt1->next = NULL;



    SDL_LockMutex(q->mutex);



    if (!q->last_pkt)

        q->first_pkt = pkt1;

    else

        q->last_pkt->next = pkt1;



    q->last_pkt = pkt1;

    q->nb_packets++;

    q->size += pkt1->pkt.size;

    SDL_CondSignal(q->cond);



    SDL_UnlockMutex(q->mutex);

    return 0;

}



static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {

    AVPacketList *pkt1;

    int ret;



    SDL_LockMutex(q->mutex);



    for (;;) {

        if (global_video_state->quit) {

            ret = -1;

            break;

        }



        pkt1 = q->first_pkt;

        if (pkt1) {

            q->first_pkt = pkt1->next;

            if (!q->first_pkt)

                q->last_pkt = NULL;

            q->nb_packets--;

            q->size -= pkt1->pkt.size;

            *pkt = pkt1->pkt;

            av_free(pkt1);

            ret = 1;

            break;

        } else if (!block) {

            ret = 0;

        } else {

            SDL_CondWait(q->cond, q->mutex);

        }

    }



    SDL_UnlockMutex(q->mutex);

    return ret;

}



int audio_decode_frame(VideoState *is) {

    int len1, data_size = 0;

    AVPacket *pkt = &is->audio_pkt;



    for (;;) {

        while (is->audio_pkt_size > 0) {

            int got_frame = 0;

            len1 = avcodec_decode_audio4(is->audio_st->codec, &is->audio_frame,

                    &got_frame, pkt);



            if (len1 < 0) {

                /*if error, skip frame*/

                is->audio_pkt_size = 0;

                break;

            }



            if (got_frame) {

                data_size = is->audio_frame.linesize[0];

                /*av_samples_get_buffer_size(NULL,

                 is->audio_st->codec->channels,

                 is->audio_frame.nb_samples,

                 is->audio_st->codec->sample_fmt, 1);*/

                memcpy(is->audio_buf, is->audio_frame.data[0], data_size);

            }



            is->audio_pkt_data += len1;

            is->audio_pkt_size -= len1;



            if (data_size <= 0) {

                /*No data yet, get more frames*/

                continue;

            }

            /* We have data, return it and come back for more later */

            return data_size;

        }

        if (pkt->data)

            av_free_packet(pkt);



        if (is->quit) {

            return -1;

        }



        /* next packet */

        if (packet_queue_get(&is->audioq, pkt, 1) < 0) {

            return -1;

        }

        is->audio_pkt_data = pkt->data;

        is->audio_pkt_size = pkt->size;

    }



    return 0;

}



void audio_callback(void *userdata, Uint8 *stream, int len) {

    VideoState *is = (VideoState *) userdata;

    int len1, audio_size;



    while (len > 0) {

        if (is->audio_buf_index >= is->audio_buf_size) {

            /* We have already sent all out data; get more*/

            audio_size = audio_decode_frame(is);

            if (audio_size < 0) {

                /* If error, output silence */

                is->audio_buf_size = 1024;

                memset(is->audio_buf, 0, is->audio_buf_size);

            } else {

                is->audio_buf_size = audio_size;

            }

            is->audio_buf_index = 0;

        }

        len1 = is->audio_buf_size - is->audio_buf_index;

        if (len1 > len)

            len1 = len;

        memcpy(stream, (uint8_t *) is->audio_buf + is->audio_buf_index, len1);

        len -= len1;

        stream += len1;

        is->audio_buf_index += len1;

    }

}



static Uint32 sdl_refresh_timer_cb(Uint32 interval, void *opaque) {

    SDL_Event event;

    event.type = FF_REFRESH_EVENT;

    event.user.data1 = opaque;

    SDL_PushEvent(&event);

    return 0;/* 0 means stop timer */

}



/* schedule a video refresh in 'delay' ms*/

static void schedule_refresh(VideoState *is, int delay) {

    SDL_AddTimer(delay, sdl_refresh_timer_cb, is);

}



void video_display(VideoState *is) {

    SDL_Rect rect;

    VideoPicture *vp;

    float aspect_ratio;

    int w, h, x, y;



    vp = &is->pictq[is->pictq_rindex];

    if (vp->bmp) {

        if (is->video_st->codec->sample_aspect_ratio.num == 0) {

            aspect_ratio = 0;

        } else {

            aspect_ratio = av_q2d(is->video_st->codec->sample_aspect_ratio)

                    * is->video_st->codec->width / is->video_st->codec->height;

        }



        if (aspect_ratio <= 0.0) {

            aspect_ratio = (float) is->video_st->codec->width

                    / (float) is->video_st->codec->height;

        }

        h = screen->h;

        w = ((int) rint(h * aspect_ratio)) & -3;

        if (w > screen->w) {

            w = screen->w;

            h = ((int) rint(w / aspect_ratio)) & -3;

        }



        x = (screen->w - w) / 2;

        y = (screen->h - h) / 2;



        rect.x = x;

        rect.y = y;

        rect.w = w;

        rect.h = h;

        SDL_DisplayYUVOverlay(vp->bmp, &rect);

    }

}



void video_refresh_timer(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    //VideoPicture *vp;

    if (is->video_st) {

        if (is->pictq_size == 0) {

            schedule_refresh(is, 1);

        } else {

            //vp = &is->pictq[is->pictq_rindex];

            /* Now, normally here goes a ton of code

             about timing, etc. we're just going to

             guess at a delay for now. You can

             increase and decrease this value and hard code

             the timing - but I don't suggest that ;)

             We'll learn how to do it for real later.

             */

            schedule_refresh(is, 80);



            /* show the picture! */

            video_display(is);



            /* update queue for next picture! */

            if (++is->pictq_rindex == VIDEO_PICTURE_QUEUE_SIZE) {

                is->pictq_rindex = 0;

            }

            SDL_LockMutex(is->pictq_mutex);

            is->pictq_size--;

            SDL_CondSignal(is->pictq_cond);

            SDL_UnlockMutex(is->pictq_mutex);

        }

    } else {

        schedule_refresh(is, 100);

    }

}



void alloc_picture(void *userdata) {

    VideoState *is = (VideoState *) userdata;

    VideoPicture *vp;



    vp = &is->pictq[is->pictq_windex];

    if (vp->bmp) {

        // we already have one make another, bigger/smaller

        SDL_FreeYUVOverlay(vp->bmp);

    }

    // Allocate a place to put our YUV image on that screen

    vp->bmp = SDL_CreateYUVOverlay(is->video_st->codec->width,

            is->video_st->codec->height, SDL_YV12_OVERLAY, screen);

    vp->width = is->video_st->codec->width;

    vp->height = is->video_st->codec->height;



    SDL_LockMutex(is->pictq_mutex);

    vp->allocated = 1;

    SDL_CondSignal(is->pictq_cond);

    SDL_UnlockMutex(is->pictq_mutex);

}



int queue_picture(VideoState *is, AVFrame *pFrame) {

    VideoPicture *vp;

    //int dst_pic_fmt

    AVPicture pict;



    /* wait unitl we have space for a new pic */

    SDL_LockMutex(is->pictq_mutex);

    while (is->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && !is->quit) {

        SDL_CondWait(is->pictq_cond, is->pictq_mutex);

    }

    SDL_UnlockMutex(is->pictq_mutex);



    if (is->quit)

        return -1;



    // windex is set to 0 initially

    vp = &is->pictq[is->pictq_windex];



    /* allocate or resize the buffer ! */

    if (!vp->bmp || vp->width != is->video_st->codec->width

            || vp->height != is->video_st->codec->height) {

        SDL_Event event;



        vp->allocated = 0;

        /* we have to do it in the main thread */

        event.type = FF_ALLOC_EVENT;

        event.user.data1 = is;

        SDL_PushEvent(&event);



        /* wait until we have a picture allocated */

        SDL_LockMutex(is->pictq_mutex);

        while (!vp->allocated && !is->quit) {

            SDL_CondWait(is->pictq_cond, is->pictq_mutex);

        }

    }

    SDL_UnlockMutex(is->pictq_mutex);

    if (is->quit) {

        return -1;

    }



    /* We have a place to put our picture on the queue */

    if (vp->bmp) {

        SDL_LockYUVOverlay(vp->bmp);

        //dst_pix_fmt = PIX_FMT_YUV420P;

        /* point pict at the queue */



        pict.data[0] = vp->bmp->pixels[0];

        pict.data[1] = vp->bmp->pixels[2];

        pict.data[2] = vp->bmp->pixels[1];



        pict.linesize[0] = vp->bmp->pitches[0];

        pict.linesize[1] = vp->bmp->pitches[2];

        pict.linesize[2] = vp->bmp->pitches[1];



        // Convert the image into YUV format that SDL uses

        sws_scale(is->sws_ctx, (const uint8_t * const *) pFrame->data,

                pFrame->linesize, 0, is->video_st->codec->height, pict.data,

                pict.linesize);

        SDL_UnlockYUVOverlay(vp->bmp);

        /* now we inform our display thread that we have a pic ready */

        if (++is->pictq_windex == VIDEO_PICTURE_QUEUE_SIZE) {

            is->pictq_windex = 0;

        }

        SDL_LockMutex(is->pictq_mutex);

        is->pictq_size++;

        SDL_UnlockMutex(is->pictq_mutex);

    }

    return 0;

}



int video_thread(void *arg) {

    VideoState *is = (VideoState *) arg;

    AVPacket pkt1, *packet = &pkt1;

    int frameFinished;

    AVFrame *pFrame;



    pFrame = av_frame_alloc();



    for (;;) {

        if (packet_queue_get(&is->videoq, packet, 1) < 0) {

            // means we quit getting packets

            break;

        }



        // Decode video frame

        avcodec_decode_video2(is->video_st->codec, pFrame, &frameFinished,

                packet);



        // Did we get a video frame?

        if (frameFinished) {

            if (queue_picture(is, pFrame) < 0) {

                break;

            }

        }

        av_free_packet(packet);

    }



    av_free(pFrame);

    return 0;

}



int stream_component_open(VideoState *is, int stream_index) {

    AVFormatContext *pFormatCtx = is->pFormatCtx;

    AVCodecContext *codecCtx;

    AVCodec *codec;

    SDL_AudioSpec wanted_spec, spec;



    if (stream_index < 0 || stream_index >= pFormatCtx->nb_streams) {

        return -1;

    }



    // Get a pointer to the codec context for the video stream

    codecCtx = pFormatCtx->streams[stream_index]->codec;



    if (codecCtx->codec_type == AVMEDIA_TYPE_AUDIO) {

        wanted_spec.freq = codecCtx->sample_rate;

        wanted_spec.format = AUDIO_S16SYS;

        wanted_spec.channels = codecCtx->channels;

        wanted_spec.silence = 0;

        wanted_spec.samples = SDL_AUDIO_BUFFER_SIZE;

        wanted_spec.callback = audio_callback;

        wanted_spec.userdata = is;



        if (SDL_OpenAudio(&wanted_spec, &spec) < 0) {

            fprintf(stderr, "SDL_OpenAudio: %s\n", SDL_GetError());

            return -1;

        }

    }

    codec = avcodec_find_decoder(codecCtx->codec_id);

    if (!codec || (avcodec_open2(codecCtx, codec, NULL) < 0)) {

        fprintf(stderr, "Unsupported codec!\n");

        return -1;

    }



    switch (codecCtx->codec_type) {

    case AVMEDIA_TYPE_AUDIO:

        is->audioStream = stream_index;

        is->audio_st = pFormatCtx->streams[stream_index];

        is->audio_buf_size = 0;

        is->audio_buf_index = 0;

        memset(&is->audio_pkt, 0, sizeof(is->audio_pkt));

        packet_queue_init(&is->audioq);

        SDL_PauseAudio(0);

        break;



    case AVMEDIA_TYPE_VIDEO:

        is->videoStream = stream_index;

        is->video_st = pFormatCtx->streams[stream_index];

        is->sws_ctx = sws_getContext(is->video_st->codec->width,

                is->video_st->codec->height, is->video_st->codec->pix_fmt,

                is->video_st->codec->width, is->video_st->codec->height,

                AV_PIX_FMT_YUV420P, SWS_FAST_BILINEAR, NULL, NULL, NULL);

        packet_queue_init(&is->videoq);

        is->video_tid = SDL_CreateThread(video_thread, is);

        break;

    default:

        break;

    }

    return 0;

}



int decode_interrupt_cb(void *opaque) {

    return (global_video_state && global_video_state->quit);

}



int decode_thread(void *arg) {

    VideoState *is = (VideoState *) arg;

    AVFormatContext *pFormatCtx = NULL;

    AVPacket pkt1, *packet = &pkt1;



    int video_index = -1;

    int audio_index = -1;

    int i;



    is->videoStream = -1;

    is->audioStream = -1;



    AVIOInterruptCB interupt_cb;



    global_video_state = is;



    // will interrup blocking functions if we quit!

    interupt_cb.callback = decode_interrupt_cb;

    interupt_cb.opaque = is;



    if (avio_open2(&is->io_ctx, is->filename, 0, &interupt_cb, NULL)) {

        fprintf(stderr, "Cannot open I/O for %s\n", is->filename);

        return -1;

    }



    //Open video file

    if (avformat_open_input(&pFormatCtx, is->filename, NULL, NULL) != 0) {

        return -1; //Couldn't open file

    }



    is->pFormatCtx = pFormatCtx;



    //Retrieve stream infomation

    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {

        return -1; // Couldn't find stream information

    }



    //Dump information about file onto standard error

    av_dump_format(pFormatCtx, 0, is->filename, 0);



    //Find the first video stream

    for (i = 0; i < pFormatCtx->nb_streams; i++) {

        if (pFormatCtx->streams[i]->codec->coder_type == AVMEDIA_TYPE_VIDEO

                && video_index < 0) {

            video_index = i;

        }



        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO

                && audio_index < 0) {

            audio_index = i;

        }

    }



    if (audio_index >= 0) {

        stream_component_open(is, audio_index);

    }



    if (video_index >= 0) {

        stream_component_open(is, video_index);

    }



    if (is->videoStream < 0 || is->audioStream <= 0) {

        fprintf(stderr, "%s: could not open codec\n", is->filename);

        goto fail;

    }



    //main decode loop

    for (;;) {

        if (is->quit) {

            break;

        }



        //seek  stuff goes here

        if (is->audioq.size > MAX_AUDIO_SIZE || is->videoq.size > MAX_VIDEO_SIZE) {

            SDL_Delay(10);

            continue;

        }

        if (av_read_frame(is->pFormatCtx, packet) < 0) {

            if (is->pFormatCtx->pb->error == 0) {

                SDL_Delay(100); /* no error; wait for user input */

                continue;

            } else {

                break;

            }

        }

        // Is this a packet from the video stream?

        if (packet->stream_index == is->videoStream) {

            packet_queue_put(&is->videoq, packet);

        } else if (packet->stream_index == is->audioStream) {

            packet_queue_put(&is->audioq, packet);

        } else {

            av_free_packet(packet);

        }

    }



    /*all done - wait for it*/

    while (!is->quit) {

        SDL_Delay(100);

    }



    fail: if (1) {

        SDL_Event event;

        event.type = FF_QUIT_EVENT;

        event.user.data1 = is;

        SDL_PushEvent(&event);

    }

    return 0;

}



int main(int argc, char *argv[]) {

    SDL_Event event;



    VideoState *is;

    is = av_malloc(sizeof(VideoState));



    char filePath[] = "./src/a.mp4";



    // Register all formats and codecs

    av_register_all();



    if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)) {

        fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());

        exit(1);

    }



    // Make a screen to put our video

#ifndef __DARWIN__

    screen = SDL_SetVideoMode(640, 480, 0, 0);

#else

    screen = SDL_SetVideoMode(640, 480, 24, 0);

#endif



    if (!screen) {

        fprintf(stderr, "SDL: could not set video mode - exiting\n");

        exit(1);

    }



    av_strlcpy(is->filename, filePath, sizeof(is->filename));



    is->pictq_mutex = SDL_CreateMutex();

    is->pictq_cond = SDL_CreateCond();



    schedule_refresh(is, 40);



    is->parse_tid = SDL_CreateThread(decode_thread, is);

    if (!is->parse_tid) {

        av_free(is);

        return -1;

    }



    for (;;) {

        SDL_WaitEvent(&event);

        switch(event.type) {

        case FF_QUIT_EVENT:

        case SDL_QUIT:

            SDL_CondSignal(is->audioq.cond);

            SDL_CondSignal(is->videoq.cond);

            is->quit = 1;

            SDL_Quit();

            return 0;

            break;

        case FF_ALLOC_EVENT:

            alloc_picture(event.user.data1);

            break;



        case FF_REFRESH_EVENT:

            video_refresh_timer(event.user.data1);

            break;

        }

    }



    return EXIT_SUCCESS;

}

 

 

 

总结：本文就是调用 SDL_CreateThread创建一个decode_thread，并给一个执行函数用来处理相应动作，比如解码数据，得到解码的packet之后根据当前是video还是audio分别创建video_thread和audio_thread(SDL_PauseAudio()会创建一个线程，此处简单认为为audio_thread)来处理相应的排队与展示动作。