Run clang-format on Aaron's patch.

1 files changed, 145 insertions, 89 deletions

diff --git a/src/lib/grok_context.h b/src/lib/grok_context.h
index 1f9726aae..1e1850717 100644
--- a/src/lib/grok_context.h
+++ b/src/lib/grok_context.h
@@ -21,10 +21,10 @@
 #pragma once
 
 #include "config.h"
-#include "log.h"
 #include "dcpomatic_log.h"
-#include "writer.h"
 #include "grok_messenger.h"
+#include "log.h"
+#include "writer.h"
 
 class Film;
 using dcp::Data;
@@ -32,126 +32,172 @@ using namespace dcpomatic;
 
 static std::mutex launchMutex;
 
-namespace grk_plugin
+namespace grk_plugin {
+
+struct GrokLogger : public MessengerLogger
 {
+	explicit GrokLogger(const std::string& preamble)
+		: MessengerLogger(preamble)
+	{
+	}
 
-struct GrokLogger : public MessengerLogger {
-	explicit GrokLogger(const std::string &preamble) : MessengerLogger(preamble)
-	{}
 	virtual ~GrokLogger() = default;
-	void info(const char* fmt, ...) override{
+
+	void info(const char* fmt, ...) override
+	{
 		va_list arg;
 		va_start(arg, fmt);
-		dcpomatic_log->log(preamble_ + log_message(fmt, arg),LogEntry::TYPE_GENERAL);
+		dcpomatic_log->log(preamble_ + log_message(fmt, arg), LogEntry::TYPE_GENERAL);
 		va_end(arg);
 	}
-	void warn(const char* fmt, ...) override{
+
+	void warn(const char* fmt, ...) override
+	{
 		va_list arg;
 		va_start(arg, fmt);
-		dcpomatic_log->log(preamble_ + log_message(fmt, arg),LogEntry::TYPE_WARNING);
+		dcpomatic_log->log(preamble_ + log_message(fmt, arg), LogEntry::TYPE_WARNING);
 		va_end(arg);
 	}
-	void error(const char* fmt, ...) override{
+
+	void error(const char* fmt, ...) override
+	{
 		va_list arg;
 		va_start(arg, fmt);
-		dcpomatic_log->log(preamble_ + log_message(fmt, arg),LogEntry::TYPE_ERROR);
+		dcpomatic_log->log(preamble_ + log_message(fmt, arg), LogEntry::TYPE_ERROR);
 		va_end(arg);
 	}
 };
 
-struct GrokInitializer {
-	GrokInitializer(void) {
+struct GrokInitializer
+{
+	GrokInitializer(void)
+	{
 		setMessengerLogger(new GrokLogger("[GROK] "));
 	}
-	~GrokInitializer()  = default;
+
+	~GrokInitializer() = default;
 };
 
-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 {
+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
+	{
 		return index_;
 	}
-	Eyes eyes(void) const {
+
+	Eyes eyes(void) const
+	{
 		return eyes_;
 	}
+
 	int index_;
 	Eyes eyes_;
 	DCPVideo vf;
 };
 
-struct DcpomaticContext {
+struct DcpomaticContext
+{
 	DcpomaticContext(std::shared_ptr<const Film> film, Writer& writer,
-						EventHistory &history, const std::string &location) :
-									film_(film), writer_(writer),
-									history_(history), location_(location),
-									width_(0), height_(0)
-	{}
-	void setDimensions(uint32_t w, uint32_t h) {
+	                 EventHistory& history, const std::string& location)
+		: film_(film)
+		, writer_(writer)
+		, history_(history)
+		, location_(location)
+		, width_(0)
+		, height_(0)
+	{
+	}
+
+	void setDimensions(uint32_t w, uint32_t h)
+	{
 		width_ = w;
 		height_ = h;
 	}
+
 	std::shared_ptr<const Film> film_;
 	Writer& writer_;
-	EventHistory &history_;
+	EventHistory& history_;
 	std::string location_;
 	uint32_t width_;
 	uint32_t height_;
 };
 
-class GrokContext {
+class GrokContext
+{
 public:
-	explicit GrokContext(const DcpomaticContext &dcpomaticContext) :
-								dcpomaticContext_(dcpomaticContext),
-								messenger_(nullptr),
-								launched_(false)
-	{
-		struct CompressedData : public dcp::Data {
-			explicit CompressedData(int dataLen) : data_(new uint8_t[dataLen]), dataLen_(dataLen)
-			{}
-			~CompressedData(void){
+	explicit GrokContext(const DcpomaticContext& dcpomaticContext)
+		: dcpomaticContext_(dcpomaticContext)
+		, messenger_(nullptr)
+		, launched_(false)
+	{
+		struct CompressedData : public dcp::Data
+		{
+			explicit CompressedData(int dataLen)
+				: data_(new uint8_t[dataLen])
+				, dataLen_(dataLen)
+			{
+			}
+
+			~CompressedData(void)
+			{
 				delete[] data_;
 			}
-			uint8_t const * data () const override {
+
+			uint8_t const* data() const override
+			{
 				return data_;
 			}
-			uint8_t * data () override {
+
+			uint8_t* data() override
+			{
 				return data_;
 			}
-			int size () const override {
+
+			int size() const override
+			{
 				return dataLen_;
 			}
-			uint8_t *data_;
+
+			uint8_t* data_;
 			int dataLen_;
 		};
-		if (Config::instance()->enable_gpu ())  {
-		    boost::filesystem::path folder(dcpomaticContext_.location_);
-		    boost::filesystem::path binaryPath = folder / "grk_compress";
-		    if (!boost::filesystem::exists(binaryPath)) {
-		    	getMessengerLogger()->error("Invalid binary location %s",
-		    			dcpomaticContext_.location_.c_str());
+
+		if (Config::instance()->enable_gpu()) {
+			boost::filesystem::path folder(dcpomaticContext_.location_);
+			boost::filesystem::path binaryPath = folder / "grk_compress";
+			if (!boost::filesystem::exists(binaryPath)) {
+				getMessengerLogger()->error("Invalid binary location %s",
+				                            dcpomaticContext_.location_.c_str());
 				return;
-		    }
+			}
 			auto proc = [this](const std::string& str) {
 				try {
 					Msg msg(str);
 					auto tag = msg.next();
-					if(tag == GRK_MSGR_BATCH_SUBMIT_COMPRESSED)
-					{
+					if (tag == GRK_MSGR_BATCH_SUBMIT_COMPRESSED) {
 						auto clientFrameId = msg.nextUint();
 						auto compressedFrameId = msg.nextUint();
 						(void)compressedFrameId;
 						auto compressedFrameLength = msg.nextUint();
-						auto  processor =
-								[this](FrameProxy srcFrame, uint8_t* compressed, uint32_t compressedFrameLength)
-						{
-							auto compressedData = std::make_shared<CompressedData>(compressedFrameLength);
-							memcpy(compressedData->data_,compressed,compressedFrameLength );
-							dcpomaticContext_.writer_.write(compressedData, srcFrame.index(), srcFrame.eyes());
-							frame_done ();
-						};
+						auto processor =
+						    [this](FrameProxy srcFrame, uint8_t* compressed, uint32_t compressedFrameLength) {
+							    auto compressedData = std::make_shared<CompressedData>(compressedFrameLength);
+							    memcpy(compressedData->data_, compressed, compressedFrameLength);
+							    dcpomaticContext_.writer_.write(compressedData, srcFrame.index(), srcFrame.eyes());
+							    frame_done();
+						    };
 						int const minimum_size = 16384;
 						bool needsRecompression = compressedFrameLength < minimum_size;
 						messenger_->processCompressed(str, processor, needsRecompression);
@@ -163,25 +209,29 @@ public:
 
 							auto encoded = std::make_shared<dcp::ArrayData>(fp.vf.encode_locally());
 							dcpomaticContext_.writer_.write(encoded, fp.vf.index(), fp.vf.eyes());
-							frame_done ();
+							frame_done();
 						}
 					}
-				} catch (std::exception &ex){
-					getMessengerLogger()->error("%s",ex.what());
+				} catch (std::exception& ex) {
+					getMessengerLogger()->error("%s", ex.what());
 				}
 			};
 			auto clientInit =
-				MessengerInit(clientToGrokMessageBuf, clientSentSynch, grokReceiveReadySynch,
-							  grokToClientMessageBuf, grokSentSynch, clientReceiveReadySynch, proc,
-							  std::thread::hardware_concurrency());
+			    MessengerInit(clientToGrokMessageBuf, clientSentSynch, grokReceiveReadySynch,
+			                  grokToClientMessageBuf, grokSentSynch, clientReceiveReadySynch, proc,
+			                  std::thread::hardware_concurrency());
 			messenger_ = new ScheduledMessenger<FrameProxy>(clientInit);
 		}
 	}
-	~GrokContext(void) {
+
+	~GrokContext(void)
+	{
 		shutdown();
 	}
-	bool launch(DCPVideo dcpv, int device){
-		if (!messenger_ )
+
+	bool launch(DCPVideo dcpv, int device)
+	{
+		if (!messenger_)
 			return false;
 		if (launched_)
 			return true;
@@ -195,32 +245,36 @@ public:
 			dcpomaticContext_.setDimensions(s.width, s.height);
 			auto config = Config::instance();
 			messenger_->launchGrok(dcpomaticContext_.location_,
-					dcpomaticContext_.width_,dcpomaticContext_.width_,
-					dcpomaticContext_.height_,
-					3, 12, device,
-					dcpomaticContext_.film_->resolution() == Resolution::FOUR_K,
-					dcpomaticContext_.film_->video_frame_rate(),
-					dcpomaticContext_.film_->j2k_bandwidth(),
-					config->gpu_license_server(),
-					config->gpu_license_port(),
-					config->gpu_license());
+			                       dcpomaticContext_.width_, dcpomaticContext_.width_,
+			                       dcpomaticContext_.height_,
+			                       3, 12, device,
+			                       dcpomaticContext_.film_->resolution() == Resolution::FOUR_K,
+			                       dcpomaticContext_.film_->video_frame_rate(),
+			                       dcpomaticContext_.film_->j2k_bandwidth(),
+			                       config->gpu_license_server(),
+			                       config->gpu_license_port(),
+			                       config->gpu_license());
 		}
-		launched_ =  messenger_->waitForClientInit();
+		launched_ = messenger_->waitForClientInit();
 
 		return launched_;
 	}
-	bool scheduleCompress(const DCPVideo &vf){
+
+	bool scheduleCompress(const DCPVideo& vf)
+	{
 		if (!messenger_)
 			return false;
 
-		auto fp = FrameProxy(vf.index(),vf.eyes(),vf);
-		auto cvt = [this, &fp](BufferSrc src){
+		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_);
 		};
 		return messenger_->scheduleCompress(fp, cvt);
 	}
-	void shutdown(void){
+
+	void shutdown(void)
+	{
 		if (!messenger_)
 			return;
 
@@ -232,14 +286,16 @@ public:
 		delete messenger_;
 		messenger_ = nullptr;
 	}
-	void frame_done () {
-		dcpomaticContext_.history_.event ();
+
+	void frame_done()
+	{
+		dcpomaticContext_.history_.event();
 	}
+
 private:
 	DcpomaticContext dcpomaticContext_;
-	ScheduledMessenger<FrameProxy> *messenger_;
+	ScheduledMessenger<FrameProxy>* messenger_;
 	bool launched_;
 };
 
-}
-
+} // namespace grk_plugin