recorderController.cxx

Go to the documentation of this file.

/**
 * PANDA 3D SOFTWARE
 * Copyright (c) Carnegie Mellon University.  All rights reserved.
 *
 * All use of this software is subject to the terms of the revised BSD
 * license.  You should have received a copy of this license along
 * with this source code in a file named "LICENSE."
 *
 * @file recorderController.cxx
 * @author drose
 * @date 2004-01-24
 */
 
#include "recorderController.h"
#include "recorderFrame.h"
#include "bamReader.h"
#include "bamWriter.h"
#include "config_recorder.h"
#include "bam.h"
#include "clockObject.h"
 
TypeHandle RecorderController::_type_handle;
RecorderController::RecorderFactory *RecorderController::_factory = nullptr;
 
/**
 *
 */
RecorderController::
RecorderController() {
  _clock_offset = 0.0;
  _frame_offset = 0;
  _writer = nullptr;
  _reader = nullptr;
  _frame_tie = true;
  _user_table = new RecorderTable;
  _user_table_modified = false;
  _file_table = nullptr;
  _active_table = nullptr;
  _eof = false;
}
 
/**
 *
 */
RecorderController::
~RecorderController() {
  close();
  delete _user_table;
}
 
/**
 * Begins recording data to the indicated filename.  All of the recorders in
 * use should already have been added.
 */
bool RecorderController::
begin_record(const Filename &filename) {
  close();
  _filename = filename;
  ClockObject *global_clock = ClockObject::get_global_clock();
  _clock_offset = global_clock->get_frame_time();
  _frame_offset = global_clock->get_frame_count();
 
  time(&_header._start_time);
 
  if (!_dout.open(_filename)) {
    recorder_cat.error() << "Unable to open " << _filename << "\n";
    return false;
  }
 
  if (!_dout.write_header(_bam_header)) {
    recorder_cat.error() << "Unable to write to " << _filename << "\n";
    return false;
  }
 
  _writer = new BamWriter(&_dout);
 
  if (!_writer->init()) {
    close();
    return false;
  }
 
  // Write out the header information.
  _writer->write_object(&_header);
 
  _user_table_modified = true;
 
  // Tell all of our recorders that they're live now.
  _user_table->set_flags(RecorderBase::F_recording);
 
  recorder_cat.info()
    << "Recording session to " << _filename << "\n";
 
  return true;
}
 
/**
 * Begins playing back data from the indicated filename.  All of the recorders
 * in use should already have been added, although this may define additional
 * recorders if they are present in the file (these new recorders will not be
 * used).  This may also undefine recorders that were previously added but are
 * not present in the file.
 */
bool RecorderController::
begin_playback(const Filename &filename) {
  close();
  _filename = filename;
  ClockObject *global_clock = ClockObject::get_global_clock();
  _clock_offset = global_clock->get_frame_time();
  _frame_offset = global_clock->get_frame_count();
 
  if (!_din.open(_filename)) {
    recorder_cat.error() << "Unable to open " << _filename << "\n";
    return false;
  }
 
  std::string head;
  if (!_din.read_header(head, _bam_header.size()) || head != _bam_header) {
    recorder_cat.error() << "Unable to read " << _filename << "\n";
    return false;
  }
 
  _reader = new BamReader(&_din);
  if (!_reader->init()) {
    close();
    return false;
  }
 
  _user_table_modified = true;
  _active_table = new RecorderTable;
  _eof = false;
 
  // Start out by reading the RecorderHeader.
  TypedWritable *object = _reader->read_object();
 
  if (object == nullptr ||
      !object->is_of_type(RecorderHeader::get_class_type())) {
    recorder_cat.error()
      << _filename << " does not contain a recorded session.\n";
    close();
    return false;
  }
 
  if (!_reader->resolve()) {
    recorder_cat.warning()
      << "Unable to resolve header data.\n";
  }
 
  RecorderHeader *new_header = DCAST(RecorderHeader, object);
  _header = (*new_header);
  delete new_header;
 
  // Now read the first frame.
  _next_frame = read_frame();
  if (_next_frame == nullptr) {
    recorder_cat.error()
      << _filename << " does not contain any frames.\n";
    close();
    return false;
  }
 
  recorder_cat.info()
    << "Playing back session from " << _filename << "\n";
 
  return true;
}
 
/**
 * Finishes recording data to the indicated filename.
 */
void RecorderController::
close() {
  if (_writer != nullptr) {
    delete _writer;
    _writer = nullptr;
 
    // Tell all of our recorders that they're no longer recording.
    _user_table->clear_flags(RecorderBase::F_recording);
  }
  if (_reader != nullptr) {
    delete _reader;
    _reader = nullptr;
 
    // Tell all of our recorders that they're no longer playing.
    _active_table->clear_flags(RecorderBase::F_playing);
  }
  _dout.close();
  _din.close();
 
  if (_file_table != nullptr) {
    delete _file_table;
    _file_table = nullptr;
  }
 
  if (_active_table != nullptr) {
    delete _active_table;
    _active_table = nullptr;
  }
}
 
/**
 * Gets the next frame of data from all of the active recorders and adds it to
 * the output file.
 */
void RecorderController::
record_frame() {
  if (is_recording()) {
    ClockObject *global_clock = ClockObject::get_global_clock();
    double now = global_clock->get_frame_time() - _clock_offset;
    int frame = global_clock->get_frame_count() - _frame_offset;
 
    RecorderFrame data(now, frame, _user_table_modified, _user_table);
    _user_table_modified = false;
 
    _writer->write_object(&data);
  }
}
 
/**
 * Gets the next frame of data from all of the active recorders and adds it to
 * the output file.
 */
void RecorderController::
play_frame() {
  if (is_playing()) {
    if (_eof) {
      close();
      return;
    }
 
    ClockObject *global_clock = ClockObject::get_global_clock();
    double now = global_clock->get_frame_time() - _clock_offset;
    int frame = global_clock->get_frame_count() - _frame_offset;
 
    while (_next_frame != nullptr) {
      if (_frame_tie) {
        if (frame < _next_frame->_frame) {
          // We haven't reached the next frame yet.
          return;
        }
 
        // Insist that the clock runs at the same rate as it did in the
        // previous session.
        // global_clock->set_frame_time(_next_frame->_timestamp +
        // _clock_offset); global_clock->set_real_time(_next_frame->_timestamp
        // + _clock_offset);
 
        // Hmm, that's crummy.  Just keep the clock offset up-to-date.
        _clock_offset = global_clock->get_frame_time() - _next_frame->_timestamp;
 
      } else {
        if (now < _next_frame->_timestamp) {
          // We haven't reached the next frame yet.
          return;
        }
 
        // Keep our frame_offset up-to-date.
        _frame_offset = global_clock->get_frame_count() - _next_frame->_frame;
      }
 
      if (_next_frame->_table_changed && _file_table != _next_frame->_table) {
        delete _file_table;
        _file_table = _next_frame->_table;
      }
 
      if (_next_frame->_table_changed || _user_table_modified) {
        // We're about to change the active table.  Temporarily disable the
        // playing flag on the currently-active recorders.
        _active_table->clear_flags(RecorderBase::F_playing);
        delete _active_table;
        _active_table = new RecorderTable(*_file_table);
        _active_table->merge_from(*_user_table);
        _user_table_modified = false;
 
        // Now reenable the playing flag on the newly-active recorders.
        _active_table->set_flags(RecorderBase::F_playing);
      }
 
      _next_frame->_table = _active_table;
      _next_frame->play_frame(_reader);
 
      delete _next_frame;
      _next_frame = read_frame();
    }
 
    if (_reader->is_eof()) {
      recorder_cat.info()
        << "End of recorded session.\n";
    } else {
      recorder_cat.error()
        << "Unable to read datagram from recorded session.\n";
    }
    _eof = true;
  }
}
 
 
/**
 * Loads the next frame data from the playback session file.  Returns the
 * frame data pointer on success, or NULL on failure.
 */
RecorderFrame *RecorderController::
read_frame() {
  TypedWritable *object = _reader->read_object();
 
  if (object == nullptr ||
      !object->is_of_type(RecorderFrame::get_class_type())) {
    return nullptr;
  }
 
  if (!_reader->resolve()) {
    recorder_cat.warning()
      << "Unable to resolve frame data.\n";
  }
 
  return DCAST(RecorderFrame, object);
}