ijkplayer源码分析 FrameQueue分析

Posted 2022-12-15 baiiu

前言

上一篇文章介绍了PacketQueue，本文介绍FrameQueue。

FrameQueue结构体

1. FrameQueue结构体，持有queue数组，是基于环形队列实现的；
2. rindex、windex、size、max_size和等待唤醒机制获取读写位置，利用环形队列最大限度节约了空间；
3. 默认队列大小为16，最后由max_size = Math.min(max_size，FRAME_QUEUE_SIZE)来决定最大的元素个数；
4. 其中keep_last表示是否保留上一个可读节点，在frame_queue_next中起作用，如果保留，则会设置rindex_shown为1，表示上一个结点是已读的。即队列中将会存储两个节点，上一个已读的和现在rindex指向的未读结点。

#define FRAME_QUEUE_SIZE 16
typedef struct Frame 
    AVFrame *frame; // 视频或音频
    AVSubtitle sub;     // 字幕
    int serial;
    SDL_VoutOverlay *bmp;
    // ...
 Frame;

typedef struct FrameQueue 
    Frame queue[FRAME_QUEUE_SIZE];
    int rindex;  // 读指针
    int windex; // 写指针
    int size;      //  当前队列个数
    int max_size;   // 队列最大容量
    int keep_last;  // 是否保留上一个可读节点，在frame_queue_next中起作用
    int rindex_shown;  // 当前节点是否已经展示，队列中还要存储上一个已读节点
    SDL_mutex *mutex;
    SDL_cond *cond;
    PacketQueue *pktq;
 FrameQueue;

FrameQueue API介绍

frame_queue_init：初始化队列，设置max_size，av_frame_alloc初始化所有元素

frame_queue_peek_writable：获取
frame_queue_push：向下移动一格可写指针，可以认为将该元素放入队列中

frame_queue_peek_readable：阻塞式获取可读节点
frame_queue_next：移动到下一格可读节点，–size
frame_queue_unref_item：释放节点

frame_queue_nb_remaining：获取当前队列元素数量
frame_queue_peek：获取当前可读节点
frame_queue_peek_last：获取上一个已读节点
frame_queue_peek_next：获取下一个可读节点

frame_queue_signal：唤醒队列中条件锁
frame_queue_destory：释放队列中所有元素

初始化

在stream_open中调用，
video的max_size是3，keep_last为1；字幕是16，keep_last为0；音频是9，keep_last为1，表示保留上一个节点；

static int frame_queue_init(FrameQueue *f, PacketQueue *pktq, int max_size, int keep_last) 
    int i;
    memset(f, 0, sizeof(FrameQueue));
    f->mutex = SDL_CreateMutex();
    f->cond = SDL_CreateCond();

    f->pktq = pktq;
    f->max_size = FFMIN(max_size, FRAME_QUEUE_SIZE);
    f->keep_last = !!keep_last; // 两个非符号，表示将传入的值规整到1或0， !!10 = 1， !!0 = 0;
    for (i = 0; i < f->max_size; i++) 
       f->queue[i].frame = av_frame_alloc())
    
    return 0;

put操作

通过frame_queue_peek_writable获取一个可写位置，如果队列已满size >= max_size，则阻塞等待；
获取到Frame后填充Frame内部数据；
然后再frame_queue_push进队列中，将++windex，++size，若windex到最后一个位置，则重置到第0个位置；

static Frame *frame_queue_peek_writable(FrameQueue *f) 
    // 等待有位置出来
    SDL_LockMutex(f->mutex);
    while (f->size >= f->max_size && !f->pktq->abort_request) 
        SDL_CondWait(f->cond, f->mutex);
    
    SDL_UnlockMutex(f->mutex);

    if (f->pktq->abort_request) 
        return NULL;
    

    // 获取windex位置
    return &f->queue[f->windex];


static void frame_queue_push(FrameQueue *f) 
    if (++f->windex == f->max_size)
        f->windex = 0;
    SDL_LockMutex(f->mutex);
    f->size++;
    SDL_CondSignal(f->cond);
    SDL_UnlockMutex(f->mutex);

阻塞式获取元素

通过frame_queue_peek_readable获取可读节点位置，读取数据后再通过frame_queue_next移动到下一个元素。
首次读取时f->rindex_shown为0，rindex也为0，调用frame_queue_next后rindex_shown为1；
再次读取时，rindex为 0，rindex_shown为1，满足size条件的话将会读取1节点，调用frame_queue_next后rindex为1，向前移动一个位置；

//  阻塞式获取可读节点
static Frame *frame_queue_peek_readable(FrameQueue *f) 
    /* 
      *等待有位置可读，size - rindex_shown为条件，即当前可读节点数量
      *上面也说过了当rindex_shown为1时队列里讲保持两个节点，一个未读和上一个已读的。
      */
    SDL_LockMutex(f->mutex);
    while (f->size - f->rindex_shown <= 0 && !f->pktq->abort_request) 
        SDL_CondWait(f->cond, f->mutex);
    
    SDL_UnlockMutex(f->mutex);

    if (f->pktq->abort_request) 
        return NULL;
    

    return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];


// 向下移动一格，释放当前元素后向下移动一格
static void frame_queue_next(FrameQueue *f) 
    if (f->keep_last && !f->rindex_shown) 
        f->rindex_shown = 1;
        return;
    
    frame_queue_unref_item(&f->queue[f->rindex]);
    if (++f->rindex == f->max_size)
        f->rindex = 0;
    SDL_LockMutex(f->mutex);
    f->size--;
    SDL_CondSignal(f->cond);
    SDL_UnlockMutex(f->mutex);


// 释放上一个节点
static void frame_queue_unref_item(Frame *vp) 
    av_frame_unref(vp->frame);
    SDL_VoutUnrefYUVOverlay(vp->bmp);
    avsubtitle_free(&vp->sub);

非阻塞式获取队列信息

// 获取队列可读节点数量
static int frame_queue_nb_remaining(FrameQueue *f) 
    return f->size - f->rindex_shown;


// peek当前可读节点
static Frame *frame_queue_peek(FrameQueue *f) 
    return &f->queue[(f->rindex + f->rindex_shown) % f->max_size];


// peek下一个可读节点
static Frame *frame_queue_peek_next(FrameQueue *f) 
    return &f->queue[(f->rindex + f->rindex_shown + 1) % f->max_size];


// peek上一个已读节点
static Frame *frame_queue_peek_last(FrameQueue *f) 
    return &f->queue[f->rindex];

重置、销毁操作

// 在decoder_abort中调用，唤醒所有等待的条件锁
static void frame_queue_signal(FrameQueue *f) 
    SDL_LockMutex(f->mutex);
    SDL_CondSignal(f->cond);
    SDL_UnlockMutex(f->mutex);


// 释放所有节点
static void frame_queue_destory(FrameQueue *f) 
    int i;
    for (i = 0; i < f->max_size; i++) 
        Frame *vp = &f->queue[i];
        frame_queue_unref_item(vp);
        av_frame_free(&vp->frame);
        free_picture(vp);
    
    SDL_DestroyMutex(f->mutex);
    SDL_DestroyCond(f->cond);

参考：
ffplay frame queue分析