Move Y'CbCr conversion into a common utility class.

[nageru] / jpeg_frame_view.cpp

diff --git a/jpeg_frame_view.cpp b/jpeg_frame_view.cpp
index 73030ffa2ce02a2b53f5ae23eef3f4b77eb66d22..3d95a7701299a6c96ccf51c6cc57e50b6dab4af9 100644 (file)
--- a/jpeg_frame_view.cpp
+++ b/jpeg_frame_view.cpp
@@ -20,7 +20,9 @@
 
 #include "defs.h"
 #include "post_to_main_thread.h"
+#include "vaapi_jpeg_decoder.h"
 #include "video_stream.h"
+#include "ycbcr_converter.h"
 
 using namespace movit;
 using namespace std;
@@ -43,17 +45,27 @@ struct LRUFrame {
        size_t last_used;
 };
 
+thread JPEGFrameView::jpeg_decoder_thread;
 mutex cache_mu;
 map<JPEGID, LRUFrame, JPEGIDLexicalOrder> cache;  // Under cache_mu.
 condition_variable any_pending_decodes, cache_updated;
 deque<pair<JPEGID, JPEGFrameView *>> pending_decodes;  // Under cache_mu.
 atomic<size_t> event_counter{0};
 extern QGLWidget *global_share_widget;
+extern atomic<bool> should_quit;
 
-// TODO: Decode using VA-API if available.
 shared_ptr<Frame> decode_jpeg(const string &filename)
 {
-       shared_ptr<Frame> frame(new Frame);
+       shared_ptr<Frame> frame;
+       if (vaapi_jpeg_decoding_usable) {
+               frame = decode_jpeg_vaapi(filename);
+               if (frame != nullptr) {
+                       return frame;
+               }
+               fprintf(stderr, "VA-API hardware decoding failed; falling back to software.\n");
+       }
+
+       frame.reset(new Frame);
 
        jpeg_decompress_struct dinfo;
        jpeg_error_mgr jerr;
@@ -184,20 +196,21 @@ shared_ptr<Frame> decode_jpeg_with_cache(JPEGID id, CacheMissBehavior cache_miss
        return frame;
 }
 
-void jpeg_decoder_thread()
+void jpeg_decoder_thread_func()
 {
        size_t num_decoded = 0, num_dropped = 0;
 
        pthread_setname_np(pthread_self(), "JPEGDecoder");
-       for ( ;; ) {
+       while (!should_quit.load()) {
                JPEGID id;
                JPEGFrameView *dest;
                CacheMissBehavior cache_miss_behavior = DECODE_IF_NOT_IN_CACHE;
                {
                        unique_lock<mutex> lock(cache_mu);  // TODO: Perhaps under another lock?
                        any_pending_decodes.wait(lock, [] {
-                               return !pending_decodes.empty();
+                               return !pending_decodes.empty() || should_quit.load();
                        });
+                       if (should_quit.load()) break;
                        id = pending_decodes.front().first;
                        dest = pending_decodes.front().second;
                        pending_decodes.pop_front();
@@ -220,8 +233,9 @@ void jpeg_decoder_thread()
                        // put directly into the cache from VideoStream.
                        unique_lock<mutex> lock(cache_mu);
                        cache_updated.wait(lock, [id] {
-                               return cache.count(id) != 0;
+                               return cache.count(id) != 0 || should_quit.load();
                        });
+                       if (should_quit.load()) break;
                        found_in_cache = true;  // Don't count it as a decode.
 
                        auto it = cache.find(id);
@@ -258,6 +272,12 @@ void jpeg_decoder_thread()
        }
 }
 
+void JPEGFrameView::shutdown()
+{
+       any_pending_decodes.notify_all();
+       jpeg_decoder_thread.join();
+}
+
 JPEGFrameView::JPEGFrameView(QWidget *parent)
        : QGLWidget(parent, global_share_widget) {
 }
@@ -295,38 +315,17 @@ void JPEGFrameView::initializeGL()
        static once_flag once;
        call_once(once, [] {
                resource_pool = new ResourcePool;
-               std::thread(&jpeg_decoder_thread).detach();
+               jpeg_decoder_thread = std::thread(jpeg_decoder_thread_func);
        });
 
-       chain.reset(new EffectChain(1280, 720, resource_pool));
-       ImageFormat image_format;
-       image_format.color_space = COLORSPACE_sRGB;
-       image_format.gamma_curve = GAMMA_sRGB;
-       ycbcr_format.luma_coefficients = YCBCR_REC_709;
-       ycbcr_format.full_range = false;
-       ycbcr_format.num_levels = 256;
-       ycbcr_format.chroma_subsampling_x = 2;
-       ycbcr_format.chroma_subsampling_y = 1;
-       ycbcr_format.cb_x_position = 0.0f;  // H.264 -- _not_ JPEG, even though our input is MJPEG-encoded
-       ycbcr_format.cb_y_position = 0.5f;  // Irrelevant.
-       ycbcr_format.cr_x_position = 0.0f;
-       ycbcr_format.cr_y_position = 0.5f;
-       ycbcr_input = (movit::YCbCrInput *)chain->add_input(new YCbCrInput(image_format, ycbcr_format, 1280, 720));
+       ycbcr_converter.reset(new YCbCrConverter(YCbCrConverter::OUTPUT_TO_RGBA, resource_pool));
 
        ImageFormat inout_format;
-        inout_format.color_space = COLORSPACE_sRGB;
-        inout_format.gamma_curve = GAMMA_sRGB;
-
-       check_error();
-       chain->add_output(inout_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED);
-       check_error();
-       chain->set_dither_bits(8);
-       check_error();
-       chain->finalize();
-       check_error();
+       inout_format.color_space = COLORSPACE_sRGB;
+       inout_format.gamma_curve = GAMMA_sRGB;
 
        overlay_chain.reset(new EffectChain(overlay_base_width, overlay_base_height, resource_pool));
-       overlay_input = (movit::FlatInput *)overlay_chain->add_input(new FlatInput(image_format, FORMAT_GRAYSCALE, GL_UNSIGNED_BYTE, overlay_base_width, overlay_base_height));
+       overlay_input = (movit::FlatInput *)overlay_chain->add_input(new FlatInput(inout_format, FORMAT_GRAYSCALE, GL_UNSIGNED_BYTE, overlay_base_width, overlay_base_height));
 
        overlay_chain->add_output(inout_format, OUTPUT_ALPHA_FORMAT_POSTMULTIPLIED);
        overlay_chain->finalize();
@@ -353,7 +352,7 @@ void JPEGFrameView::paintGL()
        }
 
        check_error();
-       chain->render_to_screen();
+       current_chain->render_to_screen();
 
        if (overlay_image != nullptr) {
                if (overlay_input_needs_refresh) {
@@ -370,17 +369,7 @@ void JPEGFrameView::setDecodedFrame(std::shared_ptr<Frame> frame)
 {
        post_to_main_thread([this, frame] {
                current_frame = frame;
-               ycbcr_format.chroma_subsampling_x = frame->chroma_subsampling_x;
-               ycbcr_format.chroma_subsampling_y = frame->chroma_subsampling_y;
-               ycbcr_input->change_ycbcr_format(ycbcr_format);
-               ycbcr_input->set_width(frame->width);
-               ycbcr_input->set_height(frame->height);
-               ycbcr_input->set_pixel_data(0, frame->y.get());
-               ycbcr_input->set_pixel_data(1, frame->cb.get());
-               ycbcr_input->set_pixel_data(2, frame->cr.get());
-               ycbcr_input->set_pitch(0, frame->pitch_y);
-               ycbcr_input->set_pitch(1, frame->pitch_chroma);
-               ycbcr_input->set_pitch(2, frame->pitch_chroma);
+               current_chain = ycbcr_converter->prepare_chain_for_conversion(frame);
                update();
        });
 }