Make current_frame_encoding non-global.

[nageru] / h264encode.cpp

diff --git a/h264encode.cpp b/h264encode.cpp
index 28330737782f38532dbc162bfdbc295844d33115..3520158857c28bd02af855f67adfbaa7d5cc1f5d 100644 (file)
--- a/h264encode.cpp
+++ b/h264encode.cpp
@@ -131,7 +131,6 @@ static  int rc_default_modes[] = {
     VA_RC_VCM,
     VA_RC_NONE,
 };
-static  unsigned long long current_frame_encoding = 0;
 static  unsigned long long current_frame_display = 0;
 static  unsigned long long current_IDR_display = 0;
 static  unsigned int current_frame_num = 0;
@@ -1525,7 +1524,7 @@ static void render_packedslice()
     free(packedslice_buffer);
 }
 
-static int render_slice(void)
+static int render_slice(int encoding_frame_num)
 {
     VABufferID slice_param_buf;
     VAStatus va_status;
@@ -1538,7 +1537,7 @@ static int render_slice(void)
     slice_param.num_macroblocks = frame_width_mbaligned * frame_height_mbaligned/(16*16); /* Measured by MB */
     slice_param.slice_type = (current_frame_type == FRAME_IDR)?2:current_frame_type;
     if (current_frame_type == FRAME_IDR) {
-        if (current_frame_encoding != 0)
+        if (encoding_frame_num != 0)
             ++slice_param.idr_pic_id;
     } else if (current_frame_type == FRAME_P) {
         int refpiclist0_max = h264_maxref & 0xffff;
@@ -1780,7 +1779,6 @@ H264Encoder::H264Encoder(QSurface *surface, int width, int height, HTTPD *httpd)
        frame_width_mbaligned = (frame_width + 15) & (~15);
        frame_height_mbaligned = (frame_height + 15) & (~15);
         frame_bitrate = 15000000;  // / 60;
-       current_frame_encoding = 0;
 
        //print_input();
 
@@ -1914,10 +1912,10 @@ void H264Encoder::end_frame(RefCountedGLsync fence, int64_t pts, const vector<Re
 void H264Encoder::copy_thread_func()
 {
        int64_t last_dts = -1;
-       for ( ;; ) {
+       for (int encoding_frame_num = 0; ; ++encoding_frame_num) {
                PendingFrame frame;
                int pts_lag;
-               encoding2display_order(current_frame_encoding, intra_period, intra_idr_period, ip_period,
+               encoding2display_order(encoding_frame_num, intra_period, intra_idr_period, ip_period,
                                       &current_frame_display, &current_frame_type, &pts_lag);
                if (current_frame_type == FRAME_IDR) {
                        numShortTerm = 0;
@@ -1928,69 +1926,75 @@ void H264Encoder::copy_thread_func()
                {
                        unique_lock<mutex> lock(frame_queue_mutex);
                        frame_queue_nonempty.wait(lock, [this]{ return copy_thread_should_quit || pending_video_frames.count(current_frame_display) != 0; });
-                       if (copy_thread_should_quit) return;
-                       frame = move(pending_video_frames[current_frame_display]);
-                       pending_video_frames.erase(current_frame_display);
-               }
-
-               // Wait for the GPU to be done with the frame.
-               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];
-               eglDestroyImageKHR(eglGetCurrentDisplay(), surf->y_egl_image);
-               eglDestroyImageKHR(eglGetCurrentDisplay(), surf->cbcr_egl_image);
-               VAStatus va_status = vaReleaseBufferHandle(va_dpy, surf->surface_image.buf);
-               CHECK_VASTATUS(va_status, "vaReleaseBufferHandle");
-               va_status = vaDestroyImage(va_dpy, surf->surface_image.image_id);
-               CHECK_VASTATUS(va_status, "vaDestroyImage");
-
-               VASurfaceID surface = surf->src_surface;
-
-               // Schedule the frame for encoding.
-               va_status = vaBeginPicture(va_dpy, context_id, surface);
-               CHECK_VASTATUS(va_status, "vaBeginPicture");
-
-               if (current_frame_type == FRAME_IDR) {
-                       render_sequence();
-                       render_picture();            
-                       if (h264_packedheader) {
-                               render_packedsequence();
-                               render_packedpicture();
+                       if (copy_thread_should_quit) {
+                               return;
+                       } else {
+                               frame = move(pending_video_frames[current_frame_display]);
+                               pending_video_frames.erase(current_frame_display);
                        }
-               } else {
-                       //render_sequence();
-                       render_picture();
                }
-               render_slice();
-               
-               va_status = vaEndPicture(va_dpy, context_id);
-               CHECK_VASTATUS(va_status, "vaEndPicture");
 
-               // Determine the pts and dts of this frame.
-               int64_t pts = frame.pts;
+               // Determine the dts of this frame.
                int64_t dts;
                if (pts_lag == -1) {
                        assert(last_dts != -1);
                        dts = last_dts + (TIMEBASE / MAX_FPS);
                } else {
-                       dts = pts - pts_lag;
+                       dts = frame.pts - pts_lag;
                }
                last_dts = dts;
 
-               // so now the data is done encoding (well, async job kicked off)...
-               // we send that to the storage thread
-               storage_task tmp;
-               tmp.display_order = current_frame_display;
-               tmp.frame_type = current_frame_type;
-               tmp.pts = pts;
-               tmp.dts = dts;
-               storage_task_enqueue(move(tmp));
-               
-               update_ReferenceFrames();
-               ++current_frame_encoding;
+               encode_frame(frame, encoding_frame_num, frame.pts, dts);
+       }
+}
+
+void H264Encoder::encode_frame(H264Encoder::PendingFrame frame, int encoding_frame_num, int64_t pts, int64_t dts)
+{
+       // Wait for the GPU to be done with the frame.
+       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];
+       eglDestroyImageKHR(eglGetCurrentDisplay(), surf->y_egl_image);
+       eglDestroyImageKHR(eglGetCurrentDisplay(), surf->cbcr_egl_image);
+       VAStatus va_status = vaReleaseBufferHandle(va_dpy, surf->surface_image.buf);
+       CHECK_VASTATUS(va_status, "vaReleaseBufferHandle");
+       va_status = vaDestroyImage(va_dpy, surf->surface_image.image_id);
+       CHECK_VASTATUS(va_status, "vaDestroyImage");
+
+       VASurfaceID surface = surf->src_surface;
+
+       // Schedule the frame for encoding.
+       va_status = vaBeginPicture(va_dpy, context_id, surface);
+       CHECK_VASTATUS(va_status, "vaBeginPicture");
+
+       if (current_frame_type == FRAME_IDR) {
+               render_sequence();
+               render_picture();            
+               if (h264_packedheader) {
+                       render_packedsequence();
+                       render_packedpicture();
+               }
+       } else {
+               //render_sequence();
+               render_picture();
        }
+       render_slice(encoding_frame_num);
+
+       va_status = vaEndPicture(va_dpy, context_id);
+       CHECK_VASTATUS(va_status, "vaEndPicture");
+
+       // so now the data is done encoding (well, async job kicked off)...
+       // we send that to the storage thread
+       storage_task tmp;
+       tmp.display_order = current_frame_display;
+       tmp.frame_type = current_frame_type;
+       tmp.pts = pts;
+       tmp.dts = dts;
+       storage_task_enqueue(move(tmp));
+
+       update_ReferenceFrames();
 }