ijkplayer源码---PacketQueue

最新推荐文章于 2024-08-07 09:53:33 发布

原总破局

最新推荐文章于 2024-08-07 09:53:33 发布

阅读量787

点赞数

分类专栏： ijkPlayer 文章标签： ffmpeg ijkplayer 链表数据结构

本文链接：https://blog.csdn.net/qq_15255121/article/details/121927094

版权

ijkPlayer 专栏收录该内容

40 篇文章 7 订阅

订阅专栏

我们这篇文章不谈论PacketQueue在ijk哪里用，只从PacketQueue的代码入手

我们先来看两个结构体

typedef struct MyAVPacketList {
    AVPacket pkt;
    struct MyAVPacketList *next;
    int serial;
} MyAVPacketList;
通过结构体可以看到MyAVPacketList是一个链表的结点，每个结点包含解封装出来的AVPacket


typedef struct PacketQueue {
    MyAVPacketList *first_pkt, *last_pkt;    //first_pkt指向MyAVPacketList为节点的头结点，last_pkt指向尾结点
    int nb_packets; //当前有多少AVPacket
    int size; //当前链表和链表中的数据占的内存有多大
    int64_t duration;
    int abort_request;
    int serial;
    SDL_mutex *mutex; //互斥锁
    SDL_cond *cond; //  信号量
    MyAVPacketList *recycle_pkt; //MyAVPacketList的回收链表，避免每次都创建MyAVPacketList，加快运行速度
    int recycle_count; //复用了几个MyAVPacketList
    int alloc_count;

    int is_buffer_indicator;
} PacketQueue;

static int packet_queue_init(PacketQueue *q)
{
    memset(q, 0, sizeof(PacketQueue));
    q->mutex = SDL_CreateMutex();
    if (!q->mutex) {
        av_log(NULL, AV_LOG_FATAL, "SDL_CreateMutex(): %s\n", SDL_GetError());
        return AVERROR(ENOMEM);
    }
    q->cond = SDL_CreateCond();
    if (!q->cond) {
        av_log(NULL, AV_LOG_FATAL, "SDL_CreateCond(): %s\n", SDL_GetError());
        return AVERROR(ENOMEM);
    }
    q->abort_request = 1;
    return 0;
}

初始化就是将PacketQueue中的成员设置为0，创建锁，信号量等

static void packet_queue_start(PacketQueue *q)
{
    SDL_LockMutex(q->mutex);
    q->abort_request = 0;
    packet_queue_put_private(q, &flush_pkt);
    SDL_UnlockMutex(q->mutex);
}

packet_queue_start 在PacketQueue当中先放入flush_pkt

什么是flush_pkt？
av_init_packet(&flush_pkt);
flush_pkt.data = (uint8_t *)&flush_pkt;

data指向了真正的数据
flush_pkt.data = (uint8_t *)&flush_pkt;这说明data指向了自身的AvPacket

我们接下来看packet_queue_put_private

static int packet_queue_put_private(PacketQueue *q, AVPacket *pkt)
{
    MyAVPacketList *pkt1;
	
	//终止请求，那么久不再往PacketQueue中放数据了
    if (q->abort_request)
       return -1;
	   
	//ffplay的源代码是每次都新建一个节点，而ijk做了优化，如果recycle_pkt有可以用的节点那么就使用，如果没有就分配，并且alloc_count加1,

#ifdef FFP_MERGE
    pkt1 = av_malloc(sizeof(MyAVPacketList)); 
#else
    pkt1 = q->recycle_pkt;
    if (pkt1) {
        q->recycle_pkt = pkt1->next;
        q->recycle_count++;
    } else {
        q->alloc_count++;
        pkt1 = av_malloc(sizeof(MyAVPacketList));
    }

#ifdef FFP_SHOW_PKT_RECYCLE
    int total_count = q->recycle_count + q->alloc_count;
    if (!(total_count % 50)) {
        av_log(ffp, AV_LOG_DEBUG, "pkt-recycle \t%d + \t%d = \t%d\n", q->recycle_count, q->alloc_count, total_count);
    }
#endif
#endif
    if (!pkt1)
        return -1;
    pkt1->pkt = *pkt;
    pkt1->next = NULL;
	//如果当前是flush_pkt，那么就serial++
    if (pkt == &flush_pkt)
        q->serial++;
    pkt1->serial = q->serial;
	
	
	如果是第一个节点，那么就为first_pkt赋值
    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 + sizeof(*pkt1); //当前链表当中的数据占多少内存

    q->duration += FFMAX(pkt1->pkt.duration, MIN_PKT_DURATION); //当前的链表能播放多长时间

    /* XXX: should duplicate packet data in DV case */
    SDL_CondSignal(q->cond);
    return 0;
}

通过上面我们可以知道最后形成的链表应该是这样的、

static void packet_queue_flush(PacketQueue *q)
{
    MyAVPacketList *pkt, *pkt1;

    SDL_LockMutex(q->mutex);
    for (pkt = q->first_pkt; pkt; pkt = pkt1) {
        pkt1 = pkt->next;
        av_packet_unref(&pkt->pkt);
#ifdef FFP_MERGE
        av_freep(&pkt);
#else
        pkt->next = q->recycle_pkt;
        q->recycle_pkt = pkt;
#endif
    }
    q->last_pkt = NULL;
    q->first_pkt = NULL;
    q->nb_packets = 0;
    q->size = 0;
    q->duration = 0;
    SDL_UnlockMutex(q->mutex);
}

//看代码就是把PacketQueue中的first_pkt链表中的AVPacket释放，并把MyAVPacketList节点放入recycle_pkt，其他字段置为0

static void packet_queue_destroy(PacketQueue *q)
{
//把PacketQueue中的first_pkt链表中的AVPacket释放，并把MyAVPacketList节点放入recycle_pkt，其他字段置为0
    packet_queue_flush(q);

    SDL_LockMutex(q->mutex);
	//释放所有的recycle_pkt中的节点
    while(q->recycle_pkt) {
        MyAVPacketList *pkt = q->recycle_pkt;
        if (pkt)
            q->recycle_pkt = pkt->next;
        av_freep(&pkt);
    }
    SDL_UnlockMutex(q->mutex);

    SDL_DestroyMutex(q->mutex);
    SDL_DestroyCond(q->cond);
}

static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block, int *serial)
{
    MyAVPacketList *pkt1;
    int ret;

    SDL_LockMutex(q->mutex);

    for (;;) {
        if (q->abort_request) {
            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 + sizeof(*pkt1);
            q->duration -= FFMAX(pkt1->pkt.duration, MIN_PKT_DURATION);
            *pkt = pkt1->pkt;
            if (serial)
                *serial = pkt1->serial;
#ifdef FFP_MERGE
            av_free(pkt1);
#else
            pkt1->next = q->recycle_pkt;
            q->recycle_pkt = pkt1;
#endif
            ret = 1;
            break;
        } else if (!block) {
            ret = 0;
            break;
        } else {
            SDL_CondWait(q->cond, q->mutex);
        }
    }
    SDL_UnlockMutex(q->mutex);
    return ret;
}


//

static int packet_queue_get_or_buffering(FFPlayer *ffp, PacketQueue *q, AVPacket *pkt, int *serial, int *finished)
{
    assert(finished);
    if (!ffp->packet_buffering)
        return packet_queue_get(q, pkt, 1, serial);

    while (1) {
        int new_packet = packet_queue_get(q, pkt, 0, serial);
        if (new_packet < 0)
            return -1;
        else if (new_packet == 0) {
            if (q->is_buffer_indicator && !*finished)
                ffp_toggle_buffering(ffp, 1);
            new_packet = packet_queue_get(q, pkt, 1, serial);
            if (new_packet < 0)
                return -1;
        }

        if (*finished == *serial) {
            av_packet_unref(pkt);
            continue;
        }
        else
            break;
    }

    return 1;
}

//取出first_pkt指向的节点对应的AVPacket，并把释放的MyAVPacketList放入recycle_pkt

static int packet_queue_put_nullpacket(PacketQueue *q, int stream_index)
{
    AVPacket pkt1, *pkt = &pkt1;
    av_init_packet(pkt);
    pkt->data = NULL;
    pkt->size = 0;
    pkt->stream_index = stream_index;
    return packet_queue_put(q, pkt);
}

//队列中放入一个AVPacket的data为null的数据