dlib C++ Library - ffmpeg_video_encoding_ex.cpp

// The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt
/*
 This is an example illustrating the use of the ffmpeg wrappers, in this case the encding API.
 This is a pretty simple example. It loads a video file, extracts the images and
 re-encodes them into a raw buffer using a user-specified codec.
 
 Please see the following examples on how to decode, demux, and get information on your installation of ffmpeg:
 - ffmpeg_info_ex.cpp
 - ffmpeg_video_decoding_ex.cpp
 - ffmpeg_video_decoding2_ex.cpp
 - ffmpeg_video_demuxing_ex.cpp
 - ffmpeg_video_demuxing2_ex.cpp
*/
#include <cstdio>
#include <dlib/media.h>
#include <dlib/cmd_line_parser.h>
using namespace std;
using namespace dlib;
using namespace dlib::ffmpeg;
int main(const int argc, const char** argv)
try
{
 command_line_parser parser;
 parser.add_option("i", "input video", 1);
 parser.add_option("codec", "codec name. e.g. h264. Defaults to mpeg4", 1);
 parser.add_option("height", "height of encoded stream. Defaults to whatever is in the video file", 1);
 parser.add_option("width", "width of encoded stream. Defaults to whatever is in the video file", 1);
 parser.set_group_name("Help Options");
 parser.add_option("h", "alias of --help");
 parser.add_option("help", "display this message and exit");
 parser.parse(argc, argv);
 const char* one_time_opts[] = {"i", "codec", "height", "width"};
 parser.check_one_time_options(one_time_opts);
 if (parser.option("h") || parser.option("help"))
 {
 parser.print_options();
 return 0;
 }
 const std::string filepath = parser.option("i").argument();
 // Load input video.
 // Note, this uses a convenient constructor which (dis)enables audio and/or video.
 demuxer cap({filepath, video_enabled, audio_disabled});
 if (!cap.is_open() || !cap.video_enabled())
 {
 cout << "Failed to open " << filepath << endl;
 return EXIT_FAILURE;
 }
 // This is a small functor that creates an encoder using the command line arguments
 // and different types of output buffers using the convenient sink() overload.
 const auto make_encoder = [&]
 {
 return encoder([&] {
 encoder::args args;
 args.args_codec.codec_name = get_option(parser, "codec", "mpeg4");
 args.args_image.h = get_option(parser, "height", cap.height());
 args.args_image.w = get_option(parser, "width", cap.width());
 args.args_image.fmt = cap.pixel_fmt();
 args.args_image.framerate = cap.fps();
 return args;
 }());
 };
 // Encode to multiple different types of buffers.
 std::vector<char> buf1;
 std::vector<int8_t> buf2;
 std::vector<uint8_t> buf3;
 std::ostringstream buf4;
 std::ofstream buf5("encoded.dat", std::ios::binary);
 // Different encoders for different buffers
 auto enc1 = make_encoder();
 auto enc2 = make_encoder();
 auto enc3 = make_encoder();
 auto enc4 = make_encoder();
 auto enc5 = make_encoder();
 frame f;
 while (cap.read(f))
 {
 enc1.push(f, sink(buf1));
 enc2.push(f, sink(buf2));
 enc3.push(f, sink(buf3));
 enc4.push(f, sink(buf4));
 enc5.push(f, sink(buf5));
 }
 enc1.flush(sink(buf1));
 enc2.flush(sink(buf2));
 enc3.flush(sink(buf3));
 enc4.flush(sink(buf4));
 enc5.flush(sink(buf5));
 cout << "vector<char> size " << buf1.size() << endl;
 cout << "vector<int8_t> size " << buf2.size() << endl;
 cout << "vector<uint8_t> size " << buf3.size() << endl;
 cout << "ostringstream size " << buf4.tellp() << endl;
 cout << "ofstream size " << buf5.tellp() << endl;
 return EXIT_SUCCESS;
}
catch (const std::exception& e)
{
 cout << e.what() << endl;
 return EXIT_FAILURE;
}