} else {
stream_audio_encoder.reset(new AudioEncoder(global_flags.stream_audio_codec_name, global_flags.stream_audio_codec_bitrate, oformat));
}
- if (global_flags.x264_video_to_http) {
+ if (global_flags.x264_video_to_http || global_flags.x264_video_to_disk) {
x264_encoder.reset(new X264Encoder(oformat));
}
stream_audio_encoder->add_mux(stream_mux.get());
quicksync_encoder->set_stream_mux(stream_mux.get());
if (global_flags.x264_video_to_http) {
- x264_encoder->set_mux(stream_mux.get());
+ x264_encoder->add_mux(stream_mux.get());
}
}
VideoEncoder::~VideoEncoder()
{
+ quicksync_encoder->shutdown();
+ x264_encoder.reset(nullptr);
+ quicksync_encoder->close_file();
quicksync_encoder.reset(nullptr);
while (quicksync_encoders_in_shutdown.load() > 0) {
usleep(10000);
stream_mux->plug();
lock_guard<mutex> lock(qs_mu);
QuickSyncEncoder *old_encoder = quicksync_encoder.release(); // When we go C++14, we can use move capture instead.
- thread([old_encoder, this]{
+ X264Encoder *old_x264_encoder = nullptr;
+ if (global_flags.x264_video_to_disk) {
+ old_x264_encoder = x264_encoder.release();
+ }
+ thread([old_encoder, old_x264_encoder, this]{
old_encoder->shutdown();
+ delete old_x264_encoder;
+ old_encoder->close_file();
stream_mux->unplug();
// We cannot delete the encoder here, as this thread has no OpenGL context.
qs_needing_cleanup.emplace_back(old_encoder);
}).detach();
+ if (global_flags.x264_video_to_disk) {
+ x264_encoder.reset(new X264Encoder(oformat));
+ if (global_flags.x264_video_to_http) {
+ x264_encoder->add_mux(stream_mux.get());
+ }
+ if (overriding_bitrate != 0) {
+ x264_encoder->change_bitrate(overriding_bitrate);
+ }
+ }
+
quicksync_encoder.reset(new QuickSyncEncoder(filename, resource_pool, surface, va_display, width, height, oformat, x264_encoder.get(), disk_space_estimator));
quicksync_encoder->set_stream_mux(stream_mux.get());
}
void VideoEncoder::change_x264_bitrate(unsigned rate_kbit)
{
+ overriding_bitrate = rate_kbit;
x264_encoder->change_bitrate(rate_kbit);
}
stream_audio_encoder->encode_audio(audio, pts + quicksync_encoder->global_delay());
}
-bool VideoEncoder::begin_frame(GLuint *y_tex, GLuint *cbcr_tex)
+bool VideoEncoder::is_zerocopy() const
+{
+ lock_guard<mutex> lock(qs_mu);
+ return quicksync_encoder->is_zerocopy();
+}
+
+bool VideoEncoder::begin_frame(int64_t pts, int64_t duration, movit::YCbCrLumaCoefficients ycbcr_coefficients, const std::vector<RefCountedFrame> &input_frames, GLuint *y_tex, GLuint *cbcr_tex)
{
lock_guard<mutex> lock(qs_mu);
qs_needing_cleanup.clear(); // Since we have an OpenGL context here, and are called regularly.
- return quicksync_encoder->begin_frame(y_tex, cbcr_tex);
+ return quicksync_encoder->begin_frame(pts, duration, ycbcr_coefficients, input_frames, y_tex, cbcr_tex);
}
-RefCountedGLsync VideoEncoder::end_frame(int64_t pts, int64_t duration, const std::vector<RefCountedFrame> &input_frames)
+RefCountedGLsync VideoEncoder::end_frame()
{
lock_guard<mutex> lock(qs_mu);
- return quicksync_encoder->end_frame(pts, duration, input_frames);
+ return quicksync_encoder->end_frame();
}
void VideoEncoder::open_output_stream()
avctx->flags = AVFMT_FLAG_CUSTOM_IO;
string video_extradata;
- if (global_flags.x264_video_to_http) {
+ if (global_flags.x264_video_to_http || global_flags.x264_video_to_disk) {
video_extradata = x264_encoder->get_global_headers();
}