void PageRecord::StopPage(bool save) {
if(!m_page_started)
return;
StopOutput(true);
StopInput();
Logger::LogInfo("[PageRecord::StopPage] " + tr("Stopping page ..."));
if(m_output_manager != NULL) {
// stop the output
if(save) {
m_output_manager->Finish();
if(m_output_manager->GetVideoEncoder() != NULL) {
m_wait_saving = true;
unsigned int frames_left = m_output_manager->GetVideoEncoder()->GetFrameLatency();
QProgressDialog dialog(tr("Encoding remaining data ..."), QString(), 0, frames_left, this);
dialog.setWindowTitle(MainWindow::WINDOW_CAPTION);
dialog.setWindowModality(Qt::WindowModal);
dialog.setCancelButton(NULL);
dialog.setMinimumDuration(500);
while(!m_output_manager->IsFinished()) {
//qDebug() << "frames left" << frames_left << "current" << m_output_manager->GetVideoEncoder()->GetFrameLatency();
dialog.setValue(frames_left - clamp(m_output_manager->GetVideoEncoder()->GetFrameLatency(), 0u, frames_left));
usleep(20000);
}
m_wait_saving = false;
}
}
m_output_manager.reset();
// delete the file if it isn't needed
if(!save && m_file_protocol.isNull()) {
if(QFileInfo(m_output_settings.file).exists())
QFile(m_output_settings.file).remove();
}
}
// destroy the GLInject input
m_gl_inject_input.reset();
// stop JACK input
#if SSR_USE_JACK
m_jack_input.reset();
#endif
Logger::LogInfo("[PageRecord::StopPage] " + tr("Stopped page."));
m_page_started = false;
UpdateSysTray();
OnUpdateHotkey();
OnUpdateSoundNotifications();
m_timer_update_info->stop();
OnUpdateInformation();
}
void PageRecord::StopPage(bool save) {
if(!m_page_started)
return;
StopOutput(true);
StopInput();
Logger::LogInfo("[PageRecord::StopPage] " + tr("Stopping page ..."));
if(m_output_manager != NULL) {
// stop the output
if(save)
FinishOutput();
m_output_manager.reset();
// delete the file if it isn't needed
if(!save && m_file_protocol.isNull()) {
if(QFileInfo(m_output_settings.file).exists())
QFile(m_output_settings.file).remove();
}
}
// destroy the GLInject input
m_gl_inject_input.reset();
// stop JACK input
#if SSR_USE_JACK
m_jack_input.reset();
#endif
Logger::LogInfo("[PageRecord::StopPage] " + tr("Stopped page."));
m_page_started = false;
UpdateSysTray();
OnUpdateSoundNotifications();
m_timer_update_info->stop();
OnUpdateInformation();
}
void PageRecord::StopPage(bool save) {
if(!m_page_started)
return;
StopOutput(true);
StopInput();
Logger::LogInfo("[PageRecord::StopPage] " + tr("Stopping page ..."));
if(m_output_manager != NULL) {
// stop the output
if(save)
m_output_manager->Finish();
m_output_manager.reset();
// delete the file if it isn't needed
if(!save && m_file_protocol.isNull()) {
if(QFileInfo(m_output_settings.file).exists())
QFile(m_output_settings.file).remove();
}
}
// free the shared memory for OpenGL recording
// This doesn't stop the program, and the memory is only actually freed when the recorded program stops too.
m_gl_inject_launcher.reset();
Logger::LogInfo("[PageRecord::StopPage] " + tr("Stopped page."));
m_page_started = false;
UpdateSysTray();
OnUpdateHotkey();
m_info_timer->stop();
OnUpdateInformation();
m_glinject_event_timer->stop();
}
void PageRecord::StartPage() {
if(m_page_started)
return;
assert(!m_input_started);
assert(!m_output_started);
// save the settings in case libav/ffmpeg decides to kill the process
m_main_window->SaveSettings();
// clear the log
m_textedit_log->clear();
// clear the preview
if(m_previewing) {
m_video_previewer->Reset();
m_audio_previewer->Reset();
}
PageInput *page_input = m_main_window->GetPageInput();
PageOutput *page_output = m_main_window->GetPageOutput();
// get the video input settings
m_video_area = page_input->GetVideoArea();
m_video_x = page_input->GetVideoX();
m_video_y = page_input->GetVideoY();
if(m_video_area == PageInput::VIDEO_AREA_GLINJECT) {
m_video_in_width = 0;
m_video_in_height = 0;
} else {
m_video_in_width = page_input->GetVideoW();
m_video_in_height = page_input->GetVideoH();
}
m_video_frame_rate = page_input->GetVideoFrameRate();
m_video_scaling = page_input->GetVideoScalingEnabled();
m_video_scaled_width = page_input->GetVideoScaledW();
m_video_scaled_height = page_input->GetVideoScaledH();
m_video_record_cursor = page_input->GetVideoRecordCursor();
// get the audio input settings
m_audio_enabled = page_input->GetAudioEnabled();
m_audio_channels = 2;
m_audio_sample_rate = 44100;
m_audio_backend = page_input->GetAudioBackend();
m_alsa_source = page_input->GetALSASourceName();
#if SSR_USE_PULSEAUDIO
m_pulseaudio_source = page_input->GetPulseAudioSourceName();
#endif
#if SSR_USE_JACK
bool jack_connect_system_capture = page_input->GetJackConnectSystemCapture();
bool jack_connect_system_playback = page_input->GetJackConnectSystemPlayback();
#endif
// get the glinject settings
QString glinject_channel = page_input->GetGLInjectChannel();
bool glinject_relax_permissions = page_input->GetGLInjectRelaxPermissions();
QString glinject_command = page_input->GetGLInjectCommand();
QString glinject_working_directory = page_input->GetGLInjectWorkingDirectory();
bool glinject_auto_launch = page_input->GetGLInjectAutoLaunch();
bool glinject_limit_fps = page_input->GetGLInjectLimitFPS();
// get file settings
m_file_base = page_output->GetFile();
m_file_protocol = page_output->GetFileProtocol();
m_separate_files = page_output->GetSeparateFiles();
// get the output settings
if(m_separate_files)
m_output_settings.file = QString(); // will be set later
else
m_output_settings.file = m_file_base;
m_output_settings.container_avname = page_output->GetContainerAVName();
m_output_settings.video_codec_avname = page_output->GetVideoCodecAVName();
m_output_settings.video_kbit_rate = page_output->GetVideoKBitRate();
m_output_settings.video_options.clear();
m_output_settings.video_width = 0;
m_output_settings.video_height = 0;
m_output_settings.video_frame_rate = m_video_frame_rate;
m_output_settings.video_allow_frame_skipping = page_output->GetVideoAllowFrameSkipping();
m_output_settings.audio_codec_avname = (m_audio_enabled)? page_output->GetAudioCodecAVName() : QString();
m_output_settings.audio_kbit_rate = page_output->GetAudioKBitRate();
m_output_settings.audio_options.clear();
m_output_settings.audio_channels = m_audio_channels;
m_output_settings.audio_sample_rate = m_audio_sample_rate;
// some codec-specific things
// you can get more information about all these options by running 'ffmpeg -h' or 'avconv -h' from a terminal
switch(page_output->GetVideoCodec()) {
case PageOutput::VIDEO_CODEC_H264: {
// x264 has a 'constant quality' mode, where the bit rate is simply set to whatever is needed to keep a certain quality. The quality is set
// with the 'crf' option. 'preset' changes the encoding speed (and hence the efficiency of the compression) but doesn't really influence the quality,
// which is great because it means you don't have to experiment with different bit rates and different speeds to get good results.
m_output_settings.video_options.push_back(std::make_pair(QString("crf"), QString::number(page_output->GetH264CRF())));
m_output_settings.video_options.push_back(std::make_pair(QString("preset"), EnumToString(page_output->GetH264Preset())));
break;
}
case PageOutput::VIDEO_CODEC_VP8: {
// The names of there parameters are very unintuitive. The two options we care about (because they change the speed) are 'deadline' and 'cpu-used'.
// 'deadline=best' is unusably slow. 'deadline=good' is the normal setting, it tells the encoder to use the speed set with 'cpu-used'. Higher
// numbers will use *less* CPU, confusingly, so a higher number is faster. I haven't done much testing with 'realtime' so I'm not sure if it's a good idea here.
// It sounds useful, but I think it will use so much CPU that it will slow down the program that is being recorded.
m_output_settings.video_options.push_back(std::make_pair(QString("deadline"), QString("good")));
m_output_settings.video_options.push_back(std::make_pair(QString("cpu-used"), QString::number(page_output->GetVP8CPUUsed())));
break;
}
case PageOutput::VIDEO_CODEC_OTHER: {
m_output_settings.video_options = GetOptionsFromString(page_output->GetVideoOptions());
break;
}
default: break; // to keep GCC happy
}
switch(page_output->GetAudioCodec()) {
case PageOutput::AUDIO_CODEC_OTHER: {
m_output_settings.audio_options = GetOptionsFromString(page_output->GetAudioOptions());
break;
}
default: break; // to keep GCC happy
}
// hide the audio previewer if there is no audio
GroupVisible({m_label_mic_icon, m_audio_previewer}, m_audio_enabled);
Logger::LogInfo("[PageRecord::StartPage] " + tr("Starting page ..."));
try {
// for OpenGL recording, create the input now
if(m_video_area == PageInput::VIDEO_AREA_GLINJECT) {
if(glinject_auto_launch)
GLInjectInput::LaunchApplication(glinject_channel, glinject_relax_permissions, glinject_command, glinject_working_directory);
m_gl_inject_input.reset(new GLInjectInput(glinject_channel, glinject_relax_permissions, m_video_record_cursor, glinject_limit_fps, m_video_frame_rate));
}
#if SSR_USE_JACK
if(m_audio_enabled) {
// for JACK, start the input now
if(m_audio_backend == PageInput::AUDIO_BACKEND_JACK)
m_jack_input.reset(new JACKInput(jack_connect_system_capture, jack_connect_system_playback));
}
#endif
} catch(...) {
Logger::LogError("[PageRecord::StartPage] " + tr("Error: Something went wrong during initialization."));
m_gl_inject_input.reset();
#if SSR_USE_JACK
m_jack_input.reset();
#endif
}
Logger::LogInfo("[PageRecord::StartPage] " + tr("Started page."));
m_page_started = true;
m_recorded_something = false;
m_wait_saving = false;
UpdateSysTray();
OnUpdateHotkey();
OnUpdateSoundNotifications();
UpdateInput();
OnUpdateInformation();
m_timer_update_info->start(1000);
}
PageRecord::PageRecord(MainWindow* main_window)
: QWidget(main_window->centralWidget()) {
m_main_window = main_window;
m_page_started = false;
m_input_started = false;
m_output_started = false;
m_previewing = false;
m_last_error_sound = std::numeric_limits<int64_t>::min();
QGroupBox *groupbox_recording = new QGroupBox(tr("Recording"), this);
{
m_pushbutton_start_pause = new QPushButton(groupbox_recording);
m_checkbox_hotkey_enable = new QCheckBox(tr("Enable recording hotkey"), groupbox_recording);
m_checkbox_sound_notifications_enable = new QCheckBox(tr("Enable sound notifications"), groupbox_recording);
QLabel *label_hotkey = new QLabel(tr("Hotkey:"), groupbox_recording);
m_checkbox_hotkey_ctrl = new QCheckBox(tr("Ctrl +"), groupbox_recording);
m_checkbox_hotkey_shift = new QCheckBox(tr("Shift +"), groupbox_recording);
m_checkbox_hotkey_alt = new QCheckBox(tr("Alt +"), groupbox_recording);
m_checkbox_hotkey_super = new QCheckBox(tr("Super +"), groupbox_recording);
m_combobox_hotkey_key = new QComboBox(groupbox_recording);
m_combobox_hotkey_key->setToolTip(tr("The key that you have to press (combined with the given modifiers) to start or pause recording.\n"
"The program that you are recording will not receive the key press."));
// Note: The choice of keys is currently rather limited, because capturing key presses session-wide is a bit harder than it looks.
// For example, applications are not allowed to capture the F1-F12 keys (on Ubuntu at least). The A-Z keys don't have this limitation apparently.
for(unsigned int i = 0; i < 26; ++i) {
m_combobox_hotkey_key->addItem(QString('A' + i));
}
connect(m_pushbutton_start_pause, SIGNAL(clicked()), this, SLOT(OnRecordStartPause()));
connect(m_checkbox_hotkey_enable, SIGNAL(clicked()), this, SLOT(OnUpdateHotkeyFields()));
connect(m_checkbox_sound_notifications_enable, SIGNAL(clicked()), this, SLOT(OnUpdateSoundNotifications()));
connect(m_checkbox_hotkey_ctrl, SIGNAL(clicked()), this, SLOT(OnUpdateHotkey()));
connect(m_checkbox_hotkey_shift, SIGNAL(clicked()), this, SLOT(OnUpdateHotkey()));
connect(m_checkbox_hotkey_alt, SIGNAL(clicked()), this, SLOT(OnUpdateHotkey()));
connect(m_checkbox_hotkey_super, SIGNAL(clicked()), this, SLOT(OnUpdateHotkey()));
connect(m_combobox_hotkey_key, SIGNAL(activated(int)), this, SLOT(OnUpdateHotkey()));
QVBoxLayout *layout = new QVBoxLayout(groupbox_recording);
layout->addWidget(m_pushbutton_start_pause);
{
QHBoxLayout *layout2 = new QHBoxLayout();
layout->addLayout(layout2);
layout2->addWidget(m_checkbox_hotkey_enable);
layout2->addWidget(m_checkbox_sound_notifications_enable);
}
{
QHBoxLayout *layout2 = new QHBoxLayout();
layout->addLayout(layout2);
layout2->addWidget(label_hotkey);
layout2->addWidget(m_checkbox_hotkey_ctrl);
layout2->addWidget(m_checkbox_hotkey_shift);
layout2->addWidget(m_checkbox_hotkey_alt);
layout2->addWidget(m_checkbox_hotkey_super);
layout2->addWidget(m_combobox_hotkey_key);
}
}
QSplitter *splitter_vertical = new QSplitter(Qt::Vertical, this);
{
QSplitter *splitter_horizontal = new QSplitter(Qt::Horizontal, splitter_vertical);
{
QGroupBox *groupbox_information = new QGroupBox(tr("Information"), splitter_horizontal);
{
QLabel *label_total_time = new QLabel(tr("Total time:"), groupbox_information);
m_label_info_total_time = new QLabel(groupbox_information);
QLabel *label_frame_rate_in = new QLabel(tr("FPS in:"), groupbox_information);
m_label_info_frame_rate_in = new QLabel(groupbox_information);
QLabel *label_frame_rate_out = new QLabel(tr("FPS out:"), groupbox_information);
m_label_info_frame_rate_out = new QLabel(groupbox_information);
QLabel *label_size_in = new QLabel(tr("Size in:"), groupbox_information);
m_label_info_size_in = new QLabel(groupbox_information);
QLabel *label_size_out = new QLabel(tr("Size out:"), groupbox_information);
m_label_info_size_out = new QLabel(groupbox_information);
QLabel *label_file_name = new QLabel(tr("File name:"), groupbox_information);
m_label_info_file_name = new ElidedLabel(QString(), Qt::ElideMiddle, groupbox_information);
m_label_info_file_name->setMinimumWidth(100);
QLabel *label_file_size = new QLabel(tr("File size:"), groupbox_information);
m_label_info_file_size = new QLabel(groupbox_information);
QLabel *label_bit_rate = new QLabel(tr("Bit rate:"), groupbox_information);
m_label_info_bit_rate = new QLabel(groupbox_information);
QGridLayout *layout = new QGridLayout(groupbox_information);
layout->addWidget(label_total_time, 0, 0);
layout->addWidget(m_label_info_total_time, 0, 1);
layout->addWidget(label_frame_rate_in, 1, 0);
layout->addWidget(m_label_info_frame_rate_in, 1, 1);
layout->addWidget(label_frame_rate_out, 2, 0);
layout->addWidget(m_label_info_frame_rate_out, 2, 1);
layout->addWidget(label_size_in, 3, 0);
layout->addWidget(m_label_info_size_in, 3, 1);
layout->addWidget(label_size_out, 4, 0);
layout->addWidget(m_label_info_size_out, 4, 1);
layout->addWidget(label_file_name, 5, 0);
layout->addWidget(m_label_info_file_name, 5, 1);
layout->addWidget(label_file_size, 6, 0);
layout->addWidget(m_label_info_file_size, 6, 1);
layout->addWidget(label_bit_rate, 7, 0);
layout->addWidget(m_label_info_bit_rate, 7, 1);
layout->setColumnStretch(1, 1);
layout->setRowStretch(8, 1);
}
QGroupBox *groupbox_preview = new QGroupBox(tr("Preview"), splitter_horizontal);
{
m_preview_page1 = new QWidget(groupbox_preview);
{
QLabel *label_preview_frame_rate = new QLabel(tr("Preview frame rate:"), m_preview_page1);
m_spinbox_preview_frame_rate = new QSpinBox(m_preview_page1);
m_spinbox_preview_frame_rate->setRange(1, 1000);
m_spinbox_preview_frame_rate->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
QLabel *label_preview_note = new QLabel(tr("Note: Previewing requires extra CPU time (especially at high frame rates)."), m_preview_page1);
label_preview_note->setWordWrap(true);
label_preview_note->setAlignment(Qt::AlignLeft | Qt::AlignTop);
label_preview_note->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::MinimumExpanding);
QGridLayout *layout = new QGridLayout(m_preview_page1);
layout->setMargin(0);
layout->addWidget(label_preview_frame_rate, 0, 0);
layout->addWidget(m_spinbox_preview_frame_rate, 0, 1);
layout->addWidget(label_preview_note, 1, 0, 1, 2);
}
m_preview_page2 = new QWidget(groupbox_preview);
{
m_video_previewer = new VideoPreviewer(m_preview_page2);
m_label_mic_icon = new QLabel(m_preview_page2);
m_label_mic_icon->setPixmap(QIcon::fromTheme("audio-input-microphone").pixmap(24, 24));
m_audio_previewer = new AudioPreviewer(m_preview_page2);
QVBoxLayout *layout = new QVBoxLayout(m_preview_page2);
layout->setMargin(0);
layout->addWidget(m_video_previewer);
{
QHBoxLayout *layout2 = new QHBoxLayout();
layout->addLayout(layout2);
layout2->addStretch();
layout2->addWidget(m_label_mic_icon);
layout2->addWidget(m_audio_previewer);
layout2->addStretch();
}
}
m_pushbutton_preview_start_stop = new QPushButton(groupbox_preview);
connect(m_pushbutton_preview_start_stop, SIGNAL(clicked()), this, SLOT(OnPreviewStartStop()));
QVBoxLayout *layout = new QVBoxLayout(groupbox_preview);
{
m_stacked_layout_preview = new QStackedLayout();
layout->addLayout(m_stacked_layout_preview);
m_stacked_layout_preview->addWidget(m_preview_page1);
m_stacked_layout_preview->addWidget(m_preview_page2);
}
layout->addWidget(m_pushbutton_preview_start_stop);
}
splitter_horizontal->addWidget(groupbox_information);
splitter_horizontal->addWidget(groupbox_preview);
splitter_horizontal->setStretchFactor(0, 1);
splitter_horizontal->setStretchFactor(1, 3);
}
QGroupBox *groupbox_log = new QGroupBox(tr("Log"), splitter_vertical);
{
m_textedit_log = new QTextEditSmall(groupbox_log);
m_textedit_log->setReadOnly(true);
QVBoxLayout *layout = new QVBoxLayout(groupbox_log);
layout->addWidget(m_textedit_log);
}
splitter_vertical->addWidget(splitter_horizontal);
splitter_vertical->addWidget(groupbox_log);
splitter_vertical->setStretchFactor(0, 3);
splitter_vertical->setStretchFactor(1, 1);
}
QPushButton *button_cancel = new QPushButton(QIcon::fromTheme("process-stop"), tr("Cancel recording"), this);
QPushButton *button_save = new QPushButton(QIcon::fromTheme("document-save"), tr("Save recording"), this);
if(g_option_systray) {
m_systray_icon = new QSystemTrayIcon(g_icon_ssr, m_main_window);
QMenu *menu = new QMenu(m_main_window);
m_systray_action_start_pause = menu->addAction(QString(), this, SLOT(OnRecordStartPause()));
m_systray_action_save = menu->addAction(tr("Save recording"), this, SLOT(OnSave()));
m_systray_action_cancel = menu->addAction(tr("Cancel recording"), this, SLOT(OnCancel()));
menu->addSeparator();
menu->addAction("Quit", m_main_window, SLOT(close()));
m_systray_icon->setContextMenu(menu);
} else {
m_systray_icon = NULL;
}
connect(button_cancel, SIGNAL(clicked()), this, SLOT(OnCancel()));
connect(button_save, SIGNAL(clicked()), this, SLOT(OnSave()));
if(m_systray_icon != NULL)
connect(m_systray_icon, SIGNAL(activated(QSystemTrayIcon::ActivationReason)), m_main_window, SLOT(OnSysTrayActivated(QSystemTrayIcon::ActivationReason)));
QVBoxLayout *layout = new QVBoxLayout(this);
layout->addWidget(groupbox_recording);
layout->addWidget(splitter_vertical);
{
QHBoxLayout *layout2 = new QHBoxLayout();
layout->addLayout(layout2);
layout2->addWidget(button_cancel);
layout2->addWidget(button_save);
}
UpdateSysTray();
UpdateRecordPauseButton();
UpdatePreview();
m_timer_update_info = new QTimer(this);
connect(m_timer_update_info, SIGNAL(timeout()), this, SLOT(OnUpdateInformation()));
connect(&m_hotkey_start_pause, SIGNAL(Triggered()), this, SLOT(OnRecordStartPause()));
connect(Logger::GetInstance(), SIGNAL(NewLine(Logger::enum_type,QString)), this, SLOT(OnNewLogLine(Logger::enum_type,QString)), Qt::QueuedConnection);
if(m_systray_icon != NULL)
m_systray_icon->show();
}
void PageRecord::StartPage() {
if(m_page_started)
return;
assert(!m_input_started);
assert(!m_output_started);
// save the settings in case libav/ffmpeg decides to kill the process
m_main_window->SaveSettings();
// clear the log
m_textedit_log->clear();
// clear the preview
if(m_previewing) {
m_video_previewer->Reset();
m_audio_previewer->Reset();
}
PageInput *page_input = m_main_window->GetPageInput();
PageOutput *page_output = m_main_window->GetPageOutput();
// get the video input settings
m_video_area = page_input->GetVideoArea();
m_video_area_follow_fullscreen = page_input->GetVideoAreaFollowFullscreen();
m_video_x = page_input->GetVideoX();
m_video_y = page_input->GetVideoY();
#if SSR_USE_OPENGL_RECORDING
if(m_video_area == PageInput::VIDEO_AREA_GLINJECT) {
m_video_in_width = 0;
m_video_in_height = 0;
} else {
#else
{
#endif
m_video_in_width = page_input->GetVideoW();
m_video_in_height = page_input->GetVideoH();
}
m_video_in_width = page_input->GetVideoW();
m_video_in_height = page_input->GetVideoH();
m_video_frame_rate = page_input->GetVideoFrameRate();
m_video_scaling = page_input->GetVideoScalingEnabled();
m_video_scaled_width = page_input->GetVideoScaledW();
m_video_scaled_height = page_input->GetVideoScaledH();
m_video_record_cursor = page_input->GetVideoRecordCursor();
// get the audio input settings
m_audio_enabled = page_input->GetAudioEnabled();
m_audio_channels = 2;
m_audio_sample_rate = 48000;
m_audio_backend = page_input->GetAudioBackend();
#if SSR_USE_ALSA
m_alsa_source = page_input->GetALSASourceName();
#endif
#if SSR_USE_PULSEAUDIO
m_pulseaudio_source = page_input->GetPulseAudioSourceName();
#endif
#if SSR_USE_JACK
bool jack_connect_system_capture = page_input->GetJackConnectSystemCapture();
bool jack_connect_system_playback = page_input->GetJackConnectSystemPlayback();
#endif
// override sample rate for problematic cases (these are hard-coded for now)
if(page_output->GetContainer() == PageOutput::CONTAINER_OTHER && page_output->GetContainerAVName() == "flv") {
m_audio_sample_rate = 44100;
}
#if SSR_USE_OPENGL_RECORDING
// get the glinject settings
QString glinject_channel = page_input->GetGLInjectChannel();
bool glinject_relax_permissions = page_input->GetGLInjectRelaxPermissions();
QString glinject_command = page_input->GetGLInjectCommand();
QString glinject_working_directory = page_input->GetGLInjectWorkingDirectory();
bool glinject_auto_launch = page_input->GetGLInjectAutoLaunch();
bool glinject_limit_fps = page_input->GetGLInjectLimitFPS();
#endif
// get file settings
m_file_base = page_output->GetFile();
m_file_protocol = page_output->GetFileProtocol();
m_separate_files = page_output->GetSeparateFiles();
m_add_timestamp = page_output->GetAddTimestamp();
// get the output settings
m_output_settings.file = QString(); // will be set later
m_output_settings.container_avname = page_output->GetContainerAVName();
m_output_settings.video_codec_avname = page_output->GetVideoCodecAVName();
m_output_settings.video_kbit_rate = page_output->GetVideoKBitRate();
m_output_settings.video_options.clear();
m_output_settings.video_width = 0;
m_output_settings.video_height = 0;
m_output_settings.video_frame_rate = m_video_frame_rate;
m_output_settings.video_allow_frame_skipping = page_output->GetVideoAllowFrameSkipping();
m_output_settings.audio_codec_avname = (m_audio_enabled)? page_output->GetAudioCodecAVName() : QString();
m_output_settings.audio_kbit_rate = page_output->GetAudioKBitRate();
m_output_settings.audio_options.clear();
m_output_settings.audio_channels = m_audio_channels;
m_output_settings.audio_sample_rate = m_audio_sample_rate;
// some codec-specific things
// you can get more information about all these options by running 'ffmpeg -h' or 'avconv -h' from a terminal
switch(page_output->GetVideoCodec()) {
case PageOutput::VIDEO_CODEC_H264: {
// x264 has a 'constant quality' mode, where the bit rate is simply set to whatever is needed to keep a certain quality. The quality is set
// with the 'crf' option. 'preset' changes the encoding speed (and hence the efficiency of the compression) but doesn't really influence the quality,
// which is great because it means you don't have to experiment with different bit rates and different speeds to get good results.
m_output_settings.video_options.push_back(std::make_pair(QString("crf"), QString::number(page_output->GetH264CRF())));
m_output_settings.video_options.push_back(std::make_pair(QString("preset"), EnumToString(page_output->GetH264Preset())));
break;
}
case PageOutput::VIDEO_CODEC_VP8: {
// The names of there parameters are very unintuitive. The two options we care about (because they change the speed) are 'deadline' and 'cpu-used'.
// 'deadline=best' is unusably slow. 'deadline=good' is the normal setting, it tells the encoder to use the speed set with 'cpu-used'. Higher
// numbers will use *less* CPU, confusingly, so a higher number is faster. I haven't done much testing with 'realtime' so I'm not sure if it's a good idea here.
// It sounds useful, but I think it will use so much CPU that it will slow down the program that is being recorded.
m_output_settings.video_options.push_back(std::make_pair(QString("deadline"), QString("good")));
m_output_settings.video_options.push_back(std::make_pair(QString("cpu-used"), QString::number(page_output->GetVP8CPUUsed())));
break;
}
case PageOutput::VIDEO_CODEC_OTHER: {
m_output_settings.video_options = GetOptionsFromString(page_output->GetVideoOptions());
break;
}
default: break; // to keep GCC happy
}
switch(page_output->GetAudioCodec()) {
case PageOutput::AUDIO_CODEC_OTHER: {
m_output_settings.audio_options = GetOptionsFromString(page_output->GetAudioOptions());
break;
}
default: break; // to keep GCC happy
}
// hide the audio previewer if there is no audio
GroupVisible({m_label_mic_icon, m_audio_previewer}, m_audio_enabled);
Logger::LogInfo("[PageRecord::StartPage] " + tr("Starting page ..."));
try {
#if SSR_USE_OPENGL_RECORDING
// for OpenGL recording, create the input now
if(m_video_area == PageInput::VIDEO_AREA_GLINJECT) {
if(glinject_auto_launch)
GLInjectInput::LaunchApplication(glinject_channel, glinject_relax_permissions, glinject_command, glinject_working_directory);
m_gl_inject_input.reset(new GLInjectInput(glinject_channel, glinject_relax_permissions, m_video_record_cursor, glinject_limit_fps, m_video_frame_rate));
}
#endif
#if SSR_USE_JACK
if(m_audio_enabled) {
// for JACK, start the input now
if(m_audio_backend == PageInput::AUDIO_BACKEND_JACK)
m_jack_input.reset(new JACKInput(jack_connect_system_capture, jack_connect_system_playback));
}
#endif
} catch(...) {
Logger::LogError("[PageRecord::StartPage] " + tr("Error: Something went wrong during initialization."));
#if SSR_USE_OPENGL_RECORDING
m_gl_inject_input.reset();
#endif
#if SSR_USE_JACK
m_jack_input.reset();
#endif
}
Logger::LogInfo("[PageRecord::StartPage] " + tr("Started page."));
m_page_started = true;
m_recorded_something = false;
m_wait_saving = false;
m_error_occurred = false;
UpdateSysTray();
#if SSR_USE_ALSA
OnUpdateSoundNotifications();
#endif
UpdateInput();
OnUpdateInformation();
m_timer_update_info->start(1000);
}
void PageRecord::StopPage(bool save) {
if(!m_page_started)
return;
StopOutput(true);
StopInput();
Logger::LogInfo("[PageRecord::StopPage] " + tr("Stopping page ..."));
if(m_output_manager != NULL) {
// stop the output
if(save)
FinishOutput();
m_output_manager.reset();
// delete the file if it isn't needed
if(!save && m_file_protocol.isNull()) {
if(QFileInfo(m_output_settings.file).exists())
QFile(m_output_settings.file).remove();
}
}
#if SSR_USE_OPENGL_RECORDING
// stop GLInject input
m_gl_inject_input.reset();
#endif
#if SSR_USE_JACK
// stop JACK input
m_jack_input.reset();
#endif
Logger::LogInfo("[PageRecord::StopPage] " + tr("Stopped page."));
m_page_started = false;
UpdateSysTray();
#if SSR_USE_ALSA
OnUpdateSoundNotifications();
#endif
m_timer_update_info->stop();
OnUpdateInformation();
}
void PageRecord::StartOutput() {
assert(m_page_started);
if(m_output_started)
return;
#if SSR_USE_ALSA
if(m_simple_synth != NULL) {
m_simple_synth->PlaySequence(SEQUENCE_RECORD_START.data(), SEQUENCE_RECORD_START.size());
usleep(200000);
}
#endif
try {
Logger::LogInfo("[PageRecord::StartOutput] " + tr("Starting output ..."));
if(m_output_manager == NULL) {
// set the file name
m_output_settings.file = GetNewSegmentFile(m_file_base, m_add_timestamp);
// for X11 recording, update the video size (if possible)
if(m_x11_input != NULL)
m_x11_input->GetCurrentSize(&m_video_in_width, &m_video_in_height);
#if SSR_USE_OPENGL_RECORDING
// for OpenGL recording, detect the video size
if(m_video_area == PageInput::VIDEO_AREA_GLINJECT && !m_video_scaling) {
if(m_gl_inject_input == NULL) {
Logger::LogError("[PageRecord::StartOutput] " + tr("Error: Could not get the size of the OpenGL application because the GLInject input has not been created."));
throw GLInjectException();
}
m_gl_inject_input->GetCurrentSize(&m_video_in_width, &m_video_in_height);
if(m_video_in_width == 0 && m_video_in_height == 0) {
Logger::LogError("[PageRecord::StartOutput] " + tr("Error: Could not get the size of the OpenGL application. Either the "
"application wasn't started correctly, or the application hasn't created an OpenGL window yet. If "
"you want to start recording before starting the application, you have to enable scaling and enter "
"the video size manually."));
throw GLInjectException();
}
}
#endif
// calculate the output width and height
if(m_video_scaling) {
// Only even width and height is allowed because some pixel formats (e.g. YUV420) require this.
m_output_settings.video_width = m_video_scaled_width / 2 * 2;
m_output_settings.video_height = m_video_scaled_height / 2 * 2;
#if SSR_USE_OPENGL_RECORDING
} else if(m_video_area == PageInput::VIDEO_AREA_GLINJECT) {
// The input size is the size of the OpenGL application and can't be changed. The output size is set to the current size of the application.
m_output_settings.video_width = m_video_in_width / 2 * 2;
m_output_settings.video_height = m_video_in_height / 2 * 2;
#endif
} else {
// If the user did not explicitly select scaling, then don't force scaling just because the recording area is one pixel too large.
// One missing row/column of pixels is probably better than a blurry video (and scaling is SLOW).
m_video_in_width = m_video_in_width / 2 * 2;
m_video_in_height = m_video_in_height / 2 * 2;
m_output_settings.video_width = m_video_in_width;
m_output_settings.video_height = m_video_in_height;
}
// start the output
m_output_manager.reset(new OutputManager(m_output_settings));
} else {
// start a new segment
m_output_manager->GetSynchronizer()->NewSegment();
}
Logger::LogInfo("[PageRecord::StartOutput] " + tr("Started output."));
m_output_started = true;
m_recorded_something = true;
UpdateSysTray();
UpdateRecordPauseButton();
UpdateInput();
} catch(...) {
Logger::LogError("[PageRecord::StartOutput] " + tr("Error: Something went wrong during initialization."));
}
}
