//#include "sysdeps.h"
+#include "h264encode.h"
+
+#include <EGL/eglplatform.h>
+#include <X11/X.h>
+#include <X11/Xlib.h>
+#include <assert.h>
+#include <epoxy/egl.h>
+#include <libavcodec/avcodec.h>
+#include <libavformat/avio.h>
+#include <libavutil/mathematics.h>
+#include <libavutil/rational.h>
+#include <libdrm/drm_fourcc.h>
+#include <stdint.h>
#include <stdio.h>
-#include <string.h>
#include <stdlib.h>
-#include <getopt.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/mman.h>
-#include <fcntl.h>
-#include <assert.h>
-#include <pthread.h>
-#include <errno.h>
-#include <math.h>
+#include <string.h>
#include <va/va.h>
-#include <va/va_x11.h>
-#include <va/va_enc_h264.h>
#include <va/va_drmcommon.h>
-#include <libdrm/drm_fourcc.h>
-#include <thread>
+#include <va/va_enc_h264.h>
+#include <va/va_x11.h>
+#include <condition_variable>
#include <mutex>
#include <queue>
-#include <condition_variable>
-#include "h264encode.h"
+#include <string>
+#include <thread>
+
+#include "context.h"
+
+class QOpenGLContext;
+class QSurface;
#define CHECK_VASTATUS(va_status, func) \
if (va_status != VA_STATUS_SUCCESS) { \
static int h264_entropy_mode = 1; /* cabac */
static char *coded_fn = NULL;
-static FILE *coded_fp = NULL;
static int frame_width = 176;
static int frame_height = 144;
coded_fn = strdup("./test.264");
}
- /* store coded data into a file */
- coded_fp = fopen(coded_fn, "w+");
- if (coded_fp == NULL) {
- printf("Open file %s failed, exit\n", coded_fn);
- exit(1);
- }
frame_width_mbaligned = (frame_width + 15) & (~15);
frame_height_mbaligned = (frame_height + 15) & (~15);
CHECK_VASTATUS(va_status, "vaMapBuffer");
while (buf_list != NULL) {
data.append(reinterpret_cast<const char *>(buf_list->buf), buf_list->size);
- if (coded_fp != nullptr)
- coded_size += fwrite(buf_list->buf, 1, buf_list->size, coded_fp);
buf_list = (VACodedBufferSegment *) buf_list->next;
frame_size += coded_size;
fprintf(stderr, "%s: avformat_new_stream() failed\n", output_filename);
exit(1);
}
- avstream->time_base = AVRational{1, frame_rate}; // TODO
+ avstream->time_base = AVRational{1, frame_rate};
avstream->codec->width = width;
avstream->codec->height = height;
- //avstream->codec->time_base = AVRational{1, 60}; // TODO
avstream->codec->time_base = AVRational{1, frame_rate};
avstream->codec->ticks_per_frame = 1; // or 2?
exit(1);
}
- coded_fp = fopen("dump.h264", "wb");
- assert(coded_fp != NULL);
-
frame_width = width;
frame_height = height;
frame_width_mbaligned = (frame_width + 15) & (~15);
return true;
}
-void H264Encoder::end_frame(GLsync fence)
+void H264Encoder::end_frame(RefCountedGLsync fence, const std::vector<RefCountedFrame> &input_frames)
{
{
unique_lock<mutex> lock(frame_queue_mutex);
- pending_frames[current_storage_frame++] = fence;
+ pending_frames[current_storage_frame++] = PendingFrame{ fence, input_frames };
}
frame_queue_nonempty.notify_one();
}
void H264Encoder::copy_thread_func()
{
for ( ;; ) {
- GLsync fence;
+ PendingFrame frame;
encoding2display_order(current_frame_encoding, intra_period, intra_idr_period, ip_period,
¤t_frame_display, ¤t_frame_type);
if (current_frame_type == FRAME_IDR) {
unique_lock<mutex> lock(frame_queue_mutex);
frame_queue_nonempty.wait(lock, [this]{ return copy_thread_should_quit || pending_frames.count(current_frame_display) != 0; });
if (copy_thread_should_quit) return;
- fence = pending_frames[current_frame_display];
+ frame = pending_frames[current_frame_display];
pending_frames.erase(current_frame_display);
}
// Wait for the GPU to be done with the frame.
- glClientWaitSync(fence, 0, 0);
- glDeleteSync(fence);
+ glClientWaitSync(frame.fence.get(), 0, 0);
+
+ // Release back any input frames we needed to render this frame.
+ frame.input_frames.clear();
// Unmap the image.
GLSurface *surf = &gl_surfaces[current_frame_display % SURFACE_NUM];