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

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

#include <iostream>
using namespace std;
 
class Base
{};
 
class Derived: private Base
{
  // Inherited private/protected
  // not public
};
 
// Driver code
int main()
{   
  Derived d1;
   
  // C-style cast allowed
  Base* b1 = (Base*)(&d1);
   
  // static_cast not allowed
  Base* b2 = static_cast<Base*>(&d1);
  return 0;
}

const char * in = ...;
unsigned char * src = (unsigned char *)in;
...
*src = 0;

const auto ptr_cast = []( const std::byte * ptr ) -> std::uint8_t * {
        return reinterpret_cast< std::uint8_t * >(
                const_cast< std::byte * >( ptr ) );
    };

fresh_frame->buf[ 0 ] = av_buffer_create(
        ptr_cast( image_bytes ),
        total_memory_size,
        []( void *, std::uint8_t * ) -> void {},
        nullptr,
        AV_BUFFER_FLAG_READONLY );
if( !(fresh_frame->buf[ 0 ]) )
{
    throw std::runtime_error{...};
}

std::size_t plane_index = 0u;
for( const auto plane_size : data_plane_sizes )
{
    fresh_frame->data[ plane_index ] = ptr_cast( image_bytes );
    image_bytes += plane_size;
    ++plane_index;
}

#include <iostream>
using namespace std;
 
class Base
{};
 
class Derived: private Base
{
  // Inherited private/protected
  // not public
};
 
// Driver code
int main()
{   
  Derived d1;
   
  // C-style cast allowed
  Base* b1 = (Base*)(&d1);
   
  // static_cast not allowed
  Base* b2 = static_cast<Base*>(&d1);
  return 0;
}

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

    const char ch = 254;
    const auto u = (unsigned)(std::uint8_t)ch;
    
    if ( ch == u )
        std::cout << "yes\n";
    else
        std::cout << "no\n";

int main() {
    int (*pf)(char, long) = nullptr;
    auto dummy = [](char, long) -> int { return 42; };
    pf = dummy;
    return (*pf)('x', 100500);
}

BFE>Ну я же не знаю, что именно хочет автор, вот и спрашиваю.

char x = -2;
auto u1 = static_cast<unsigned>(static_cast<unsigned char>(x));
auto u2 = static_cast<unsigned>(x);

#include <algorithm>
#include <string>
#include <vector>
#include <random>

int main()
{
    std::mt19937 g{ std::random_device{}() };

    std::vector< std::string > words;

    for( auto & w : words )
    {
        auto w32 = w;
        if( w32.size() > 10u )
        {
            const auto mid = static_cast<std::ptrdiff_t>( w32.size() / 2 );
            std::shuffle( w32.begin() + 1, w32.begin() + mid, g );
            std::shuffle( w32.begin() + mid, w32.end() - 2, g );
        }
    }
}

tmp\rsdn_cpp_20230729>cl -EHsc -WX -Wall -std:c++17 t1.cpp
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32532 for x64
Copyright (C) Microsoft Corporation.  All rights reserved.

t1.cpp
Microsoft (R) Incremental Linker Version 14.36.32532.0
Copyright (C) Microsoft Corporation.  All rights reserved.

/out:t1.exe
t1.obj

void f(int /*some_arg*/) {
}

int main(int argc, char ** argv) {
  (void)argc; // Старая школа.
  std::ignore = argv; // Можно и молодежно.
}

// .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;
 }

BFE>А то я не вижу!

static void buffer_replace(AVBufferRef **dst, AVBufferRef **src)
 {
     AVBuffer *b;
  
     b = (*dst)->buffer;
  
     if (src) {
         **dst = **src;
         av_freep(src);
     } else
         av_freep(dst);
  
     if (atomic_fetch_sub_explicit(&b->refcount, 1, memory_order_acq_rel) == 1) {
         /* b->free below might already free the structure containing *b,
          * so we have to read the flag now to avoid use-after-free. */
         int free_avbuffer = !(b->flags_internal & BUFFER_FLAG_NO_FREE);
         b->free(b->opaque, b->data);
         if (free_avbuffer)
             av_free(b);
     }
 }

std::size_t plane_index = 0u;
for( const auto plane_size : data_plane_sizes )
{
    fresh_frame->data[ plane_index ] = ptr_cast( image_bytes );
    image_bytes += plane_size;
    ++plane_index;
}

auto pImgBytes = ptr_cast( image_bytes );
auto pData     = std::begin(fresh_frame->data);
for( const auto plane_size : data_plane_sizes )
{
    *pData++   = pImgBytes;
    pImgBytes += plane_size;
}

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

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

constexpr unsigned unsigned_from_char(char c) { return static_cast<unsigned>(static_cast<unsigned char>(c)); }
constexpr unsigned unsigned_from_char(auto) = delete;  // во избежание неявных кастов

...
auto u = unsigned_from_char(ch);
...

-Werror=old-style-cast