Remove default constructor from DCPVideo.

diff --git a/src/lib/dcp_video.h b/src/lib/dcp_video.h
index 67a2c9f4412e8b06dc5932a73ee66b574e9f8150..d07c8322b56a456de6ddd1417eca3bdcd3e960ee 100644 (file)
--- a/src/lib/dcp_video.h
+++ b/src/lib/dcp_video.h
@@ -49,7 +49,6 @@ class PlayerVideo;
 class DCPVideo
 {
 public:
-       DCPVideo() : DCPVideo(nullptr, 0, 0, 0, Resolution::TWO_K) {}
        DCPVideo (std::shared_ptr<const PlayerVideo>, int index, int dcp_fps, int bandwidth, Resolution r);
        DCPVideo (std::shared_ptr<const PlayerVideo>, cxml::ConstNodePtr);
 

diff --git a/src/lib/grok/context.h b/src/lib/grok/context.h
index 7a447d35ac8b6a5ea4366eb8f707e05e0f92de3e..cb913f58db5a2b2b0bb0143ec7b06deffe0e1089 100644 (file)
--- a/src/lib/grok/context.h
+++ b/src/lib/grok/context.h
@@ -68,8 +68,6 @@ struct GrokInitializer {
 };
 
 struct FrameProxy {
-       FrameProxy(void) : FrameProxy(0,Eyes::LEFT,DCPVideo())
-       {}
        FrameProxy(int index, Eyes eyes, DCPVideo dcpv) : index_(index), eyes_(eyes), vf(dcpv)
        {}
        int index() const {
@@ -157,13 +155,13 @@ public:
                                                bool needsRecompression = compressedFrameLength < minimum_size;
                                                messenger_->processCompressed(str, processor, needsRecompression);
                                                if (needsRecompression) {
-                                                       bool success = false;
-                                                       auto fp = messenger_->retrieve(clientFrameId, success);
-                                                       if (!success)
+                                                       auto fp = messenger_->retrieve(clientFrameId);
+                                                       if (!fp) {
                                                                return;
+                                                       }
 
-                                                       auto encoded = std::make_shared<dcp::ArrayData>(fp.vf.encode_locally());
-                                                       dcpomaticContext_.writer_.write(encoded, fp.vf.index(), fp.vf.eyes());
+                                                       auto encoded = std::make_shared<dcp::ArrayData>(fp->vf.encode_locally());
+                                                       dcpomaticContext_.writer_.write(encoded, fp->vf.index(), fp->vf.eyes());
                                                        frame_done ();
                                                }
                                        }
@@ -210,11 +208,11 @@ public:
 
                return launched_;
        }
-       bool scheduleCompress(const DCPVideo &vf){
+       bool scheduleCompress(DCPVideo const& vf){
                if (!messenger_)
                        return false;
 
-               auto fp = FrameProxy(vf.index(),vf.eyes(),vf);
+               auto fp = FrameProxy(vf.index(), vf.eyes(), vf);
                auto cvt = [this, &fp](BufferSrc src){
                        // xyz conversion
                        fp.vf.convert_to_xyz((uint16_t*)src.framePtr_);

diff --git a/src/lib/grok/messenger.h b/src/lib/grok/messenger.h
index 45ee752e5a0d9b636f7f44427d6894898a70c442..86a50d53045e47a94cfb37c64a776baa796ab928 100644 (file)
--- a/src/lib/grok/messenger.h
+++ b/src/lib/grok/messenger.h
@@ -825,22 +825,20 @@ static void processorThread(Messenger* messenger, std::function<void(std::string
 template<typename F>
 struct ScheduledFrames
 {
-       void store(F& val)
+       void store(F const& val)
        {
                std::unique_lock<std::mutex> lk(mapMutex_);
                auto it = map_.find(val.index());
                if (it == map_.end())
-                       map_[val.index()] = val;
+                       map_.emplace(std::make_pair(val.index(), val));
        }
-       F retrieve(size_t index, bool &success)
+       boost::optional<F> retrieve(size_t index)
        {
                std::unique_lock<std::mutex> lk(mapMutex_);
-               success = false;
                auto it = map_.find(index);
                if(it == map_.end())
-                       return F();
+                       return {};
 
-               success = true;
                F val = it->second;
                map_.erase(index);
 
@@ -862,7 +860,7 @@ struct ScheduledMessenger : public Messenger
        ~ScheduledMessenger(void) {
                shutdown();
        }
-       bool scheduleCompress(F proxy, std::function<void(BufferSrc)> converter){
+       bool scheduleCompress(F const& proxy, std::function<void(BufferSrc const&)> converter){
                size_t frameSize = init_.uncompressedFrameSize_;
                assert(frameSize >= init_.uncompressedFrameSize_);
                BufferSrc src;
@@ -882,11 +880,11 @@ struct ScheduledMessenger : public Messenger
                auto compressedFrameId = msg.nextUint();
                auto compressedFrameLength = msg.nextUint();
                if (!needsRecompression) {
-                       bool success = false;
-                       auto srcFrame = scheduledFrames_.retrieve(clientFrameId,success);
-                       if (!success)
+                       auto src_frame = scheduledFrames_.retrieve(clientFrameId);
+                       if (!src_frame) {
                                return;
-                       processor(srcFrame, getCompressedFrame(compressedFrameId),compressedFrameLength);
+                       }
+                       processor(*src_frame, getCompressedFrame(compressedFrameId),compressedFrameLength);
                }
                ++framesCompressed_;
                send(GRK_MSGR_BATCH_PROCESSSED_COMPRESSED, compressedFrameId);
@@ -914,9 +912,11 @@ struct ScheduledMessenger : public Messenger
                }
 
        }
-       F retrieve(size_t index, bool &success) {
-               return scheduledFrames_.retrieve(index, success);
+
+       boost::optional<F> retrieve(size_t index) {
+               return scheduledFrames_.retrieve(index);
        }
+
        void store(F& val) {
                scheduledFrames_.store(val);
        }