Merge commit 'b634b36fcebfe16b837b6c4044f5d5cb99a75040'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 6 Sep 2013 10:05:02 +0000 (12:05 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 6 Sep 2013 10:05:02 +0000 (12:05 +0200)
* commit 'b634b36fcebfe16b837b6c4044f5d5cb99a75040':
  mem: Improve documentation wording and spelling

Conflicts:
libavutil/mem.c
libavutil/mem.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavutil/mem.c
libavutil/mem.h

diff --cc libavutil/mem.c
@@@ -77,8 -65,8 +77,8 @@@ void *av_malloc(size_t size
      long diff;
  #endif
  
-     /* let's disallow possible ambiguous cases */
+     /* let's disallow possibly ambiguous cases */
 -    if (size > (INT_MAX - 32) || !size)
 +    if (size > (max_alloc_size - 32))
          return NULL;
  
  #if CONFIG_MEMALIGN_HACK
@@@ -144,8 -119,8 +144,8 @@@ void *av_realloc(void *ptr, size_t size
      int diff;
  #endif
  
-     /* let's disallow possible ambiguous cases */
+     /* let's disallow possibly ambiguous cases */
 -    if (size > (INT_MAX - 16))
 +    if (size > (max_alloc_size - 32))
          return NULL;
  
  #if CONFIG_MEMALIGN_HACK
diff --cc libavutil/mem.h
@@@ -175,20 -163,7 +174,19 @@@ void av_free(void *ptr)
  void *av_mallocz(size_t size) av_malloc_attrib av_alloc_size(1);
  
  /**
-  * Helper function to allocate a block of size * nmemb bytes with
-  * using av_mallocz()
 + * Allocate a block of nmemb * size bytes with alignment suitable for all
 + * memory accesses (including vectors if available on the CPU) and
 + * zero all the bytes of the block.
 + * The allocation will fail if nmemb * size is greater than or equal
 + * to INT_MAX.
 + * @param nmemb
 + * @param size
 + * @return Pointer to the allocated block, NULL if it cannot be allocated.
 + */
 +void *av_calloc(size_t nmemb, size_t size) av_malloc_attrib;
 +
 +/**
+  * Allocate a block of size * nmemb bytes with av_mallocz().
   * @param nmemb Number of elements
   * @param size Size of the single element
   * @return Pointer to the allocated block, NULL if the block cannot
@@@ -229,76 -196,9 +227,76 @@@ void *av_memdup(const void *p, size_t s
  void av_freep(void *ptr);
  
  /**
-  * @brief deliberately overlapping memcpy implementation
 + * Add an element to a dynamic array.
 + *
 + * The array to grow is supposed to be an array of pointers to
 + * structures, and the element to add must be a pointer to an already
 + * allocated structure.
 + *
 + * The array is reallocated when its size reaches powers of 2.
 + * Therefore, the amortized cost of adding an element is constant.
 + *
 + * In case of success, the pointer to the array is updated in order to
 + * point to the new grown array, and the number pointed to by nb_ptr
 + * is incremented.
 + * In case of failure, the array is freed, *tab_ptr is set to NULL and
 + * *nb_ptr is set to 0.
 + *
 + * @param tab_ptr pointer to the array to grow
 + * @param nb_ptr  pointer to the number of elements in the array
 + * @param elem    element to add
 + * @see av_dynarray2_add()
 + */
 +void av_dynarray_add(void *tab_ptr, int *nb_ptr, void *elem);
 +
 +/**
 + * Add an element of size elem_size to a dynamic array.
 + *
 + * The array is reallocated when its number of elements reaches powers of 2.
 + * Therefore, the amortized cost of adding an element is constant.
 + *
 + * In case of success, the pointer to the array is updated in order to
 + * point to the new grown array, and the number pointed to by nb_ptr
 + * is incremented.
 + * In case of failure, the array is freed, *tab_ptr is set to NULL and
 + * *nb_ptr is set to 0.
 + *
 + * @param tab_ptr   pointer to the array to grow
 + * @param nb_ptr    pointer to the number of elements in the array
 + * @param elem_size size in bytes of the elements in the array
 + * @param elem_data pointer to the data of the element to add. If NULL, the space of
 + *                  the new added element is not filled.
 + * @return          pointer to the data of the element to copy in the new allocated space.
 + *                  If NULL, the new allocated space is left uninitialized."
 + * @see av_dynarray_add()
 + */
 +void *av_dynarray2_add(void **tab_ptr, int *nb_ptr, size_t elem_size,
 +                       const uint8_t *elem_data);
 +
 +/**
 + * Multiply two size_t values checking for overflow.
 + * @return  0 if success, AVERROR(EINVAL) if overflow.
 + */
 +static inline int av_size_mult(size_t a, size_t b, size_t *r)
 +{
 +    size_t t = a * b;
 +    /* Hack inspired from glibc: only try the division if nelem and elsize
 +     * are both greater 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;
 +}
 +
 +/**
 + * Set the maximum size that may me allocated in one block.
 + */
 +void av_max_alloc(size_t max);
 +
 +/**
+  * deliberately overlapping memcpy implementation
   * @param dst destination buffer
 - * @param back how many bytes back we start (the initial size of the overlapping window)
 + * @param back how many bytes back we start (the initial size of the overlapping window), must be > 0
   * @param cnt number of bytes to copy, must be >= 0
   *
   * cnt > back is valid, this will copy the bytes we just copied,