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);
};
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 {
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 ();
}
}
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_);
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);
~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;
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);
}
}
- 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);
}