FFmpeg

https://ffmpeg.org/doxygen/trunk/
Admin
FFmpeg is a comprehensive multimedia framework that provides libraries for encoding, decoding,...
Tokens:22,570,774
Snippets:99,424
Trust Score:9.9
Update:2 months ago
Show doc for...
Tokens:
Raw
### Start MediaCodec

Source: https://ffmpeg.org/doxygen/trunk/mediacodec__wrapper_8h_source.html

Starts the MediaCodec instance.

```c
static int ff_AMediaCodec_start(FFAMediaCodec *codec)
```

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

### Setup Window

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

Creates and maps an XCB window for screen capture, optionally applying shape masks.

```c
static void setup_window(AVFormatContext *s)
{
	XCBGrabContext *c = s->priv_data;
	uint32_t mask = XCB_CW_OVERRIDE_REDIRECT | XCB_CW_EVENT_MASK;
	uint32_t values[] = { 1,
			      XCB_EVENT_MASK_EXPOSURE |
			      XCB_EVENT_MASK_STRUCTURE_NOTIFY };
	av_unused xcb_rectangle_t rect = { 0, 0, c->width, c->height };

	c->window = xcb_generate_id(c->conn);

	xcb_create_window(c->conn, XCB_COPY_FROM_PARENT,
			  c->window,
			  c->screen->root,
			  c->x - c->region_border,
			  c->y - c->region_border,
			  c->width + c->region_border * 2,
			  c->height + c->region_border * 2,
			  0,
			  XCB_WINDOW_CLASS_INPUT_OUTPUT,
			  XCB_COPY_FROM_PARENT,
			  mask, values);

#if CONFIG_LIBXCB_SHAPE
	xcb_shape_rectangles(c->conn, XCB_SHAPE_SO_SUBTRACT,
			     XCB_SHAPE_SK_BOUNDING, XCB_CLIP_ORDERING_UNSORTED,
			     c->window,
			     c->region_border, c->region_border,
			     1, &rect);
#endif

	xcb_map_window(c->conn, c->window);

	draw_rectangle(s);
}
```

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

### Decoder Initialization and Stream Setup

Source: https://ffmpeg.org/doxygen/trunk/ffplay_8c_source.html

Initializes decoders for audio, video, or subtitle streams and starts the corresponding threads.

```c
is->audio_st = ic->streams[stream_index];

if ((ret = decoder_init(&is->auddec, avctx, &is->audioq, is->continue_read_thread)) < 0)
goto fail;
if (is->ic->iformat->flags & AVFMT_NOTIMESTAMPS) {
is->auddec.start_pts = is->audio_st->start_time;
is->auddec.start_pts_tb = is->audio_st->time_base;
}
if ((ret = decoder_start(&is->auddec, audio_thread, "audio_decoder", is)) < 0)
goto out;
SDL_PauseAudioDevice(audio_dev, 0);
break;
case AVMEDIA_TYPE_VIDEO:
is->video_stream = stream_index;
is->video_st = ic->streams[stream_index];

if ((ret = decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread)) < 0)
goto fail;
if ((ret = decoder_start(&is->viddec, video_thread, "video_decoder", is)) < 0)
goto out;
is->queue_attachments_req = 1;
break;
case AVMEDIA_TYPE_SUBTITLE:
is->subtitle_stream = stream_index;
is->subtitle_st = ic->streams[stream_index];

if ((ret = decoder_init(&is->subdec, avctx, &is->subtitleq, is->continue_read_thread)) < 0)
goto fail;
if ((ret = decoder_start(&is->subdec, subtitle_thread, "subtitle_decoder", is)) < 0)
goto out;
break;
```

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

### Operation Setup Functions

Source: https://ffmpeg.org/doxygen/trunk/x86_2ops_8c_source.html

Various setup functions for scaling, clearing, dithering, and linear operations.

```c
static int setup_scale(const SwsImplParams *params, SwsImplResult *out)
{
const SwsUOp *uop = params->uop;
switch (uop->type) {
case SWS_PIXEL_U8: out->priv.u16[0] = uop->data.scalar.u8; break; /* for pmullw */
case SWS_PIXEL_U16: out->priv.u16[0] = uop->data.scalar.u16; break;
case SWS_PIXEL_U32: out->priv.u32[0] = uop->data.scalar.u32; break;
case SWS_PIXEL_F32: out->priv.f32[0] = uop->data.scalar.f32; break;
default: return AVERROR(EINVAL);
}

return 0;
}

static int setup_clear(const SwsImplParams *params, SwsImplResult *out)
{
const SwsUOp *uop = params->uop;
for (int i = 0; i < 4; i++)
out->priv.u32[i] = uop->data.vec4[i].u32;
return 0;
}

static int setup_dither(const SwsImplParams *params, SwsImplResult *out)
{
out->priv.ptr = av_refstruct_ref(params->uop->data.ptr);
out->free = ff_op_priv_unref;
return 0;
}

static int setup_linear(const SwsImplParams *params, SwsImplResult *out)
{
const SwsUOp *uop = params->uop;
out->priv.ptr = av_memdup(uop->data.mat4, sizeof(uop->data.mat4));
out->free = ff_op_priv_free;
return out->priv.ptr ? 0 : AVERROR(ENOMEM);
}
```

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

### Get GUID

Source: https://ffmpeg.org/doxygen/trunk/asfdec__o_8c_source.html

Reads a GUID from an AVIOContext.

```c
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
```

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

### Main Entry Point

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

Initializes the output media context and handles command line arguments.

```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) {
if (!strcmp(argv[i], "-flags") || !strcmp(argv[i], "-fflags"))
av_dict_set(&opt, argv[i]+1, argv[i+1], 0);
}
/* allocate the output media context */
avformat_alloc_output_context2(&oc, NULL, NULL, filename);
if (!oc) {

```

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

### Get Start Offset

Source: https://ffmpeg.org/doxygen/trunk/rv34_8c_source.html

Decodes the starting slice position from the bitstream.

```c
int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size)
{
int i;
for(i = 0; i < 5; i++)
if(rv34_mb_max_sizes[i] >= mb_size - 1)
break;
return get_bits(gb, rv34_mb_bits_sizes[i]);
}
```

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

### Compile and Invoke qt-faststart

Source: https://ffmpeg.org/doxygen/trunk/qt-faststart_8c_source.html

Instructions for building the utility within the FFmpeg environment and the command syntax for execution.

```bash
make tools/qt-faststart
qt-faststart <infile.mov> <outfile.mov>
```

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

### Get codec GUID

Source: https://ffmpeg.org/doxygen/trunk/riff_8h_source.html

Retrieves the GUID associated with a codec ID.

```c
const ff_asf_guid * ff_get_codec_guid(enum AVCodecID id, const AVCodecGuid *av_guid)
```

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

### Main Audio Encoding Setup

Source: https://ffmpeg.org/doxygen/trunk/encode__audio_8c_source.html

Initializes the codec context, configures parameters, and prepares the environment for encoding.

```c
int main(int argc, char **argv)
{
const char *filename;
const AVCodec *codec;
AVCodecContext *c= NULL;
AVFrame *frame;
AVPacket *pkt;
int i, j, k, ret;
FILE *f;
uint16_t *samples;
float t, tincr;

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

/* find the MP2 encoder */
codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
if (!codec) {
fprintf(stderr, "Codec not found\n");
exit(1);
}

c = avcodec_alloc_context3(codec);
if (!c) {
fprintf(stderr, "Could not allocate audio codec context\n");
exit(1);
}

/* put sample parameters */
c->bit_rate = 64000;

/* check that the encoder supports s16 pcm input */
c->sample_fmt = AV_SAMPLE_FMT_S16;
if (!check_sample_fmt(codec, c->sample_fmt)) {
fprintf(stderr, "Encoder does not support sample format %s",
av_get_sample_fmt_name(c->sample_fmt));
exit(1);
}

/* select other audio parameters supported by the encoder */
c->sample_rate = select_sample_rate(codec);
ret = select_channel_layout(codec, &c->ch_layout);
if (ret < 0)
exit(1);

/* open it */
if (avcodec_open2(c, codec, NULL) < 0) {
fprintf(stderr, "Could not open codec\n");
exit(1);
}

f = fopen(filename, "wb");
if (!f) {
fprintf(stderr, "Could not open %s\n", filename);
exit(1);
}

/* packet for holding encoded output */
pkt = av_packet_alloc();
if (!pkt) {
fprintf(stderr, "could not allocate the packet\n");
exit(1);
}

/* frame containing input raw audio */
frame = av_frame_alloc();
```

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

### Get FourCC from GUID

Source: https://ffmpeg.org/doxygen/trunk/mf__utils_8h_source.html

Retrieves a FourCC code from a given GUID.

```c
int ff_fourcc_from_guid(const GUID *guid, uint32_t *out_fourcc)
```

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

### Main application initialization

Source: https://ffmpeg.org/doxygen/trunk/ffprobe_8c_source.html

The entry point for ffprobe, handling environment setup, option parsing, and flag initialization.

```c
3366 int main(int argc, char **argv)
3367 {
3368 const AVTextFormatter *f;
3369 AVTextFormatContext *tctx;
3370 AVTextWriterContext *wctx;
3371 char *buf;
3372 char *f_name = NULL, *f_args = NULL;
3373 int ret, input_ret;
3374 AVTextFormatDataDump data_dump_format_id = AV_TEXTFORMAT_DATADUMP_XXD;
3375
3376 init_dynload();
3377
3378 setvbuf(stderr, NULL, _IONBF, 0); /* win32 runtime needs this */
3379
3380 av_log_set_flags(AV_LOG_SKIP_REPEATED);
3381
3382 options = real_options;
3383 parse_loglevel(argc, argv, options);
3384 avformat_network_init();
3385 #if CONFIG_AVDEVICE
3386 avdevice_register_all();
3387 #endif
3388
3389 show_banner(argc, argv, options);
3390 ret = parse_options(NULL, argc, argv, options, opt_input_file);
3391 if (ret < 0) {
3392 ret = (ret == AVERROR_EXIT) ? 0 : ret;
3393 goto end;
3394 }
3395
3396 if (do_show_log)
3397 av_log_set_callback(log_callback);
3398
3399 /* mark things to show, based on -show_entries */
3400 SET_DO_SHOW(CHAPTERS, chapters);
3401 SET_DO_SHOW(ERROR, error);
3402 SET_DO_SHOW(FORMAT, format);
3403 SET_DO_SHOW(FRAMES, frames);
3404 SET_DO_SHOW(LIBRARY_VERSIONS, library_versions);
3405 SET_DO_SHOW(PACKETS, packets);
3406 SET_DO_SHOW(PIXEL_FORMATS, pixel_formats);
3407 SET_DO_SHOW(PIXEL_FORMAT_FLAGS, pixel_format_flags);
3408 SET_DO_SHOW(PIXEL_FORMAT_COMPONENTS, pixel_format_components);
3409 SET_DO_SHOW(PROGRAM_VERSION, program_version);
3410 SET_DO_SHOW(PROGRAMS, programs);
3411 SET_DO_SHOW(STREAM_GROUP_DISPOSITION, stream_group_disposition);
3412 SET_DO_SHOW(STREAM_GROUPS, stream_groups);
3413 SET_DO_SHOW(STREAM_GROUP_COMPONENTS, stream_group_components);
3414 SET_DO_SHOW(STREAMS, streams);
3415 SET_DO_SHOW(STREAM_DISPOSITION, stream_disposition);
3416 SET_DO_SHOW(PROGRAM_STREAM_DISPOSITION, stream_disposition);
3417 SET_DO_SHOW(STREAM_GROUP_STREAM_DISPOSITION, stream_disposition);
3418
3419 SET_DO_SHOW(CHAPTER_TAGS, chapter_tags);
```

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

### Get codec ID from GUID

Source: https://ffmpeg.org/doxygen/trunk/riff_8h_source.html

Retrieves the codec ID corresponding to a specific GUID.

```c
enum AVCodecID ff_codec_guid_get_id(const AVCodecGuid *guids, ff_asf_guid guid)
```

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

### Main Entry Point

Source: https://ffmpeg.org/doxygen/trunk/qsv_transcode_8c-example.html

Parses command line arguments and initializes dynamic settings for the transcoding process.

```c
int main(int argc, char **argv)
{
const AVCodec *enc_codec;
int ret = 0;
AVPacket *dec_pkt = NULL;
if (argc < 5 || (argc - 5) % 2) {
av_log(NULL, AV_LOG_ERROR, "Usage: %s <input file> <encoder> <output file>"
" <\"encoding option set 0\"> [<frame_number> <\"encoding options set 1\">]...\n", argv[0]);
return 1;
}
setting_number = (argc - 5) / 2;
dynamic_setting = av_malloc(setting_number * sizeof(*dynamic_setting));
if (!dynamic_setting) {
ret = AVERROR(ENOMEM);
goto end;
}
current_setting_number = 0;
for (int i = 0; i < setting_number; i++) {
dynamic_setting[i].frame_number = atoi(argv[i*2 + 5]);
dynamic_setting[i].optstr = argv[i*2 + 6];
}
```

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

### Get Start Index and Number

Source: https://ffmpeg.org/doxygen/trunk/dashenc_8c_source.html

Initializes the starting index and number for DASH segments.

```c
368 static void get_start_index_number(OutputStream *os, DASHContext *c,
369 int *start_index, int *start_number) {
370 *start_index = 0;
371 *start_number = 1;
```

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

### Get Start of Tile Segment

Source: https://ffmpeg.org/doxygen/trunk/jpeg2000dec_8c_source.html

Parses the Start of Tile (SOT) marker and initializes tile-part structures.

```c
static int get_sot(Jpeg2000DecoderContext *s, int n)
{
Jpeg2000TilePart *tp;
uint16_t Isot;
uint32_t Psot;
unsigned TPsot;

if (bytestream2_get_bytes_left(&s->g) < 8)
return AVERROR_INVALIDDATA;

s->curtileno = 0;
Isot = bytestream2_get_be16u(&s->g); // Isot
if (Isot >= s->numXtiles * s->numYtiles)
return AVERROR_INVALIDDATA;

s->curtileno = Isot;
Psot = bytestream2_get_be32u(&s->g); // Psot
TPsot = bytestream2_get_byteu(&s->g); // TPsot

/* Read TNSot but not used */
bytestream2_get_byteu(&s->g); // TNsot

if (!Psot)
Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;

if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
return AVERROR_INVALIDDATA;
}

if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
avpriv_request_sample(s->avctx, "Too many tile parts");
return AVERROR_PATCHWELCOME;
}

s->tile[Isot].tp_idx = TPsot;
tp = s->tile[Isot].tile_part + TPsot;
tp->tile_index = Isot;
tp->tp_end = s->g.buffer + Psot - n - 2;

if (!TPsot) {
Jpeg2000Tile *tile = s->tile + s->curtileno;

/* copy defaults */
memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
tile->poc.is_default = 1;
}

return 0;
}
```

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

### Initialize and Execute QSV Transcoding

Source: https://ffmpeg.org/doxygen/trunk/qsv_transcode_8c-example.html

This snippet demonstrates the setup of a QSV hardware device, input/output file handling, and the main transcoding loop.

```c
ret = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_QSV, NULL, NULL, 0);
if (ret < 0) {
fprintf(stderr, "Failed to create a QSV device. Error code: %s\n", av_err2str(ret));
goto end;
}
dec_pkt = av_packet_alloc();
if (!dec_pkt) {
fprintf(stderr, "Failed to allocate decode packet\n");
goto end;
}
if ((ret = open_input_file(argv[1])) < 0)
goto end;
if (!(enc_codec = avcodec_find_encoder_by_name(argv[2]))) {
fprintf(stderr, "Could not find encoder '%s'\n", argv[2]);
ret = -1;
goto end;
}
if ((ret = (avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, argv[3]))) < 0) {
fprintf(stderr, "Failed to deduce output format from file extension. Error code: "
"%s\n", av_err2str(ret));
goto end;
}
if (!(encoder_ctx = avcodec_alloc_context3(enc_codec))) {
ret = AVERROR(ENOMEM);
goto end;
}
ret = avio_open(&ofmt_ctx->pb, argv[3], AVIO_FLAG_WRITE);
if (ret < 0) {
fprintf(stderr, "Cannot open output file. "
"Error code: %s\n", av_err2str(ret));
goto end;
}
/* read all packets and only transcoding video */
while (ret >= 0) {
if ((ret = av_read_frame(ifmt_ctx, dec_pkt)) < 0)
break;
if (video_stream == dec_pkt->stream_index)
ret = dec_enc(dec_pkt, enc_codec, argv[4]);
av_packet_unref(dec_pkt);
}
/* flush decoder */
av_packet_unref(dec_pkt);
if ((ret = dec_enc(dec_pkt, enc_codec, argv[4])) < 0) {
fprintf(stderr, "Failed to flush decoder %s\n", av_err2str(ret));
goto end;
}
/* flush encoder */
if ((ret = encode_write(dec_pkt, NULL)) < 0) {
fprintf(stderr, "Failed to flush encoder %s\n", av_err2str(ret));
goto end;
}
/* write the trailer for output stream */
if ((ret = av_write_trailer(ofmt_ctx)) < 0)
fprintf(stderr, "Failed to write trailer %s\n", av_err2str(ret));
end:
avformat_close_input(&ifmt_ctx);
if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
avio_closep(&ofmt_ctx->pb);
avformat_free_context(ofmt_ctx);
avcodec_free_context(&decoder_ctx);
avcodec_free_context(&encoder_ctx);
av_buffer_unref(&hw_device_ctx);
av_packet_free(&dec_pkt);
av_freep(&dynamic_setting);
return ret;
}
```

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

### Get segment start time based on timeline

Source: https://ffmpeg.org/doxygen/trunk/dashdec_8c_source.html

Calculates the start time of a segment using the representation timeline.

```c
static int64_t get_segment_start_time_based_on_timeline(struct representation *pls, int64_t cur_seq_no)
```

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

### Initialize SRT Setup Function

Source: https://ffmpeg.org/doxygen/trunk/libsrt_8c_source.html

Defines the entry point for setting up an SRT URL context, including address info and local variables.

```c
391 static int libsrt_setup(URLContext *h, const char *uri, int flags)
392 {
393 struct addrinfo hints = { 0 }, *ai, *cur_ai;
394 int port, fd;
395 SRTContext *s = h->priv_data;
396 int ret;
397 char hostname[1024],proto[1024],path[1024];
398 char portstr[10];
399 int64_t open_timeout = 0;
```

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

### Start MPEG Field Decoding

Source: https://ffmpeg.org/doxygen/trunk/mpeg12dec_8c_source.html

Manages the start of frame or field decoding, including side data allocation and hardware acceleration setup.

```c
static int mpeg_field_start(Mpeg1Context *s1, const uint8_t *buf, int buf_size)
{
MPVContext *const s = &s1->slice.c;
AVCodecContext *avctx = s->avctx;
int second_field = 0;
int ret;

if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
if (s->mb_width * s->mb_height * 11LL / (33 * 2 * 8) > buf_size)
return AVERROR_INVALIDDATA;
}

/* start frame decoding */
if (s->first_field || s->picture_structure == PICT_FRAME) {
AVFrameSideData *pan_scan;

if ((ret = ff_mpv_frame_start(s, avctx)) < 0)
return ret;

if (s->picture_structure != PICT_FRAME) {
s->cur_pic.ptr->f->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST *
(s->picture_structure == PICT_TOP_FIELD);

for (int i = 0; i < 3; i++) {
if (s->picture_structure == PICT_BOTTOM_FIELD) {
s->cur_pic.data[i] = FF_PTR_ADD(s->cur_pic.data[i],
s->cur_pic.linesize[i]);
}
s->cur_pic.linesize[i] *= 2;
}
}

ff_mpeg_er_frame_start(s);

/* first check if we must repeat the frame */
s->cur_pic.ptr->f->repeat_pict = 0;
if (s->repeat_first_field) {
if (s->progressive_sequence) {
if (s->top_field_first)
s->cur_pic.ptr->f->repeat_pict = 4;
else
s->cur_pic.ptr->f->repeat_pict = 2;
} else if (s->progressive_frame) {
s->cur_pic.ptr->f->repeat_pict = 1;
}
}

ret = ff_frame_new_side_data(s->avctx, s->cur_pic.ptr->f,
AV_FRAME_DATA_PANSCAN, sizeof(s1->pan_scan),
&pan_scan);
if (ret < 0)
return ret;
if (pan_scan)
memcpy(pan_scan->data, &s1->pan_scan, sizeof(s1->pan_scan));

if (s1->a53_buf_ref) {
ret = ff_frame_new_side_data_from_buf(
s->avctx, s->cur_pic.ptr->f, AV_FRAME_DATA_A53_CC,
&s1->a53_buf_ref);
if (ret < 0)
return ret;
}

if (s1->has_stereo3d) {
AVStereo3D *stereo = av_stereo3d_create_side_data(s->cur_pic.ptr->f);
if (!stereo)
return AVERROR(ENOMEM);

stereo->type = s1->stereo3d_type;
s1->has_stereo3d = 0;
}

if (s1->has_afd) {
AVFrameSideData *sd;
ret = ff_frame_new_side_data(s->avctx, s->cur_pic.ptr->f,
AV_FRAME_DATA_AFD, 1, &sd);
if (ret < 0)
return ret;
if (sd)
*sd->data = s1->afd;
s1->has_afd = 0;
}
} else { // second field
second_field = 1;
if (!s->cur_pic.ptr) {
av_log(s->avctx, AV_LOG_ERROR, "first field missing\n");
return AVERROR_INVALIDDATA;
}

if (s->avctx->hwaccel) {
if ((ret = FF_HW_SIMPLE_CALL(s->avctx, end_frame)) < 0) {
av_log(avctx, AV_LOG_ERROR,
"hardware accelerator failed to decode first field\n");
return ret;
}
}
ret = ff_mpv_alloc_dummy_frames(s);
if (ret < 0)
return ret;

for (int i = 0; i < 3; i++) {
s->cur_pic.data[i] = s->cur_pic.ptr->f->data[i];
if (s->picture_structure == PICT_BOTTOM_FIELD)
s->cur_pic.data[i] +=
s->cur_pic.ptr->f->linesize[i];
}
}

if (avctx->hwaccel) {
if ((ret = FF_HW_CALL(avctx, start_frame, NULL, buf, buf_size)) < 0)
return ret;
} else if (s->codec_tag == MKTAG('V', 'C', 'R', '2')) {
// Exchange UV
FFSWAP(uint8_t*, s->cur_pic.data[1], s->cur_pic.data[2]);
FFSWAP(ptrdiff_t, s->cur_pic.linesize[1], s->cur_pic.linesize[2]);
if (!second_field) {
FFSWAP(uint8_t*, s->next_pic.data[1], s->next_pic.data[2]);
```

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

### Include headers and copyright notice

Source: https://ffmpeg.org/doxygen/trunk/h264__qpel_8c_source.html

Initial file setup including copyright headers and standard library dependencies.

```c
/*
* Copyright (c) 2004-2005 Michael Niedermayer, Loren Merritt
* Copyright (c) 2011 Daniel Kang
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/

#include <stddef.h>

#include "libavutil/attributes.h"
#include "libavutil/avassert.h"
#include "libavutil/cpu.h"
```

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

### Main Entry Point

Source: https://ffmpeg.org/doxygen/trunk/tests_2movenc_8c_source.html

Parses command line arguments and initializes the MD5 and packet contexts.

```c
388 int main(int argc, char **argv)
389 {
390 int c;
391 uint8_t header[HASH_SIZE];
392 uint8_t content[HASH_SIZE];
393 int empty_moov_pos;
394 int prev_pos;
395
396 for (;;) {
397 c = getopt(argc, argv, "wh");
398 if (c == -1)
399 break;
400 switch (c) {
401 case 'w':
402 write_file = 1;
403 break;
404 default:
405 case 'h':
406 help();
407 return 0;
408 }
409 }
410
411 md5 = av_md5_alloc();
412 if (!md5)
413 return 1;
414 pkt = av_packet_alloc();
415 if (!pkt) {
416 av_free(md5);
417 return 1;
418 }
```

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

### FFmpeg Hashing API Initialization

Source: https://ffmpeg.org/doxygen/trunk/ffhash_8c-example.html

Initial setup and includes for the FFmpeg hashing API example.

```c
/*
* Copyright (c) 2002 Fabrice Bellard
* Copyright (c) 2013 Michael Niedermayer
* Copyright (c) 2013 James Almer
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "config.h"
#include "libavutil/avstring.h"
```

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

### Main Entry Point

Source: https://ffmpeg.org/doxygen/trunk/sws__ops_8c_source.html

Initializes the context and graph, parses command-line arguments, and initiates the operation list enumeration.

```c
int main(int argc, char **argv)
{
enum AVPixelFormat src_fmt = AV_PIX_FMT_NONE;
enum AVPixelFormat dst_fmt = AV_PIX_FMT_NONE;
SwsContext *ctx = NULL;
SwsGraph *graph = NULL;
int ret = 1;

#ifdef _WIN32
_setmode(_fileno(stdout), _O_BINARY);
#endif

for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-help") || !strcmp(argv[i], "--help")) {
fprintf(stderr,
"sws_ops [options...]\n"
" -help\n"
" This text\n"
" -dst <pixfmt>\n"
" Only test the specified destination pixel format\n"
" -src <pixfmt>\n"
" Only test the specified source pixel format\n"
" -v <level>\n"
" Enable log verbosity at given level\n"
);
return 0;
}
if (!strcmp(argv[i], "-src")) {
if (i + 1 >= argc)
goto bad_option;
src_fmt = av_get_pix_fmt(argv[i + 1]);
if (src_fmt == AV_PIX_FMT_NONE) {
fprintf(stderr, "invalid pixel format %s\n", argv[i + 1]);
return AVERROR(EINVAL);
}
i++;
} else if (!strcmp(argv[i], "-dst")) {
if (i + 1 >= argc)
goto bad_option;
dst_fmt = av_get_pix_fmt(argv[i + 1]);
if (dst_fmt == AV_PIX_FMT_NONE) {
fprintf(stderr, "invalid pixel format %s\n", argv[i + 1]);
return AVERROR(EINVAL);
}
i++;
} else if (!strcmp(argv[i], "-v")) {
if (i + 1 >= argc)
goto bad_option;
av_log_set_level(atoi(argv[i + 1]));
i++;
} else {
bad_option:
fprintf(stderr, "bad option or argument missing (%s) see -help\n", argv[i]);
return AVERROR(EINVAL);
}
}

/* Allocate dummy graph and context for ff_sws_compile_pass() */
graph = ff_sws_graph_alloc();
if (!graph)
goto fail;
graph->ctx = ctx = sws_alloc_context();
if (!ctx)
goto fail;
ctx->scaler = SWS_SCALE_BILINEAR; /* reduce filter generation overhead */

av_log_set_callback(log_stdout);

ret = ff_sws_enum_op_lists(ctx, graph, src_fmt, dst_fmt, print_passes);
if (ret < 0)
goto fail;

ret = 0;
fail:
sws_free_context(&ctx);
ff_sws_graph_free(&graph);
return ret;
}
```

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

### Get Relative Time

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

Retrieves the current time in microseconds since an unspecified starting point.

```c
int64_t av_gettime_relative(void)
```

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

### Main Entry Point

Source: https://ffmpeg.org/doxygen/trunk/api-band-test_8c_source.html

Initializes the video decoding process by validating command line arguments.

```c
221 int main(int argc, char **argv)
222 {
223 if (argc < 2)
224 {
225 av_log(NULL, AV_LOG_ERROR, "Incorrect input: expected %s <name of a video file>\n", argv[0]);
226 return 1;
227 }
228
229 if (video_decode(argv[1]) != 0)
230 return 1;
231
232 return 0;
233 }
```

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

### Get OpenCL Event Time

Source: https://ffmpeg.org/doxygen/trunk/opencl_8c_source.html

Calculates the duration between command start and end times for an OpenCL event.

```c
cl_ulong ff_opencl_get_event_time(cl_event event)
```

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

### Include Guard and Initial Setup

Source: https://ffmpeg.org/doxygen/trunk/x86_2mathops_8h_source.html

Defines the header guard and includes necessary configuration and common utility headers.

```c
1 /*
2 * simple math operations
3 * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> et al
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #ifndef AVCODEC_X86_MATHOPS_H
23 #define AVCODEC_X86_MATHOPS_H
24
25 #include "config.h"
26
27 #include "libavutil/common.h"
28
29 #if HAVE_INLINE_ASM
```

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

### ff_aptx_init

Source: https://ffmpeg.org/doxygen/trunk/aptx_8h.html

Initializes the APTX codec context.

```c
int ff_aptx_init(AVCodecContext * _avctx_)
```

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

### Setup Hardware Acceleration Device

Source: https://ffmpeg.org/doxygen/trunk/nvenc_8c_source.html

Configures the encoder GUID and maps hardware frames or device contexts for CUDA or D3D11VA.

```c
713 static av_cold int nvenc_setup_device(AVCodecContext *avctx)
714 {
715 NvencContext *ctx = avctx->priv_data;
716 NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs;
717
718 switch (avctx->codec->id) {
719 case AV_CODEC_ID_H264:
720 ctx->init_encode_params.encodeGUID = NV_ENC_CODEC_H264_GUID;
721 break;
722 case AV_CODEC_ID_HEVC:
723 ctx->init_encode_params.encodeGUID = NV_ENC_CODEC_HEVC_GUID;
724 break;
725 #if CONFIG_AV1_NVENC_ENCODER
726 case AV_CODEC_ID_AV1:
727 ctx->init_encode_params.encodeGUID = NV_ENC_CODEC_AV1_GUID;
728 break;
729 #endif
730 default:
731 return AVERROR_BUG;
732 }
733
734 nvenc_map_preset(ctx);
735
736 if (IS_HWACCEL(avctx->pix_fmt) ||
737 avctx->hw_frames_ctx || avctx->hw_device_ctx) {
738 AVHWFramesContext *frames_ctx;
739 AVHWDeviceContext *hwdev_ctx;
740 AVCUDADeviceContext *cuda_device_hwctx = NULL;
741 #if CONFIG_D3D11VA
742 AVD3D11VADeviceContext *d3d11_device_hwctx = NULL;
743 #endif
744 int ret;
745
746 if (avctx->hw_frames_ctx) {
747 frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
748 if (frames_ctx->format == AV_PIX_FMT_CUDA || frames_ctx->format == AV_PIX_FMT_CUARRAY)
749 cuda_device_hwctx = frames_ctx->device_ctx->hwctx;
750 #if CONFIG_D3D11VA
751 else if (frames_ctx->format == AV_PIX_FMT_D3D11)
752 d3d11_device_hwctx = frames_ctx->device_ctx->hwctx;
753 #endif
754 else
755 return AVERROR(EINVAL);
756 } else if (avctx->hw_device_ctx) {
757 hwdev_ctx = (AVHWDeviceContext*)avctx->hw_device_ctx->data;
758 if (hwdev_ctx->type == AV_HWDEVICE_TYPE_CUDA)
759 cuda_device_hwctx = hwdev_ctx->hwctx;
760 #if CONFIG_D3D11VA
761 else if (hwdev_ctx->type == AV_HWDEVICE_TYPE_D3D11VA)
762 d3d11_device_hwctx = hwdev_ctx->hwctx;
763 #endif
764 else
765 return AVERROR(EINVAL);
766 } else {
767 return AVERROR(EINVAL);
768 }
769
770 if (cuda_device_hwctx) {
771 ctx->cu_context = cuda_device_hwctx->cuda_ctx;
772 ctx->cu_stream = cuda_device_hwctx->stream;
773 }
774 #if CONFIG_D3D11VA
775 else if (d3d11_device_hwctx) {
776 ctx->d3d11_device = d3d11_device_hwctx->device;
777 ID3D11Device_AddRef(ctx->d3d11_device);
778 }
779 #endif
780
781 ret = nvenc_open_session(avctx);
782 if (ret < 0)
783 return ret;
784
785 ret = nvenc_check_capabilities(avctx);
786 if (ret < 0) {
```

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

### Transcoding Pipeline Implementation

Source: https://ffmpeg.org/doxygen/trunk/transcode_8c-example.html

This example demonstrates the full lifecycle of media processing including opening input/output files, setting up decoders and encoders, and managing stream contexts.

```c
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
#include <libavutil/channel_layout.h>
#include <libavutil/mem.h>
#include <libavutil/opt.h>
#include <libavutil/pixdesc.h>
static AVFormatContext *ifmt_ctx;
static AVFormatContext *ofmt_ctx;
typedef struct FilteringContext {
AVFilterContext *buffersink_ctx;
AVFilterContext *buffersrc_ctx;
AVFilterGraph *filter_graph;
AVPacket *enc_pkt;
AVFrame *filtered_frame;
} FilteringContext;
static FilteringContext *filter_ctx;
typedef struct StreamContext {
AVCodecContext *dec_ctx;
AVCodecContext *enc_ctx;
AVFrame *dec_frame;
} StreamContext;
static StreamContext *stream_ctx;
static int open_input_file(const char *filename)
{
int ret;
unsigned int i;
ifmt_ctx = NULL;
if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
return ret;
}
if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
return ret;
}
stream_ctx = av_calloc(ifmt_ctx->nb_streams, sizeof(*stream_ctx));
if (!stream_ctx)
return AVERROR(ENOMEM);
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
AVStream *stream = ifmt_ctx->streams[i];
const AVCodec *dec = avcodec_find_decoder(stream->codecpar->codec_id);
AVCodecContext *codec_ctx;
if (!dec) {
av_log(NULL, AV_LOG_ERROR, "Failed to find decoder for stream #%u\n", i);
return AVERROR_DECODER_NOT_FOUND;
}
codec_ctx = avcodec_alloc_context3(dec);
if (!codec_ctx) {
av_log(NULL, AV_LOG_ERROR, "Failed to allocate the decoder context for stream #%u\n", i);
return AVERROR(ENOMEM);
}
ret = avcodec_parameters_to_context(codec_ctx, stream->codecpar);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to copy decoder parameters to input decoder context "
"for stream #%u\n", i);
return ret;
}
/* Inform the decoder about the timebase for the packet timestamps.
* This is highly recommended, but not mandatory. */
codec_ctx->pkt_timebase = stream->time_base;
/* Reencode video & audio and remux subtitles etc. */
if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
|| codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
codec_ctx->framerate = av_guess_frame_rate(ifmt_ctx, stream, NULL);
/* Open decoder */
ret = avcodec_open2(codec_ctx, dec, NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
return ret;
}
}
stream_ctx[i].dec_ctx = codec_ctx;
stream_ctx[i].dec_frame = av_frame_alloc();
if (!stream_ctx[i].dec_frame)
return AVERROR(ENOMEM);
}
av_dump_format(ifmt_ctx, 0, filename, 0);
return 0;
}
static int open_output_file(const char *filename)
{
AVStream *out_stream;
AVStream *in_stream;
AVCodecContext *dec_ctx, *enc_ctx;
const AVCodec *encoder;
int ret;
unsigned int i;
ofmt_ctx = NULL;
avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename);
if (!ofmt_ctx) {
av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");
return AVERROR_UNKNOWN;
}
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
out_stream = avformat_new_stream(ofmt_ctx, NULL);
if (!out_stream) {
av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
return AVERROR_UNKNOWN;
}
in_stream = ifmt_ctx->streams[i];
dec_ctx = stream_ctx[i].dec_ctx;
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
|| dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
/* in this example, we choose transcoding to same codec */
encoder = avcodec_find_encoder(dec_ctx->codec_id);
if (!encoder) {
av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");
return AVERROR_INVALIDDATA;
}
enc_ctx = avcodec_alloc_context3(encoder);
if (!enc_ctx) {
av_log(NULL, AV_LOG_FATAL, "Failed to allocate the encoder context\n");
return AVERROR(ENOMEM);
}
/* In this example, we transcode to same properties (picture size,
* sample rate etc.). These properties can be changed for output
* streams easily using filters */
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
const enum AVPixelFormat *pix_fmts = NULL;
enc_ctx->height = dec_ctx->height;
enc_ctx->width = dec_ctx->width;
enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;
ret = avcodec_get_supported_config(enc_ctx, NULL,
AV_CODEC_CONFIG_PIX_FORMAT, 0,
(const void**)&pix_fmts, NULL);
/* take first format from list of supported formats */
enc_ctx->pix_fmt = (ret >= 0 && pix_fmts) ?
pix_fmts[0] : dec_ctx->pix_fmt;
/* video time_base can be set to whatever is handy and supported by encoder */
enc_ctx->time_base = av_inv_q(dec_ctx->framerate);
} else {
const enum AVSampleFormat *sample_fmts = NULL;
```

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

### Get Concat Demuxer Selection

Source: https://ffmpeg.org/doxygen/trunk/f__select_8c_source.html

Determines frame selection based on concat demuxer metadata start time and duration.

```c
static double get_concatdec_select(AVFrame *frame, int64_t pts)
{
AVDictionary *metadata = frame->metadata;
AVDictionaryEntry *start_time_entry = av_dict_get(metadata, "lavf.concatdec.start_time", NULL, 0);
AVDictionaryEntry *duration_entry = av_dict_get(metadata, "lavf.concatdec.duration", NULL, 0);
if (start_time_entry) {
int64_t start_time = strtoll(start_time_entry->value, NULL, 10);
if (pts >= start_time) {
if (duration_entry) {
int64_t duration = strtoll(duration_entry->value, NULL, 10);
if (pts < start_time + duration)
return -1;
else
return 0;
}
return -1;
}
return 0;
}
return NAN;
}
```

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

### FFmpeg Main Entry Point

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

Initializes the application, parses command-line options, executes the transcoding process, and handles cleanup.

```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 */

	av_log_set_flags(AV_LOG_SKIP_REPEATED);
	parse_loglevel(argc, argv, options);

#if CONFIG_AVDEVICE
	avdevice_register_all();
#endif
	avformat_network_init();

	show_banner(argc, argv, options);

	sch = sch_alloc();
	if (!sch) {
		ret = AVERROR(ENOMEM);
		goto finish;
	}

	/* parse options and open all input/output files */
	ret = ffmpeg_parse_options(argc, argv, sch);
	if (ret < 0)
		goto finish;

	if (nb_output_files <= 0 && nb_input_files == 0) {
		show_usage();
		av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
		ret = 1;
		goto finish;
	}

	if (nb_output_files <= 0) {
		av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
		ret = 1;
		goto finish;
	}

#if CONFIG_MEDIACODEC
	android_binder_threadpool_init_if_required();
#endif

	current_time = ti = get_benchmark_time_stamps();
	ret = transcode(sch);
	if (ret >= 0 && do_benchmark) {
		int64_t utime, stime, rtime;
		current_time = get_benchmark_time_stamps();
		utime = current_time.user_usec - ti.user_usec;
		stime = current_time.sys_usec - ti.sys_usec;
		rtime = current_time.real_usec - ti.real_usec;
		av_log(NULL, AV_LOG_INFO,
			"bench: utime=%0.3fs stime=%0.3fs rtime=%0.3fs\n",
			utime / 1000000.0, stime / 1000000.0, rtime / 1000000.0);
	}

	ret = received_nb_signals ? 255 :
		(ret == FFMPEG_ERROR_RATE_EXCEEDED) ? 69 : ret;

finish:
	if (ret == AVERROR_EXIT)
		ret = 0;

	ffmpeg_cleanup(ret);

	sch_free(&sch);

	av_log(NULL, AV_LOG_VERBOSE, "\n");
	av_log(NULL, AV_LOG_VERBOSE, "Exiting with exit code %d\n", ret);

	return ret;
}
```
Tokens:
Raw