CtSaving.cpp

//###########################################################################
// This file is part of LImA, a Library for Image Acquisition
//
// Copyright (C) : 2009-2011
// European Synchrotron Radiation Facility
// BP 220, Grenoble 38043
// FRANCE
//
// This is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, see <http://www.gnu.org/licenses/>.
//###########################################################################
#include <cmath>
#include <sstream>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>

#ifdef __linux__ 
#include <dirent.h>
#include <sys/statvfs.h>
#else
#include <direct.h>
#endif

#include "CtSaving.h"
#include "CtSaving_Edf.h"
#include "CtAcquisition.h"
#include "CtBuffer.h"

#ifdef WITH_NXS_SAVING
#include "CtSaving_Nxs.h"
#endif

#ifdef WITH_CBF_SAVING
#include "CtSaving_Cbf.h"
#endif

#ifdef WITH_FITS_SAVING
#include "CtSaving_Fits.h"
#endif

#include "TaskMgr.h"
#include "SinkTask.h"

using namespace lima;

static const char DIR_SEPARATOR = '/';

/** @brief save task class
 */
class CtSaving::Stream::_SaveTask : public SinkTaskBase
{
    DEB_CLASS_NAMESPC(DebModControl,"CtSaving::Stream::_SaveTask","Control");
public:
  _SaveTask(CtSaving::Stream& stream) 
    : SinkTaskBase(), m_stream(stream) {}

  virtual void process(Data &aData)
  {
    DEB_MEMBER_FUNCT();
    DEB_PARAM() << DEB_VAR1(aData);

    m_stream.writeFile(aData, m_header);
  }

  CtSaving::HeaderMap	 m_header;
private:
  CtSaving::Stream& m_stream;
};
/** @brief save callback
 */
class CtSaving::Stream::_SaveCBK : public TaskEventCallback
{
    DEB_CLASS_NAMESPC(DebModControl,"CtSaving::Stream::_SaveCBK","Control");
public:
  _SaveCBK(Stream& stream) : m_stream(stream) {}
  virtual void finished(Data &aData)
  {
    DEB_MEMBER_FUNCT();
    DEB_PARAM() << DEB_VAR1(aData);

    m_stream.saveFinished(aData);
  }
private:
  Stream& m_stream;
};
/** @brief compression callback
 */
class CtSaving::Stream::_CompressionCBK : public TaskEventCallback
{
    DEB_CLASS_NAMESPC(DebModControl,"CtSaving::_CompressionCBK","Control");
public:
  _CompressionCBK(Stream& stream) : m_stream(stream) {}
  virtual void finished(Data &aData)
  {
    DEB_MEMBER_FUNCT();
    DEB_PARAM() << DEB_VAR1(aData);

    m_stream.compressionFinished(aData);
  }
private:
  Stream &m_stream;
};
/** @brief manual background saving
 */
class CtSaving::_ManualBackgroundSaveTask : public SinkTaskBase
{
public:
  _ManualBackgroundSaveTask(CtSaving& ct_saving,
			    HeaderMap &aHeader) :
    m_saving(ct_saving),
    m_header(aHeader)
  {
  }

  ~_ManualBackgroundSaveTask()
  {
    AutoMutex lock(m_saving.m_cond.mutex());
    m_saving.m_ready_flag = true;
    m_saving.m_cond.broadcast();
  }

  virtual void process(Data &aData)
  {
    m_saving._synchronousSaving(aData,m_header);
  }
private:
  CtSaving &m_saving;
  HeaderMap m_header;
};
/** @brief Parameters default constructor
 */
CtSaving::Parameters::Parameters()
  : nextNumber(0), fileFormat(RAW), savingMode(Manual), 
    overwritePolicy(Abort),
    indexFormat("%04d"),framesPerFile(1)
{
}

void CtSaving::Parameters::checkValid() const
{
  switch(fileFormat)
    {
#ifdef WITH_CBF_SAVING
    case CBFFormat :
      if(framesPerFile > 1)
	throw LIMA_CTL_EXC(InvalidValue, "CBF file format does not support "
			                 "multi frame per file");
      break;
#endif
#ifndef __unix
#pragma message ( "--- WARNING / TODO - no cases???" )
#endif
    default:
      break;
    }
}


//@brief constructor
CtSaving::Stream::Stream(CtSaving& aCtSaving, int idx)
  : m_saving(aCtSaving), m_idx(idx),
    m_save_cnt(NULL),
    m_pars_dirty_flag(false),
    m_active(false),
    m_compression_cbk(NULL)
{
  DEB_CONSTRUCTOR();

  createSaveContainer();
  m_saving_cbk = new _SaveCBK(*this);
  m_compression_cbk = new _CompressionCBK(*this);
}

//@brief destructor
CtSaving::Stream::~Stream()
{
  DEB_DESTRUCTOR();

  delete m_save_cnt;
  m_saving_cbk->unref();
  m_compression_cbk->unref();
}

const 
CtSaving::Parameters& CtSaving::Stream::getParameters(ParameterType type) const
{ 
  bool from_acq = (type == Acq) || ((type == Auto) && !m_pars_dirty_flag);
  return *(from_acq ? &m_acquisition_pars : &m_pars); 
}

CtSaving::Parameters& CtSaving::Stream::getParameters(ParameterType type)
{ 
  bool from_acq = (type == Acq) || ((type == Auto) && !m_pars_dirty_flag);
  return *(from_acq ? &m_acquisition_pars : &m_pars); 
}

void CtSaving::Stream::setParameters(const CtSaving::Parameters& pars)
{ 
  DEB_MEMBER_FUNCT();

  if (pars.nextNumber == m_acquisition_pars.nextNumber)
    m_pars.nextNumber = pars.nextNumber;

  if (pars == m_pars)
    return;

  pars.checkValid(); 
  m_pars_dirty_flag = true; 
  m_pars = pars; 

  DEB_TRACE() << "pars changed";
}

void CtSaving::Stream::setActive(bool active)
{
  DEB_MEMBER_FUNCT();

  if (active == m_active)
    return;
  
  if (!active)
    m_save_cnt->close();

  m_active = active;
}

void CtSaving::Stream::prepare()
{
  DEB_MEMBER_FUNCT();

  if (hasAutoSaveMode())
    {
      m_save_cnt->close();
      updateParameters();
      checkWriteAccess();
    }
}

void CtSaving::Stream::updateParameters()
{
  DEB_MEMBER_FUNCT();

  if (!m_pars_dirty_flag)
    return;

  if (m_pars.fileFormat != m_acquisition_pars.fileFormat)
    createSaveContainer();

  m_acquisition_pars = m_pars;
  m_pars_dirty_flag = false;
}

void CtSaving::Stream::createSaveContainer()
{
  DEB_MEMBER_FUNCT();

  switch (m_pars.fileFormat) {
  case CBFFormat :
#ifndef WITH_CBF_SAVING
    THROW_CTL_ERROR(NotSupported) << "Lima is not compiled with the cbf "
                                     "saving option, not managed";  
#endif
    goto common;

  case NXS:
#ifndef WITH_NXS_SAVING
    THROW_CTL_ERROR(NotSupported) << "Lima is not compiled with the nxs "
                                     "saving option, not managed";  
#endif        
    goto common;

  case FITS:
#ifndef WITH_FITS_SAVING
    THROW_CTL_ERROR(NotSupported) << "Lima is not compiled with the fits "
                                     "saving option, not managed";  
#endif        
    goto common;
  case EDFGZ:
#ifndef WITH_EDFGZ_SAVING
    THROW_CTL_ERROR(NotSupported) << "Lima is not compiled with the edf gzip "
                                     "saving option, not managed"; 
#endif
    goto common;
  case RAW:
  case EDF:

  common:
    if (m_save_cnt) {
      m_save_cnt->close();
      delete m_save_cnt;
    }
    break;

  default:
    THROW_CTL_ERROR(NotSupported) << "File format not yet managed";
  }

  switch(m_pars.fileFormat)
  {
  case RAW:
  case EDF:
  case EDFGZ:
    m_save_cnt = new SaveContainerEdf(*this,m_pars.fileFormat);
    break;
#ifdef WITH_CBF_SAVING
  case CBFFormat:
    m_save_cnt = new SaveContainerCbf(*this);
    m_pars.framesPerFile = 1;
    break;
#endif
#ifdef WITH_NXS_SAVING
  case NXS:
    m_save_cnt = new SaveContainerNxs(*this);
    break;
#endif
#ifdef WITH_FITS_SAVING
  case FITS:
    m_save_cnt = new SaveContainerFits(*this);
    break;
#endif
  default:
    break;
  }
}

void CtSaving::Stream::writeFile(Data& data, HeaderMap& header)
{
  DEB_MEMBER_FUNCT();

  m_save_cnt->writeFile(data, header);
}


SinkTaskBase *CtSaving::Stream::getTask(TaskType type, const HeaderMap& header)
{
  DEB_MEMBER_FUNCT();

  SinkTaskBase *save_task;

  if (type == Compression) {
    if (!needCompression())
      return NULL;
    save_task = m_save_cnt->getCompressionTask(header);
    save_task->setEventCallback(m_compression_cbk);
  } else {
    _SaveTask *real_task = new _SaveTask(*this);
    real_task->m_header = header;
    save_task = real_task;
    save_task->setEventCallback(m_saving_cbk);
  }

  return save_task;
}

void CtSaving::Stream::compressionFinished(Data& data)
{
  DEB_MEMBER_FUNCT();
  m_saving._compressionFinished(data, *this);
}

void CtSaving::Stream::saveFinished(Data& data)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR2(data, getIndex());

  m_saving._saveFinished(data, *this);
}

class CtSaving::_NewFrameSaveCBK : public HwSavingCtrlObj::Callback
{
public:
  _NewFrameSaveCBK(CtSaving &ct_saving) :
    m_saving(ct_saving)
  {
  }
  bool newFrameWritten(int frame_id)
  {
    return m_saving._newFrameWrite(frame_id);
  }
private:
  CtSaving&	m_saving;
};

//@brief constructor
CtSaving::CtSaving(CtControl &aCtrl) :
  m_ctrl(aCtrl),
  m_stream(NULL),
  m_ready_flag(true),
  m_need_compression(false),
  m_nb_save_cbk(0),
  m_end_cbk(NULL),
  m_managed_mode(Software)
{
  DEB_CONSTRUCTOR();

  m_nb_stream = 5;
  m_stream = new Stream *[m_nb_stream];
  for (int s = 0; s < m_nb_stream; ++s)
    m_stream[s] = new Stream(*this, s);

  m_stream[0]->setActive(true);

  resetLastFrameNb();

  HwInterface *hw = aCtrl.hwInterface();
  m_has_hwsaving = hw->getHwCtrlObj(m_hwsaving);
  if(m_has_hwsaving)
    {
      m_new_frame_save_cbk = new _NewFrameSaveCBK(*this);
      m_hwsaving->registerCallback(m_new_frame_save_cbk);
    }
  else
    m_new_frame_save_cbk = NULL;
}

//@brief destructor
CtSaving::~CtSaving()
{
  DEB_DESTRUCTOR();

  for (int s = 0; s < m_nb_stream; ++s)
    delete m_stream[s];
  delete [] m_stream;

  setEndCallback(NULL);
  if(m_has_hwsaving)
    {
      m_hwsaving->unregisterCallback(m_new_frame_save_cbk);
      delete m_new_frame_save_cbk;
    }
}

CtSaving::Stream& CtSaving::getStreamExc(int stream_idx) const
{
  DEB_MEMBER_FUNCT();
  THROW_CTL_ERROR(InvalidValue) << "Invalid " << DEB_VAR1(stream_idx);
}

/** @brief set saving parameter for a saving stream

    @param pars parameters for the saving stream
    @param stream_idx the id of the saving stream
 */
void CtSaving::setParameters(const CtSaving::Parameters &pars, int stream_idx)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR2(pars, stream_idx);

  AutoMutex aLock(m_cond.mutex());
  Stream& stream = getStream(stream_idx);
  stream.setParameters(pars);
}

/** @brief get the saving stream parameters

    @param pars the return parameters
    @param stream_idx the stream id
 */
void CtSaving::getParameters(CtSaving::Parameters &pars, int stream_idx) const
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(stream_idx);

  AutoMutex aLock(m_cond.mutex());
  const Stream& stream = getStream(stream_idx);
  pars = stream.getParameters(Auto);

  DEB_RETURN() << DEB_VAR1(pars);
}
/** @brief set the saving directory for a saving stream
 */
void CtSaving::setDirectory(const std::string &directory, int stream_idx)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR2(directory, stream_idx);

  AutoMutex aLock(m_cond.mutex());
  Stream& stream = getStream(stream_idx);
  Parameters pars = stream.getParameters(Auto);
  pars.directory = directory;
  stream.setParameters(pars);
}
/** @brief get the saving directory for a saving stream
 */
void CtSaving::getDirectory(std::string& directory, int stream_idx) const
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(stream_idx);

  AutoMutex aLock(m_cond.mutex());
  const Stream& stream = getStream(stream_idx);
  const Parameters& pars = stream.getParameters(Auto);
  directory = pars.directory;

  DEB_RETURN() << DEB_VAR1(directory);
}
/** @brief set the filename prefix for a saving stream
 */
void CtSaving::setPrefix(const std::string &prefix, int stream_idx)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR2(prefix, stream_idx);

  AutoMutex aLock(m_cond.mutex());
  Stream& stream = getStream(stream_idx);
  Parameters pars = stream.getParameters(Auto);
  pars.prefix = prefix;
  stream.setParameters(pars);
}
/** @brief get the filename prefix for a saving stream
 */
void CtSaving::getPrefix(std::string& prefix, int stream_idx) const
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(stream_idx);

  AutoMutex aLock(m_cond.mutex());
  const Stream& stream = getStream(stream_idx);
  const Parameters& pars = stream.getParameters(Auto);
  prefix = pars.prefix;

  DEB_RETURN() << DEB_VAR1(prefix);
}
/** @brief set the filename suffix for a saving stream
 */
void CtSaving::setSuffix(const std::string &suffix, int stream_idx)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR2(suffix, stream_idx);

  AutoMutex aLock(m_cond.mutex());
  Stream& stream = getStream(stream_idx);
  Parameters pars = stream.getParameters(Auto);
  pars.suffix = suffix;
  stream.setParameters(pars);
}
/** @brief get the filename suffix for a saving stream
 */
void CtSaving::getSuffix(std::string& suffix, int stream_idx) const
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(stream_idx);

  AutoMutex aLock(m_cond.mutex());
  const Stream& stream = getStream(stream_idx);
  const Parameters& pars = stream.getParameters(Auto);
  suffix = pars.suffix;

  DEB_RETURN() << DEB_VAR1(suffix);
}
/** @brief set the next number for the filename for a saving stream
 */
void CtSaving::setNextNumber(long number, int stream_idx)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR2(number, stream_idx);

  AutoMutex aLock(m_cond.mutex());
  Stream& stream = getStream(stream_idx);
  Parameters pars = stream.getParameters(Auto);
  pars.nextNumber = number;
  stream.setParameters(pars);
}
/** @brief get the next number for the filename for a saving stream
 */
void CtSaving::getNextNumber(long& number, int stream_idx) const
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(stream_idx);
  
  AutoMutex aLock(m_cond.mutex());
  const Stream& stream = getStream(stream_idx);
  const Parameters& pars = stream.getParameters(Auto);
  number = pars.nextNumber;

  DEB_RETURN() << DEB_VAR1(number);
}
/** @brief set the saving format for a saving stream
 */
void CtSaving::setFormat(FileFormat format, int stream_idx)
{
  DEB_MEMBER_FUNCT();

  AutoMutex aLock(m_cond.mutex());
  Stream& stream = getStream(stream_idx);
  Parameters pars = stream.getParameters(Auto);
  pars.fileFormat = format;
  stream.setParameters(pars);
}
/** @brief get the saving format for a saving stream
 */
void CtSaving::getFormat(FileFormat& format, int stream_idx) const
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(stream_idx);

  AutoMutex aLock(m_cond.mutex());
  const Stream& stream = getStream(stream_idx);
  const Parameters& pars = stream.getParameters(Auto);
  format = pars.fileFormat;

  DEB_RETURN() << DEB_VAR1(format);
}
/** @brief return a list of hardware possible saving format
 */
void CtSaving::getHardwareFormatList(std::list<std::string> &format_list) const
{
  DEB_MEMBER_FUNCT();

  if(!m_has_hwsaving)
    THROW_CTL_ERROR(NotSupported) << "No hardware saving for this camera";
  
  m_hwsaving->getPossibleSaveFormat(format_list);
}

void CtSaving::setHardwareFormat(const std::string &format)
{
  DEB_MEMBER_FUNCT();

  if(!m_has_hwsaving)
    THROW_CTL_ERROR(NotSupported) << "No hardware saving for this camera";

  bool found = _checkHwFileFormat(format);
  
  if(!found)
    {
      THROW_CTL_ERROR(NotSupported) << 
	"Hardware does not support" << DEB_VAR1(format);
    }

  m_specific_hardware_format = format;
}

bool CtSaving::_checkHwFileFormat(const std::string &format) const
{
  std::list<std::string> format_list;
  m_hwsaving->getPossibleSaveFormat(format_list);
  bool found = false;
  for(std::list<std::string>::const_iterator i = format_list.begin();
      !found && i != format_list.end();++i)
    found = *i == format;
  return found;
}

void CtSaving::_ReadImage(Data &image,int frameNumber)
{
  DEB_MEMBER_FUNCT();

  if(m_hwsaving->getCapabilities() & HwSavingCtrlObj::MANUAL_READ)
    {
      HwFrameInfoType frame;
      m_hwsaving->readFrame(frame,frameNumber);
      CtBuffer::transformHwFrameInfoToData(image,frame);
    }
  else
    THROW_CTL_ERROR(NotSupported) << "Image read is not supported for this hardware";
}
void CtSaving::getHardwareFormat(std::string &format) const
{
  DEB_MEMBER_FUNCT();

  if(!m_has_hwsaving)
    THROW_CTL_ERROR(NotSupported) << "No hardware saving for this camera";
  
  format = m_specific_hardware_format;
}

/** @brief set the saving mode for a saving stream
 */
void CtSaving::setSavingMode(SavingMode mode)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(mode);

  AutoMutex aLock(m_cond.mutex());
  for (int s = 0; s < m_nb_stream; ++s) {
    Stream& stream = getStream(s);
    Parameters pars = stream.getParameters(Auto);
    pars.savingMode = mode;
    stream.setParameters(pars);
  }
}
/** @brief get the saving mode for a saving stream
 */
void CtSaving::getSavingMode(SavingMode& mode) const
{ 
  DEB_MEMBER_FUNCT();
  
  AutoMutex aLock(m_cond.mutex());
  const Stream& stream = getStream(0);
  const Parameters& pars = stream.getParameters(Auto);
  mode = pars.savingMode;
  
  DEB_RETURN() << DEB_VAR1(mode);
}
/** @brief set the overwrite policy for a saving stream
 */
void CtSaving::setOverwritePolicy(OverwritePolicy policy, int stream_idx)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR2(policy, stream_idx);

  AutoMutex aLock(m_cond.mutex());
  Stream& stream = getStream(stream_idx);
  Parameters pars = stream.getParameters(Auto);
  pars.overwritePolicy = policy;
  stream.setParameters(pars);
}
/** @brief get the overwrite policy for a saving stream
 */
void CtSaving::getOverwritePolicy(OverwritePolicy& policy, 
				  int stream_idx) const
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(stream_idx);
  
  AutoMutex aLock(m_cond.mutex());
  const Stream& stream = getStream(stream_idx);
  const Parameters& pars = stream.getParameters(Auto);
  policy = pars.overwritePolicy;

  DEB_RETURN() << DEB_VAR1(policy);
}
/** @brief set the number of frame saved per file for a saving stream
 */
void CtSaving::setFramesPerFile(unsigned long frames_per_file, int stream_idx)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR2(frames_per_file, stream_idx);

  AutoMutex aLock(m_cond.mutex());
  Stream& stream = getStream(stream_idx);
  Parameters pars = stream.getParameters(Auto);
  pars.framesPerFile = frames_per_file;
  stream.setParameters(pars);
}
/** @brief get the number of frame saved per file for a saving stream
 */
void CtSaving::getFramePerFile(unsigned long& frames_per_file, 
			       int stream_idx) const
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(stream_idx);

  AutoMutex aLock(m_cond.mutex());
  const Stream& stream = getStream(stream_idx);
  const Parameters& pars = stream.getParameters(Auto);
  frames_per_file = pars.framesPerFile;

  DEB_RETURN() << DEB_VAR1(frames_per_file);
}

/** @brief set who will manage the saving.
 *
 *  with this methode you can choose who will do the saving
 *   - if mode is set to Software, the saving will be managed by Lima core
 *   - if mode is set to Hardware then it's the sdk or the hardware of the camera that will manage the saving.
 *  @param mode can be either Software or Hardware
*/
void CtSaving::setManagedMode(CtSaving::ManagedMode mode)
{
  DEB_MEMBER_FUNCT();
  if(mode == Hardware && !m_has_hwsaving)
    THROW_CTL_ERROR(InvalidValue) << DEB_VAR1(mode) << "Not supported";

  AutoMutex aLock(m_cond.mutex());
  if(mode == Hardware)
    {
      if(!m_has_hwsaving)
	THROW_CTL_ERROR(NotSupported) << "Hardware saving is not supported";

      int hw_cap = m_hwsaving->getCapabilities();
      if(hw_cap & HwSavingCtrlObj::COMMON_HEADER)
	m_hwsaving->setCommonHeader(m_common_header);
      else if(!m_common_header.empty())
	{
	  THROW_CTL_ERROR(Error) << "Hardware saving do not manage common header"
				 << ", clear it first";
	}
    }
  m_managed_mode = mode;
}

void CtSaving::getManagedMode(CtSaving::ManagedMode &mode) const
{
  DEB_MEMBER_FUNCT();

  AutoMutex aLock(m_cond.mutex());
  mode = m_managed_mode;
}

void CtSaving::_getTaskList(TaskType type, long frame_nr, 
			    const HeaderMap& header, TaskList& task_list)
{
  DEB_MEMBER_FUNCT();

  task_list.clear();
  for (int s = 0; s < m_nb_stream; ++s) {
    Stream& stream = getStream(s);
    if (stream.isActive()) {
      SinkTaskBase *save_task = stream.getTask(type, header);
      if (save_task)
	task_list.push_back(save_task);
    }
  }
  int nb_cbk = task_list.size();
  DEB_TRACE() << DEB_VAR1(nb_cbk);
  if (type == Compression) {
    FrameCbkCountMap::value_type map_pair(frame_nr, nb_cbk);
    m_nb_compression_cbk.insert(map_pair);
  } else
    m_nb_save_cbk = nb_cbk;
}
/** @brief clear the common header
 */
void CtSaving::resetCommonHeader()
{
  DEB_MEMBER_FUNCT();

  AutoMutex aLock(m_cond.mutex());
  ManagedMode managed_mode = getManagedMode();
  if(managed_mode == Hardware)
    {
      int hw_cap = m_hwsaving->getCapabilities();
      if(hw_cap & HwSavingCtrlObj::COMMON_HEADER)
	m_hwsaving->resetCommonHeader();
      else
	THROW_CTL_ERROR(NotSupported) << "Common header is not supported";
    }
  m_common_header.clear();
}
/** @brief set the common header.
    This is the header which will be write for all frame for this acquisition
 */
void CtSaving::setCommonHeader(const HeaderMap &header)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(header);

  AutoMutex aLock(m_cond.mutex());
  ManagedMode managed_mode = getManagedMode();
  if(managed_mode == Hardware)
    {
      int hw_cap = m_hwsaving->getCapabilities();
      if(hw_cap & HwSavingCtrlObj::COMMON_HEADER)
	m_hwsaving->setCommonHeader(header);
      else
	THROW_CTL_ERROR(NotSupported) << "Common header is not supported";
    }
  m_common_header = header;
}
/** @brief replace/add field in the common header
 */
void CtSaving::updateCommonHeader(const HeaderMap &header)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(header);

  AutoMutex aLock(m_cond.mutex());
  //Update
  for(HeaderMap::const_iterator i = header.begin();
      i != header.end();++i)
    {
      std::pair<HeaderMap::iterator,bool> result= 
	m_common_header.insert(HeaderMap::value_type(i->first,i->second));
      //if it exist, update
      if(!result.second)
	result.first->second = i->second;
    }
}
/** @brief get the current common header
 */
void CtSaving::getCommonHeader(HeaderMap& header) const
{
  DEB_MEMBER_FUNCT();

  AutoMutex aLock(m_cond.mutex());
  header = HeaderMap(m_common_header);

  DEB_RETURN() << DEB_VAR1(header);
}
/** @brief add/replace a header value in the current common header
 */
void CtSaving::addToCommonHeader(const HeaderValue &value)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(value);

  AutoMutex aLock(m_cond.mutex());
  m_common_header.insert(value);
}
/** @brief add/replace a header value in the current frame header
 */
void CtSaving::addToFrameHeader(long frame_nr,const HeaderValue &value)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR2(frame_nr,value);

  AutoMutex aLock(m_cond.mutex());
  m_frame_headers[frame_nr].insert(value);
}
/** @brief add/replace several value in the current frame header
 */
void CtSaving::updateFrameHeader(long frame_nr,const HeaderMap &header)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR2(frame_nr,header);

  AutoMutex aLock(m_cond.mutex());
  HeaderMap &frameHeader = m_frame_headers[frame_nr];
  for(HeaderMap::const_iterator i = header.begin();
      i != header.end();++i)
    {
      std::pair<HeaderMap::iterator,bool> result= 
	frameHeader.insert(HeaderMap::value_type(i->first,i->second));
      //if it exist, update
      if(!result.second)
	result.first->second = i->second;
    }
}
/** @brief validate a header for a frame.
    this mean that the header is ready and can now be save.
    If you are in AutoHeader this will trigger the saving if the data frame is available
 */
void CtSaving::validateFrameHeader(long frame_nr)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(frame_nr);

  AutoMutex aLock(m_cond.mutex());
  SavingMode saving_mode = getAcqSavingMode();
  if (saving_mode != CtSaving::AutoHeader)
    return;

  FrameMap::iterator frame_iter = m_frame_datas.find(frame_nr);
  bool data_available = (frame_iter != m_frame_datas.end());
  bool can_save = (m_ready_flag && (m_last_frameid_saved == frame_nr - 1));
  if (!data_available || !(m_need_compression || can_save))
    return;
  Data aData = frame_iter->second;

  HeaderMap task_header;
  FrameHeaderMap::iterator aHeaderIter;
  aHeaderIter = m_frame_headers.find(frame_nr);
  bool keep_header = m_need_compression;
  _takeHeader(aHeaderIter, task_header, keep_header);

  TaskType task_type = m_need_compression ? Compression : Save;
  TaskList task_list;
  _getTaskList(task_type, frame_nr, task_header, task_list);
  if (!m_need_compression) {
    m_frame_datas.erase(frame_iter);
    m_ready_flag = false, m_last_frameid_saved = frame_nr;
  }
  aLock.unlock();
  _postTaskList(aData, task_list);
}
/** @brief get the frame header.

    @param frame_nr the frame id
    @param header the current frame header
 */
void CtSaving::getFrameHeader(long frame_nr, HeaderMap& header) const
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(frame_nr);

  AutoMutex aLock(m_cond.mutex());
  FrameHeaderMap::const_iterator i = m_frame_headers.find(frame_nr);
  if(i != m_frame_headers.end())
    header.insert(i->second.begin(),i->second.end());

  DEB_RETURN() << DEB_VAR1(header);
}

/** @brief get the frame header and remove it from the container
 */
void CtSaving::takeFrameHeader(long frame_nr, HeaderMap& header)
{
  DEB_MEMBER_FUNCT();
  DEB_PARAM() << DEB_VAR1(frame_nr);

  AutoMutex aLock(m_cond.mutex());
  FrameHeaderMap::iterator i = m_frame_headers.find(frame_nr);
  if(i != m_frame_headers.end())
    {
      header = i->second;
      m_frame_headers.erase(i);
    }