comparison trunk/src/Modules/Output/Graphics/GraphicsView.cc @ 411:a908972d234e

- Added support for movies!

 
 #include "Support/Common.h"
 
 #include "Modules/Output/Graphics/GraphicsView.h"
 #include "Modules/Output/Graphics/Devices/GraphicsOutputDevice.h"
+#include "Modules/Output/Graphics/Devices/GraphicsOutputDeviceMovie.h"
 
 namespace aimc {
 
 GraphicsView::GraphicsView(Parameters *parameters) : Module(parameters) {
   module_description_ = "Graphics output.";
   module_identifier_ = "graphics";
   module_type_ = "output";
   module_version_ = "$Id: $";
   
-  m_pDev = new GraphicsOutputDeviceCairo();
+  m_pDev = new GraphicsOutputDeviceMovie(parameters);
   m_bPlotLabels = false;
   m_pAxisX = new GraphAxisSpec();
   AIM_ASSERT(m_pAxisX);
   m_pAxisY = new GraphAxisSpec();
   AIM_ASSERT(m_pAxisY);

                             1,
                             Scale::SCALE_LINEAR)) {
     LOG_ERROR("Axis initialization failed");
     initialized_ = false;
   }
-  m_fMarginLeft = parameters_->GetFloat(_S("graph.margin.left"));
-  m_fMarginRight = parameters_->GetFloat(_S("graph.margin.right"));
-  m_fMarginTop = parameters_->GetFloat(_S("graph.margin.top"));
-  m_fMarginBottom = parameters_->GetFloat(_S("graph.margin.bottom"));
-  m_bPlotLabels = parameters_->GetBool(_S("graph.plotlabels"));
-
-  const char *sGraphType = parameters_->GetString(_S("graph.type"));
+  m_fMarginLeft = parameters_->DefaultFloat(_S("graph.margin.left"), 0.05);
+  m_fMarginRight = parameters_->DefaultFloat(_S("graph.margin.right"), 0.005);
+  m_fMarginTop = parameters_->DefaultFloat(_S("graph.margin.top"), 0.005);
+  m_fMarginBottom = parameters_->DefaultFloat(_S("graph.margin.bottom"), 0.05);
+  m_bPlotLabels = parameters_->DefaultBool(_S("graph.plotlabels"), true);
+
+  const char *sGraphType = parameters_->DefaultString(_S("graph.type"), "line");
   if (strcmp(sGraphType, _S("line"))==0)
     m_iGraphType = GraphTypeLine;
   else if (strcmp(sGraphType, _S("colormap"))==0)
     m_iGraphType = GraphTypeColormap;
   else if (strcmp(sGraphType, _S("none"))==0)

   else {
     LOG_ERROR(_T("Unrecognized graph type: '%s'"), sGraphType);
     initialized_ = false;
   }
 
-  if (strcmp(parameters_->GetString(_S("graph.mindistance")),"auto") == 0)
+  if (strcmp(parameters_->DefaultString(_S("graph.mindistance"), "auto"),"auto") == 0)
     // -1 means detect later, based on type and Fire() argument
     m_fMinPlotDistance = -1;
   else
     m_fMinPlotDistance = parameters_->GetFloat(_S("graph.mindistance"));
 }

   DELETE_IF_NONNULL(m_pAxisY);
   DELETE_IF_NONNULL(m_pAxisFreq);
 }
 
 void GraphicsView::ResetInternal() {
+  if (m_pDev != NULL) {
+    m_pDev->Stop();
+  }
 }
 
 bool GraphicsView::InitializeInternal(const SignalBank &bank) {
   if (!m_pDev) {
     LOG_ERROR("Output device not connected");

   if (!m_pAxisFreq->Initialize(parameters_,
                                "graph.freq",
                                y_min,
                                y_max,
                                Scale::SCALE_ERB)) {
-    LOG_ERROR("");
+    LOG_ERROR("Frequency axis init failed.");
     return false;
   }
 
   float x_min = 0.0;
   float x_max = 1000.0 * bank.buffer_length() / bank.sample_rate();
   if (!m_pAxisX->Initialize(parameters_,
                             "graph.x",
                             x_min,
                             x_max,
                             Scale::SCALE_LINEAR)) {
-     LOG_ERROR("");
+     LOG_ERROR("Time axis init failed.");
      return false;
   }
 
   /* Inform graphics output of maximum number of vertices between
    * gBegin*() and gEnd(), for any type of plot. Colormap needs most.
    */
-  if (!m_pDev->Initialize(std::max<int>(10, bank.buffer_length() * 2 + 2))) {
-    LOG_ERROR("");
+  LOG_INFO("Initializing graphics output device.");
+  
+  if (!m_pDev->Initialize(global_parameters_)) {
+    LOG_ERROR("Graphics output device init failed.");
     return false;
   }
+  m_pDev->Start();
+  previous_start_time_ = 0;
   return true;
 }
 
 void GraphicsView::Process(const SignalBank &bank) {
   float height = 1.0 / bank.channel_count();

     yOffs = yOffs * (1.0f - height) + height / 2.0;
     yOffs = yOffs * (1.0f - m_fMarginTop - m_fMarginBottom) + m_fMarginBottom;
     PlotData(bank[i], bank.sample_rate(), yOffs, heightMinMargin, xScaling);
   }
   m_pDev->gRelease();
+  
+  frame_rate_ = bank.sample_rate()
+                / (bank.start_time() - previous_start_time_);
+  previous_start_time_ = bank.start_time();
+  global_parameters_->SetFloat("frame_rate", frame_rate_);
 }
 
 void GraphicsView::SetAxisScale(Scale::ScaleType iHori,
                                 Scale::ScaleType iVert,
                                 Scale::ScaleType iFreq) {