Mike/add fits writer

camerad/CMakeLists.txt

@@ -128,7 +128,7 @@ list (APPEND INTERFACE_SOURCES
 add_library(${INTERFACE_TARGET} ${INTERFACE_SOURCES})
 target_link_libraries(${INTERFACE_TARGET}
                       common
-                      shared_memory_writer
+                      frame_output_factory
                       )
 target_include_directories(${INTERFACE_TARGET} PUBLIC ${INTERFACE_INCLUDES})
 
@@ -173,7 +173,6 @@ target_link_libraries(camerad
   network
   utilities
   logentry
-  shared_memory_writer
   ${INTERFACE_TARGET}
   ${INTERFACE_LIBS}
   ${CMAKE_THREAD_LIBS_INIT}

camerad/archon_controller.cpp

@@ -1584,8 +1584,6 @@ namespace Camera {
     }
     else error=this->fetchlog();
 
-    this->is_camera_mode = false;         // require that a mode be selected after loading new firmware
-
     return error;
   }
   /***** Camera::ArchonController::load_acf ***********************************/

camerad/archon_controller.h

@@ -294,7 +294,6 @@ namespace Camera {
       std::atomic_flag archon_busy = ATOMIC_FLAG_INIT;  //!< indicates a thread is accessing Archon
       bool is_firmwareloaded;
       std::string firmware;
-      bool is_camera_mode{false};      //!< has a camera mode been selected
       int msgref;
       std::string backplaneversion;
       std::vector<int> modtype;             //!< type of each module from SYSTEM command

camerad/archon_exposure_modes.cpp

@@ -7,6 +7,8 @@
 #include "archon_exposure_modes.h"
 #include "archon_interface.h"
 
+#include <cstdlib>
+
 namespace Camera {
 
   /***** Camera::ExposureModeSingle *******************************************/
@@ -111,43 +113,49 @@ namespace Camera {
 
   /***** Camera::ExposureModeSingle::image_processing_thread ******************/
   /**
-   * @brief  implementation of Archon-specific expose for Single
-   *
+   * @brief  Consumer thread: pop each frame off the queue and fan out to
+   *         every configured FrameOutput on the interface
    */
   void ExposureModeSingle::image_processing_thread() {
     const std::string function("Camera::ExposureModeSingle::image_processing_thread");
     logwrite(function, "enter");
 
-//  open FITS file ?
+    auto* camera_info = &this->interface->camera_info;
+    auto* controller  = this->interface->controller;
+    auto* mode        = &controller->modemap[controller->selectedmode];
+    const size_t   bufferbytes = static_cast<size_t>(camera_info->image_data_bytes) * camera_info->cubedepth;
+    const uint32_t bpp         = (mode->samplemode == 1) ? 4 : 2;
+    const uint32_t width       = static_cast<uint32_t>(mode->geometry.pixelcount);
+    const uint32_t height      = static_cast<uint32_t>(mode->geometry.linecount);
 
-    // pop an image out of the queue,
-    // wait until producer stops producing data, or aborted
-    //
     while (!this->interface->is_aborted()) {
+      std::shared_ptr<ArchonImageBuffer> buf;
       {
-      std::unique_lock<std::mutex> lock(this->queue_mutex);
-      // keep trying to get the queue lock until success or aborted
-      this->queue_cv.wait(lock, [this] {
-          return !this->imagebuf_queue.empty() || this->is_producer_finished || this->interface->is_aborted();
-          });
-      if (this->interface->is_aborted()) break;
-      if (this->imagebuf_queue.empty()) {
-        if (this->is_producer_finished) {
-          logwrite(function, "queue empty and producer finished");
-          break;
-        }
-        else {
-          logwrite(function, "queue empty, producer not finished");
+        std::unique_lock<std::mutex> lock(this->queue_mutex);
+        this->queue_cv.wait(lock, [this] {
+            return !this->imagebuf_queue.empty() || this->is_producer_finished || this->interface->is_aborted();
+            });
+        if (this->interface->is_aborted()) break;
+        if (this->imagebuf_queue.empty()) {
+          if (this->is_producer_finished) {
+            logwrite(function, "queue empty and producer finished");
+            break;
+          }
           continue;
         }
+        buf = this->imagebuf_queue.front();
+        this->imagebuf_queue.pop();
       }
-      this->imagebuf_queue.pop();
-      }
-//    process_image
-      std::this_thread::sleep_for(std::chrono::milliseconds(500));
+
+      Camera::FrameMetadata meta;
+      meta.frame_number    = buf->bufframen_slice.empty()    ? 0 : static_cast<uint64_t>(buf->bufframen_slice[0]);
+      meta.timestamp       = buf->buftimestamp_slice.empty() ? 0 : buf->buftimestamp_slice[0];
+      meta.width           = width;
+      meta.height          = height;
+      meta.bytes_per_pixel = bpp;
+      this->interface->dispatch_frame(buf->rawpixels.get(), bufferbytes, meta);
     }
 
-//  close FITS file ?
     logwrite(function, "exit");
   }
   /***** Camera::ExposureModeSingle::image_processing_thread ******************/

camerad/archon_interface.cpp

@@ -807,9 +807,8 @@ namespace Camera {
 
     // if we made it all the way to the end then this is the selected mode
     this->controller->selectedmode = modeselect;
-    this->controller->is_camera_mode = true;
 
-    std::string target = ArchonExposureMode::SINGLE;
+    std::string target = this->default_exposure_mode_name();
     for (const auto &m : this->get_exposure_modes()) {
       if (m == modeselect) { target = modeselect; break; }
     }

camerad/archon_interface.h

@@ -68,6 +68,9 @@ namespace Camera {
       long set_vcpu_inreg(const std::string &args, std::string &retstring);
       long autofetch_mode(const std::string &args, std::string &retstring);
 
+      // Fallback for set_camera_mode when the camera-mode name is unknown
+      virtual std::string default_exposure_mode_name() const { return "SINGLE"; }
+
       char* get_framebuf() { return controller->framebuf; }
 
       bool is_autofetch_mode{false};

camerad/camera_interface.h

@@ -12,6 +12,10 @@
 #include "camera_information.h"
 #include "camerad_commands.h"
 #include "exposure_modes.h"
+#include "frame_output.h"
+
+#include <memory>
+#include <vector>
 
 namespace Camera {
 
@@ -54,6 +58,16 @@ namespace Camera {
 
       Config configfile;
       Camera::Information camera_info;
+
+      // Frame output destinations populated by Camera::make_frame_outputs()
+      std::vector<std::unique_ptr<FrameOutput>> frame_outputs;
+
+      // Fan a frame out to every configured FrameOutput
+      void dispatch_frame(const char* data, size_t size, const FrameMetadata &meta) {
+        for (auto &output : this->frame_outputs) {
+          output->write(data, size, meta);
+        }
+      }
 //    Common::FitsKeys systemkeys;  move to Camera::Information?
 
       // These functions are shared by all interfaces with common implementations,

camerad/exposure_modes.h

@@ -48,7 +48,7 @@ namespace Camera {
       }
 
       virtual ~ExposureMode() = default;
-      virtual long expose() = 0;
+      virtual long expose() { return NO_ERROR; }
       virtual void image_acquisition_thread() { };
       virtual void image_processing_thread() { };
 

utils/CMakeLists.txt

@@ -29,6 +29,28 @@ add_library(shared_memory_writer STATIC
 target_include_directories(shared_memory_writer PRIVATE ${PROJECT_BASE_DIR}/common ${PROJECT_BASE_DIR}/utils)
 target_link_libraries(shared_memory_writer nlohmann_json::nlohmann_json $<IF:$<PLATFORM_ID:Linux>,rt,>)
 
+add_library(fits_writer STATIC
+        ${PROJECT_UTILS_DIR}/fits_writer.cpp
+)
+target_include_directories(fits_writer PRIVATE ${PROJECT_BASE_DIR}/common ${PROJECT_BASE_DIR}/utils)
+find_library(FITSWRITER_CCFITS_LIB CCfits NAMES libCCfits PATHS /usr/local/lib /opt/homebrew/lib)
+find_library(FITSWRITER_CFITS_LIB cfitsio NAMES libcfitsio PATHS /usr/local/lib /opt/homebrew/lib)
+target_link_libraries(fits_writer
+        nlohmann_json::nlohmann_json
+        ${FITSWRITER_CCFITS_LIB}
+        ${FITSWRITER_CFITS_LIB}
+)
+
+add_library(frame_output_factory STATIC
+        ${PROJECT_UTILS_DIR}/frame_output_factory.cpp
+)
+target_include_directories(frame_output_factory PRIVATE ${PROJECT_BASE_DIR}/common ${PROJECT_BASE_DIR}/utils)
+target_link_libraries(frame_output_factory
+        nlohmann_json::nlohmann_json
+        shared_memory_writer
+        fits_writer
+)
+
 add_library(md5 STATIC
         ${PROJECT_UTILS_DIR}/md5.cpp
 )