ffmpeg历史垃圾桶中的AVFifoBuffer源码分析

typedef struct AVFifoBuffer {
    uint8_t *buffer;//缓冲区地址
    uint8_t *rptr, *wptr, *end;//读指针，写指针，以及尾巴
    uint32_t rndx, wndx;//用于记录写了多少个字节，读了多少个字节
} AVFifoBuffer;

/* 初始化一个 AVFifoBuffer

@参数 size: FIFO的尺寸，实际是FIFO中buffer的大小

@返回值 成功则返回指向 AVFifoBuffer的指针，否则返回NULL

*/

AVFifoBuffer *av_fifo_alloc(unsigned int size)
{
    //可以看出是先分配buffer的内存，然后再分配AVFifoBuffer内存
    //原因可能是考虑到buffer内存有可能会很大，
    //存在更多分配失败的可能，便于错误处理
    //注意av_malloc与malloc的区别，av_malloc会进行内存对齐
    void *buffer = av_malloc(size);
    return fifo_alloc_common(buffer, size);
}

//主要分配AVFifoBuffer本身内存，及部分参数赋值
//独立出此函数，是为了与接下来的av_fifo_alloc_array复用部分代码
//参数buffer表示已分配的buffer指针，size为传入的FIFO大小参数
static AVFifoBuffer *fifo_alloc_common(void *buffer, size_t size)
{
    AVFifoBuffer *f; 
    if (!buffer)
        return NULL;
    f = av_mallocz(sizeof(AVFifoBuffer));
    if (!f) {
        av_free(buffer);
        return NULL;
    }
    f->buffer = buffer;        //size字节的buffer
    f->end    = f->buffer + size;  //buffer一共size个字节，所以end指向了buffer的尾巴
    av_fifo_reset(f);        //部分参数初始化
    return f;
}
void av_fifo_reset(AVFifoBuffer *f)
{
    //初始化参数，此时没有任何数据，所以读指针，写指针与buffer一致
    f->wptr = f->rptr = f->buffer;
    //初始时没读也没写，均为0
    f->wndx = f->rndx = 0;
}

/**  * 初始化一个AVFifoBuffer，区别是此时的buffer大小不是直接使用size来分配，而是使用单个元素大小乘以元素个数的方式.

* @param nmemb:元素个数

* @param size :单个元素的字节数

* @返回值 成功则返回指向 AVFifoBuffer的指针，否则返回NULL

*/

AVFifoBuffer *av_fifo_alloc_array(size_t nmemb, size_t size)
{
    //先来看av_malloc_array
    void *buffer = av_malloc_array(nmemb, size);
    return fifo_alloc_common(buffer, nmemb * size);
}
//本质还是调用的av_malloc,区别是多了个av_size_mult操作
void *av_malloc_array(size_t nmemb, size_t size)
{
    size_t result;
    //重点看这个函数
    if (av_size_mult(nmemb, size, &result) < 0)
        return NULL;
    return av_malloc(result);
}

//检查两个数字相乘会不会溢出
//因为比较复杂，在正文中分析
static inline int av_size_mult(size_t a, size_t b, size_t *r)
{
    size_t t = a * b;
    /* Hack inspired from glibc: don't try the division if nelem and elsize
     * are both less than sqrt(SIZE_MAX). */
    if ((a | b) >= ((size_t)1 << (sizeof(size_t) * 4)) && a && t / a != b)
        return AVERROR(EINVAL);
    *r = t;
    return 0;
}

void av_fifo_free(AVFifoBuffer *f)
{
    if (f) {
      //释放buffer内存，并把buffer指针置null
      //这里重点看下到底是怎么把buffer指针置null的
        av_freep(&f->buffer);
        av_free(f);      //释放AVFifoBuffer内存
    }
}
//注意这里传入的是个二级指针，即指向指针的指针
void av_freep(void *arg)
{
    void *val;

    memcpy(&val, arg, sizeof(val));
    //这里用到了C99的语法，Compound Literals
    memcpy(arg, &(void *){ NULL }, sizeof(val));
    av_free(val);
}

void av_fifo_freep(AVFifoBuffer **f)
{
    if (f) {
        av_fifo_free(*f);  //调用av_fifo_free
        *f = NULL;      //多了一个指针置null的操作
    }
}

/**  * 返回buffer中还有多少字节可以读  */

int av_fifo_size(const AVFifoBuffer *f)
{
    //看图就好了，表示写了还没读的，就是有多少字节可以读
    return (uint32_t)(f->wndx - f->rndx);
}

/** 返回还有多少字节可用来写  */

int av_fifo_space(const AVFifoBuffer *f)
{
    //f->end - f->buffer是buffer的总大小
    //av_fifo_size(f)是多少字节可读，即已经写进去的字节数
    //总的减去已经写进去多少，等于还有多少可以写
    return f->end - f->buffer - av_fifo_size(f);
}

/**  * 扩充一个AVFifoBuffer.

* 为防止重新分配内存失败, 老的fifo保持不变.

* 扩充大小有一定的规则，所以新的fifo大小可能大于需要的大小.

* @param f :待扩充的AVFifoBuffer

* @param additional_space，需要额外扩充的字节数

 * @return <0 for failure, >=0 otherwise

*/
int av_fifo_grow(AVFifoBuffer *f, unsigned int size)
{
    //old_size实际为原来可用的总空间
    unsigned int old_size = f->end - f->buffer;
    if(size + (unsigned)av_fifo_size(f) < size) //防止超过u32范围
        return AVERROR(EINVAL);
    //入参size为需要扩充的字节数，新的空间大小 = size + 已经写入了的字节数
    size += av_fifo_size(f);

    //比如原来有120字节空间，已经写了30个，希望扩展60个，此时一共需要90个字节，
    //但是原来就有120个了，此时就不需要再扩展了，如果希望扩展100个字节
    //此时一同需要130个字节，原来的空间120个是不够的，则进入重新分配内存的流程
    if (old_size < size)
        //原来的总空间小于扩展后的总空间,则需要重新分配内存
        return av_fifo_realloc2(f, FFMAX(size, 2*old_size));
    //若原来的总空间就比新空间大，则不需要分配内存,直接返回即可
    return 0;
}

//修改AVFifoBuffer的大小
//传入的参数new_size是希望AVFifoBuffer变成的大小
int av_fifo_realloc2(AVFifoBuffer *f, unsigned int new_size)
{
    //之前的总大小
    unsigned int old_size = f->end - f->buffer;
    //通常都是小于new_size,否则的话直接不需要扩容
    if (old_size < new_size) {
        //已经写入的大小，也就是可以读取的大小
        int len          = av_fifo_size(f);
        //按照新的大小分配一个新的
        AVFifoBuffer *f2 = av_fifo_alloc(new_size);
        if (!f2)
            return AVERROR(ENOMEM);
        //把原来f中的已经写入的拷贝到新的buffer中
        av_fifo_generic_read(f, f2->buffer, len, NULL);
        f2->wptr += len;
        f2->wndx += len;
        //这里把原来的buffer释放掉
        av_free(f->buffer);
        //这里直接把新分配的AVFifoBuffer替换掉了原来的AVFifoBuffer，
        //用户看着好像什么都没发生，其实已经被偷偷换成了复制品
        *f = *f2;
        //把AVFifoBuffer本身的内存释放掉，不会影响到buffer
        av_free(f2);
    }
    return 0;
}

/**  

* 从一个AVFifoBuffer中把buffer取出buf_size的长度交给func回调处理，如果func为空就直接复制到dest中  

* @param f:要读取的AVFifoBuffer  

* @param 将要读取的数据大小  

* @param func 用户自定义的回调函数   

* @param dest 目标内存地址  

*/ 
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size,
                         void (*func)(void *, void *, int))
{
// Read memory barrier needed for SMP here in theory
    do {
        //取两者之间较小值是为了防止读时越界，
        //这里越界是不要越过0点位置，0点前后分开处理
        //原因是两个地址不一样，需要手动拨回
        int len = FFMIN(f->end - f->rptr, buf_size);
        //只有在func有定义的时候才执行，且跟memcpy是互斥的
        if (func)
            func(dest, f->rptr, len);
        else {
            //直接拷贝len长度数据过去
            memcpy(dest, f->rptr, len);
            //这里只为循环服务，在这里修改dest只是修改入参的副本
            dest = (uint8_t *)dest + len;
        }
// memory barrier needed for SMP here in theory
        //已经拷贝走的数据就读出来扔掉
        av_fifo_drain(f, len);
        //也是为循环服务
        buf_size -= len;
        //如果len等于buf_size,此时循环结束，
        //什么时候buf_size > 0成立？
        //就是f->end - f->rptr，要小于要读取的大小buf_size，
        //即数据越过0边界的s以后，就需要跟多次处理
    } while (buf_size > 0);
    return 0;
}

/**

* 从AVFifoBuffer读取一定数量的数据然后抛弃掉

* @param f 要读取的AVFifoBuffer

* @param size 要读取的字节数

*/

void av_fifo_drain(AVFifoBuffer *f, int size)
{
    //无法只剩十个字节可读取时还要读取十一个字节，
    //但实际上这行代码只是调试代码，实际中由于编译选项
    //assert-level默认为0，所以av_assert2
    //并没有任何作用，可认为不存在
    av_assert2(av_fifo_size(f) >= size);
    //读指针后移动size个字节
    f->rptr += size;
    //读到边界了或者超过了边界
    if (f->rptr >= f->end)
        //读指针往前移动整个长度
        f->rptr -= f->end - f->buffer;
    //因为是读操作所以加法运算
    f->rndx += size;
}

/**

* 从AVFifoBuffer中读取数据进行用户自定义的处理，与av_fifo_gereric_read相似，

* 但是读取之后不会把数据舍弃.

* @param f 待读取的AVFifoBuffer

* @param buf_size 要读取的字节数

* @param func 用户自定义的方法，用于处理读取到的数据

*@param dest 目标数据区域

*/
int av_fifo_generic_peek(AVFifoBuffer *f, void *dest, int buf_size,
                         void (*func)(void *, void *, int))
{
    // Read memory barrier needed for SMP here in theory
    uint8_t *rptr = f->rptr;

    do {
        int len = FFMIN(f->end - rptr, buf_size);
        if (func)
            func(dest, rptr, len);
        else {
            memcpy(dest, rptr, len);
            dest = (uint8_t *)dest + len;
        }
        // memory barrier needed for SMP here in theory
        // 与av_fifo_gereric_read的唯一区别，就是增加的指针的副本，
        // 而不是直接对指针操作
        rptr += len;
        if (rptr >= f->end)
            rptr -= f->end - f->buffer;
        buf_size -= len;
    } while (buf_size > 0);

    return 0;
}

/**  * 从AVFifoBuffer中读取数据进行用户自定义的处理， 

* 与av_fifo_generic_peek类似， 

* 唯一的区别是可以从指定的偏移量开始读取 

* @param offset：从当前读取位置开始的偏移量

*/


int av_fifo_generic_peek_at(AVFifoBuffer *f, void *dest, int offset, int buf_size, void (*func)(void*, void*, int))
{
    uint8_t *rptr = f->rptr;

    av_assert2(offset >= 0);

    /*
     * *ndx are indexes modulo 2^32, they are intended to overflow,
     * to handle *ndx greater than 4gb.
     */
    av_assert2(buf_size + (unsigned)offset <= f->wndx - f->rndx);

    if (offset >= f->end - rptr)
        rptr += offset - (f->end - f->buffer);
    else
        rptr += offset;

    while (buf_size > 0) {
        int len;

        if (rptr >= f->end)
            rptr -= f->end - f->buffer;

        len = FFMIN(f->end - rptr, buf_size);
        if (func)
            func(dest, rptr, len);
        else {
            memcpy(dest, rptr, len);
            dest = (uint8_t *)dest + len;
        }

        buf_size -= len;
        rptr     += len;
    }

    return 0;
}

/**
*  经过用户自定义的回调从src读取数据填充到AVFifoBuffer
* @param f 待写的AVFifoBuffer
* @param src：源数据，不能是const指针，因为自定义回调中可能会更改数据
* @param size：即将要写的字节数
* @param func：写回调函数，第一个参数是源，第二个是目标buf，第三个是目标buf字节数
* 函数必须返回写入到目标buf的字节数，如果没有足够的数据可写，返回值 <= 0
* 如果用户自定义回调是空，则直接拷贝src中的数据到AVFifoBuffer
* @返回值: 写到目标buf中的字节数
*/
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size,
                          int (*func)(void *, void *, int))
{
    int total = size;
    //几乎是读数据的镜像过程
    uint32_t wndx= f->wndx;
    uint8_t *wptr= f->wptr;
    do {
        //f->end - wptr 即为还没被写的空间
        int len = FFMIN(f->end - wptr, size);
        if (func) {
            len = func(src, wptr, len);
            if (len <= 0)
                break;
        } else {
            memcpy(wptr, src, len);
            src = (uint8_t *)src + len;
        }
// Write memory barrier needed for SMP here in theory
        wptr += len;
        if (wptr >= f->end)
            //此时转了一圈，写满了，wptr强制归位
            wptr = f->buffer;
        wndx    += len;
        size    -= len;
    } while (size > 0);
    //这里最后再更新，是为了防止中间处理到一半中断了，虽然并不能从根本上防止
    f->wndx= wndx;
    f->wptr= wptr;
    //如果刚好写完，此时size应为0，total即为最开始的要写入的全部数据
    //当需要写入的空间大于剩余的空间时，size即为剩余的那几个字节，total-size即为已经写入的数据

    return total - size;
}