StreamPlayer.h

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <vrs/ForwardDefinitions.h>
#include <vrs/Record.h>
#include <vrs/VrsExport.h>
 
namespace vrs {
 
class RecordReader;
 
struct VRS_API CurrentRecord {
  double timestamp;
  StreamId streamId;
  Record::Type recordType;
  uint32_t formatVersion;
  uint32_t recordSize; 
  RecordReader* reader;
  const IndexRecord::RecordInfo* recordInfo;
  RecordFileReader* fileReader;
};
 
class VRS_API StreamPlayer {
 public:
  virtual ~StreamPlayer();
 
  virtual void onAttachedToFileReader(RecordFileReader&, StreamId) {}
 
  virtual bool processRecordHeader(const CurrentRecord& record, DataReference& outDataReference) {
    if (record.recordType == Record::Type::DATA) {
      return processDataHeader(record, outDataReference);
    } else if (record.recordType == Record::Type::CONFIGURATION) {
      return processConfigurationHeader(record, outDataReference);
    } else if (record.recordType == Record::Type::STATE) {
      return processStateHeader(record, outDataReference);
    } else {
      return false;
    }
  }
  virtual void processRecord(const CurrentRecord& record, uint32_t readSize) {
    if (record.recordType == Record::Type::DATA) {
      processData(record, readSize);
    } else if (record.recordType == Record::Type::CONFIGURATION) {
      processConfiguration(record, readSize);
    } else if (record.recordType == Record::Type::STATE) {
      processState(record, readSize);
    }
  }
 
  virtual bool processStateHeader(
      const CurrentRecord& /* record */,
      DataReference& /* outDataReference */) {
    return false;
  }
 
  virtual void processState(const CurrentRecord& /* record */, uint32_t /* bytesWrittenCount */) {}
 
  virtual bool processConfigurationHeader(
      const CurrentRecord& /* record */,
      DataReference& /* outDataReference */) {
    return false;
  }
 
  virtual void processConfiguration(
      const CurrentRecord& /* record */,
      uint32_t /* bytesWrittenCount */) {}
 
  virtual bool processDataHeader(
      const CurrentRecord& /* record */,
      DataReference& /* outDataReference */) {
    return false;
  }
 
  virtual void processData(const CurrentRecord& /* record */, uint32_t /* bytesWrittenCount */) {}
 
  virtual int recordReadComplete(
      RecordFileReader& /*reader*/,
      const IndexRecord::RecordInfo& /*recordInfo*/) {
    return 0;
  }
 
  virtual void flush() {}
};
 
} // namespace vrs