我的ffmpeg开源项目地址Viktor_ffmpeg
该项目主要以学习ffmpeg为主,代码中将ffplay摘抄出来（主要去除了sdl，使用c++的std），用自己的方式实现(面向对象)。
从该项目中你可以学到
1.如何使用ffmpeg解码视频并播放
2.如何多个视频串行播放
该项目是以剪映的功能为目标

ffplay源码中多处用到serial概念，用于区分是否连续的数据。

serial主要存在于如下几个ffplay的结构体中

typedef struct MyAVPacketList {
    AVPacket pkt;
    struct MyAVPacketList *next;
    int serial;
} MyAVPacketList;

typedef struct PacketQueue {
    MyAVPacketList *first_pkt, *last_pkt;
    .....
    int serial;
    .....
} PacketQueue;

typedef struct Decoder {
    .....
    int pkt_serial;
    .....
} Decoder;

typedef struct Clock {
    .....
    int serial;           /* clock is based on a packet with this serial */
    .....
    int *queue_serial;    /* pointer to the current packet queue serial, used for obsolete clock detection */
} Clock;


typedef struct Frame {
    .....
    int serial;
    double pts;           /* presentation timestamp for the frame 帧的表示时间戳，即相对总时长的偏移位置*/
    double duration;      /* estimated duration of the frame 帧的估计持续时间*/
    int64_t pos;          /* byte position of the frame in the input file 帧的字节位置*/
    .....
} Frame;

typedef struct VideoState {
    .....
    int audio_clock_serial;
    .....
}

首先分析PacketQueue和MyAVPacketList中的serial

所有结构体中的serial的赋值、更改都是由这两个结构体中的serial更改开始或者引起的。

PacketQueue.serial == MyAVPacketList.serial

在 packet_queue_put_private方法中，保证二者相等，并且二者的值的改变永远在该方法中。

static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
{
    MyAVPacketList *pkt1;
    .....
    //如果放入的是flush_pkt，需要增加 队列的序列号，以区分不连续的两段数据
    if (pkt == &flush_pkt)
        q->serial++;
    pkt1->serial = q->serial;//用队列的序列号 标记节点
    .....
    return 0;
}

什么情况下PacketQueue.serial 和MyAVPacketList.serial的值会更改？？

static void packet_queue_start(PacketQueue *q)
{
     .....
    /**
     这里放入了一个flush_pkt
     fush_pkt定义是static AVPacket flush_pkt;
     是一个特殊的packet，主要用来作为非连续的两端数据的“分界”标记
     */
    packet_queue_put_private(q, &flush_pkt);
    .....
}


static int packet_queue_put(PacketQueue *q, AVPacket *pkt)
{
    int ret;
    .....
    ret = packet_queue_put_private(q, pkt);
    .....
    if (pkt != &flush_pkt && ret < 0)
        av_packet_unref(pkt);
    return ret;
}

这2个方法packet_queue_start、packet_queue_put分别在如下情况调用
packet_queue_start：
在stream_component_open中的switch case语句中会依次打开video,auido,subtitle开始解码：decoder_start---->packet_queue_start
即开始解码时，会往各自的PacketQueue中放入一个flush_pkt

packet_queue_put:
packet_queue_put方法被调用的地方很多，主要看read_thread方法中后面的for语句中seek相关操作。在seek成功后，会先调用packet_queue_flush清除PacketQueue的缓存，然后调用packet_queue_put往PacketQueue中放入一个flush_pkt，标记发生一次seek

if (is->seek_req) {
    .....
    ret = avformat_seek_file(is->ic, -1, seek_min, seek_target, seek_max, is->seek_flags);
    if (ret < 0) {
        av_log(NULL, AV_LOG_ERROR,
                "%s: error while seeking\n", is->ic->url);
    } else {
        /*
        1.清除PacketQueue的缓存，并放入一个flush_pkt。放入的flush_pkt可以让PacketQueue的serial增1，以区分seek前后的数据
        2.同步外部时钟
        */
        if (is->audio_stream >= 0) {
            packet_queue_flush(&is->audioq);
            packet_queue_put(&is->audioq, &flush_pkt);
        }
        if (is->subtitle_stream >= 0) {
            packet_queue_flush(&is->subtitleq);
            packet_queue_put(&is->subtitleq, &flush_pkt);
        }
        if (is->video_stream >= 0) {
            packet_queue_flush(&is->videoq);
            packet_queue_put(&is->videoq, &flush_pkt);
        }
        .....
    }
    .....
}

分析到这里可以看出：
serial值的改变都是因为放入一个flush_pkt导致！
放入flush_pkt时机：
1.一个是在开始解码时，会往各自的PacketQueue中放入一个flush_pkt，导致serial初次更改，此时serial=1;
2.其他的改变都是在seek成功后清除了PacketQueue数据后放入一个flush_pkt，并且都是累加，例如运行起来后，seek了一次，这时serial=2

Decoder.pkt_serial

Decoder.pkt_serial的赋值在packet_queue_get方法中
decoder_decode_frame--->do while(1)---->if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial)
在video，audio，subtitle3个解码线程各自解码时，即decoder_decode_frame方法中的do while(1)语句中，从各自的PacketQueue中获取AVPacket时给Decoder.pkt_serial赋值的，

do {     
    if (d->queue->nb_packets == 0)
        .....
    if (d->packet_pending) {
        
    } else {
        if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial) < 0)
            return -1;
    }
    if (d->queue->serial == d->pkt_serial)
        break;
    av_packet_unref(&pkt);
} while (1);
----------------------------
static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
{
    MyAVPacketList *pkt1;
    .....
    for (;;) {
            .....
            if (serial)//如果需要输出serial，把serial输出
                *serial = pkt1->serial;
            av_free(pkt1);
            .....
        } else if (!block) {
           .....
        } else {
            .....
        }
    }
    .....
    return ret;
}

那么Decoder的pkt_serial的作用，或者pkt_serial都用在什么地方呢？

1.在decoder_decode_frame方法中比较是否一个连续的流"d->queue->serial == d->pkt_serial"
2.在decoder_decode_frame方法中取一个packet的do while中packet_queue_get方法中赋值，然后比较是否同一个流之后跳出do while
3.在get_video_frame方法中，丢帧处理时做if条件判断使用is->viddec.pkt_serial == is->vidclk.serial
4.在audio_thread中给Frame.serial赋值 af->serial = is->auddec.pkt_serial
5.在vidoe_thread的queue_picture方法中给Frame.serial赋值 vp->serial = serial
6.在subtitle_thread中给Frame.serial赋值 sp->serial = is->subdec.pkt_serial
7.在decoder_decode_frame方法中给Decoder.finished赋值

关于Decoder.finished赋值主要也在decoder_decode_frame方法中，
一次是解码完成时：d->finished = d->pkt_serial
一次是：d->finished = 0（过滤掉flush_pkt这种无效数据）

Decoder.finished主要作用在read_thread方法中判断是否播放完成，决定是要循环播放还是退出，
例如is->auddec.finished == is->audioq.serial
关于Decoder.finished在read_thread方法判断是否播放完成，可以如下追踪finished的来源decoder_decode_frame-->packet_queue_get(PacketQueue.serial-->MyAVPacketList.serial-->Decoder.pkt_serial-->Decoder.finished) -->read_thread-->is->auddec.finished == is->audioq.serial && is->viddec.finished == is->videoq.serial)

Frame.serial

来自于：
1.视频-->video_thread解码---->queue_picture入队----->is->viddec.pkt_serial----->vp->serial = serial
2.音频-->audio_thread解码---->frame入队列---->af->serial = is->auddec.pkt_serial'
3.文字-->subtitle_thread解码---->frame入队列---->sp->serial = is->subdec.pkt_serial
即Frame的serial来自音频，视频，文字解码时赋值，并且都是来自各自的解码Decoder.pkt_serial:
PacketQueue.serial-->MyAVPacketList.serial-->Decoder.pkt_serial-->Frame.serial

作用：
1.frame_queue_last_pos 条件判断是否同流
2.video_refresh 中:
----a.vp->serial != is->videoq.serial条件判断，标记一个节点已经被读过
----b.lastvp->serial != vp->serial 条件判断，更新VideoState.frame_timer
----c.update_video_pts 用于给视频时钟和外部时钟更新serial(见Clock.serial分析)
----d.vp_duration 条件判断是否同流
----e.字幕展示逻辑中，条件判断是否同流
3.sdl_audio_callback-->audio_decode_frame-->do while中做条件判断4.sdl_audio_callback-->audio_decode_frame---->is->audio_clock_serial = af->serial给audio_clock_serial赋值
其实最主要作用就是更新Clock.serial

Clock.serial和Clock.queue_serial

在set_clock_at中赋值：set_clock-->set_clock_at
set_clock方法主要被调用关键点:
1.read_thread中seek成功后给extclk.serial=0(即seek成功后将同步外部时钟extclk.serial清0)
2.set_clock_speed-->set_clock方法改变速度时，给外部时钟extclk.serial赋值，即自己给自己赋值
3.stream_toggle_pause-->set_clock方法暂停播放时，给vidclk,extclk各自的serial赋值，即自己给自己赋值
4.update_video_pts-->set_clock和sync_clock_to_slave(video_refresh视频)
sdl_audio_callback->set_clock和sync_clock_to_slave(sdl_audio_callback音频)sync_clock_to_slave-->set_clock即音频，视频各自的时钟同步到extclk

作用：
1.get_clock中用于判断Clock中的serial是否同一个流（*c->queue_serial != c->serial）
2.在get_video_frame方法中，丢帧处理时做if条件判断使用is->viddec.pkt_serial == is->vidclk.serial

Clock.queue_serial
(在init_clock中赋值，来自于PacketQueue.serial的地址，即指针，所以在packet_queue_put_private中给
PacketQueue.serial赋值，即给Clock.queue_serial赋值
作用：get_clock中用于判断Clock中的serial是否同一个流（*c->queue_serial != c->serial)

VideoState.audio_clock_serial

audio_clock_serial感觉比较鸡肋，这个值就是给音频重采样完成后同步audclk中的serial中使用的(即调用set_clock_at方法)。
sdl_audio_callback-->audio_decode_frame
1.在audio_decode_frame中使用Frame结构体中的serial给audio_clock_serial赋值(is->audio_clock_serial = af->serial);
2.回到sdl_audio_callback后去同步audclk时再用audio_clock_serial给audclk.serial赋值。

视频同步时钟直接调用update_video_pts，使用的serial就是来自Frame.serial

而音频同步却绕了一步，将Frame.serial赋值给audio_clock_serial，再在sdl_audio_callback中使用audio_clock_serial去同步时钟。
这里考虑的原因可能是sdl_audio_callback方法是opensles中调用的，在sdl_audio_callback方法中获取不到Frame,所以采用这种方式。

整理！！

先让我们整理下整个流程，ffplay的main函数是入口函数！
main-->stream_open
stream_open会启动一个read_thread线程，
在read_thread中干了2件大事

1.启动3个流(video，audio，subtitle)stream_component_open。
2.for循环去读取AVPacket,将AVPacket放入3个流各自的PacketQueue中。
接着3个流各自的stream_component_open中又启动了线程：
video_thread，audio_thread,subtitle_thread
到这里为止，共启动了4个线程
1.read_thread（主要读取AVPacket，存入3个流的PacketQueue中）
2.video_thread--->get_video_frame--->decoder_decode_frame
3.audio_thread--->decoder_decode_frame
4.subtitle_thread--->decoder_decode_frame

video_thread，audio_thread,subtitle_thread 3个线程都调用了decoder_decode_frame方法去解码,
就是将read_thread中for循环读取的AVPacket取出去解码，然后将解码后的Frame放入3个流各自的FrameQueue中

关于展示画面和播放声音

main-->event_loop-->refresh_loop_wait_event--->video_refresh
在video_refresh中不停的去视频对应的FrameQueue中获取AVFrame去显示

至于声音播放是在音频的stream_component_open--->audio_open---->打开了opensles去播放音频，opensles会不停的调用sdl_audio_callback
sdl_audio_callback--->audio_decode_frame(重采样)

image.png

整个流程主要是这些，回到主题，分析serial！
在3个流的stream_component_open中，都有

decoder_init--->d->queue = queue和d->pkt_serial = -1
decoder_start--->packet_queue_start:会将一个flush_pkt放入到视频PacketQueue中，且这时PacketQueue.serial == MyAVPacketList.serial == 1

(注意这里我们只分析视频流，另外2个流几乎相同，暂不分析)
此时PacketQueue.serial == MyAVPacketList.serial == 1，Decoder.pkt_serial = -1
当read_thread正常启动，正常读取一个AVPacket，假设为avPacket1存入PacketQueue中（记住此时PacketQueue.first_pkt==flush_pkt，PacketQueue.last_pkt==avPacket1）
目前为止
PacketQueue.serial == MyAVPacketList.serial == 1，Decoder.pkt_serial = -1
PacketQueue中的first_pkt==flush_pkt和last_pkt==avPacket1两个MyAVPacketList的serial都是1

同时video_thread运行
video_thread中的for循环启动--->get_video_frame--->decoder_decode_frame

static int decoder_decode_frame(Decoder *d, AVFrame *frame, AVSubtitle *sub) {
    int ret = AVERROR(EAGAIN);
    for (;;) {
        AVPacket pkt;
        .....
        if (d->queue->serial == d->pkt_serial) {
            do {
                if (d->queue->abort_request)
                    return -1;

                switch (d->avctx->codec_type) {
                    case AVMEDIA_TYPE_VIDEO:
                        ret = avcodec_receive_frame(d->avctx, frame);
                        if (ret >= 0) {
                            if (decoder_reorder_pts == -1) {
                                frame->pts = frame->best_effort_timestamp;
                            } else if (!decoder_reorder_pts) {
                                frame->pts = frame->pkt_dts;
                            }
                        }
                        break;
                    case AVMEDIA_TYPE_AUDIO:
                        ....
                        break;
                }
                if (ret == AVERROR_EOF) {
                    d->finished = d->pkt_serial;
                    avcodec_flush_buffers(d->avctx);
                    return 0;
                }
                if (ret >= 0)
                    return 1;
            } while (ret != AVERROR(EAGAIN));
        }

        do {
            if (d->queue->nb_packets == 0)
                SDL_CondSignal(d->empty_queue_cond);
            if (d->packet_pending) {//如果有待重发的pkt，则先取待重发的pkt
                av_packet_move_ref(&pkt, &d->pkt);
                d->packet_pending = 0;
            } else {
                if (packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial) < 0)
                    return -1;
            }
            if (d->queue->serial == d->pkt_serial)
                break;
            av_packet_unref(&pkt);
        } while (1);

        if (pkt.data == flush_pkt.data) {
            avcodec_flush_buffers(d->avctx);
            d->finished = 0;
            d->next_pts = d->start_pts;
            d->next_pts_tb = d->start_pts_tb;
        } else {
            if (d->avctx->codec_type == AVMEDIA_TYPE_SUBTITLE) {
                .....
            } else {
                if (avcodec_send_packet(d->avctx, &pkt) == AVERROR(EAGAIN)) {
                    d->packet_pending = 1;
                    av_packet_move_ref(&d->pkt, &pkt);
                }
            }
            av_packet_unref(&pkt);
        }
    }
}

decoder_decode_frame方法：
第一次进入该方法，for循环开始，
1.if (d->queue->serial == d->pkt_serial)不满足，因为上面的PacketQueue.serial=1，Decoder.pkt_serial = -1
2.接着走do while(1)--->packet_queue_get(d->queue, &pkt, 1, &d->pkt_serial),取出数据,该数据为flush_pkt，重点！！！这时在packet_queue_get方法中Decoder.pkt_serial已经为1了
3.继续进入下面的if判断，因为是flush_pkt，所以执行avcodec_flush_buffers，d->finished = 0等操作

第2次for循环
1.if (d->queue->serial == d->pkt_serial)满足，因为此时PacketQueue.serial=1，Decoder.pkt_serial = 1
2.进入do while (ret != AVERROR(EAGAIN))---->avcodec_receive_frame,去获取解码后的数据，这时ret==AVERROR(EAGAIN)，可以看下avcodec_receive_frame方法返回值说明
，AVERROR(EAGAIN)说明（output is not available in this state - user must try to send new input，大致意思就是这个状态下表明输入端还么有数据，就是avcodec_send_packet还没有输入数据）
3.跳出do while(ret != AVERROR(EAGAIN))，接着执行下面的do while (1)获取一个AVPacket,此时是avPacket1
4.执行下面的if判断，走else，然后将数据通过avcodec_send_packet输入
（这里多说一句，如果avcodec_send_packet返回AVERROR(EAGAIN)，说明输出端应该及时调用avcodec_receive_frame读取数据，然后再重新发送一次该AVPacket。
可以看到，d->packet_pending = 1，然后do while(1)逻辑中
if (d->packet_pending)也是将数据再次赋值，而不是从packet_queue_get中获取)

第3次for循环
1.if (d->queue->serial == d->pkt_serial)满足，因为此时PacketQueue.serial=1，Decoder.pkt_serial = 1
2.进入do while (ret != AVERROR(EAGAIN))---->avcodec_receive_frame,去获取解码后的数据，此时正常逻辑ret==0，跳出整个for循环，decoder_decode_frame方法返回

综上decoder_decode_frame---->get_video_frame--->video_thread将解码得到的AVFrame存入FrameQueue---->queue_picture(....., is->viddec.pkt_serial)
---->Frame.serial=viddec.pkt_serial
到这里video_thread中的for循环已经走了一遍，此时总结下

PacketQueue.serial == MyAVPacketList.serial == 1，Decoder.pkt_serial == 1，存入FrameQueue中的Frame.serial=1
然后video_thread中的for循环一直执行，不停从PacketQueue中获取AVPacket去解码然后存入FrameQueue

到目前为止只剩下Clock的serial还未赋值(audclk,vidclk,extclk)
这个肯定是在去展示画面或者播放音频的时候去赋值的

1.在video_refresh--->update_video_pts--->set_clock_at和sync_clock_to_slave，会分别给vidclk.serial和extclk.serial赋值
2.在音频播放过程中sdl_audio_callback--->set_clock_at和sync_clock_to_slave，会分别给audclk.serial和extclk.serial赋值
并且赋值的serial都是来自Frame.serial，目前都是1

这时如果发生seek操作，那么上面说的read_thread线程中for循环读取AVPacket过程中，会检查是否有seek操作，一旦有就会将3个流各自的PacketQueue清空(不会清空PacketQueue.serial)，并放入一个flush_pkt，且serial++。

此时PacketQueue.serial == MyAVPacketList.serial == 2,并且for循环继续往下执行读取AVPacket,假设此时读取一个AVPacket为avPacket2存入PacketQueue中
（记住此时PacketQueue.first_pkt==flush_pkt，PacketQueue.last_pkt==avPacket2）

目前因为seek操作之后
PacketQueue.serial == MyAVPacketList.serial == 2，Decoder.pkt_serial = 1
PacketQueue中的first_pkt==flush_pkt和last_pkt==avPacket2两个MyAVPacketList的serial都是2

3个流的decoder_decode_frame方法还在继续执行，关于decoder_decode_frame方法的再次for循环不用在分析了，和上面逻辑是一样的