Basic attempt at injecting and reading back user data unregistered (UDU) supplemental enhancement information (SEI) with ffmpeg / libav.
Some references:
Basic attempt at injecting and reading back user data unregistered (UDU) supplemental enhancement information (SEI) with ffmpeg / libav.
Some references:
*.dSYM | |
test.* | |
mux_withsei | |
demux_decode_withsei |
/* | |
* Copyright (c) 2012 Stefano Sabatini | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions: | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
*/ | |
/** | |
* @file libavformat and libavcodec demuxing and decoding API usage example | |
* @example demux_decode.c | |
* | |
* Show how to use the libavformat and libavcodec API to demux and decode audio | |
* and video data. Write the output as raw audio and input files to be played by | |
* ffplay. | |
*/ | |
#include <libavutil/imgutils.h> | |
#include <libavutil/samplefmt.h> | |
#include <libavutil/timestamp.h> | |
/** TOM mod **/ | |
#include <libavutil/uuid.h> | |
/** end TOM mod **/ | |
#include <libavcodec/avcodec.h> | |
#include <libavformat/avformat.h> | |
static AVFormatContext *fmt_ctx = NULL; | |
static AVCodecContext *video_dec_ctx = NULL, *audio_dec_ctx; | |
static int width, height; | |
static enum AVPixelFormat pix_fmt; | |
static AVStream *video_stream = NULL, *audio_stream = NULL; | |
static const char *src_filename = NULL; | |
static const char *video_dst_filename = NULL; | |
static const char *audio_dst_filename = NULL; | |
static FILE *video_dst_file = NULL; | |
static FILE *audio_dst_file = NULL; | |
static uint8_t *video_dst_data[4] = {NULL}; | |
static int video_dst_linesize[4]; | |
static int video_dst_bufsize; | |
static int video_stream_idx = -1, audio_stream_idx = -1; | |
static AVFrame *frame = NULL; | |
static AVPacket *pkt = NULL; | |
static int video_frame_count = 0; | |
static int audio_frame_count = 0; | |
static int output_video_frame(AVFrame *frame) | |
{ | |
if (frame->width != width || frame->height != height || | |
frame->format != pix_fmt) { | |
/* To handle this change, one could call av_image_alloc again and | |
* decode the following frames into another rawvideo file. */ | |
fprintf(stderr, "Error: Width, height and pixel format have to be " | |
"constant in a rawvideo file, but the width, height or " | |
"pixel format of the input video changed:\n" | |
"old: width = %d, height = %d, format = %s\n" | |
"new: width = %d, height = %d, format = %s\n", | |
width, height, av_get_pix_fmt_name(pix_fmt), | |
frame->width, frame->height, | |
av_get_pix_fmt_name(frame->format)); | |
return -1; | |
} | |
printf("video_frame n:%d\n", | |
video_frame_count++); | |
/** TOM mod **/ | |
AVFrameSideData *sd; | |
// The API seems to indicate there can only be a single AV_FRAME_DATA_SEI_UNREGISTERED item | |
// but that's not the case. We need to loop over all side data rather than calling | |
// sd = av_frame_get_side_data(frame, AV_FRAME_DATA_SEI_UNREGISTERED); | |
for (int i = 0; i < frame->nb_side_data; i++) { | |
sd = frame->side_data[i]; | |
if (sd && sd->type == AV_FRAME_DATA_SEI_UNREGISTERED) { | |
// First 16 bytes is the UUID, unregistered payload start at index 16 and the | |
// total size including UUID is given by sd->size | |
char uuid_str[37]; | |
av_uuid_unparse(sd->data, uuid_str); | |
printf("side-data size %ld UUID {%s} content {%.*s} at pts %lld\n", | |
sd->size, | |
uuid_str, | |
(int)(sd->size-16), &sd->data[16], | |
frame->pts); | |
} | |
} | |
/** end TOM mod **/ | |
/* copy decoded frame to destination buffer: | |
* this is required since rawvideo expects non aligned data */ | |
av_image_copy2(video_dst_data, video_dst_linesize, | |
frame->data, frame->linesize, | |
pix_fmt, width, height); | |
/* write to rawvideo file */ | |
fwrite(video_dst_data[0], 1, video_dst_bufsize, video_dst_file); | |
return 0; | |
} | |
static int output_audio_frame(AVFrame *frame) | |
{ | |
size_t unpadded_linesize = frame->nb_samples * av_get_bytes_per_sample(frame->format); | |
printf("audio_frame n:%d nb_samples:%d pts:%s\n", | |
audio_frame_count++, frame->nb_samples, | |
av_ts2timestr(frame->pts, &audio_dec_ctx->time_base)); | |
/* Write the raw audio data samples of the first plane. This works | |
* fine for packed formats (e.g. AV_SAMPLE_FMT_S16). However, | |
* most audio decoders output planar audio, which uses a separate | |
* plane of audio samples for each channel (e.g. AV_SAMPLE_FMT_S16P). | |
* In other words, this code will write only the first audio channel | |
* in these cases. | |
* You should use libswresample or libavfilter to convert the frame | |
* to packed data. */ | |
fwrite(frame->extended_data[0], 1, unpadded_linesize, audio_dst_file); | |
return 0; | |
} | |
static int decode_packet(AVCodecContext *dec, const AVPacket *pkt) | |
{ | |
int ret = 0; | |
// submit the packet to the decoder | |
ret = avcodec_send_packet(dec, pkt); | |
if (ret < 0) { | |
fprintf(stderr, "Error submitting a packet for decoding (%s)\n", av_err2str(ret)); | |
return ret; | |
} | |
// get all the available frames from the decoder | |
while (ret >= 0) { | |
ret = avcodec_receive_frame(dec, frame); | |
if (ret < 0) { | |
// those two return values are special and mean there is no output | |
// frame available, but there were no errors during decoding | |
if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) | |
return 0; | |
fprintf(stderr, "Error during decoding (%s)\n", av_err2str(ret)); | |
return ret; | |
} | |
// write the frame data to output file | |
if (dec->codec->type == AVMEDIA_TYPE_VIDEO) | |
ret = output_video_frame(frame); | |
else | |
ret = output_audio_frame(frame); | |
av_frame_unref(frame); | |
} | |
return ret; | |
} | |
static int open_codec_context(int *stream_idx, | |
AVCodecContext **dec_ctx, AVFormatContext *fmt_ctx, enum AVMediaType type) | |
{ | |
int ret, stream_index; | |
AVStream *st; | |
const AVCodec *dec = NULL; | |
ret = av_find_best_stream(fmt_ctx, type, -1, -1, NULL, 0); | |
if (ret < 0) { | |
fprintf(stderr, "Could not find %s stream in input file '%s'\n", | |
av_get_media_type_string(type), src_filename); | |
return ret; | |
} else { | |
stream_index = ret; | |
st = fmt_ctx->streams[stream_index]; | |
/* find decoder for the stream */ | |
dec = avcodec_find_decoder(st->codecpar->codec_id); | |
if (!dec) { | |
fprintf(stderr, "Failed to find %s codec\n", | |
av_get_media_type_string(type)); | |
return AVERROR(EINVAL); | |
} | |
/* Allocate a codec context for the decoder */ | |
*dec_ctx = avcodec_alloc_context3(dec); | |
if (!*dec_ctx) { | |
fprintf(stderr, "Failed to allocate the %s codec context\n", | |
av_get_media_type_string(type)); | |
return AVERROR(ENOMEM); | |
} | |
/* Copy codec parameters from input stream to output codec context */ | |
if ((ret = avcodec_parameters_to_context(*dec_ctx, st->codecpar)) < 0) { | |
fprintf(stderr, "Failed to copy %s codec parameters to decoder context\n", | |
av_get_media_type_string(type)); | |
return ret; | |
} | |
/* Init the decoders */ | |
if ((ret = avcodec_open2(*dec_ctx, dec, NULL)) < 0) { | |
fprintf(stderr, "Failed to open %s codec\n", | |
av_get_media_type_string(type)); | |
return ret; | |
} | |
*stream_idx = stream_index; | |
} | |
return 0; | |
} | |
static int get_format_from_sample_fmt(const char **fmt, | |
enum AVSampleFormat sample_fmt) | |
{ | |
int i; | |
struct sample_fmt_entry { | |
enum AVSampleFormat sample_fmt; const char *fmt_be, *fmt_le; | |
} sample_fmt_entries[] = { | |
{ AV_SAMPLE_FMT_U8, "u8", "u8" }, | |
{ AV_SAMPLE_FMT_S16, "s16be", "s16le" }, | |
{ AV_SAMPLE_FMT_S32, "s32be", "s32le" }, | |
{ AV_SAMPLE_FMT_FLT, "f32be", "f32le" }, | |
{ AV_SAMPLE_FMT_DBL, "f64be", "f64le" }, | |
}; | |
*fmt = NULL; | |
for (i = 0; i < FF_ARRAY_ELEMS(sample_fmt_entries); i++) { | |
struct sample_fmt_entry *entry = &sample_fmt_entries[i]; | |
if (sample_fmt == entry->sample_fmt) { | |
*fmt = AV_NE(entry->fmt_be, entry->fmt_le); | |
return 0; | |
} | |
} | |
fprintf(stderr, | |
"sample format %s is not supported as output format\n", | |
av_get_sample_fmt_name(sample_fmt)); | |
return -1; | |
} | |
int main (int argc, char **argv) | |
{ | |
int ret = 0; | |
if (argc != 4) { | |
fprintf(stderr, "usage: %s input_file video_output_file audio_output_file\n" | |
"API example program to show how to read frames from an input file.\n" | |
"This program reads frames from a file, decodes them, and writes decoded\n" | |
"video frames to a rawvideo file named video_output_file, and decoded\n" | |
"audio frames to a rawaudio file named audio_output_file.\n", | |
argv[0]); | |
exit(1); | |
} | |
src_filename = argv[1]; | |
video_dst_filename = argv[2]; | |
audio_dst_filename = argv[3]; | |
/* open input file, and allocate format context */ | |
if (avformat_open_input(&fmt_ctx, src_filename, NULL, NULL) < 0) { | |
fprintf(stderr, "Could not open source file %s\n", src_filename); | |
exit(1); | |
} | |
/* retrieve stream information */ | |
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) { | |
fprintf(stderr, "Could not find stream information\n"); | |
exit(1); | |
} | |
if (open_codec_context(&video_stream_idx, &video_dec_ctx, fmt_ctx, AVMEDIA_TYPE_VIDEO) >= 0) { | |
video_stream = fmt_ctx->streams[video_stream_idx]; | |
video_dst_file = fopen(video_dst_filename, "wb"); | |
if (!video_dst_file) { | |
fprintf(stderr, "Could not open destination file %s\n", video_dst_filename); | |
ret = 1; | |
goto end; | |
} | |
/* allocate image where the decoded image will be put */ | |
width = video_dec_ctx->width; | |
height = video_dec_ctx->height; | |
pix_fmt = video_dec_ctx->pix_fmt; | |
ret = av_image_alloc(video_dst_data, video_dst_linesize, | |
width, height, pix_fmt, 1); | |
if (ret < 0) { | |
fprintf(stderr, "Could not allocate raw video buffer\n"); | |
goto end; | |
} | |
video_dst_bufsize = ret; | |
} | |
if (open_codec_context(&audio_stream_idx, &audio_dec_ctx, fmt_ctx, AVMEDIA_TYPE_AUDIO) >= 0) { | |
audio_stream = fmt_ctx->streams[audio_stream_idx]; | |
audio_dst_file = fopen(audio_dst_filename, "wb"); | |
if (!audio_dst_file) { | |
fprintf(stderr, "Could not open destination file %s\n", audio_dst_filename); | |
ret = 1; | |
goto end; | |
} | |
} | |
/* dump input information to stderr */ | |
av_dump_format(fmt_ctx, 0, src_filename, 0); | |
if (!audio_stream && !video_stream) { | |
fprintf(stderr, "Could not find audio or video stream in the input, aborting\n"); | |
ret = 1; | |
goto end; | |
} | |
frame = av_frame_alloc(); | |
if (!frame) { | |
fprintf(stderr, "Could not allocate frame\n"); | |
ret = AVERROR(ENOMEM); | |
goto end; | |
} | |
pkt = av_packet_alloc(); | |
if (!pkt) { | |
fprintf(stderr, "Could not allocate packet\n"); | |
ret = AVERROR(ENOMEM); | |
goto end; | |
} | |
if (video_stream) | |
printf("Demuxing video from file '%s' into '%s'\n", src_filename, video_dst_filename); | |
if (audio_stream) | |
printf("Demuxing audio from file '%s' into '%s'\n", src_filename, audio_dst_filename); | |
/* read frames from the file */ | |
while (av_read_frame(fmt_ctx, pkt) >= 0) { | |
// check if the packet belongs to a stream we are interested in, otherwise | |
// skip it | |
if (pkt->stream_index == video_stream_idx) | |
ret = decode_packet(video_dec_ctx, pkt); | |
else if (pkt->stream_index == audio_stream_idx) | |
ret = decode_packet(audio_dec_ctx, pkt); | |
av_packet_unref(pkt); | |
if (ret < 0) | |
break; | |
} | |
/* flush the decoders */ | |
if (video_dec_ctx) | |
decode_packet(video_dec_ctx, NULL); | |
if (audio_dec_ctx) | |
decode_packet(audio_dec_ctx, NULL); | |
printf("Demuxing succeeded.\n"); | |
if (video_stream) { | |
printf("Play the output video file with the command:\n" | |
"ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n", | |
av_get_pix_fmt_name(pix_fmt), width, height, | |
video_dst_filename); | |
} | |
if (audio_stream) { | |
enum AVSampleFormat sfmt = audio_dec_ctx->sample_fmt; | |
int n_channels = audio_dec_ctx->ch_layout.nb_channels; | |
const char *fmt; | |
if (av_sample_fmt_is_planar(sfmt)) { | |
const char *packed = av_get_sample_fmt_name(sfmt); | |
printf("Warning: the sample format the decoder produced is planar " | |
"(%s). This example will output the first channel only.\n", | |
packed ? packed : "?"); | |
sfmt = av_get_packed_sample_fmt(sfmt); | |
n_channels = 1; | |
} | |
if ((ret = get_format_from_sample_fmt(&fmt, sfmt)) < 0) | |
goto end; | |
printf("Play the output audio file with the command:\n" | |
"ffplay -f %s -ac %d -ar %d %s\n", | |
fmt, n_channels, audio_dec_ctx->sample_rate, | |
audio_dst_filename); | |
} | |
end: | |
avcodec_free_context(&video_dec_ctx); | |
avcodec_free_context(&audio_dec_ctx); | |
avformat_close_input(&fmt_ctx); | |
if (video_dst_file) | |
fclose(video_dst_file); | |
if (audio_dst_file) | |
fclose(audio_dst_file); | |
av_packet_free(&pkt); | |
av_frame_free(&frame); | |
av_free(video_dst_data[0]); | |
return ret < 0; | |
} |
/* | |
* Copyright (c) 2003 Fabrice Bellard | |
* | |
* Permission is hereby granted, free of charge, to any person obtaining a copy | |
* of this software and associated documentation files (the "Software"), to deal | |
* in the Software without restriction, including without limitation the rights | |
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
* copies of the Software, and to permit persons to whom the Software is | |
* furnished to do so, subject to the following conditions: | |
* | |
* The above copyright notice and this permission notice shall be included in | |
* all copies or substantial portions of the Software. | |
* | |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | |
* THE SOFTWARE. | |
*/ | |
/** | |
* @file libavformat muxing API usage example | |
* @example mux.c | |
* | |
* Generate a synthetic audio and video signal and mux them to a media file in | |
* any supported libavformat format. The default codecs are used. | |
*/ | |
#include <stdlib.h> | |
#include <stdio.h> | |
#include <string.h> | |
#include <math.h> | |
#include <libavutil/avassert.h> | |
#include <libavutil/channel_layout.h> | |
#include <libavutil/opt.h> | |
#include <libavutil/mathematics.h> | |
#include <libavutil/timestamp.h> | |
#include <libavcodec/avcodec.h> | |
#include <libavformat/avformat.h> | |
#include <libswscale/swscale.h> | |
#include <libswresample/swresample.h> | |
/** TOM mod **/ | |
//#define STREAM_DURATION 10.0 | |
#define STREAM_DURATION 1.0 | |
/** end TOM mod **/ | |
#define STREAM_FRAME_RATE 25 /* 25 images/s */ | |
#define STREAM_PIX_FMT AV_PIX_FMT_YUV420P /* default pix_fmt */ | |
#define SCALE_FLAGS SWS_BICUBIC | |
// a wrapper around a single output AVStream | |
typedef struct OutputStream { | |
AVStream *st; | |
AVCodecContext *enc; | |
/* pts of the next frame that will be generated */ | |
int64_t next_pts; | |
int samples_count; | |
AVFrame *frame; | |
AVFrame *tmp_frame; | |
AVPacket *tmp_pkt; | |
float t, tincr, tincr2; | |
struct SwsContext *sws_ctx; | |
struct SwrContext *swr_ctx; | |
} OutputStream; | |
static void log_packet(const AVFormatContext *fmt_ctx, const AVPacket *pkt) | |
{ | |
AVRational *time_base = &fmt_ctx->streams[pkt->stream_index]->time_base; | |
printf("pts:%s pts_time:%s dts:%s dts_time:%s duration:%s duration_time:%s stream_index:%d\n", | |
av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, time_base), | |
av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, time_base), | |
av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, time_base), | |
pkt->stream_index); | |
} | |
static int write_frame(AVFormatContext *fmt_ctx, AVCodecContext *c, | |
AVStream *st, AVFrame *frame, AVPacket *pkt) | |
{ | |
int ret; | |
// send the frame to the encoder | |
ret = avcodec_send_frame(c, frame); | |
if (ret < 0) { | |
fprintf(stderr, "Error sending a frame to the encoder: %s\n", | |
av_err2str(ret)); | |
exit(1); | |
} | |
while (ret >= 0) { | |
ret = avcodec_receive_packet(c, pkt); | |
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) | |
break; | |
else if (ret < 0) { | |
fprintf(stderr, "Error encoding a frame: %s\n", av_err2str(ret)); | |
exit(1); | |
} | |
/* rescale output packet timestamp values from codec to stream timebase */ | |
av_packet_rescale_ts(pkt, c->time_base, st->time_base); | |
pkt->stream_index = st->index; | |
/* Write the compressed frame to the media file. */ | |
log_packet(fmt_ctx, pkt); | |
ret = av_interleaved_write_frame(fmt_ctx, pkt); | |
/* pkt is now blank (av_interleaved_write_frame() takes ownership of | |
* its contents and resets pkt), so that no unreferencing is necessary. | |
* This would be different if one used av_write_frame(). */ | |
if (ret < 0) { | |
fprintf(stderr, "Error while writing output packet: %s\n", av_err2str(ret)); | |
exit(1); | |
} | |
} | |
return ret == AVERROR_EOF ? 1 : 0; | |
} | |
/* Add an output stream. */ | |
static void add_stream(OutputStream *ost, AVFormatContext *oc, | |
const AVCodec **codec, | |
enum AVCodecID codec_id) | |
{ | |
AVCodecContext *c; | |
int i; | |
/* find the encoder */ | |
*codec = avcodec_find_encoder(codec_id); | |
if (!(*codec)) { | |
fprintf(stderr, "Could not find encoder for '%s'\n", | |
avcodec_get_name(codec_id)); | |
exit(1); | |
} | |
ost->tmp_pkt = av_packet_alloc(); | |
if (!ost->tmp_pkt) { | |
fprintf(stderr, "Could not allocate AVPacket\n"); | |
exit(1); | |
} | |
ost->st = avformat_new_stream(oc, NULL); | |
if (!ost->st) { | |
fprintf(stderr, "Could not allocate stream\n"); | |
exit(1); | |
} | |
ost->st->id = oc->nb_streams-1; | |
c = avcodec_alloc_context3(*codec); | |
if (!c) { | |
fprintf(stderr, "Could not alloc an encoding context\n"); | |
exit(1); | |
} | |
ost->enc = c; | |
switch ((*codec)->type) { | |
case AVMEDIA_TYPE_AUDIO: | |
c->sample_fmt = (*codec)->sample_fmts ? | |
(*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP; | |
c->bit_rate = 64000; | |
c->sample_rate = 44100; | |
if ((*codec)->supported_samplerates) { | |
c->sample_rate = (*codec)->supported_samplerates[0]; | |
for (i = 0; (*codec)->supported_samplerates[i]; i++) { | |
if ((*codec)->supported_samplerates[i] == 44100) | |
c->sample_rate = 44100; | |
} | |
} | |
av_channel_layout_copy(&c->ch_layout, &(AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO); | |
ost->st->time_base = (AVRational){ 1, c->sample_rate }; | |
break; | |
case AVMEDIA_TYPE_VIDEO: | |
c->codec_id = codec_id; | |
c->bit_rate = 400000; | |
/* Resolution must be a multiple of two. */ | |
c->width = 352; | |
c->height = 288; | |
/* timebase: This is the fundamental unit of time (in seconds) in terms | |
* of which frame timestamps are represented. For fixed-fps content, | |
* timebase should be 1/framerate and timestamp increments should be | |
* identical to 1. */ | |
ost->st->time_base = (AVRational){ 1, STREAM_FRAME_RATE }; | |
c->time_base = ost->st->time_base; | |
c->gop_size = 12; /* emit one intra frame every twelve frames at most */ | |
c->pix_fmt = STREAM_PIX_FMT; | |
if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) { | |
/* just for testing, we also add B-frames */ | |
c->max_b_frames = 2; | |
} | |
if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) { | |
/* Needed to avoid using macroblocks in which some coeffs overflow. | |
* This does not happen with normal video, it just happens here as | |
* the motion of the chroma plane does not match the luma plane. */ | |
c->mb_decision = 2; | |
} | |
break; | |
default: | |
break; | |
} | |
/* Some formats want stream headers to be separate. */ | |
if (oc->oformat->flags & AVFMT_GLOBALHEADER) | |
c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER; | |
} | |
/**************************************************************/ | |
/* audio output */ | |
static AVFrame *alloc_audio_frame(enum AVSampleFormat sample_fmt, | |
const AVChannelLayout *channel_layout, | |
int sample_rate, int nb_samples) | |
{ | |
AVFrame *frame = av_frame_alloc(); | |
if (!frame) { | |
fprintf(stderr, "Error allocating an audio frame\n"); | |
exit(1); | |
} | |
frame->format = sample_fmt; | |
av_channel_layout_copy(&frame->ch_layout, channel_layout); | |
frame->sample_rate = sample_rate; | |
frame->nb_samples = nb_samples; | |
if (nb_samples) { | |
if (av_frame_get_buffer(frame, 0) < 0) { | |
fprintf(stderr, "Error allocating an audio buffer\n"); | |
exit(1); | |
} | |
} | |
return frame; | |
} | |
static void open_audio(AVFormatContext *oc, const AVCodec *codec, | |
OutputStream *ost, AVDictionary *opt_arg) | |
{ | |
AVCodecContext *c; | |
int nb_samples; | |
int ret; | |
AVDictionary *opt = NULL; | |
c = ost->enc; | |
/* open it */ | |
av_dict_copy(&opt, opt_arg, 0); | |
ret = avcodec_open2(c, codec, &opt); | |
av_dict_free(&opt); | |
if (ret < 0) { | |
fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret)); | |
exit(1); | |
} | |
/* init signal generator */ | |
ost->t = 0; | |
ost->tincr = 2 * M_PI * 110.0 / c->sample_rate; | |
/* increment frequency by 110 Hz per second */ | |
ost->tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate; | |
if (c->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE) | |
nb_samples = 10000; | |
else | |
nb_samples = c->frame_size; | |
ost->frame = alloc_audio_frame(c->sample_fmt, &c->ch_layout, | |
c->sample_rate, nb_samples); | |
ost->tmp_frame = alloc_audio_frame(AV_SAMPLE_FMT_S16, &c->ch_layout, | |
c->sample_rate, nb_samples); | |
/* copy the stream parameters to the muxer */ | |
ret = avcodec_parameters_from_context(ost->st->codecpar, c); | |
if (ret < 0) { | |
fprintf(stderr, "Could not copy the stream parameters\n"); | |
exit(1); | |
} | |
/* create resampler context */ | |
ost->swr_ctx = swr_alloc(); | |
if (!ost->swr_ctx) { | |
fprintf(stderr, "Could not allocate resampler context\n"); | |
exit(1); | |
} | |
/* set options */ | |
av_opt_set_chlayout (ost->swr_ctx, "in_chlayout", &c->ch_layout, 0); | |
av_opt_set_int (ost->swr_ctx, "in_sample_rate", c->sample_rate, 0); | |
av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0); | |
av_opt_set_chlayout (ost->swr_ctx, "out_chlayout", &c->ch_layout, 0); | |
av_opt_set_int (ost->swr_ctx, "out_sample_rate", c->sample_rate, 0); | |
av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt", c->sample_fmt, 0); | |
/* initialize the resampling context */ | |
if ((ret = swr_init(ost->swr_ctx)) < 0) { | |
fprintf(stderr, "Failed to initialize the resampling context\n"); | |
exit(1); | |
} | |
} | |
/* Prepare a 16 bit dummy audio frame of 'frame_size' samples and | |
* 'nb_channels' channels. */ | |
static AVFrame *get_audio_frame(OutputStream *ost) | |
{ | |
AVFrame *frame = ost->tmp_frame; | |
int j, i, v; | |
int16_t *q = (int16_t*)frame->data[0]; | |
/* check if we want to generate more frames */ | |
if (av_compare_ts(ost->next_pts, ost->enc->time_base, | |
STREAM_DURATION, (AVRational){ 1, 1 }) > 0) | |
return NULL; | |
for (j = 0; j <frame->nb_samples; j++) { | |
v = (int)(sin(ost->t) * 10000); | |
for (i = 0; i < ost->enc->ch_layout.nb_channels; i++) | |
*q++ = v; | |
ost->t += ost->tincr; | |
ost->tincr += ost->tincr2; | |
} | |
frame->pts = ost->next_pts; | |
ost->next_pts += frame->nb_samples; | |
return frame; | |
} | |
/* | |
* encode one audio frame and send it to the muxer | |
* return 1 when encoding is finished, 0 otherwise | |
*/ | |
static int write_audio_frame(AVFormatContext *oc, OutputStream *ost) | |
{ | |
AVCodecContext *c; | |
AVFrame *frame; | |
int ret; | |
int dst_nb_samples; | |
c = ost->enc; | |
frame = get_audio_frame(ost); | |
if (frame) { | |
/* convert samples from native format to destination codec format, using the resampler */ | |
/* compute destination number of samples */ | |
dst_nb_samples = av_rescale_rnd(swr_get_delay(ost->swr_ctx, c->sample_rate) + frame->nb_samples, | |
c->sample_rate, c->sample_rate, AV_ROUND_UP); | |
av_assert0(dst_nb_samples == frame->nb_samples); | |
/* when we pass a frame to the encoder, it may keep a reference to it | |
* internally; | |
* make sure we do not overwrite it here | |
*/ | |
ret = av_frame_make_writable(ost->frame); | |
if (ret < 0) | |
exit(1); | |
/* convert to destination format */ | |
ret = swr_convert(ost->swr_ctx, | |
ost->frame->data, dst_nb_samples, | |
(const uint8_t **)frame->data, frame->nb_samples); | |
if (ret < 0) { | |
fprintf(stderr, "Error while converting\n"); | |
exit(1); | |
} | |
frame = ost->frame; | |
frame->pts = av_rescale_q(ost->samples_count, (AVRational){1, c->sample_rate}, c->time_base); | |
ost->samples_count += dst_nb_samples; | |
} | |
return write_frame(oc, c, ost->st, frame, ost->tmp_pkt); | |
} | |
/**************************************************************/ | |
/* video output */ | |
static AVFrame *alloc_frame(enum AVPixelFormat pix_fmt, int width, int height) | |
{ | |
AVFrame *frame; | |
int ret; | |
frame = av_frame_alloc(); | |
if (!frame) | |
return NULL; | |
frame->format = pix_fmt; | |
frame->width = width; | |
frame->height = height; | |
/* allocate the buffers for the frame data */ | |
ret = av_frame_get_buffer(frame, 0); | |
if (ret < 0) { | |
fprintf(stderr, "Could not allocate frame data.\n"); | |
exit(1); | |
} | |
return frame; | |
} | |
static void open_video(AVFormatContext *oc, const AVCodec *codec, | |
OutputStream *ost, AVDictionary *opt_arg) | |
{ | |
int ret; | |
AVCodecContext *c = ost->enc; | |
AVDictionary *opt = NULL; | |
av_dict_copy(&opt, opt_arg, 0); | |
/* open the codec */ | |
ret = avcodec_open2(c, codec, &opt); | |
av_dict_free(&opt); | |
if (ret < 0) { | |
fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret)); | |
exit(1); | |
} | |
/* allocate and init a re-usable frame */ | |
ost->frame = alloc_frame(c->pix_fmt, c->width, c->height); | |
if (!ost->frame) { | |
fprintf(stderr, "Could not allocate video frame\n"); | |
exit(1); | |
} | |
/* If the output format is not YUV420P, then a temporary YUV420P | |
* picture is needed too. It is then converted to the required | |
* output format. */ | |
ost->tmp_frame = NULL; | |
if (c->pix_fmt != AV_PIX_FMT_YUV420P) { | |
ost->tmp_frame = alloc_frame(AV_PIX_FMT_YUV420P, c->width, c->height); | |
if (!ost->tmp_frame) { | |
fprintf(stderr, "Could not allocate temporary video frame\n"); | |
exit(1); | |
} | |
} | |
/* copy the stream parameters to the muxer */ | |
ret = avcodec_parameters_from_context(ost->st->codecpar, c); | |
if (ret < 0) { | |
fprintf(stderr, "Could not copy the stream parameters\n"); | |
exit(1); | |
} | |
} | |
/* Prepare a dummy image. */ | |
static void fill_yuv_image(AVFrame *pict, int frame_index, | |
int width, int height) | |
{ | |
int x, y, i; | |
i = frame_index; | |
/* Y */ | |
for (y = 0; y < height; y++) | |
for (x = 0; x < width; x++) | |
pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3; | |
/* Cb and Cr */ | |
for (y = 0; y < height / 2; y++) { | |
for (x = 0; x < width / 2; x++) { | |
pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2; | |
pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5; | |
} | |
} | |
} | |
static AVFrame *get_video_frame(OutputStream *ost) | |
{ | |
AVCodecContext *c = ost->enc; | |
/** TOM mod **/ | |
AVFrameSideData *side_data; | |
// An arbitrary generated UUID: e3edb015-dd70-4220-8247-0fe462b12220 | |
// 16 bytes (we could use the utilities in libavutil/uuid.h) | |
uint8_t uuid[] = {0xe3, 0xed, 0xb0, 0x15, | |
0xdd, 0x70, 0x42, 0x20, | |
0x82, 0x47, 0x0f, 0xe4, | |
0x62, 0xb1, 0x22, 0x20}; | |
/** end TOM mod **/ | |
/* check if we want to generate more frames */ | |
if (av_compare_ts(ost->next_pts, c->time_base, | |
STREAM_DURATION, (AVRational){ 1, 1 }) > 0) | |
return NULL; | |
/* when we pass a frame to the encoder, it may keep a reference to it | |
* internally; make sure we do not overwrite it here */ | |
if (av_frame_make_writable(ost->frame) < 0) | |
exit(1); | |
if (c->pix_fmt != AV_PIX_FMT_YUV420P) { | |
/* as we only generate a YUV420P picture, we must convert it | |
* to the codec pixel format if needed */ | |
if (!ost->sws_ctx) { | |
ost->sws_ctx = sws_getContext(c->width, c->height, | |
AV_PIX_FMT_YUV420P, | |
c->width, c->height, | |
c->pix_fmt, | |
SCALE_FLAGS, NULL, NULL, NULL); | |
if (!ost->sws_ctx) { | |
fprintf(stderr, | |
"Could not initialize the conversion context\n"); | |
exit(1); | |
} | |
} | |
fill_yuv_image(ost->tmp_frame, ost->next_pts, c->width, c->height); | |
sws_scale(ost->sws_ctx, (const uint8_t * const *) ost->tmp_frame->data, | |
ost->tmp_frame->linesize, 0, c->height, ost->frame->data, | |
ost->frame->linesize); | |
} else { | |
fill_yuv_image(ost->frame, ost->next_pts, c->width, c->height); | |
} | |
/** TOM mod **/ | |
char sei_message_buffer[100]; | |
int sei_message_size = snprintf(sei_message_buffer, 100, "This is a test SEI message at pts=%lld!", ost->next_pts); | |
AVBufferRef* sei_buffer = av_buffer_alloc(16+sei_message_size); | |
memcpy(sei_buffer->data, uuid, 16); | |
memcpy((sei_buffer->data)+16, sei_message_buffer, sei_message_size); | |
// The API seems to indicate there can only be a single AV_FRAME_DATA_SEI_UNREGISTERED item | |
// but that's not the case. We first need to clear our previous meta. | |
// TODO. check we don't incidentally remove AV_FRAME_DATA_SEI_UNREGISTERED from others. | |
av_frame_remove_side_data(ost->frame, AV_FRAME_DATA_SEI_UNREGISTERED); | |
side_data = av_frame_new_side_data_from_buf(ost->frame, AV_FRAME_DATA_SEI_UNREGISTERED, sei_buffer); | |
if (!side_data) { | |
fprintf(stderr, "Could not allocate the video frame side data\n"); | |
exit(1); | |
} | |
printf("Added message: {%.*s}\n", (int)(sei_message_size), side_data->data+16); | |
/** end TOM mod **/ | |
ost->frame->pts = ost->next_pts++; | |
return ost->frame; | |
} | |
/* | |
* encode one video frame and send it to the muxer | |
* return 1 when encoding is finished, 0 otherwise | |
*/ | |
static int write_video_frame(AVFormatContext *oc, OutputStream *ost) | |
{ | |
return write_frame(oc, ost->enc, ost->st, get_video_frame(ost), ost->tmp_pkt); | |
} | |
static void close_stream(AVFormatContext *oc, OutputStream *ost) | |
{ | |
avcodec_free_context(&ost->enc); | |
av_frame_free(&ost->frame); | |
av_frame_free(&ost->tmp_frame); | |
av_packet_free(&ost->tmp_pkt); | |
sws_freeContext(ost->sws_ctx); | |
swr_free(&ost->swr_ctx); | |
} | |
/**************************************************************/ | |
/* media file output */ | |
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); | |
} | |
/** TOM mod **/ | |
av_dict_set_int(&opt, "udu_sei", 1, 0); | |
/** end TOM mod **/ | |
/* allocate the output media context */ | |
avformat_alloc_output_context2(&oc, NULL, NULL, filename); | |
if (!oc) { | |
printf("Could not deduce output format from file extension: using MPEG.\n"); | |
avformat_alloc_output_context2(&oc, NULL, "mpeg", filename); | |
} | |
if (!oc) | |
return 1; | |
fmt = oc->oformat; | |
/* Add the audio and video streams using the default format codecs | |
* and initialize the codecs. */ | |
if (fmt->video_codec != AV_CODEC_ID_NONE) { | |
add_stream(&video_st, oc, &video_codec, fmt->video_codec); | |
have_video = 1; | |
encode_video = 1; | |
} | |
if (fmt->audio_codec != AV_CODEC_ID_NONE) { | |
add_stream(&audio_st, oc, &audio_codec, fmt->audio_codec); | |
have_audio = 1; | |
encode_audio = 1; | |
} | |
/* Now that all the parameters are set, we can open the audio and | |
* video codecs and allocate the necessary encode buffers. */ | |
if (have_video) | |
open_video(oc, video_codec, &video_st, opt); | |
if (have_audio) | |
open_audio(oc, audio_codec, &audio_st, opt); | |
av_dump_format(oc, 0, filename, 1); | |
/* open the output file, if needed */ | |
if (!(fmt->flags & AVFMT_NOFILE)) { | |
ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE); | |
if (ret < 0) { | |
fprintf(stderr, "Could not open '%s': %s\n", filename, | |
av_err2str(ret)); | |
return 1; | |
} | |
} | |
/* Write the stream header, if any. */ | |
ret = avformat_write_header(oc, &opt); | |
if (ret < 0) { | |
fprintf(stderr, "Error occurred when opening output file: %s\n", | |
av_err2str(ret)); | |
return 1; | |
} | |
while (encode_video || encode_audio) { | |
/* select the stream to encode */ | |
if (encode_video && | |
(!encode_audio || av_compare_ts(video_st.next_pts, video_st.enc->time_base, | |
audio_st.next_pts, audio_st.enc->time_base) <= 0)) { | |
encode_video = !write_video_frame(oc, &video_st); | |
} else { | |
encode_audio = !write_audio_frame(oc, &audio_st); | |
} | |
} | |
av_write_trailer(oc); | |
/* Close each codec. */ | |
if (have_video) | |
close_stream(oc, &video_st); | |
if (have_audio) | |
close_stream(oc, &audio_st); | |
if (!(fmt->flags & AVFMT_NOFILE)) | |
/* Close the output file. */ | |
avio_closep(&oc->pb); | |
/* free the stream */ | |
avformat_free_context(oc); | |
return 0; | |
} |
#!/usr/bin/env sh | |
echo 'Compiling\n' | |
cc -g -o mux_withsei mux_withsei.c -I/opt/homebrew/include -L/opt/homebrew/lib -lavutil -lavformat -lavcodec -lswscale -lswresample | |
(($? != 0)) && { printf '%s\n' "Compilation exited with non-zero"; exit 1; } | |
cc -g -o demux_decode_withsei demux_decode_withsei.c -I/opt/homebrew/include -L/opt/homebrew/lib -lavutil -lavformat -lavcodec -lswscale -lswresample | |
(($? != 0)) && { printf '%s\n' "Compilation exited with non-zero"; exit 1; } | |
echo '\nMuxing\n' | |
./mux_withsei test.mov | |
echo '\nFFProbing\n' | |
ffprobe -hide_banner test.mov | |
echo '\nNb video frames' | |
ffprobe -v error -select_streams v:0 -count_frames -show_entries stream=nb_read_frames -print_format default=nokey=1:noprint_wrappers=1 test.mov | |
echo '\nDemuxing\n' | |
./demux_decode_withsei test.mov test.video.raw test.audio.raw |