// .hpp-файл.

void f(int some_arg);

// .cpp-файл.
void f(int /*some_arg*/) {
  ...
}

void f(int) {
  ...
}

M>auto u = (unsigned)(std::uint8_t)ch;
M>

M>auto u = static_cast<unsigned>(static_cast<std::uint8_t>(ch));
M>

auto u = unsigned(std::uint8_t(ch));

char *strchr(const char *s, int c);

 AVBufferRef *av_buffer_create(uint8_t *data, size_t size,
                               void (*free)(void *opaque, uint8_t *data),
                               void *opaque, int flags)
 {
     AVBufferRef *ret;
     AVBuffer *buf = av_mallocz(sizeof(*buf)); // тут заказали память под AVBuffer 
     if (!buf)
         return NULL;
  
     ret = buffer_create(buf, data, size, free, opaque, flags);
     if (!ret) {
         av_free(buf);
         return NULL;
     }
     return ret;
 }

 static AVBufferRef *buffer_create(AVBuffer *buf, uint8_t *data, size_t size,
                                   void (*free)(void *opaque, uint8_t *data),
                                   void *opaque, int flags)
 {
     AVBufferRef *ref = NULL;
  
     buf->data     = data;
     buf->size     = size;
     buf->free     = free ? free : av_buffer_default_free; // т.к. free не NULL, то она будет использована вместо av_buffer_default_free
     buf->opaque   = opaque;
  
     atomic_init(&buf->refcount, 1);// очевидно подсчёт числа "ссылок", т.о. ниже идёт имитация intrusive смарт указателя
  
     buf->flags = flags;
  
     ref = av_mallocz(sizeof(*ref)); // заказали память под "ссылку"
     if (!ref)
         return NULL;
  
     ref->buffer = buf;  // в "ссылку" положили указатель на объект AVBuffer. это, впрочем, не важно.
     ref->data   = data;
     ref->size   = size;
  
     return ref;
 }

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

void *av_malloc(size_t size)
 {
     void *ptr = NULL;
  
     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
     /* 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.
      */
 #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;
 }