vector<float> audio;
{
unique_lock<mutex> lock(frame_queue_mutex);
- frame_queue_nonempty.wait(lock, [this]{ return copy_thread_should_quit || !pending_audio_frames.empty(); });
- if (copy_thread_should_quit && pending_audio_frames.empty()) return;
+ frame_queue_nonempty.wait(lock, [this]{ return storage_thread_should_quit || !pending_audio_frames.empty(); });
+ if (storage_thread_should_quit && pending_audio_frames.empty()) return;
auto it = pending_audio_frames.begin();
if (it->first > task.pts) break;
audio_pts = it->first;
// wait until there's an encoded frame
unique_lock<mutex> lock(storage_task_queue_mutex);
storage_task_queue_changed.wait(lock, [this]{ return storage_thread_should_quit || !storage_task_queue.empty(); });
- if (storage_thread_should_quit) return;
+ if (storage_thread_should_quit && storage_task_queue.empty()) return;
current = move(storage_task_queue.front());
storage_task_queue.pop();
}
storage_thread = thread(&H264Encoder::storage_task_thread, this);
- copy_thread = thread([this]{
+ encode_thread = thread([this]{
//SDL_GL_MakeCurrent(window, context);
QOpenGLContext *context = create_context(this->surface);
eglBindAPI(EGL_OPENGL_API);
eglGetError());
exit(1);
}
- copy_thread_func();
+ encode_thread_func();
});
}
{
{
unique_lock<mutex> lock(frame_queue_mutex);
- copy_thread_should_quit = true;
+ encode_thread_should_quit = true;
frame_queue_nonempty.notify_all();
}
- copy_thread.join();
+ encode_thread.join();
{
unique_lock<mutex> lock(storage_task_queue_mutex);
storage_thread_should_quit = true;
+ frame_queue_nonempty.notify_all();
storage_task_queue_changed.notify_all();
}
storage_thread.join();
frame_queue_nonempty.notify_all();
}
-void H264Encoder::copy_thread_func()
+void H264Encoder::encode_thread_func()
{
int64_t last_dts = -1;
int gop_start_display_frame_num = 0;
{
unique_lock<mutex> lock(frame_queue_mutex);
frame_queue_nonempty.wait(lock, [this, display_frame_num]{
- return copy_thread_should_quit || pending_video_frames.count(display_frame_num) != 0;
+ return encode_thread_should_quit || pending_video_frames.count(display_frame_num) != 0;
});
- if (copy_thread_should_quit) {
+ if (encode_thread_should_quit && pending_video_frames.count(display_frame_num) == 0) {
+ // We have queued frames that were supposed to be B-frames,
+ // but will be no P-frame to encode them against. Encode them all
+ // as P-frames instead. Note that this happens under the mutex,
+ // but nobody else uses it at this point, since we're shutting down,
+ // so there's no contention.
+ encode_remaining_frames_as_p(encoding_frame_num, gop_start_display_frame_num, last_dts);
return;
} else {
frame = move(pending_video_frames[display_frame_num]);
}
}
+void H264Encoder::encode_remaining_frames_as_p(int encoding_frame_num, int gop_start_display_frame_num, int64_t last_dts)
+{
+ if (pending_video_frames.empty()) {
+ return;
+ }
+
+ for (auto &pending_frame : pending_video_frames) {
+ int display_frame_num = pending_frame.first;
+ assert(display_frame_num > 0);
+ PendingFrame frame = move(pending_frame.second);
+ int64_t dts = last_dts + (TIMEBASE / MAX_FPS);
+ printf("Finalizing encode: Encoding leftover frame %d as P-frame instead of B-frame.\n", display_frame_num);
+ encode_frame(frame, encoding_frame_num++, display_frame_num, gop_start_display_frame_num, FRAME_P, frame.pts, dts);
+ last_dts = dts;
+ }
+}
+
void H264Encoder::encode_frame(H264Encoder::PendingFrame frame, int encoding_frame_num, int display_frame_num, int gop_start_display_frame_num,
int frame_type, int64_t pts, int64_t dts)
{