#include "audio_encoder.h"
#include "basic_stats.h"
+#ifdef HAVE_CEF
+#include "cef_capture.h"
+#endif
#include "defs.h"
#include "flags.h"
#include "ffmpeg_capture.h"
#include <errno.h>
#include <functional>
#include <memory>
+#include <movit/image_format.h>
#include <signal.h>
#include <stddef.h>
#include <stdint.h>
#include <libavutil/version.h>
}
+#ifdef HAVE_CEF
+#include "cef_encoder_adapter.h"
+#include "nageru_cef_app.h"
+CefRefPtr<NageruCefApp> cef_app;
+#endif
+
using namespace bmusb;
using namespace movit;
using namespace std;
return mux;
}
+// NOTE: If we start using the timecode for anything, CEFEncoderAdapter will need adjustment.
void video_frame_callback(FFmpegCapture *video, X264Encoder *x264_encoder, AudioEncoder *audio_encoder,
int64_t video_pts, AVRational video_timebase,
int64_t audio_pts, AVRational audio_timebase,
video_pts = av_rescale_q(video_pts, video_timebase, AVRational{ 1, TIMEBASE });
int64_t frame_duration = int64_t(TIMEBASE) * video_format.frame_rate_den / video_format.frame_rate_nom;
- x264_encoder->add_frame(video_pts, frame_duration, video->get_current_frame_ycbcr_format().luma_coefficients, video_frame.data + video_offset, ts);
+ YCbCrLumaCoefficients luma_coefficients = video ? video->get_current_frame_ycbcr_format().luma_coefficients : YCBCR_REC_709;
+ x264_encoder->add_frame(video_pts, frame_duration, luma_coefficients, video_frame.data + video_offset, ts);
global_basic_stats->update(frame_num++, /*dropped_frames=*/0);
}
if (audio_frame.len > 0) {
int main(int argc, char *argv[])
{
+#ifdef HAVE_CEF
+ // Let CEF have first priority on parsing the command line, because we might be
+ // launched as a CEF sub-process.
+ CefMainArgs main_args(argc, argv);
+ cef_app = CefRefPtr<NageruCefApp>(new NageruCefApp());
+ int err = CefExecuteProcess(main_args, cef_app.get(), nullptr);
+ if (err >= 0) {
+ return err;
+ }
+#endif
+
parse_flags(PROGRAM_KAERU, argc, argv);
if (optind + 1 != argc) {
usage(PROGRAM_KAERU);
}
global_x264_encoder = x264_encoder.get();
- FFmpegCapture video(argv[optind], global_flags.width, global_flags.height);
- video.set_pixel_format(FFmpegCapture::PixelFormat_NV12);
- if (global_flags.transcode_video) {
- video.set_frame_callback(bind(video_frame_callback, &video, x264_encoder.get(), audio_encoder.get(), _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11));
- } else {
- video.set_video_callback(bind(raw_packet_callback, http_mux.get(), /*stream_index=*/0, _1, _2));
- }
- if (!global_flags.transcode_audio && global_flags.enable_audio) {
- AVBSFContext *bsfctx = nullptr;
- if (strcmp(oformat->name, "mp4") == 0 && strcmp(audio_encoder->get_codec()->name, "aac") == 0) {
- // We need to insert the aac_adtstoasc filter, seemingly (or we will get warnings to do so).
- const AVBitStreamFilter *filter = av_bsf_get_by_name("aac_adtstoasc");
- int err = av_bsf_alloc(filter, &bsfctx);
- if (err < 0) {
- fprintf(stderr, "av_bsf_alloc() failed with %d\n", err);
- exit(1);
- }
- }
- if (bsfctx == nullptr) {
- video.set_audio_callback(bind(raw_packet_callback, http_mux.get(), /*stream_index=*/1, _1, _2));
- } else {
- video.set_audio_callback(bind(filter_packet_callback, http_mux.get(), /*stream_index=*/1, bsfctx, _1, _2));
- }
+ CaptureInterface *video;
+ unique_ptr<FFmpegCapture> ffmpeg_video;
+#ifdef HAVE_CEF
+ unique_ptr<CEFCapture> cef_video;
+ unique_ptr<CEFEncoderAdapter> cef_encoder_adapter;
+ if (global_flags.use_cef) {
+ cef_encoder_adapter.reset(new CEFEncoderAdapter(global_flags.width, global_flags.height, x264_encoder.get(), audio_encoder.get()));
+ cef_video.reset(new CEFCapture(argv[optind], global_flags.width, global_flags.height));
+ cef_video->set_pixel_format(bmusb::PixelFormat_8BitBGRA);
+ cef_video->set_frame_callback(bind(&CEFEncoderAdapter::video_frame_callback, cef_encoder_adapter.get(), _1, _2, _3, _4, _5, _6, _7));
+ // NOTE: No CEF audio support yet.
+ video = cef_video.get();
+ } else
+#endif
+ {
+ ffmpeg_video.reset(new FFmpegCapture(argv[optind], global_flags.width, global_flags.height));
+ ffmpeg_video->set_pixel_format(FFmpegCapture::PixelFormat_NV12);
+ if (global_flags.transcode_video) {
+ ffmpeg_video->set_frame_callback(bind(video_frame_callback, ffmpeg_video.get(), x264_encoder.get(), audio_encoder.get(), _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11));
+ } else {
+ ffmpeg_video->set_video_callback(bind(raw_packet_callback, http_mux.get(), /*stream_index=*/0, _1, _2));
+ }
+ if (!global_flags.transcode_audio && global_flags.enable_audio) {
+ AVBSFContext *bsfctx = nullptr;
+ if (strcmp(oformat->name, "mp4") == 0 && strcmp(audio_encoder->get_codec()->name, "aac") == 0) {
+ // We need to insert the aac_adtstoasc filter, seemingly (or we will get warnings to do so).
+ const AVBitStreamFilter *filter = av_bsf_get_by_name("aac_adtstoasc");
+ int err = av_bsf_alloc(filter, &bsfctx);
+ if (err < 0) {
+ fprintf(stderr, "av_bsf_alloc() failed with %d\n", err);
+ exit(1);
+ }
+ }
+ if (bsfctx == nullptr) {
+ ffmpeg_video->set_audio_callback(bind(raw_packet_callback, http_mux.get(), /*stream_index=*/1, _1, _2));
+ } else {
+ ffmpeg_video->set_audio_callback(bind(filter_packet_callback, http_mux.get(), /*stream_index=*/1, bsfctx, _1, _2));
+ }
+ }
+ ffmpeg_video->change_rate(10.0); // Play as fast as possible.
+ video = ffmpeg_video.get();
}
- video.configure_card();
- video.start_bm_capture();
- video.change_rate(10.0); // Play as fast as possible.
+ video->configure_card();
+ video->start_bm_capture();
BasicStats basic_stats(/*verbose=*/false, /*use_opengl=*/false);
global_basic_stats = &basic_stats;
signal(SIGINT, request_quit);
while (!should_quit.should_quit()) {
+#ifdef HAVE_CEF
+ if (global_flags.use_cef) {
+ cef_encoder_adapter->duplicate_frame_if_needed(&should_quit);
+ continue;
+ }
+#endif
should_quit.sleep_for(hours(1000));
}
- video.stop_dequeue_thread();
+ video->stop_dequeue_thread();
// Stop the x264 encoder before killing the mux it's writing to.
global_x264_encoder = nullptr;
x264_encoder.reset();
projects / nageru / blobdiff