FFmpeg5.0源码阅读——内存分配和释放

Posted 落樱弥城

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了FFmpeg5.0源码阅读——内存分配和释放相关的知识,希望对你有一定的参考价值。

  参考的源码为FFmpeg5.0,commit-id为641c434。
  简单看一下FFmpeg中申请和释放内存的相关函数的具体实现。在解析源码的时候会移除部分内容方便阅读。

1 基本的内存分配和释放

  FFmpeg中内存申请和分配的实现都是对mallocfree的包装,基本都在libavutil/mem.c文件中。

1.1 av_mallocav_malloczav_calloc

  av_malloc:申请size大小的内存。
  av_mallocz:申请size大小的内存并初始化为0。
  av_calloc:申请n个元素大小的内存。

void *av_malloc(size_t size)
    void *ptr = NULL;
    //检查传入的size是否大于最大值
    if (size > atomic_load_explicit(&max_alloc_size, memory_order_relaxed))
        return NULL;
    //内存对齐
#if HAVE_POSIX_MEMALIGN
    if (size) //OS X on SDK 10.6 has a broken posix_memalign implementation
    if (posix_memalign(&ptr, ALIGN, size))
        ptr = NULL;
#elif HAVE_ALIGNED_MALLOC
    ptr = _aligned_malloc(size, ALIGN);
#elif HAVE_MEMALIGN
#ifndef __DJGPP__
    ptr = memalign(ALIGN, size);
#else
    ptr = memalign(size, ALIGN);
#endif
#else
    ptr = malloc(size);
#endif
    if(!ptr && !size) 
        size = 1;
        ptr= av_malloc(1);
    
#if CONFIG_MEMORY_POISONING
    if (ptr)
        memset(ptr, FF_MEMORY_POISON, size);
#endif
    return ptr;

  上面是FFmpeg中的av_malloc的源码,能够看到首先会检查传入的size是否大于默认的最大值,如果大于则返回NULL。其中默认的最大值max_alloc_size是一个静态变量。atomic_load_explicit就是以原子方式加载并返回指向的原子变量的当前值。

static atomic_size_t max_alloc_size = ATOMIC_VAR_INIT(INT_MAX);

  之后会根据不同的配置以不同的内存对齐方式分配内存。内存对齐对访存友好、缓存友好、原子性等优点,具体可参考purpose-of-memory-alignmentposix_memalign_aligned_mallocmemalign就是不同平台以不同的ALIGN的内存对齐方式分配内存。默认的ALIGN根据是否支持avx512分别为32和16。

#define ALIGN (HAVE_AVX512 ? 64 : (HAVE_AVX ? 32 : 16))
    /* Why 64?
     * Indeed, we should align it:
     *   on  4 for 386
     *   on 16 for 486
     *   on 32 for 586, PPro - K6-III
     *   on 64 for K7 (maybe for P3 too).
     * Because L1 and L2 caches are aligned on those values.
     * But I don't want to code such logic here!
     */
    /* Why 32?
     * For AVX ASM. SSE / NEON needs only 16.
     * Why not larger? Because I did not see a difference in benchmarks ...
     */
    /* benchmarks with P3
     * memalign(64) + 1          3071, 3051, 3032
     * memalign(64) + 2          3051, 3032, 3041
     * memalign(64) + 4          2911, 2896, 2915
     * memalign(64) + 8          2545, 2554, 2550
     * memalign(64) + 16         2543, 2572, 2563
     * memalign(64) + 32         2546, 2545, 2571
     * memalign(64) + 64         2570, 2533, 2558
     *
     * BTW, malloc seems to do 8-byte alignment by default here.
     */

  之后会检查插入的size为0时,返回的内存时不是真的是NULL,是的话就会重新调用av_malloc分配1byte的内存。下面是该处的commit message。

Only add 1 byte to av_malloc(0) when it actually returned NULL

  最后会感觉是否设置了CONFIG_MEMORY_POISONING将申请到的内存设置为默认值FF_MEMORY_POISON(0x2a)
  从上面的实现可以看出,我们需要关心的就是内存对齐,即传入的size实际的内存可能比size大。以及传入size为0时,得到的内存不一定为NULL,可能为1byte的内存的指针。

void *av_mallocz(size_t size)
    void *ptr = av_malloc(size);
    if (ptr)
        memset(ptr, 0, size);
    return ptr;

  av_mallocz的实现就是调用了av_malloc只不过初始化为0,。

void *av_calloc(size_t nmemb, size_t size)
    size_t result;
    if (size_mult(nmemb, size, &result) < 0)
        return NULL;
    return av_mallocz(result);

  av_calloc实现比较简单不详述。

1.2 av_realloc

  av_realloc:类似realloc,相比而言做了边检检查、对齐和初始化工作。

void *av_realloc(void *ptr, size_t size)
    void *ret;
    if (size > atomic_load_explicit(&max_alloc_size, memory_order_relaxed))
        return NULL;

#if HAVE_ALIGNED_MALLOC
    ret = _aligned_realloc(ptr, size + !size, ALIGN);
#else
    ret = realloc(ptr, size + !size);
#endif
#if CONFIG_MEMORY_POISONING
    if (ret && !ptr)
        memset(ret, FF_MEMORY_POISON, size);
#endif
    return ret;

  av_realloc的实现和av_malloc相比基本流程类似:首先检查传入的size是否超出默认的值;然后根据是否需要对齐分别采用对应版本的api重新分配内存,这里有点儿不同的是size + !size保证传入的尺寸至少不会为0,因为realloc传入0等同于free;最后根据需要设置内存。

1.3 av_realloc_f

  av_realloc_f:realloc分配n个对应元素的大小的内存。

void *av_realloc_f(void *ptr, size_t nelem, size_t elsize)

    size_t size;
    void *r;

    if (size_mult(elsize, nelem, &size)) 
        av_free(ptr);
        return NULL;
    
    r = av_realloc(ptr, size);
    if (!r)
        av_free(ptr);
    return r;

  具体时间调用av_realloc实现,区别是av_realloc返回的是指定大小内存的指针,而av_realloc_f返回n个大小为elsize的元素的内存指针。首先计算实际需要分配的内存大小;然后调用av_realloc分配内存;最后检查如果失败则调用av_free释放内存。释放的原因注释中提到了:

 It frees the input block in case of failure, thus avoiding the memory leak with the classic

  而size_mult就是用来计算实际的内存大小的。除了计算a*b外还做了越界检查。

static int size_mult(size_t a, size_t b, size_t *r)
    size_t t;

#if (!defined(__INTEL_COMPILER) && AV_GCC_VERSION_AT_LEAST(5,1)) || AV_HAS_BUILTIN(__builtin_mul_overflow)
    if (__builtin_mul_overflow(a, b, &t))
        return AVERROR(EINVAL);
#else
    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);
#endif
    *r = t;
    return 0;

1.4 av_reallocp

  av_reallocp:功能和av_realloc类似只是实现不同。

int av_reallocp(void *ptr, size_t size)
    void *val;

    if (!size) 
        av_freep(ptr);
        return 0;
    

    memcpy(&val, ptr, sizeof(val));
    val = av_realloc(val, size);

    if (!val) 
        av_freep(ptr);
        return AVERROR(ENOMEM);
    

    memcpy(ptr, &val, sizeof(val));
    return 0;

  在阅读av_reallocp的实现之前,首先需要明确的是av_reallocp接受的p是一个二级指针,即如果你希望申请内存的指针为ptr,传入的应该是&ptr。比如下面是FFmpeg中调用av_reallocp的例子:

char *src = NULL;
err = av_reallocp(&src, len);

  了解到这一点阅读就会轻松很多。首先会检查size是否为0,为0就释放内存,然后将ptr的值拷贝到临时变量&val中,此时val*ptr指向同一块内存,然后通过av_realloc申请内存,最后检查是否成功以及将&val拷贝回ptr
  需要注意的是FFmpeg中的内存管理的api中后缀带p的都是类似的实现。

1.5 av_malloc_arrayav_mallocz_array

  av_malloc_array:申请n个元素大小的内存;
  av_mallocz_array:申请n个元素大小的内存并初始化。

void *av_malloc_array(size_t nmemb, size_t size)
    size_t result;
    if (size_mult(nmemb, size, &result) < 0)
        return NULL;
    return av_malloc(result);


#if FF_API_AV_MALLOCZ_ARRAY
void *av_mallocz_array(size_t nmemb, size_t size)
    size_t result;
    if (size_mult(nmemb, size, &result) < 0)
        return NULL;
    return av_mallocz(result);

1.6 av_realloc_arrayav_reallocp_array

  av_realloc_array:realloc n个元素大小的内存;
  av_reallocp_array:realloc n个元素大小的内存;

void *av_realloc_array(void *ptr, size_t nmemb, size_t size)
    size_t result;
    if (size_mult(nmemb, size, &result) < 0)
        return NULL;
    return av_realloc(ptr, result);


int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
    void *val;

    memcpy(&val, ptr, sizeof(val));
    val = av_realloc_f(val, nmemb, size);
    memcpy(ptr, &val, sizeof(val));
    if (!val && nmemb && size)
        return AVERROR(ENOMEM);

    return 0;

  二者的功能类似,只是实现不同,av_reallocp_array是使用上面av_reallocp类似的实现方式实现。

1.7 av_freeav_freep

  av_free:释放内存;
  av_freep:释放内存并将指针置为NULL;

void av_free(void *ptr)
#if HAVE_ALIGNED_MALLOC
    _aligned_free(ptr);
#else
    free(ptr);
#endif


void av_freep(void *arg)
    void *val;

    memcpy(&val, arg, sizeof(val));
    memcpy(arg, &(void *) NULL , sizeof(val));
    av_free(val);

  av_free实际调用的就是对齐版本的free和普通版本的free实现。而av_freep实现调用的是av_free,并将指针置为NULL。

1.8 av_memdupav_strdupav_strndup

  av_strdup:拷贝字符串;
  av_strndup:拷贝字符串的len长度的值;
  av_memdup:内存复制。

char *av_strdup(const char *s)
    char *ptr = NULL;
    if (s) 
        size_t len = strlen(s) + 1;
        ptr = av_realloc(NULL, len);
        if (ptr)
            memcpy(ptr, s, len);
    
    return ptr;


char *av_strndup(const char *s, size_t len)
    char *ret = NULL, *end;

    if (!s)
        return NULL;

    end = memchr(s, 0, len);
    if (end)
        len = end - s;

    ret = av_realloc(NULL, len + 1);
    if (!ret)
        return NULL;

    memcpy(ret, s, len);
    ret[len] = 0;
    return ret;


void *av_memdup(const void *p, size_t size)
    void *ptr = NULL;
    if (p) 
        ptr = av_malloc(size);
        if (ptr)
            memcpy(ptr, p, size);
    
    return ptr;

  av_strdupav_strndup的实现比较简单,主要区别是av_strndup需要考虑末尾的\\0的问题。av_memdup就是简单的申请然后拷贝操作。

1.9 av_dynarray_add_nofreeav_dynarray_addav_dynarray2_add

  av_dynarray_add:在列表末尾添加元素,失败释放内存;
  av_dynarray_add_nofree:在列表末尾添加元素,失败不释放内存;
  av_dynarray2_add:在列表末尾添加元素,失败释放内存;

void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem)
    void **tab;
    memcpy(&tab, tab_ptr, sizeof(tab));

    FF_DYNARRAY_ADD(INT_MAX, sizeof(*tab), tab, *nb_ptr, 
        tab[*nb_ptr] = elem;
        memcpy(tab_ptr, &tab, sizeof(tab));
    , 
        *nb_ptr = 0;
        av_freep(tab_ptr);
    );

  av_dynarray_add的实现类似上面提到的带p的函数的实现,传入的tab_ptr实际上是一个三级指针此时的(void**)*tabptrtab指向通一块内存。

const char **pix_fmts = NULL;
av_dynarray_add(&pix_fmts, &nb_pix_fmts, (void *)pix_name);

  而FF_DYNARRAY_ADD宏,比较难看懂,我们可以把该宏改写成函数的伪代码看下:

typedef (*function)();
void ff_dynarray_add_macro(int av_size_max, int av_elt_size, void **av_array, int av_size, function av_success, function av_failure)
    do
        size_t av_size_new = av_size;
        //如果av_size是2的n次幂则返回0
        if((av_size & (av_size - 1)) == 0)
            av_size_new = av_size ? av_size << 1 : 1;
            //判断是否超出最大容量
            if(av_size_new > (av_size_max / av_elt_size))
                av_size_new = 0;
            else
                void *av_array_new = av_realloc(av_array, av_size_new * av_elt_size);
                if(av_array_new == NULL)
                    av_size_new = 0;
                else
                    av_array = av_array_new;
                
            
        

        if(av_size_new != 0)
            av_sucess();
            av_size++;
        else
            av_failture();
        
    while(0);

  改写后并不是标准的C语言,比如av_array以及av_size的修改不会生效,function仅仅是个占位符表示相关操作而已,把ff_dynarray_add_macro看成宏就可以。现在看的话其实FF_DYNARRAY_ADD就很简单,首先检查数组的元素数量是不是2的幂次方是的话则调用av_realloc重新分配2倍的内存,成功的话就调用sucess相关的操作这里是在末尾添加元素并更新大小,失败则调用fail相关操作,这里是释放内存。

int av_dynarray_add_nofree(void *tab_ptr, int *nb_ptr, void *elem)
    void **tab;
    memcpy(&tab, tab_ptr, sizeof(tab));

    FF_DYNARRAY_ADD(INT_MAX, sizeof(*tab), tab, *nb_ptr, 
        tab[*nb_ptr] = elem;
        memcpy(tab_ptr, &tab, sizeof(tab));
    , 
        return AVERROR(ENOMEM);
    );
    return 0;

  av_dynarray_add_nofreeav_dynarray_add唯一的区别就是失败不释放内存。

void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
                       const uint8_t *elem_data)
    uint8_t *tab_elem_data = NULL;

    FF_DYNARRAY_ADD(INT_MAX, elem_size, *tab_ptr, *nb_ptr, 
        tab_elem_data = (uint8_t *)*tab_ptr + (*nb_ptr) * elem_size;
        if (elem_data)
            memcpy(tab_elem_data, elem_data, elem_size);
        else if (CONFIG_MEMORY_POISONING)
            memset(tab_elem_data, FF_MEMORY_POISON, elem_size);
    , 
        av_freep(tab_ptr);
        *nb_ptr = 0;
    );
    return tab_elem_data;
以上是关于FFmpeg5.0源码阅读——内存分配和释放的主要内容,如果未能解决你的问题,请参考以下文章

FFmpeg5.0源码阅读——内存池AVBufferPool

FFmpeg5.0源码阅读之AVClass和AVOption

FFmpeg5.0源码阅读之AVClass和AVOption

FFmpeg5.0源码阅读之AVClass和AVOption

FFmpeg5.0源码阅读——AVPacket

FFmpeg5.0源码阅读——AVFrame