diff options
Diffstat (limited to 'src/main.cpp')
| -rw-r--r-- | src/main.cpp | 461 |
1 files changed, 194 insertions, 267 deletions
diff --git a/src/main.cpp b/src/main.cpp index 3b8b133..647dbc4 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -32,7 +32,6 @@ extern "C" { #include <stdlib.h> #include <string> #include <vector> -#include <unordered_map> #include <thread> #include <mutex> #include <signal.h> @@ -58,7 +57,6 @@ extern "C" { #include <libavfilter/buffersrc.h> } -#include <deque> #include <future> #ifndef GSR_VERSION @@ -145,96 +143,6 @@ static int x11_io_error_handler(Display*) { return 0; } -struct PacketData { - PacketData() {} - PacketData(const PacketData&) = delete; - PacketData& operator=(const PacketData&) = delete; - - ~PacketData() { - av_free(data.data); - } - - AVPacket data; - double timestamp = 0.0; -}; - -// |stream| is only required for non-replay mode -static void receive_frames(AVCodecContext *av_codec_context, int stream_index, AVStream *stream, int64_t pts, - AVFormatContext *av_format_context, - double replay_start_time, - std::deque<std::shared_ptr<PacketData>> &frame_data_queue, - int replay_buffer_size_secs, - bool &frames_erased, - std::mutex &write_output_mutex, - double paused_time_offset, - bool record_to_file, - int64_t recording_pts_offset, - const std::function<bool(const AVPacket &packet)> &record_condition_handler) { - for (;;) { - AVPacket *av_packet = av_packet_alloc(); - if(!av_packet) - break; - - av_packet->data = NULL; - av_packet->size = 0; - int res = avcodec_receive_packet(av_codec_context, av_packet); - if (res == 0) { // we have a packet, send the packet to the muxer - av_packet->stream_index = stream_index; - av_packet->pts = pts; - av_packet->dts = pts; - - std::lock_guard<std::mutex> lock(write_output_mutex); - if(replay_buffer_size_secs != -1) { - const double time_now = clock_get_monotonic_seconds(); - // TODO: Preallocate all frames data and use those instead. - // Why are we doing this you ask? there is a new ffmpeg bug that causes cpu usage to increase over time when you have - // packets that are not being free'd until later. So we copy the packet data, free the packet and then reconstruct - // the packet later on when we need it, to keep packets alive only for a short period. - auto new_packet = std::make_shared<PacketData>(); - new_packet->data = *av_packet; - new_packet->data.data = (uint8_t*)av_malloc(av_packet->size); - memcpy(new_packet->data.data, av_packet->data, av_packet->size); - new_packet->timestamp = time_now; - - const double record_passed_time = time_now - paused_time_offset; - double replay_time_elapsed = record_passed_time - replay_start_time; - - frame_data_queue.push_back(std::move(new_packet)); - if(replay_time_elapsed >= replay_buffer_size_secs) { - frame_data_queue.pop_front(); - frames_erased = true; - } - } - - if(record_to_file && record_condition_handler(*av_packet)) { - av_packet->pts -= recording_pts_offset; - av_packet->dts -= recording_pts_offset; - - av_packet_rescale_ts(av_packet, av_codec_context->time_base, stream->time_base); - av_packet->stream_index = stream->index; - // TODO: Is av_interleaved_write_frame needed?. Answer: might be needed for mkv but dont use it! it causes frames to be inconsistent, skipping frames and duplicating frames - int ret = av_write_frame(av_format_context, av_packet); - if(ret < 0) { - fprintf(stderr, "Error: Failed to write frame index %d to muxer, reason: %s (%d)\n", av_packet->stream_index, av_error_to_string(ret), ret); - } - } - av_packet_free(&av_packet); - } else if (res == AVERROR(EAGAIN)) { // we have no packet - // fprintf(stderr, "No packet!\n"); - av_packet_free(&av_packet); - break; - } else if (res == AVERROR_EOF) { // this is the end of the stream - av_packet_free(&av_packet); - fprintf(stderr, "End of stream!\n"); - break; - } else { - av_packet_free(&av_packet); - fprintf(stderr, "Unexpected error: %d\n", res); - break; - } - } -} - static AVCodecID audio_codec_get_id(gsr_audio_codec audio_codec) { switch(audio_codec) { case GSR_AUDIO_CODEC_AAC: return AV_CODEC_ID_AAC; @@ -1197,7 +1105,6 @@ struct AudioDeviceData { struct AudioTrack { std::string name; AVCodecContext *codec_context = nullptr; - AVStream *stream = nullptr; std::vector<AudioDeviceData> audio_devices; AVFilterGraph *graph = nullptr; @@ -1257,13 +1164,18 @@ static bool add_hdr_metadata_to_video_stream(gsr_capture *cap, AVStream *video_s return true; } +struct RecordingStartAudio { + const AudioTrack *audio_track; + AVStream *stream; +}; + struct RecordingStartResult { AVFormatContext *av_format_context = nullptr; AVStream *video_stream = nullptr; - std::unordered_map<int, AudioTrack*> stream_index_to_audio_track_map; + std::vector<RecordingStartAudio> audio_inputs; }; -static RecordingStartResult start_recording_create_streams(const char *filename, const char *container_format, AVCodecContext *video_codec_context, std::vector<AudioTrack> &audio_tracks, bool hdr, gsr_capture *capture) { +static RecordingStartResult start_recording_create_streams(const char *filename, const char *container_format, AVCodecContext *video_codec_context, const std::vector<AudioTrack> &audio_tracks, bool hdr, gsr_capture *capture) { AVFormatContext *av_format_context; avformat_alloc_output_context2(&av_format_context, nullptr, container_format, filename); @@ -1271,20 +1183,19 @@ static RecordingStartResult start_recording_create_streams(const char *filename, avcodec_parameters_from_context(video_stream->codecpar, video_codec_context); RecordingStartResult result; + result.audio_inputs.reserve(audio_tracks.size()); - for(AudioTrack &audio_track : audio_tracks) { - result.stream_index_to_audio_track_map[audio_track.stream_index] = &audio_track; + for(const AudioTrack &audio_track : audio_tracks) { AVStream *audio_stream = create_stream(av_format_context, audio_track.codec_context); if(!audio_track.name.empty()) av_dict_set(&audio_stream->metadata, "title", audio_track.name.c_str(), 0); avcodec_parameters_from_context(audio_stream->codecpar, audio_track.codec_context); - audio_track.stream = audio_stream; + result.audio_inputs.push_back({&audio_track, audio_stream}); } const int open_ret = avio_open(&av_format_context->pb, filename, AVIO_FLAG_WRITE); if(open_ret < 0) { fprintf(stderr, "gsr error: start: could not open '%s': %s\n", filename, av_error_to_string(open_ret)); - result.stream_index_to_audio_track_map.clear(); return result; } @@ -1297,7 +1208,6 @@ static RecordingStartResult start_recording_create_streams(const char *filename, fprintf(stderr, "gsr error: start: error occurred when writing header to output file: %s\n", av_error_to_string(header_write_ret)); avio_close(av_format_context->pb); avformat_free_context(av_format_context); - result.stream_index_to_audio_track_map.clear(); return result; } @@ -1322,102 +1232,79 @@ static bool stop_recording_close_streams(AVFormatContext *av_format_context) { } static std::future<void> save_replay_thread; -static std::vector<std::shared_ptr<PacketData>> save_replay_packets; static std::string save_replay_output_filepath; -// Binary search. Returns 0 if input is empty -static size_t find_frame_data_index_by_time_passed(const std::deque<std::shared_ptr<PacketData>> &frame_data_queue, int seconds) { - const double now = clock_get_monotonic_seconds(); - if(frame_data_queue.empty()) - return 0; +static std::string create_new_recording_filepath_from_timestamp(std::string directory, const char *filename_prefix, const std::string &file_extension, bool date_folders) { + std::string output_filepath; + if(date_folders) { + std::string output_folder = directory + '/' + get_date_only_str(); + if(create_directory_recursive(&output_folder[0]) != 0) + fprintf(stderr, "Error: failed to create directory: %s\n", output_folder.c_str()); + output_filepath = output_folder + "/" + filename_prefix + "_" + get_time_only_str() + "." + file_extension; + } else { + if(create_directory_recursive(&directory[0]) != 0) + fprintf(stderr, "Error: failed to create directory: %s\n", directory.c_str()); + output_filepath = directory + "/" + filename_prefix + "_" + get_date_str() + "." + file_extension; + } + return output_filepath; +} - size_t lower_bound = 0; - size_t upper_bound = frame_data_queue.size(); - size_t index = 0; - for(;;) { - index = lower_bound + (upper_bound - lower_bound) / 2; - const PacketData &packet_data = *frame_data_queue[index]; - const double time_passed_since_packet = now - packet_data.timestamp; - if(time_passed_since_packet >= seconds) { - if(lower_bound == index) - break; - lower_bound = index; - } else { - if(upper_bound == index) - break; - upper_bound = index; - } +static RecordingStartAudio* get_recording_start_item_by_stream_index(RecordingStartResult &result, int stream_index) { + for(auto &audio_input : result.audio_inputs) { + if(audio_input.stream->index == stream_index) + return &audio_input; } - return index; + return nullptr; } -static void save_replay_async(AVCodecContext *video_codec_context, int video_stream_index, std::vector<AudioTrack> &audio_tracks, std::deque<std::shared_ptr<PacketData>> &frame_data_queue, bool frames_erased, std::string output_dir, const char *container_format, const std::string &file_extension, std::mutex &write_output_mutex, bool date_folders, bool hdr, gsr_capture *capture, int current_save_replay_seconds) { +static void save_replay_async(AVCodecContext *video_codec_context, int video_stream_index, const std::vector<AudioTrack> &audio_tracks, gsr_replay_buffer *replay_buffer, std::string output_dir, const char *container_format, const std::string &file_extension, bool date_folders, bool hdr, gsr_capture *capture, int current_save_replay_seconds) { if(save_replay_thread.valid()) return; - size_t start_index = (size_t)-1; - int64_t video_pts_offset = 0; - int64_t audio_pts_offset = 0; - - { - std::lock_guard<std::mutex> lock(write_output_mutex); - const size_t search_start_index = current_save_replay_seconds == save_replay_seconds_full ? 0 : find_frame_data_index_by_time_passed(frame_data_queue, current_save_replay_seconds); - start_index = (size_t)-1; - for(size_t i = search_start_index; i < frame_data_queue.size(); ++i) { - const AVPacket &av_packet = frame_data_queue[i]->data; - if((av_packet.flags & AV_PKT_FLAG_KEY) && av_packet.stream_index == video_stream_index) { - start_index = i; - break; - } - } - - if(start_index == (size_t)-1) - return; - - video_pts_offset = frame_data_queue[start_index]->data.pts; - - // Find the next audio packet to use as audio pts offset. - // TODO: Also search backwards, if an earlier audio packet is closer - for(size_t i = start_index; i < frame_data_queue.size(); ++i) { - const AVPacket &av_packet = frame_data_queue[i]->data; - if(av_packet.stream_index != video_stream_index) { - audio_pts_offset = av_packet.pts; - break; - } - } + const size_t search_start_index = current_save_replay_seconds == save_replay_seconds_full ? 0 : gsr_replay_buffer_find_packet_index_by_time_passed(replay_buffer, current_save_replay_seconds); + const size_t video_start_index = gsr_replay_buffer_find_keyframe(replay_buffer, search_start_index, video_stream_index, false); + if(video_start_index == (size_t)-1) { + fprintf(stderr, "gsr error: failed to save replay: failed to find a video keyframe. perhaps replay was saved too fast, before anything has been recorded\n"); + return; + } - save_replay_packets.resize(frame_data_queue.size()); - for(size_t i = 0; i < frame_data_queue.size(); ++i) { - save_replay_packets[i] = frame_data_queue[i]; - } + const size_t audio_start_index = gsr_replay_buffer_find_keyframe(replay_buffer, video_start_index, video_stream_index, true); + if(audio_start_index == (size_t)-1) { + fprintf(stderr, "gsr error: failed to save replay: failed to find an audio keyframe. perhaps replay was saved too fast, before anything has been recorded\n"); + return; } - if(date_folders) { - std::string output_folder = output_dir + '/' + get_date_only_str(); - create_directory_recursive(&output_folder[0]); - save_replay_output_filepath = output_folder + "/Replay_" + get_time_only_str() + "." + file_extension; - } else { - create_directory_recursive(&output_dir[0]); - save_replay_output_filepath = output_dir + "/Replay_" + get_date_str() + "." + file_extension; + const int64_t video_pts_offset = gsr_replay_buffer_get_packet_at_index(replay_buffer, video_start_index)->packet.pts; + const int64_t audio_pts_offset = gsr_replay_buffer_get_packet_at_index(replay_buffer, audio_start_index)->packet.pts; + + gsr_replay_buffer cloned_replay_buffer; + if(!gsr_replay_buffer_clone(replay_buffer, &cloned_replay_buffer)) { + // TODO: Return this error to mark the replay as failed + fprintf(stderr, "gsr error: failed to save replay: failed to clone replay buffer\n"); + return; } - RecordingStartResult recording_start_result = start_recording_create_streams(save_replay_output_filepath.c_str(), container_format, video_codec_context, audio_tracks, hdr, capture); + std::string output_filepath = create_new_recording_filepath_from_timestamp(output_dir, "Replay", file_extension, date_folders); + RecordingStartResult recording_start_result = start_recording_create_streams(output_filepath.c_str(), container_format, video_codec_context, audio_tracks, hdr, capture); if(!recording_start_result.av_format_context) return; - save_replay_thread = std::async(std::launch::async, [video_stream_index, recording_start_result, start_index, video_pts_offset, audio_pts_offset, video_codec_context, &audio_tracks]() mutable { - for(size_t i = start_index; i < save_replay_packets.size(); ++i) { + save_replay_output_filepath = std::move(output_filepath); + + save_replay_thread = std::async(std::launch::async, [video_stream_index, recording_start_result, video_start_index, video_pts_offset, audio_pts_offset, video_codec_context, cloned_replay_buffer]() mutable { + for(size_t i = video_start_index; i < cloned_replay_buffer.num_packets; ++i) { + const gsr_av_packet *packet = gsr_replay_buffer_get_packet_at_index(&cloned_replay_buffer, i); // TODO: Check if successful AVPacket av_packet; memset(&av_packet, 0, sizeof(av_packet)); - //av_packet_from_data(av_packet, save_replay_packets[i]->data.data, save_replay_packets[i]->data.size); - av_packet.data = save_replay_packets[i]->data.data; - av_packet.size = save_replay_packets[i]->data.size; - av_packet.stream_index = save_replay_packets[i]->data.stream_index; - av_packet.pts = save_replay_packets[i]->data.pts; - av_packet.dts = save_replay_packets[i]->data.pts; - av_packet.flags = save_replay_packets[i]->data.flags; - //av_packet.duration = save_replay_packets[i]->data.duration; + //av_packet_from_data(av_packet, packet->packet.data, packet->packet.size); + av_packet.data = packet->packet.data; + av_packet.size = packet->packet.size; + av_packet.stream_index = packet->packet.stream_index; + av_packet.pts = packet->packet.pts; + av_packet.dts = packet->packet.pts; + av_packet.flags = packet->packet.flags; + //av_packet.duration = packet->packet.duration; AVStream *stream = recording_start_result.video_stream; AVCodecContext *codec_context = video_codec_context; @@ -1426,29 +1313,31 @@ static void save_replay_async(AVCodecContext *video_codec_context, int video_str av_packet.pts -= video_pts_offset; av_packet.dts -= video_pts_offset; } else { - AudioTrack *audio_track = recording_start_result.stream_index_to_audio_track_map[av_packet.stream_index]; - stream = audio_track->stream; + RecordingStartAudio *recording_start_audio = get_recording_start_item_by_stream_index(recording_start_result, av_packet.stream_index); + if(!recording_start_audio) { + fprintf(stderr, "gsr error: save_replay_async: failed to find audio stream by index: %d\n", av_packet.stream_index); + continue; + } + const AudioTrack *audio_track = recording_start_audio->audio_track; + stream = recording_start_audio->stream; codec_context = audio_track->codec_context; av_packet.pts -= audio_pts_offset; av_packet.dts -= audio_pts_offset; } - av_packet.stream_index = stream->index; + //av_packet.stream_index = stream->index; av_packet_rescale_ts(&av_packet, codec_context->time_base, stream->time_base); const int ret = av_write_frame(recording_start_result.av_format_context, &av_packet); if(ret < 0) - fprintf(stderr, "Error: Failed to write frame index %d to muxer, reason: %s (%d)\n", stream->index, av_error_to_string(ret), ret); + fprintf(stderr, "Error: Failed to write frame index %d to muxer, reason: %s (%d)\n", packet->packet.stream_index, av_error_to_string(ret), ret); //av_packet_free(&av_packet); } stop_recording_close_streams(recording_start_result.av_format_context); - - for(AudioTrack &audio_track : audio_tracks) { - audio_track.stream = nullptr; - } + gsr_replay_buffer_deinit(&cloned_replay_buffer); }); } @@ -2483,8 +2372,6 @@ static void match_app_audio_input_to_available_apps(const std::vector<AudioInput // OH, YOU MISSPELLED THE AUDIO INPUT? FUCK YOU static std::vector<MergedAudioInputs> parse_audio_inputs(const AudioDevices &audio_devices, const Arg *audio_input_arg) { std::vector<MergedAudioInputs> requested_audio_inputs; - if(!audio_input_arg) - return requested_audio_inputs; for(int i = 0; i < audio_input_arg->num_values; ++i) { const char *audio_input = audio_input_arg->values[i]; @@ -2985,6 +2872,28 @@ static bool av_open_file_write_header(AVFormatContext *av_format_context, const return success; } +static int audio_codec_get_frame_size(gsr_audio_codec audio_codec) { + switch(audio_codec) { + case GSR_AUDIO_CODEC_AAC: return 1024; + case GSR_AUDIO_CODEC_OPUS: return 960; + case GSR_AUDIO_CODEC_FLAC: + assert(false); + return 1024; + } + assert(false); + return 1024; +} + +static size_t calculate_estimated_replay_buffer_packets(int64_t replay_buffer_size_secs, int fps, gsr_audio_codec audio_codec, const std::vector<MergedAudioInputs> &audio_inputs) { + if(replay_buffer_size_secs == -1) + return 0; + + int audio_fps = 0; + if(!audio_inputs.empty()) + audio_fps = AUDIO_SAMPLE_RATE / audio_codec_get_frame_size(audio_codec); + return replay_buffer_size_secs * (fps + audio_fps * audio_inputs.size()); +} + int main(int argc, char **argv) { setlocale(LC_ALL, "C"); // Sigh... stupid C @@ -3040,9 +2949,10 @@ int main(int argc, char **argv) { //av_log_set_level(AV_LOG_TRACE); const Arg *audio_input_arg = args_parser_get_arg(&arg_parser, "-a"); + assert(audio_input_arg); AudioDevices audio_devices; - if(audio_input_arg) + if(audio_input_arg->num_values > 0) audio_devices = get_pulseaudio_inputs(); std::vector<MergedAudioInputs> requested_audio_inputs = parse_audio_inputs(audio_devices, audio_input_arg); @@ -3139,7 +3049,7 @@ int main(int argc, char **argv) { gsr_image_format image_format; if(get_image_format_from_filename(arg_parser.filename, &image_format)) { - if(audio_input_arg) { + if(audio_input_arg->num_values > 0) { fprintf(stderr, "Error: can't record audio (-a) when taking a screenshot\n"); _exit(1); } @@ -3239,7 +3149,8 @@ int main(int argc, char **argv) { _exit(1); } - if(!gsr_video_encoder_start(video_encoder, video_codec_context, video_frame)) { + const size_t estimated_replay_buffer_packets = calculate_estimated_replay_buffer_packets(arg_parser.replay_buffer_size_secs, arg_parser.fps, arg_parser.audio_codec, requested_audio_inputs); + if(!gsr_video_encoder_start(video_encoder, video_codec_context, video_frame, estimated_replay_buffer_packets)) { fprintf(stderr, "Error: failed to start video encoder\n"); _exit(1); } @@ -3267,8 +3178,11 @@ int main(int argc, char **argv) { } else { open_video_hardware(video_codec_context, low_power, egl, arg_parser); } - if(video_stream) + + if(video_stream) { avcodec_parameters_from_context(video_stream->codecpar, video_codec_context); + gsr_video_encoder_add_recording_destination(video_encoder, video_codec_context, av_format_context, video_stream, 0); + } int audio_max_frame_size = 1024; int audio_stream_index = VIDEO_STREAM_INDEX + 1; @@ -3277,8 +3191,11 @@ int main(int argc, char **argv) { AVCodecContext *audio_codec_context = create_audio_codec_context(arg_parser.fps, arg_parser.audio_codec, use_amix, arg_parser.audio_bitrate); AVStream *audio_stream = nullptr; - if(!is_replaying) + if(!is_replaying) { audio_stream = create_stream(av_format_context, audio_codec_context); + if(gsr_video_encoder_add_recording_destination(video_encoder, audio_codec_context, av_format_context, audio_stream, 0) == (size_t)-1) + fprintf(stderr, "gsr error: added too many audio sources\n"); + } if(audio_stream && !merged_audio_inputs.track_name.empty()) av_dict_set(&audio_stream->metadata, "title", merged_audio_inputs.track_name.c_str(), 0); @@ -3327,7 +3244,6 @@ int main(int argc, char **argv) { AudioTrack audio_track; audio_track.name = merged_audio_inputs.track_name; audio_track.codec_context = audio_codec_context; - audio_track.stream = audio_stream; audio_track.audio_devices = std::move(audio_track_audio_devices); audio_track.graph = graph; audio_track.sink = sink; @@ -3356,31 +3272,14 @@ int main(int argc, char **argv) { double paused_time_start = 0.0; bool replay_recording = false; RecordingStartResult replay_recording_start_result; - int64_t video_frame_pts_start = 0; - bool force_iframe_frame = false; - - bool replay_recording_keyframe_found = false; - auto record_condition_handler = [is_replaying, &replay_recording_keyframe_found](const AVPacket &av_packet) { - if(!is_replaying) - return true; - - if(replay_recording_keyframe_found) - return true; - - if(av_packet.flags & AV_PKT_FLAG_KEY) { - replay_recording_keyframe_found = true; - return true; - } - return false; - }; + std::vector<size_t> replay_recording_items; + std::string replay_recording_filepath; + bool force_iframe_frame = false; // Only needed for video since audio frames are always iframes - std::mutex write_output_mutex; std::mutex audio_filter_mutex; const double record_start_time = clock_get_monotonic_seconds(); std::atomic<double> replay_start_time(record_start_time); - std::deque<std::shared_ptr<PacketData>> frame_data_queue; - bool frames_erased = false; const size_t audio_buffer_size = audio_max_frame_size * 4 * 2; // max 4 bytes/sample, 2 channels uint8_t *empty_audio = (uint8_t*)malloc(audio_buffer_size); @@ -3497,10 +3396,11 @@ int main(int argc, char **argv) { ret = avcodec_send_frame(audio_track.codec_context, audio_device.frame); if(ret >= 0) { // TODO: Move to separate thread because this could write to network (for example when livestreaming) - receive_frames(audio_track.codec_context, audio_track.stream_index, audio_track.stream, audio_device.frame->pts, av_format_context, replay_start_time, frame_data_queue, arg_parser.replay_buffer_size_secs, frames_erased, write_output_mutex, paused_time_offset, arg_parser.replay_buffer_size_secs == -1, 0, record_condition_handler); + gsr_video_encoder_receive_packets(video_encoder, audio_track.codec_context, audio_device.frame->pts, audio_track.stream_index); } else { fprintf(stderr, "Failed to encode audio!\n"); } + audio_track.pts += audio_track.codec_context->frame_size; } audio_device.frame->pts += audio_track.codec_context->frame_size; @@ -3519,8 +3419,9 @@ int main(int argc, char **argv) { audio_device.frame->data[0] = (uint8_t*)sound_buffer; first_frame = false; + std::lock_guard<std::mutex> lock(audio_filter_mutex); + if(audio_track.graph) { - std::lock_guard<std::mutex> lock(audio_filter_mutex); // TODO: av_buffersrc_add_frame if(av_buffersrc_write_frame(audio_device.src_filter_ctx, audio_device.frame) < 0) { fprintf(stderr, "Error: failed to add audio frame to filter\n"); @@ -3529,10 +3430,11 @@ int main(int argc, char **argv) { ret = avcodec_send_frame(audio_track.codec_context, audio_device.frame); if(ret >= 0) { // TODO: Move to separate thread because this could write to network (for example when livestreaming) - receive_frames(audio_track.codec_context, audio_track.stream_index, audio_track.stream, audio_device.frame->pts, av_format_context, replay_start_time, frame_data_queue, arg_parser.replay_buffer_size_secs, frames_erased, write_output_mutex, paused_time_offset, arg_parser.replay_buffer_size_secs == -1, 0, record_condition_handler); + gsr_video_encoder_receive_packets(video_encoder, audio_track.codec_context, audio_device.frame->pts, audio_track.stream_index); } else { fprintf(stderr, "Failed to encode audio!\n"); } + audio_track.pts += audio_track.codec_context->frame_size; } audio_device.frame->pts += audio_track.codec_context->frame_size; @@ -3563,7 +3465,7 @@ int main(int argc, char **argv) { err = avcodec_send_frame(audio_track.codec_context, aframe); if(err >= 0){ // TODO: Move to separate thread because this could write to network (for example when livestreaming) - receive_frames(audio_track.codec_context, audio_track.stream_index, audio_track.stream, aframe->pts, av_format_context, replay_start_time, frame_data_queue, arg_parser.replay_buffer_size_secs, frames_erased, write_output_mutex, paused_time_offset, arg_parser.replay_buffer_size_secs == -1, 0, record_condition_handler); + gsr_video_encoder_receive_packets(video_encoder, audio_track.codec_context, aframe->pts, audio_track.stream_index); } else { fprintf(stderr, "Failed to encode audio!\n"); } @@ -3693,11 +3595,6 @@ int main(int argc, char **argv) { const int64_t expected_frames = std::round((this_video_frame_time - record_start_time) / target_fps); const int num_missed_frames = std::max((int64_t)1LL, expected_frames - video_pts_counter); - if(force_iframe_frame) { - video_frame->pict_type = AV_PICTURE_TYPE_I; - video_frame->flags |= AV_FRAME_FLAG_KEY; - } - // TODO: Check if duplicate frame can be saved just by writing it with a different pts instead of sending it again const int num_frames_to_encode = arg_parser.framerate_mode == GSR_FRAMERATE_MODE_CONSTANT ? num_missed_frames : 1; for(int i = 0; i < num_frames_to_encode; ++i) { @@ -3711,24 +3608,24 @@ int main(int argc, char **argv) { continue; } + if(force_iframe_frame) { + video_frame->pict_type = AV_PICTURE_TYPE_I; + video_frame->flags |= AV_FRAME_FLAG_KEY; + } + int ret = avcodec_send_frame(video_codec_context, video_frame); if(ret == 0) { - const bool record_to_file = arg_parser.replay_buffer_size_secs == -1 || replay_recording_start_result.av_format_context != nullptr; - AVFormatContext *recording_format_context = replay_recording_start_result.av_format_context ? replay_recording_start_result.av_format_context : av_format_context; - AVStream *recording_video_stream = replay_recording_start_result.video_stream ? replay_recording_start_result.video_stream : video_stream; // TODO: Move to separate thread because this could write to network (for example when livestreaming) - receive_frames(video_codec_context, VIDEO_STREAM_INDEX, recording_video_stream, video_frame->pts, recording_format_context, - replay_start_time, frame_data_queue, arg_parser.replay_buffer_size_secs, frames_erased, write_output_mutex, paused_time_offset, record_to_file, video_frame_pts_start, record_condition_handler); - // TODO: Also update replay recording for audio, with record to file, recording format context, recording audio stream and pts offset + gsr_video_encoder_receive_packets(video_encoder, video_codec_context, video_frame->pts, VIDEO_STREAM_INDEX); } else { fprintf(stderr, "Error: avcodec_send_frame failed, error: %s\n", av_error_to_string(ret)); } - } - if(force_iframe_frame) { - force_iframe_frame = false; - video_frame->pict_type = AV_PICTURE_TYPE_NONE; - video_frame->flags &= ~AV_FRAME_FLAG_KEY; + if(force_iframe_frame) { + force_iframe_frame = false; + video_frame->pict_type = AV_PICTURE_TYPE_NONE; + video_frame->flags &= ~AV_FRAME_FLAG_KEY; + } } video_pts_counter += num_frames_to_encode; @@ -3748,15 +3645,31 @@ int main(int argc, char **argv) { paused = !paused; } - if(toggle_replay_recording && is_replaying) { + if(toggle_replay_recording && !arg_parser.replay_recording_directory) { + toggle_replay_recording = 0; + fprintf(stderr, "Error: unable to start recording since the -ro option was not specified\n"); + } + + if(toggle_replay_recording && arg_parser.replay_recording_directory) { + toggle_replay_recording = 0; const bool new_replay_recording_state = !replay_recording; if(new_replay_recording_state) { - // TODO: Filename - replay_recording_start_result = start_recording_create_streams("video.mp4", arg_parser.container_format, video_codec_context, audio_tracks, hdr, capture); + std::lock_guard<std::mutex> lock(audio_filter_mutex); + replay_recording_items.clear(); + replay_recording_filepath = create_new_recording_filepath_from_timestamp(arg_parser.replay_recording_directory, "Recording", file_extension, arg_parser.date_folders); + replay_recording_start_result = start_recording_create_streams(replay_recording_filepath.c_str(), arg_parser.container_format, video_codec_context, audio_tracks, hdr, capture); if(replay_recording_start_result.av_format_context) { - replay_recording_keyframe_found = false; + const size_t video_recording_destination_id = gsr_video_encoder_add_recording_destination(video_encoder, video_codec_context, replay_recording_start_result.av_format_context, replay_recording_start_result.video_stream, video_frame->pts); + if(video_recording_destination_id != (size_t)-1) + replay_recording_items.push_back(video_recording_destination_id); + + for(const auto &audio_input : replay_recording_start_result.audio_inputs) { + const size_t audio_recording_destination_id = gsr_video_encoder_add_recording_destination(video_encoder, audio_input.audio_track->codec_context, replay_recording_start_result.av_format_context, audio_input.stream, audio_input.audio_track->pts); + if(audio_recording_destination_id != (size_t)-1) + replay_recording_items.push_back(audio_recording_destination_id); + } + replay_recording = true; - video_frame_pts_start = video_frame->pts; force_iframe_frame = true; fprintf(stderr, "Started recording\n"); } else { @@ -3764,42 +3677,48 @@ int main(int argc, char **argv) { fprintf(stderr, "Failed to start recording\n"); } } else if(replay_recording_start_result.av_format_context) { + for(size_t id : replay_recording_items) { + gsr_video_encoder_remove_recording_destination(video_encoder, id); + } + replay_recording_items.clear(); + if(stop_recording_close_streams(replay_recording_start_result.av_format_context)) { - // TODO: Output saved filepath to stdout - fprintf(stderr, "Saved recording\n"); - // TODO: run this, with correct filename - //run_recording_saved_script_async(recording_saved_script, filename, "regular"); + fprintf(stderr, "Stopped recording\n"); + puts(replay_recording_filepath.c_str()); + fflush(stdout); + if(arg_parser.recording_saved_script) + run_recording_saved_script_async(arg_parser.recording_saved_script, replay_recording_filepath.c_str(), "regular"); } else { // TODO: Output "Error: failed to start recording" to stdout, catch in gsr-ui. Catch all That starts with Error: fprintf(stderr, "Failed to save recording\n"); } + replay_recording_start_result = RecordingStartResult{}; replay_recording = false; + replay_recording_filepath.clear(); } - - toggle_replay_recording = 0; } if(save_replay_thread.valid() && save_replay_thread.wait_for(std::chrono::seconds(0)) == std::future_status::ready) { save_replay_thread.get(); - puts(save_replay_output_filepath.c_str()); - fflush(stdout); - if(arg_parser.recording_saved_script) - run_recording_saved_script_async(arg_parser.recording_saved_script, save_replay_output_filepath.c_str(), "replay"); - - std::lock_guard<std::mutex> lock(write_output_mutex); - save_replay_packets.clear(); + if(save_replay_output_filepath.empty()) { + // TODO: Output failed to save + } else { + puts(save_replay_output_filepath.c_str()); + fflush(stdout); + if(arg_parser.recording_saved_script) + run_recording_saved_script_async(arg_parser.recording_saved_script, save_replay_output_filepath.c_str(), "replay"); + } } if(save_replay_seconds != 0 && !save_replay_thread.valid() && is_replaying) { const int current_save_replay_seconds = save_replay_seconds; save_replay_seconds = 0; - save_replay_async(video_codec_context, VIDEO_STREAM_INDEX, audio_tracks, frame_data_queue, frames_erased, arg_parser.filename, arg_parser.container_format, file_extension, write_output_mutex, arg_parser.date_folders, hdr, capture, current_save_replay_seconds); + save_replay_output_filepath.clear(); + save_replay_async(video_codec_context, VIDEO_STREAM_INDEX, audio_tracks, &video_encoder->replay_buffer, arg_parser.filename, arg_parser.container_format, file_extension, arg_parser.date_folders, hdr, capture, current_save_replay_seconds); - std::lock_guard<std::mutex> lock(write_output_mutex); if(arg_parser.restart_replay_on_save && current_save_replay_seconds == save_replay_seconds_full) { - frame_data_queue.clear(); - frames_erased = true; + gsr_replay_buffer_clear(&video_encoder->replay_buffer); replay_start_time = clock_get_monotonic_seconds() - paused_time_offset; } } @@ -3834,12 +3753,27 @@ int main(int argc, char **argv) { if(save_replay_thread.valid()) { save_replay_thread.get(); - puts(save_replay_output_filepath.c_str()); - fflush(stdout); - if(arg_parser.recording_saved_script) - run_recording_saved_script_async(arg_parser.recording_saved_script, save_replay_output_filepath.c_str(), "replay"); - std::lock_guard<std::mutex> lock(write_output_mutex); - save_replay_packets.clear(); + if(save_replay_output_filepath.empty()) { + // TODO: Output failed to save + } else { + puts(save_replay_output_filepath.c_str()); + fflush(stdout); + if(arg_parser.recording_saved_script) + run_recording_saved_script_async(arg_parser.recording_saved_script, save_replay_output_filepath.c_str(), "replay"); + } + } + + if(replay_recording_start_result.av_format_context) { + if(stop_recording_close_streams(replay_recording_start_result.av_format_context)) { + fprintf(stderr, "Stopped recording\n"); + puts(replay_recording_filepath.c_str()); + fflush(stdout); + if(arg_parser.recording_saved_script) + run_recording_saved_script_async(arg_parser.recording_saved_script, replay_recording_filepath.c_str(), "regular"); + } else { + // TODO: Output "Error: failed to start recording" to stdout, catch in gsr-ui. Catch all That starts with Error: + fprintf(stderr, "Failed to save recording\n"); + } } for(AudioTrack &audio_track : audio_tracks) { @@ -3862,13 +3796,6 @@ int main(int argc, char **argv) { avformat_free_context(av_format_context); } - if(replay_recording_start_result.av_format_context) { - if(stop_recording_close_streams(replay_recording_start_result.av_format_context)) { - // TODO: run this, with correct filename - //run_recording_saved_script_async(recording_saved_script, filename, "regular"); - } - } - gsr_damage_deinit(&damage); gsr_color_conversion_deinit(&color_conversion); gsr_video_encoder_destroy(video_encoder, video_codec_context); |