FFmpeg

https://ffmpeg.org/doxygen/8.0/
Admin
FFmpeg is a comprehensive multimedia framework providing libraries for encoding, decoding,...
Tokens:22,502,172
Snippets:157,434
Trust Score:9.9
Update:2 days ago
Show doc for...
Tokens:
Raw
### PulseAudio mainloop start and context setup

Source: https://ffmpeg.org/doxygen/8.0/pulse__audio__enc_8c_source.html

Starts the PulseAudio threaded mainloop, handles failure by logging and freeing resources, then locks the mainloop, retrieves the API, creates a context, sets state and subscribe callbacks, and connects to the server. On errors, logs and returns AVERROR_EXTERNAL or AVERROR(ENOMEM).

```c
if ((ret = pa_threaded_mainloop_start(s->mainloop)) < 0) {
    av_log(s, AV_LOG_ERROR, "Cannot start threaded mainloop: %s.\n", pa_strerror(ret));
    pa_threaded_mainloop_free(s->mainloop);
    s->mainloop = NULL;
    return AVERROR_EXTERNAL;
}

pa_threaded_mainloop_lock(s->mainloop);

mainloop_api = pa_threaded_mainloop_get_api(s->mainloop);
if (!mainloop_api) {
    av_log(s, AV_LOG_ERROR, "Cannot get mainloop API.\n");
    ret = AVERROR_EXTERNAL;
    goto fail;
}

s->ctx = pa_context_new(mainloop_api, s->name);
if (!s->ctx) {
    av_log(s, AV_LOG_ERROR, "Cannot create context.\n");
    ret = AVERROR(ENOMEM);
    goto fail;
}
pa_context_set_state_callback(s->ctx, pulse_context_state, s);
pa_context_set_subscribe_callback(s->ctx, pulse_event, h);

if ((ret = pa_context_connect(s->ctx, s->server, 0, NULL)) < 0) {
    av_log(s, AV_LOG_ERROR, "Cannot connect context: %s.\n", pa_strerror(ret));
    ret = AVERROR_EXTERNAL;
}
```

--------------------------------

### main: Set up and run the muxing example

Source: https://ffmpeg.org/doxygen/8.0/mux_8c-example.html

Parses command-line arguments, checks for the output filename, and initializes the output format context. The loop over remaining arguments is incomplete in the source; the snippet is shown as displayed.

```c
int main(int argc, char **argv)

{

OutputStream video_st = { 0 }, audio_st = { 0 };

const AVOutputFormat *fmt;

const char *filename;

AVFormatContext *oc;

const AVCodec *audio_codec, *video_codec;

int ret;

int have_video = 0, have_audio = 0;

int encode_video = 0, encode_audio = 0;

AVDictionary *opt = NULL;

int i;

if (argc < 2) {

printf("usage: %s output_file\n"

"API example program to output a media file with libavformat.\n"

"This program generates a synthetic audio and video stream, encodes and\n"

"muxes them into a file named output_file.\n"

"The output format is automatically guessed according to the file extension.\n"

"Raw images can also be output by using '%%d' in the filename.\n"

"\n", argv[0]);

return 1;

}

filename = argv[1];

for (i = 2; i+1 < argc; i+=2) {
```

--------------------------------

### xcbgrab_read_header: function start and context setup

Source: https://ffmpeg.org/doxygen/8.0/xcbgrab_8c_source.html

This is the beginning of the xcbgrab_read_header function, which retrieves the private context and declares variables for the XCB setup and display name.

```c
static av_cold int xcbgrab_read_header(AVFormatContext *s)
{
  XCBGrabContext *c = s->priv_data;
  int screen_num, ret;
  const xcb_setup_t *setup;
  char *display_name = av_strdup(s->url);

```

--------------------------------

### Main function for libswscale scaling example

Source: https://ffmpeg.org/doxygen/8.0/scale_video_8c-example.html

Entry point that parses command-line arguments (output_file and output_size), sets up source and destination buffers, and initializes the scaling context. It expects exactly two arguments and prints usage information if the argument count is incorrect.

```c
int main(int argc, char **argv)
{
    uint8_t *src_data[4], *dst_data[4];
    int src_linesize[4], dst_linesize[4];
    int src_w = 320, src_h = 240, dst_w, dst_h;
    enum AVPixelFormat src_pix_fmt = AV_PIX_FMT_YUV420P, dst_pix_fmt = AV_PIX_FMT_RGB24;
    const char *dst_size = NULL;
    const char *dst_filename = NULL;
    FILE *dst_file;
    int dst_bufsize;
    struct SwsContext *sws_ctx;
    int i, ret;

    if (argc != 3) {
        fprintf(stderr, "Usage: %s output_file output_size\n"
                "API example program to show how to scale an image with libswscale.\n"
                "This program generates a series of pictures, rescales them to the given "
                "output_size and saves them to an output file named output_file\n."
                "\n", argv[0]);
        exit(1);
    }

    dst_filename = argv[1];
    dst_size = argv[2];
```

--------------------------------

### extract_extradata_mpeg12: Function signature and context setup

Source: https://ffmpeg.org/doxygen/8.0/extract__extradata_8c_source.html

Shows the start of the MPEG-1/2 extradata extraction function. It retrieves the private context from the AVBSFContext and initializes the start code state to UINT32_MAX.

```c
static int extract_extradata_mpeg12(AVBSFContext *ctx, AVPacket *pkt,
                                 uint8_t **data, int *size)
{
  ExtractExtradataContext *s = ctx->priv_data;
  uint32_t state = UINT32_MAX;
```

--------------------------------

### main function setup

Source: https://ffmpeg.org/doxygen/8.0/doc_2examples_2mux_8c_source.html

Declares output stream structures, format context, codecs, and flags. Prints usage if no output file argument is provided.

```c
int main(int argc, char **argv)
{
    OutputStream video_st = { 0 }, audio_st = { 0 };
    const AVOutputFormat *fmt;
    const char *filename;
    AVFormatContext *oc;
    const AVCodec *audio_codec, *video_codec;
    int ret;
    int have_video = 0, have_audio = 0;
    int encode_video = 0, encode_audio = 0;
    AVDictionary *opt = NULL;
    int i;

    if (argc < 2) {
        printf("usage: %s output_file\n"
               "API example program to output a media file with libavformat.\n"
               "This program generates a synthetic audio and video stream, encodes and\n"
               "muxes them into a file named output_file.\n"
               "The output format is automatically guessed according to the file extension.\n");
    }
```

--------------------------------

### W64 GUID start and end helper functions

Source: https://ffmpeg.org/doxygen/8.0/wavenc_8c_source.html

start_guid writes a 16-byte GUID and placeholder size; end_guid patches the size after aligning to 8 bytes. Used for W64 (Wave64) muxing.

```c
static void start_guid(AVIOContext *pb, const uint8_t *guid, int64_t *pos)
{
    *pos = avio_tell(pb);

    avio_write(pb, guid, 16);
    avio_wl64(pb, INT64_MAX);
}

static void end_guid(AVIOContext *pb, int64_t start)
{
    int64_t end, pos = avio_tell(pb);

    end = FFALIGN(pos, 8);
    ffio_fill(pb, 0, end - pos);
    avio_seek(pb, start + 16, SEEK_SET);
    avio_wl64(pb, end - start);
    avio_seek(pb, end, SEEK_SET);
}
```

--------------------------------

### main function: initialization and setup

Source: https://ffmpeg.org/doxygen/8.0/ffmpeg_8c_source.html

Entry point that initializes dynamic loading and sets stderr to unbuffered for Windows runtime compatibility.

```c
int main(int argc, char **argv)
{
    Scheduler *sch = NULL;

    int ret;
    BenchmarkTimeStamps ti;

    init_dynload();

    setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
```

--------------------------------

### ff_opencl_get_event_time()

Source: https://ffmpeg.org/doxygen/8.0/opencl_8h.html

Gets the command start and end times for the given event and returns the difference (the time that the event took).

```APIDOC
## ff_opencl_get_event_time()

### Description
Gets the command start and end times for the given event and returns the difference (the time that the event took).

### Function Signature
cl_ulong ff_opencl_get_event_time(cl_event _event_)

### Parameters
- **event** (cl_event) - Required - The OpenCL event for which to get the command times.

### Return Value
- **cl_ulong** - The difference between the command start and end times (the duration of the event).

### Definition
Defined at line 342 of file opencl.c.

### Referenced By
- filter_frame()

```

--------------------------------

### Begin setup_refs function

Source: https://ffmpeg.org/doxygen/8.0/vulkan__encode__h265_8c_source.html

Starts the static function setup_refs that takes an AVCodecContext and FFHWBaseEncodePicture. The function body is not shown on this page.

```c
static void setup_refs(AVCodecContext *avctx,
  FFHWBaseEncodePicture *pic,
```

--------------------------------

### ff_opencl_get_event_time

Source: https://ffmpeg.org/doxygen/8.0/opencl_8h.html

Gets the command start and end times for the given event and returns the difference (the time that the event took).

```APIDOC
## ff_opencl_get_event_time

### Description
Gets the command start and end times for the given event and returns the difference (the time that the event took).

### Function Signature
cl_ulong ff_opencl_get_event_time(cl_event event)

### Parameters
- **event** (cl_event) - The OpenCL event to query.

### Return Value
- **cl_ulong** - The duration of the event in nanoseconds.
```

--------------------------------

### ff_decklink_write_trailer: get private context

Source: https://ffmpeg.org/doxygen/8.0/decklink__enc_8cpp_source.html

Retrieves the decklink_cctx private data from the AVFormatContext. This is the start of the trailer writing function.

```c
av_cold int ff_decklink_write_trailer(AVFormatContext *avctx)
{
    struct decklink_cctx *cctx = (struct decklink_cctx *)avctx->priv_data;
```

--------------------------------

### Main function: parse arguments and initialize network

Source: https://ffmpeg.org/doxygen/8.0/avio_http_serve_files_8c-example.html

This is the main function of the example. It sets up variables, sets log level to AV_LOG_TRACE, checks command-line arguments, and initializes the network with avformat_network_init. It expects usage: input http://hostname[:port].

```c
int main(int argc, char **argv)

{

    AVDictionary *options = NULL;

    AVIOContext *client = NULL, *server = NULL;

    const char *in_uri, *out_uri;

    int ret, pid;

    av_log_set_level(AV_LOG_TRACE);

    if (argc < 3) {

        printf("usage: %s input http://hostname[:port]\n"

               "API example program to serve http to multiple clients.\n"

               "\n", argv[0]);

        return 1;

    }

    in_uri = argv[1];

    out_uri = argv[2];

    avformat_network_init();
```

--------------------------------

### main function for QSV decoding example

Source: https://ffmpeg.org/doxygen/8.0/qsv__decode_8c_source.html

Entry point that parses command-line arguments, opens the input file, finds the first H.264 video stream, initializes the QSV decoder, and decodes all packets. Writes raw YUV420p frames to the output file. Returns 0 on success or 1 on usage error.

```c
int main(int argc, char **argv)
{
    AVFormatContext *input_ctx = NULL;
    AVStream *video_st = NULL;
    AVCodecContext *decoder_ctx = NULL;
    const AVCodec *decoder;

    AVPacket *pkt = NULL;
    AVFrame *frame = NULL, *sw_frame = NULL;

    AVIOContext *output_ctx = NULL;

    int ret, i;

    AVBufferRef *device_ref = NULL;

    if (argc < 3) {
        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
        return 1;
    }

    /* open the input file */
    ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
        goto finish;
    }

    /* find the first H.264 video stream */
    for (i = 0; i < input_ctx->nb_streams; i++) {
        AVStream *st = input_ctx->streams[i];

        if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !video_st) {
            video_st = st;
            break;
        }
    }

    if (!video_st) {
        fprintf(stderr, "Could not find H.264 video stream in the input file\n");
        goto finish;
    }

    /* find the decoder for the video stream */
    decoder = avcodec_find_decoder(video_st->codecpar->codec_id);
    if (!decoder) {
        fprintf(stderr, "Failed to find decoder\n");
        goto finish;
    }

    /* allocate the codec context */
    decoder_ctx = avcodec_alloc_context3(decoder);
    if (!decoder_ctx) {
        fprintf(stderr, "Failed to allocate the codec context\n");
        goto finish;
    }

    /* copy the stream parameters to the decoder context */
    ret = avcodec_parameters_to_context(decoder_ctx, video_st->codecpar);
    if (ret < 0) {
        fprintf(stderr, "Failed to copy stream parameters to decoder context\n");
        goto finish;
    }

    /* set the QSV device */
    ret = av_hwdevice_ctx_create(&device_ref, AV_HWDEVICE_TYPE_QSV, NULL, NULL, 0);
    if (ret < 0) {
        fprintf(stderr, "Failed to create QSV device\n");
        goto finish;
    }
    decoder_ctx->hw_device_ctx = av_buffer_ref(device_ref);

    /* open the decoder */
    ret = avcodec_open2(decoder_ctx, NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Failed to open decoder\n");
        goto finish;
    }

    /* allocate the frame and the packet */
    frame = av_frame_alloc();
    sw_frame = av_frame_alloc();
    pkt = av_packet_alloc();
    if (!frame || !sw_frame || !pkt) {
        fprintf(stderr, "Could not allocate frame or packet\n");
        goto finish;
    }

    /* open the output file */
    ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
    if (ret < 0) {
        fprintf(stderr, "Could not open output file '%s': ", argv[2]);
        goto finish;
    }

    /* decode the video stream */
    while (av_read_frame(input_ctx, pkt) >= 0) {
        if (pkt->stream_index == video_st->index) {
            ret = decode_packet(decoder_ctx, frame, sw_frame, pkt, output_ctx);
            if (ret < 0) {
                fprintf(stderr, "Error while decoding packet: %s\n", av_err2str(ret));
                goto finish;
            }
        }
        av_packet_unref(pkt);
    }

    /* flush the decoder */
    decode_packet(decoder_ctx, frame, sw_frame, NULL, output_ctx);

finish:
    avformat_close_input(&input_ctx);
    avio_closep(&output_ctx);
    avcodec_free_context(&decoder_ctx);
    av_frame_free(&frame);
    av_frame_free(&sw_frame);
    av_packet_free(&pkt);
    av_buffer_unref(&device_ref);

    return ret < 0 ? 1 : 0;
}
```

--------------------------------

### Update size in output

Source: https://ffmpeg.org/doxygen/8.0/movenccenc_8c_source.html

Starts a function that updates a size field in the output, using avio_tell to get the current position.

```c
static int64_t update_size(AVIOContext *pb, int64_t pos)
{
    int64_t curpos = avio_tell(pb);
```

--------------------------------

### ff_rtsp_make_setup_request function start (C)

Source: https://ffmpeg.org/doxygen/8.0/rtsp_8c_source.html

Begins the ff_rtsp_make_setup_request function, initializing the RTSP state, reply structure, and command buffer. Checks if the transport is RTSP_TRANSPORT_RDT to set the transport preference string.

```c
int ff_rtsp_make_setup_request(AVFormatContext *s, const char *host, int port,
                                 int lower_transport, const char *real_challenge)
{
    RTSPState *rt = s->priv_data;
    int rtx = 0, j, i, err, interleave = 0, port_off = 0;
    RTSPStream *rtsp_st;
    RTSPMessageHeader reply1, *reply = &reply1;
    char cmd[MAX_URL_SIZE];
    const char *trans_pref;

    memset(&reply1, 0, sizeof(reply1));

    if (rt->transport == RTSP_TRANSPORT_RDT)
        trans_pref = "x-pn-tng";
```

--------------------------------

### av_strnlen

Source: https://ffmpeg.org/doxygen/8.0/avstring_8h.html

Gets the count of continuous non zero chars starting from the beginning. Returns the length of the string, limited to len.

```APIDOC
## av_strnlen

### Description
Gets the count of continuous non zero chars starting from the beginning. Returns the length of the string, limited to len.

### Function Signature
size_t av_strnlen(const char *s, size_t len)

### Parameters
- **s** (const char*) - Input string.
- **len** (size_t) - Maximum length to check.

### Return Value
- **size_t** - Length of the string, limited to len.
```

--------------------------------

### av_gettime_relative

Source: https://ffmpeg.org/doxygen/8.0/avio_8c_source.html

Gets the current time in microseconds since some unspecified starting point. This is useful for measuring relative time intervals.

```APIDOC
## av_gettime_relative

### Description
Get the current time in microseconds since some unspecified starting point.

### Function Signature
int64_t av_gettime_relative(void)

### Return Value
- **int64_t** - Current time in microseconds.
```

--------------------------------

### Initialize AudioFIRSegment with memory allocation and FFT setup

Source: https://ffmpeg.org/doxygen/8.0/libavfilter_2af__afir_8c_source.html

Allocates per-channel arrays for part_index and output_offset, checks for allocation failure, then initializes FFT contexts with scaling factors depending on sample format (AV_SAMPLE_FMT_FLTP or AV_SAMPLE_FMT_DBLP). Uses av_tx_init with RDFT types and asserts on unsupported formats.

```c
seg->part_index = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->part_index));
seg->output_offset = av_calloc(ctx->inputs[0]->ch_layout.nb_channels, sizeof(*seg->output_offset));
if (!seg->part_index || !seg->output_offset)
    return AVERROR(ENOMEM);

switch (s->format) {
case AV_SAMPLE_FMT_FLTP:
    cscale.f = 1.f;
    scale.f = 1.f / sqrtf(2.f * part_size);
    iscale.f = 1.f / sqrtf(2.f * part_size);
    tx_type = AV_TX_FLOAT_RDFT;
    break;
case AV_SAMPLE_FMT_DBLP:
    cscale.d = 1.0;
    scale.d = 1.0 / sqrt(2.0 * part_size);
    iscale.d = 1.0 / sqrt(2.0 * part_size);
    tx_type = AV_TX_DOUBLE_RDFT;
    break;
default:
    av_assert1(0);
}

for (int ch = 0; ch < ctx->inputs[0]->ch_layout.nb_channels && part_size >= 1; ch++) {
    ret = av_tx_init(&seg->ctx[ch], &seg->ctx_fn, tx_type,
                     0, 2 * part_size, &cscale, 0);
    if (ret < 0)
        return ret;

    ret = av_tx_init(&seg->tx[ch], &seg->tx_fn, tx_type,
                     0, 2 * part_size, &scale, 0);
    if (ret < 0)
        return ret;
}
```

--------------------------------

### MSA H.264 QPEL 16x16 MC10 Function Start

Source: https://ffmpeg.org/doxygen/8.0/h264qpel__msa_8c_source.html

This snippet shows the beginning of the ff_avg_h264_qpel16_mc10_msa function, including variable declarations, mask setup, and the start of a loop. It uses MSA intrinsics like __msa_ldi_b and macros like LD_SB3.

```C
void ff_avg_h264_qpel16_mc10_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
  uint32_t loop_cnt;
  v16u8 dst0, dst1, dst2, dst3;
  v16i8 out0, out1, out2, out3, src0, src1, src2, src3, src4, src5, src6;
  v16i8 mask0, mask1, mask2, mask3, mask4, mask5, src7, vec11;
  v16i8 vec0, vec1, vec2, vec3, vec4, vec5, vec6, vec7, vec8, vec9, vec10;
  v8i16 res0, res1, res2, res3, res4, res5, res6, res7;
  v16i8 minus5b = __msa_ldi_b(-5);
  v16i8 plus20b = __msa_ldi_b(20);

  LD_SB3(&luma_mask_arr[0], 16, mask0, mask1, mask2);
  mask3 = mask0 + 8;
  mask4 = mask1 + 8;
  mask5 = mask2 + 8;
  src -= 2;

  for (loop_cnt = 4; loop_cnt--;) {
```

--------------------------------

### v4l2.c: create stream, open device, and select video input

Source: https://ffmpeg.org/doxygen/8.0/v4l2_8c_source.html

This snippet from FFmpeg's v4l2.c shows the sequence for setting up a V4L2 device: creating a new stream, optionally redirecting libv4l2 logs to /dev/null, opening the device, and then either setting the video input via VIDIOC_S_INPUT or getting the current one via VIDIOC_G_INPUT, followed by enumerating the input with VIDIOC_ENUMINPUT. It includes error handling that logs errors and jumps to a fail label.

```c
st = avformat_new_stream(ctx, NULL);
if (!st)
    return AVERROR(ENOMEM);

#if CONFIG_LIBV4L2
/* silence libv4l2 logging. if fopen() fails v4l2_log_file will be NULL
   and errors will get sent to stderr */
if (s->use_libv4l2)
    v4l2_log_file = fopen("/dev/null", "w");
#endif

s->fd = device_open(ctx, ctx->url);
if (s->fd < 0)
    return s->fd;

if (s->channel != -1) {
    /* set video input */
    av_log(ctx, AV_LOG_DEBUG, "Selecting input_channel: %d\n", s->channel);
    if (v4l2_ioctl(s->fd, VIDIOC_S_INPUT, &s->channel) < 0) {
        res = AVERROR(errno);
        av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_S_INPUT): %s\n", av_err2str(res));
        goto fail;
    }
} else {
    /* get current video input */
    if (v4l2_ioctl(s->fd, VIDIOC_G_INPUT, &s->channel) < 0) {
        res = AVERROR(errno);
        av_log(ctx, AV_LOG_ERROR, "ioctl(VIDIOC_G_INPUT): %s\n", av_err2str(res));
        goto fail;
    }
}

/* enum input */
input.index = s->channel;
if (v4l2_ioctl(s->fd, VIDIOC_ENUMINPUT, &input) < 0) {
    res = AVERROR(errno);
```

--------------------------------

### Initialize swr contexts and setup arrays

Source: https://ffmpeg.org/doxygen/8.0/tests_2swresample_8c_source.html

Initializes forward and backward SwrContexts, checks swr_init return values, and sets up input, intermediate, and output sample arrays using setup_array. Includes a disabled block for manual sample generation and an audiogen call.

```c
fprintf(stderr, "Failed to init backw_ctx\n");

return 1;
}

if(swr_init(forw_ctx) < 0)
fprintf(stderr, "swr_init(->) failed\n");
if(swr_init(backw_ctx) < 0)
fprintf(stderr, "swr_init(<-) failed\n");
//FIXME test planar
setup_array(ain , array_in , in_sample_fmt, SAMPLES);
setup_array(amid, array_mid, out_sample_fmt, 3*SAMPLES);
setup_array(aout, array_out, in_sample_fmt , SAMPLES);
#if 0
for(ch=0; ch<in_ch_count; ch++){
for(i=0; i<SAMPLES; i++)
set(ain, ch, i, in_ch_count, in_sample_fmt, sin(i*i*3/SAMPLES));
}
#else
audiogen(ain, in_sample_fmt, in_ch_count, SAMPLES/6+1, SAMPLES);
#endif
```

--------------------------------

### H.264 frame decode function signature and setup

Source: https://ffmpeg.org/doxygen/8.0/libavcodec_2h264dec_8c_source.html

Starts the h264_decode_frame function, extracting packet data and context, and resetting decoder state.

```c
static int h264_decode_frame(AVCodecContext *avctx, AVFrame *pict,
                             int *got_frame, AVPacket *avpkt)
{
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
    H264Context *h = avctx->priv_data;
    int buf_index;
    int ret;

    h->flags = avctx->flags;
    h->setup_finished = 0;
```

--------------------------------

### Initialize QSV hardware device and H.264 decoder

Source: https://ffmpeg.org/doxygen/8.0/qsv__decode_8c_source.html

Sets up the QSV hardware device and initializes the H.264 decoder. Checks for a video stream, creates the hardware device context, finds the 'h264_qsv' decoder, allocates the decoder context, and copies extradata if present. Includes error handling with goto finish on failures.

```c
if (video_st->codecpar->codec_id != AV_CODEC_ID_H264) {
    if (video_st) {
        video_st->discard = AVDISCARD_ALL;
    }
}
if (!video_st) {
    fprintf(stderr, "No H.264 video stream in the input file\n");
    goto finish;
}

/* open the hardware device */
ret = av_hwdevice_ctx_create(&device_ref, AV_HWDEVICE_TYPE_QSV,
                             "auto", NULL, 0);
if (ret < 0) {
    fprintf(stderr, "Cannot open the hardware device\n");
    goto finish;
}

/* initialize the decoder */
decoder = avcodec_find_decoder_by_name("h264_qsv");
if (!decoder) {
    fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
    goto finish;
}

decoder_ctx = avcodec_alloc_context3(decoder);
if (!decoder_ctx) {
    ret = AVERROR(ENOMEM);
    goto finish;
}
decoder_ctx->codec_id = AV_CODEC_ID_H264;
if (video_st->codecpar->extradata_size) {
    decoder_ctx->extradata = av_mallocz(video_st->codecpar->extradata_size +
                                        AV_INPUT_BUFFER_PADDING_SIZE);
    if (!decoder_ctx->extradata) {
        ret = AVERROR(ENOMEM);
        goto finish;
    }
}
```

--------------------------------

### Write Vorbis setup header with codebooks, floors, residues, and mappings

Source: https://ffmpeg.org/doxygen/8.0/vorbisenc_8c_source.html

Writes the Vorbis setup header using put_bits functions. It starts by writing a zero comment count and framing bit, then initializes the bitstream for the setup header, writes the magic 'vorbis' string, and writes the number of codebooks, floors, residues, and mappings, followed by their respective headers.

```c
put_bits32(&pb, 0); // amount of comments
put_bits(&pb, 1, 1); // framing

flush_put_bits(&pb);
hlens[1] = put_bytes_output(&pb);
buffer_len -= hlens[1];
p += hlens[1];

// setup header
init_put_bits(&pb, p, buffer_len);
put_bits(&pb, 8, 5); //magic
for (i = 0; "vorbis"[i]; i++)
    put_bits(&pb, 8, "vorbis"[i]);

// codebooks
put_bits(&pb, 8, venc->ncodebooks - 1);
for (i = 0; i < venc->ncodebooks; i++)
    put_codebook_header(&pb, &venc->codebooks[i]);

// time domain, reserved, zero
put_bits(&pb, 6, 0);
put_bits(&pb, 16, 0);

// floors
put_bits(&pb, 6, venc->nfloors - 1);
for (i = 0; i < venc->nfloors; i++)
    put_floor_header(&pb, &venc->floors[i]);

// residues
put_bits(&pb, 6, venc->nresidues - 1);
for (i = 0; i < venc->nresidues; i++)
    put_residue_header(&pb, &venc->residues[i]);

// mappings
put_bits(&pb, 6, venc->nmappings - 1);
```

--------------------------------

### Main function setup

Source: https://ffmpeg.org/doxygen/8.0/encode_audio_8c-example.html

Declares variables for the main function, including filename, codec, codec context, frame, and packet.

```c
int main(int argc, char **argv)

{

const char *filename;

const AVCodec *codec;

AVCodecContext *c= NULL;

AVFrame *frame;

AVPacket *pkt;
```

--------------------------------

### Get BMD timecode from video frame (function start)

Source: https://ffmpeg.org/doxygen/8.0/decklink__dec_8cpp_source.html

Starts the get_bmd_timecode function. Declares a timecode pointer and initializes ret to AVERROR(ENOENT). Conditionally sets hfr based on BLACKMAGIC_DECKLINK_API_VERSION and tc_format. Calls videoFrame->GetTimecode and then GetComponents to extract timecode components.

```cpp
static int get_bmd_timecode(AVFormatContext *avctx, AVTimecode *tc, AVRational frame_rate, BMDTimecodeFormat tc_format, IDeckLinkVideoInputFrame *videoFrame)
{
	IDeckLinkTimecode *timecode;
	int ret = AVERROR(ENOENT);
#if BLACKMAGIC_DECKLINK_API_VERSION >= 0x0b000000
	int hfr = (tc_format == bmdTimecodeRP188HighFrameRate);
#else
	int hfr = 0;
#endif
	if (videoFrame->GetTimecode(tc_format, &timecode) == S_OK) {
		uint8_t hh, mm, ss, ff;
		if (timecode->GetComponents(&hh, &mm, &ss, &ff) == S_OK) {
```

--------------------------------

### main(int argc, char **argv)

Source: https://ffmpeg.org/doxygen/8.0/show__metadata_8c.html

The main entry point of the show_metadata example. It takes command-line arguments (the input file path) and prints the metadata of the specified media file.

```APIDOC
## main(int argc, char **argv)

### Description
This is the main function of the show_metadata example program. It opens the media file specified by the command-line argument, reads its metadata, and prints it to the standard output.

### Method
Function call

### Endpoint
Not applicable (C function)

### Parameters
- **argc** (int) - Required - Number of command-line arguments.
- **argv** (char**) - Required - Array of command-line argument strings. The first argument (argv[1]) should be the input media file path.

### Request Example
Not applicable

### Response
#### Success Response
- Prints the metadata of the media file to stdout.

#### Response Example
Not applicable

### Error Handling
- If the file cannot be opened or metadata cannot be read, the program may exit with an error message.
```

--------------------------------

### IFF decode_frame function signature and setup

Source: https://ffmpeg.org/doxygen/8.0/libavcodec_2iff_8c_source.html

Starts the decode_frame function for the IFF decoder, retrieving the IffContext from priv_data and setting up buffer pointers from the AVPacket.

```c
static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
                        int *got_frame, AVPacket *avpkt)
{
  IffContext *s = avctx->priv_data;
  const uint8_t *buf = avpkt->data;
  int buf_size = avpkt->size;
  const uint8_t *buf_end = buf + buf_size;
  int y, plane, res;
```

--------------------------------

### main function: parse arguments and initialize demo

Source: https://ffmpeg.org/doxygen/8.0/rotozoom_8c_source.html

This function checks that exactly two arguments are provided (image.pnm and file|dir), prints usage if not, attempts to redirect stdout to the second argument, sets default dimensions, allocates rgb_tab, and calls init_demo. Returns 1 on failure.

```c
int main(int argc, char **argv)
{
    int w, h, i;
    char buf[1024];
    int isdir = 0;

    if (argc != 3) {
        printf("usage: %s image.pnm file|dir\n"
               "generate a test video stream\n", argv[0]);
        return 1;
    }

    if (!freopen(argv[2], "wb", stdout))
        isdir = 1;

    w = DEFAULT_WIDTH;
    h = DEFAULT_HEIGHT;

    rgb_tab = malloc(w * h * 3);
    wrap = w * 3;
    width = w;
    height = h;

    if (init_demo(argv[1]))
        return 1;
}
```

--------------------------------

### write_frame function signature and setup (alacenc.c)

Source: https://ffmpeg.org/doxygen/8.0/alacenc_8c_source.html

This is the start of the write_frame function, which sets up the PutBitContext, channel count, channel elements, and channel layout offsets.

```c
static int write_frame(AlacEncodeContext *s, AVPacket *avpkt,
                       uint8_t * const *samples)
{
    PutBitContext *pb = &s->pbctx;
    int channels = s->avctx->ch_layout.nb_channels;
    const enum AlacRawDataBlockType *ch_elements = ff_alac_channel_elements[channels - 1];
    const uint8_t *ch_map = ff_alac_channel_layout_offsets[channels - 1];
    int ch, element, sce, cpe;
```

--------------------------------

### write_stream_data function (C)

Source: https://ffmpeg.org/doxygen/8.0/wtvenc_8c_source.html

Starts the write_stream_data function by getting the AVIOContext from the format context and declaring a return variable. The function body is incomplete in the source.

```c
static int write_stream_data(AVFormatContext *s, AVStream *st)
{
    AVIOContext *pb = s->pb;
    int ret;

```

--------------------------------

### VAAPI encode: main() setup and device creation

Source: https://ffmpeg.org/doxygen/8.0/doc_2examples_2vaapi__encode_8c_source.html

Parses command-line arguments (width, height, input file, output file), opens files, creates a VAAPI hardware device context with av_hwdevice_ctx_create, finds the h264_vaapi encoder, and allocates a codec context. Exits with usage message if fewer than 5 arguments are provided.

```c
int main(int argc, char *argv[])
{
 int size, err;
 FILE *fin = NULL, *fout = NULL;
 AVFrame *sw_frame = NULL, *hw_frame = NULL;
 AVCodecContext *avctx = NULL;
 const AVCodec *codec = NULL;
 const char *enc_name = "h264_vaapi";

 if (argc < 5) {
 fprintf(stderr, "Usage: %s <width> <height> <input file> <output file>\n", argv[0]);
 return -1;
 }

 width = atoi(argv[1]);
 height = atoi(argv[2]);
 size = width * height;

 if (!(fin = fopen(argv[3], "r"))) {
 fprintf(stderr, "Fail to open input file : %s\n", strerror(errno));
 return -1;
 }
 if (!(fout = fopen(argv[4], "w+b"))) {
 fprintf(stderr, "Fail to open output file : %s\n", strerror(errno));
 err = -1;
 goto close;
 }

 err = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI,
 NULL, NULL, 0);
 if (err < 0) {
 fprintf(stderr, "Failed to create a VAAPI device. Error code: %s\n", av_err2str(err));
 goto close;
 }

 if (!(codec = avcodec_find_encoder_by_name(enc_name))) {
 fprintf(stderr, "Could not find encoder.\n");
 err = -1;
 goto close;
 }

 if (!(avctx = avcodec_alloc_context3(codec))) {
 err = AVERROR(ENOMEM);
 goto close;
 }

 avctx->width = width;
```
Tokens:
Raw