diff --git a/six/modules/c++/cphd/include/cphd/CPHDWriter.h b/six/modules/c++/cphd/include/cphd/CPHDWriter.h index 49988b826..49aef9d77 100644 --- a/six/modules/c++/cphd/include/cphd/CPHDWriter.h +++ b/six/modules/c++/cphd/include/cphd/CPHDWriter.h @@ -28,6 +28,9 @@ #include #include #include +#include +#include +#include #include #include @@ -74,6 +77,12 @@ struct CPHDWriter final * that may be used if byte swapping is necessary. * Default is 4 MB */ + CPHDWriter( + const Metadata& metadata, + io::SeekableOutputStream& stream, + const std::vector* pSchemaPaths = nullptr, + size_t numThreads = 0, + size_t scratchSpaceSize = 4 * 1024 * 1024); CPHDWriter( const Metadata& metadata, std::shared_ptr stream, @@ -106,6 +115,12 @@ struct CPHDWriter final const std::vector& schemaPaths = std::vector(), size_t numThreads = 0, size_t scratchSpaceSize = 4 * 1024 * 1024); + CPHDWriter( + const Metadata& metadata, + const std::filesystem::path& pathname, + const std::vector* pSchemaPaths = nullptr, + size_t numThreads = 0, + size_t scratchSpaceSize = 4 * 1024 * 1024); CPHDWriter() = delete; CPHDWriter(const CPHDWriter&) = delete; @@ -114,6 +129,9 @@ struct CPHDWriter final CPHDWriter& operator=(CPHDWriter&&) = delete; ~CPHDWriter() = default; + std::unique_ptr make_DataWriter(io::OutputStream&) const; + std::unique_ptr make_DataWriter() const; + /* * \func write * \brief Writes the complete CPHD into the file. @@ -129,14 +147,27 @@ struct CPHDWriter final * \param supportData (Optional) The support array data to write to disk. */ template - void write(const PVPBlock& pvpBlock, const T* widebandData, + void write(io::SeekableOutputStream&, const PVPBlock& pvpBlock, const T* widebandData, std::span supportData); template + void write(const PVPBlock& pvpBlock, const T* widebandData, + std::span supportData) + { + write(mStream, pvpBlock, widebandData, supportData); + } + template void write(const PVPBlock& pvpBlock, const T* widebandData) { write(pvpBlock, widebandData, std::span()); } + template + size_t writeChannel(DataWriter&, const T* widebandData, size_t); + template + void writeChannels(DataWriter&, const T* widebandData); + + + /* * \func writeMetadata * \brief Writes the header, and metadata into the file. @@ -146,7 +177,13 @@ struct CPHDWriter final * * \param pvpBlock The vector based metadata to write. */ - void writeMetadata(const PVPBlock& pvpBlock); + void writeMetadata(io::OutputStream&, const PVPBlock& pvpBlock); + void writeMetadata(const PVPBlock& pvpBlock) + { + writeMetadata(mStream, pvpBlock); + } + void getMetadata(const PVPBlock&, size_t& supportSize, /*Optional*/ size_t& pvpSize, size_t& cphdSize) const; + /* * \func writeSupportData @@ -159,12 +196,17 @@ struct CPHDWriter final * \param id The unique identifier of the support array */ template - void writeSupportData(const T* data_, - const std::string& id) + void writeSupportData(io::OutputStream& stream, + const T* data_, const std::string& id) { const auto size = mMetadata.data.getSupportArrayById(id).size_bytes(); - const auto data = sys::make_span(data_, size); - writeSupportDataImpl(data, mMetadata.data.getSupportArrayById(id).bytesPerElement); + const auto data = sys::make_span(data_, size); + writeSupportDataImpl(stream, data, mMetadata.data.getSupportArrayById(id).bytesPerElement); + } + template + void writeSupportData(const T* data, const std::string& id) + { + writeSupportData(mStream, data, id); } /* @@ -175,16 +217,28 @@ struct CPHDWriter final * * \param data A pointer to the start of the support array data block */ - void writeSupportData(std::span); + void writeSupportData(io::SeekableOutputStream&, std::span); + + template + void writeSupportData(io::SeekableOutputStream& stream, std::span data) + { + writeSupportData(stream, std::as_bytes(data)); + } template void writeSupportData(std::span data) { - writeSupportData(std::as_bytes(data)); + writeSupportData(mStream, data); + } + + template + void writeSupportData(io::SeekableOutputStream& stream, const std::vector& data) + { + writeSupportData(stream, sys::make_span(data)); } template void writeSupportData(const std::vector& data) { - writeSupportData(sys::make_span(data)); + writeSupportData(mStream, data); } /* @@ -194,7 +248,13 @@ struct CPHDWriter final * \param PVPBlock A populated PVPBlock object that will be written * to the file as a block of data */ - void writePVPData(const PVPBlock& PVPBlock); + void writePVPData(io::SeekableOutputStream&, const PVPBlock&); + void writePVPData(const PVPBlock& pvpBlock) + { + writePVPData(mStream, pvpBlock); + } + static void writePvpPadBytes(io::OutputStream& stream, int64_t pvpPadBytes); + static void writePVPData(DataWriter& dataWriter, const cphd::Data&, const PVPBlock&); /* * \func writeCPHDData @@ -214,53 +274,49 @@ struct CPHDWriter final * \param channel For selecting channel of compressed signal block */ template - void writeCPHDData(const T* data, + void writeCPHDData(DataWriter&, + const T* data, + size_t numElements, + size_t channel = 1); + template + void writeCPHDData(io::SeekableOutputStream&, + const T* data, size_t numElements, size_t channel = 1); - - void close() + template + void writeCPHDData(const T* data, + size_t numElements, + size_t channel = 1) { - mStream->close(); + writeCPHDData(mStream, data, numElements, channel); } + std::shared_ptr getStream() const + { + return mSharedStream; + } + io::SeekableOutputStream& stream() const { return mStream; } + void close() + { + stream().close(); + } private: /* * Write metadata helper */ - void writeMetadata( + void writeMetadata(io::OutputStream&, size_t supportSize, // Optional size_t pvpSize, size_t cphdSize); - /* - * Write pvp helper - */ - void writePVPData(const std::byte* pvpBlock, - size_t index); - - /* - * Implementation of write wideband - */ - void writeCPHDDataImpl(const std::byte* data, - size_t size); - - /* - * Implementation of write compressed wideband - */ - void writeCompressedCPHDDataImpl(const std::byte* data, - size_t channel); - /* * Implementation of write support data */ - void writeSupportDataImpl(std::span, size_t elementSize); - - //! DataWriter object - std::unique_ptr mDataWriter; + void writeSupportDataImpl(io::OutputStream&, std::span, size_t elementSize); // Book-keeping element //! metadata information @@ -272,9 +328,11 @@ struct CPHDWriter final //! number of threads for parallelism const size_t mNumThreads; //! schemas for XML validation - const std::vector mSchemaPaths; + const std::vector mSchemaPaths; + const std::vector* mpSchemaPaths = nullptr; //! Output stream contains CPHD file - std::shared_ptr mStream; + std::shared_ptr mSharedStream; + io::SeekableOutputStream& mStream; //! header information FileHeader mHeader; }; diff --git a/six/modules/c++/cphd/source/CPHDWriter.cpp b/six/modules/c++/cphd/source/CPHDWriter.cpp index 9d649c18f..403e74750 100644 --- a/six/modules/c++/cphd/source/CPHDWriter.cpp +++ b/six/modules/c++/cphd/source/CPHDWriter.cpp @@ -23,7 +23,7 @@ #include #include -#include +#include #include @@ -46,6 +46,28 @@ static Version getVersion(const Metadata& metadata) return retval; } +CPHDWriter::CPHDWriter(const Metadata& metadata, + io::SeekableOutputStream& outStream, + const std::vector* pSchemaPaths, + size_t numThreads, + size_t scratchSpaceSize) : + mMetadata(metadata), + mElementSize(metadata.data.getNumBytesPerSample()), + mScratchSpaceSize(scratchSpaceSize), + mNumThreads(numThreads), + mpSchemaPaths(pSchemaPaths), + mStream(outStream), + mHeader(getVersion(metadata)) +{ +} + +static auto transform(const std::vector& schemaPaths) +{ + std::vector retval; + std::transform(schemaPaths.begin(), schemaPaths.end(), std::back_inserter(retval), + [](const std::string& s) { return s; }); + return retval; +} CPHDWriter::CPHDWriter(const Metadata& metadata, std::shared_ptr outStream, const std::vector& schemaPaths, @@ -55,13 +77,12 @@ CPHDWriter::CPHDWriter(const Metadata& metadata, mElementSize(metadata.data.getNumBytesPerSample()), mScratchSpaceSize(scratchSpaceSize), mNumThreads(numThreads), - mSchemaPaths(schemaPaths), - mStream(outStream), + mSchemaPaths(transform(schemaPaths)), + mpSchemaPaths(&mSchemaPaths), + mSharedStream(outStream), + mStream(*mSharedStream), mHeader(getVersion(metadata)) { - // Get the correct dataWriter. - // The CPHD file needs to be big endian. - mDataWriter = make_DataWriter(*mStream, mNumThreads, mScratchSpaceSize); } CPHDWriter::CPHDWriter(const Metadata& metadata, @@ -76,60 +97,64 @@ CPHDWriter::CPHDWriter(const Metadata& metadata, scratchSpaceSize) { } - -void CPHDWriter::writeMetadata(size_t supportSize, - size_t pvpSize, - size_t cphdSize) +CPHDWriter::CPHDWriter(const Metadata& metadata, + const std::filesystem::path& pathname, + const std::vector* pSchemaPaths, + size_t numThreads, + size_t scratchSpaceSize) : + mMetadata(metadata), + mElementSize(metadata.data.getNumBytesPerSample()), + mScratchSpaceSize(scratchSpaceSize), + mNumThreads(numThreads), + mpSchemaPaths(pSchemaPaths), + mSharedStream(std::make_shared(pathname)), // Initialize output stream + mStream(*mSharedStream), + mHeader(getVersion(metadata)) { - const auto xmlMetadata(CPHDXMLControl().toXMLString(mMetadata, mSchemaPaths)); +} +void CPHDWriter::writeMetadata(io::OutputStream& stream, + size_t supportSize, size_t pvpSize, size_t cphdSize) +{ mHeader.setVersion(getVersion(mMetadata)); // update classification and release info - if (!six::Init::isUndefined( - mMetadata.collectionID.getClassificationLevel()) && - !six::Init::isUndefined(mMetadata.collectionID.releaseInfo)) + auto&& collectionID = mMetadata.collectionID; + if (!six::Init::isUndefined(collectionID.getClassificationLevel()) && !six::Init::isUndefined(collectionID.releaseInfo)) { - mHeader.setClassification( - mMetadata.collectionID.getClassificationLevel()); - mHeader.setReleaseInfo(mMetadata.collectionID.releaseInfo); + mHeader.setClassification(collectionID.getClassificationLevel()); + mHeader.setReleaseInfo(collectionID.releaseInfo); } else { - throw except::Exception(Ctxt("Classification level and Release " - "informaion must be specified")); + throw except::Exception(Ctxt("Classification level and Release informaion must be specified")); } + + const auto xmlMetadata(CPHDXMLControl().toXMLString(mMetadata, mpSchemaPaths)); + // set header size, final step before write mHeader.set(xmlMetadata.size(), supportSize, pvpSize, cphdSize); - mStream->write(mHeader.toString()); - mStream->write("\f\n"); - mStream->write(xmlMetadata); - mStream->write("\f\n"); + stream.write(mHeader.toString()); + stream.write("\f\n"); + stream.write(xmlMetadata); + stream.write("\f\n"); } -void CPHDWriter::writePVPData(const std::byte* pvpBlock, size_t channel) +std::unique_ptr CPHDWriter::make_DataWriter(io::OutputStream& stream) const { - const size_t size = (mMetadata.data.getNumVectors(channel) * - mMetadata.data.getNumBytesPVPSet()) / - 8; - - //! The vector based parameters are always 64 bit - (*mDataWriter)(pvpBlock, size, 8); + // Get the correct dataWriter. + // The CPHD file needs to be big endian. + return cphd::make_DataWriter(stream, mNumThreads, mScratchSpaceSize); } - -void CPHDWriter::writeCPHDDataImpl(const std::byte* data, size_t size) +std::unique_ptr CPHDWriter::make_DataWriter() const { - //! We have to pass in the data as though it was not complex - // thus we pass in twice the number of elements at half the size. - (*mDataWriter)(data, size * 2, mElementSize / 2); + return make_DataWriter(mStream); } -void CPHDWriter::writeCompressedCPHDDataImpl(const std::byte* data, - size_t channel) +void CPHDWriter::writeSupportDataImpl(io::OutputStream& stream, std::span data, size_t elementSize) { - //! We have to pass in the data as though it was 1 signal array sized - // element of ubytes - (*mDataWriter)(data, mMetadata.data.getCompressedSignalSize(channel), 1); + auto dataWriter = make_DataWriter(stream); + (*dataWriter)(data, elementSize); } static auto make_span(std::span data, const cphd::Data::SupportArray& dataArray) @@ -137,116 +162,148 @@ static auto make_span(std::span data, const cphd::Data::Support const auto pData = data.data() + dataArray.arrayByteOffset; return sys::make_span(pData, dataArray.size_bytes()); } - -void CPHDWriter::writeSupportDataImpl(std::span data, size_t elementSize) -{ - (*mDataWriter)(data, elementSize); -} -void CPHDWriter::writeSupportData(std::span data) +void CPHDWriter::writeSupportData(io::SeekableOutputStream& stream, std::span data) { + const auto supportBlockByteOffset = mHeader.getSupportBlockByteOffset(); + + auto dataWriter = make_DataWriter(stream); for (auto&& mapEntry : mMetadata.data.supportArrayMap) { auto&& dataArray = mapEntry.second; // Move inputstream head to offset of particular support array - mStream->seek(mHeader.getSupportBlockByteOffset() + dataArray.arrayByteOffset, io::SeekableOutputStream::START); - writeSupportDataImpl(make_span(data, dataArray), dataArray.bytesPerElement); + stream.seek(supportBlockByteOffset + dataArray.arrayByteOffset, io::SeekableOutputStream::START); + + (*dataWriter)(make_span(data, dataArray), dataArray.bytesPerElement); } // Move inputstream head to the end of the support block after all supports have been written - mStream->seek(mHeader.getSupportBlockByteOffset() + mHeader.getSupportBlockSize(), io::SeekableOutputStream::START); + stream.seek(supportBlockByteOffset + mHeader.getSupportBlockSize(), io::SeekableOutputStream::START); } +template +size_t CPHDWriter::writeChannel(DataWriter& dataWriter, const T* widebandData, size_t channel) +{ + auto&& data = mMetadata.data; + + const size_t numElements = data.getNumVectors(channel) * data.getNumSamples(channel); + // writeCPHDData handles compressed data as well + writeCPHDData(dataWriter, widebandData, numElements, channel); + return numElements; +} template -void CPHDWriter::write(const PVPBlock& pvpBlock, +void CPHDWriter::writeChannels(DataWriter& dataWriter, const T* widebandData) +{ + // Doesn't require pading because pvp block is always 8 bytes words + // Write wideband (or signal) block + size_t elementsWritten = 0; // Used to increment widebandData pointer + for (size_t ii = 0; ii < mMetadata.data.getNumChannels(); ++ii) + { + elementsWritten += writeChannel(dataWriter, widebandData + elementsWritten, ii); + } +} + +template +void CPHDWriter::write(io::SeekableOutputStream& stream, + const PVPBlock& pvpBlock, const T* widebandData, std::span supportData) { + // Throw exception right away ... before writing anything. + if (mMetadata.data.getNumSupportArrays() != 0) + { + if (supportData.empty()) + { + throw except::Exception(Ctxt("SupportData is not provided")); + } + } + // Write File header and metadata to file // Padding is added in writeMetadata - writeMetadata(pvpBlock); + writeMetadata(stream, pvpBlock); // Write optional support array block // Padding is added in writeSupportData if (mMetadata.data.getNumSupportArrays() != 0) { - if (supportData.empty()) - { - throw except::Exception(Ctxt("SupportData is not provided")); - } writeSupportData(supportData); } // Write pvp data block // Padding is added in writePVPData - writePVPData(pvpBlock); + writePVPData(stream, pvpBlock); - // Doesn't require pading because pvp block is always 8 bytes words - // Write wideband (or signal) block - size_t elementsWritten = 0; // Used to increment widebandData pointer - for (size_t ii = 0; ii < mMetadata.data.getNumChannels(); ++ii) + if (!mMetadata.data.isCompressed()) { - size_t numElements = mMetadata.data.getNumVectors(ii) * - mMetadata.data.getNumSamples(ii); - // writeCPHDData handles compressed data as well - writeCPHDData(widebandData + elementsWritten, numElements, ii); - elementsWritten += numElements; + if (mElementSize != sizeof(T)) + { + throw except::Exception(Ctxt("Incorrect buffer data type used for metadata!")); + } } + auto dataWriter = make_DataWriter(stream); + writeChannels(*dataWriter, widebandData); } -template void CPHDWriter::write(const PVPBlock&, const std::byte* widebandData, std::span); // For compressed data -template void CPHDWriter::write(const PVPBlock&, const cphd::zint8_t* widebandData, std::span); -template void CPHDWriter::write(const PVPBlock&, const cphd::zint16_t* widebandData, std::span); -template void CPHDWriter::write(const PVPBlock&, const cphd::zfloat* widebandData, std::span); -//template void CPHDWriter::write(const PVPBlock&, const cphd::zint8_t* widebandData, std::span); -//template void CPHDWriter::write(const PVPBlock&, const cphd::zint16_t* widebandData, std::span); -//template void CPHDWriter::write(const PVPBlock&, const cphd::zfloat* widebandData, std::span); - -void CPHDWriter::writeMetadata(const PVPBlock& pvpBlock) +template void CPHDWriter::write(io::SeekableOutputStream&, const PVPBlock&, const std::byte* widebandData, std::span); // For compressed data +template void CPHDWriter::write(io::SeekableOutputStream&, const PVPBlock&, const cphd::zint8_t* widebandData, std::span); +template void CPHDWriter::write(io::SeekableOutputStream&, const PVPBlock&, const cphd::zint16_t* widebandData, std::span); +template void CPHDWriter::write(io::SeekableOutputStream&, const PVPBlock&, const cphd::zfloat* widebandData, std::span); +//template void CPHDWriter::write(io::SeekableOutputStream&, const PVPBlock&, const cphd::zint8_t* widebandData, std::span); +//template void CPHDWriter::write(io::SeekableOutputStream&, const PVPBlock&, const cphd::zint16_t* widebandData, std::span); +//template void CPHDWriter::write(io::SeekableOutputStream&, const PVPBlock&, const cphd::zfloat* widebandData, std::span); + +void CPHDWriter::getMetadata(const PVPBlock& pvpBlock, + size_t& totalSupportSize, size_t& totalPVPSize, size_t& totalCPHDSize) const { + auto&& data = mMetadata.data; + // Update the number of bytes per PVP - if (mMetadata.data.numBytesPVP != pvpBlock.getNumBytesPVPSet()) + if (data.numBytesPVP != pvpBlock.getNumBytesPVPSet()) { std::ostringstream ostr; - ostr << "Number of pvp block bytes in metadata: " - << mMetadata.data.numBytesPVP - << " does not match calculated size of pvp block: " - << pvpBlock.getNumBytesPVPSet(); + ostr << "Number of pvp block bytes in metadata: " << data.numBytesPVP + << " does not match calculated size of pvp block: " << pvpBlock.getNumBytesPVPSet(); throw except::Exception(ostr.str()); } - const size_t numChannels = mMetadata.data.getNumChannels(); - size_t totalSupportSize = 0; - size_t totalPVPSize = 0; - size_t totalCPHDSize = 0; + const size_t numChannels = data.getNumChannels(); - for (auto it = mMetadata.data.supportArrayMap.begin(); - it != mMetadata.data.supportArrayMap.end(); - ++it) + totalSupportSize = 0; + for (auto&& kv : data.supportArrayMap) { - totalSupportSize += it->second.getSize(); + totalSupportSize += kv.second.getSize(); } + totalPVPSize = 0; + totalCPHDSize = 0; for (size_t ii = 0; ii < numChannels; ++ii) { totalPVPSize += pvpBlock.getPVPsize(ii); - totalCPHDSize += mMetadata.data.getNumVectors(ii) * - mMetadata.data.getNumSamples(ii) * mElementSize; + totalCPHDSize += data.getNumVectors(ii) * data.getNumSamples(ii) * mElementSize; } - - writeMetadata(totalSupportSize, totalPVPSize, totalCPHDSize); +} +void CPHDWriter::writeMetadata(io::OutputStream& stream, const PVPBlock& pvpBlock) +{ + size_t totalSupportSize; + size_t totalPVPSize; + size_t totalCPHDSize; + getMetadata(pvpBlock, totalSupportSize, totalPVPSize, totalCPHDSize); + writeMetadata(stream, totalSupportSize, totalPVPSize, totalCPHDSize); } -void CPHDWriter::writePVPData(const PVPBlock& pvpBlock) +void CPHDWriter::writePvpPadBytes(io::OutputStream& stream, int64_t pvpPadBytes) { // Add padding char zero = 0; - for (int64_t ii = 0; ii < mHeader.getPvpPadBytes(); ++ii) + for (int64_t ii = 0; ii < pvpPadBytes; ++ii) { - mStream->write(&zero, 1); + stream.write(&zero, 1); } +} +void CPHDWriter::writePVPData(DataWriter& dataWriter, const cphd::Data& data, const PVPBlock& pvpBlock) +{ // Write each PVP array - const size_t numChannels = mMetadata.data.getNumChannels(); + const size_t numChannels = data.getNumChannels(); std::vector pvpData; for (size_t ii = 0; ii < numChannels; ++ii) { @@ -257,48 +314,75 @@ void CPHDWriter::writePVPData(const PVPBlock& pvpBlock) ostr << "PVPBlock of channel " << ii << " is empty"; throw except::Exception(Ctxt(ostr.str())); } - writePVPData(pvpData.data(), ii); + + const size_t size = (data.getNumVectors(ii) * data.getNumBytesPVPSet()) / 8; + + //! The vector based parameters are always 64 bit + dataWriter(pvpData.data(), size, 8); } } +void CPHDWriter::writePVPData(io::SeekableOutputStream& stream, const PVPBlock& pvpBlock) +{ + // Add padding + writePvpPadBytes(stream, mHeader.getPvpPadBytes()); + + auto dataWriter = make_DataWriter(stream); + writePVPData(*dataWriter, mMetadata.data, pvpBlock); +} template -void CPHDWriter::writeCPHDData(const T* data, - size_t numElements, - size_t channel) +void CPHDWriter::writeCPHDData(DataWriter& dataWriter, + const T* data_, + size_t numElements, + size_t channel) { - const void* const pData = data; + const void* const pData = data_; + const std::byte* const data = static_cast(pData); + if (mMetadata.data.isCompressed()) { - writeCompressedCPHDDataImpl(static_cast(pData), channel); + //! We have to pass in the data as though it was 1 signal array sized + // element of ubytes + dataWriter(data, mMetadata.data.getCompressedSignalSize(channel), 1); } else + { + //! We have to pass in the data as though it was not complex + // thus we pass in twice the number of elements at half the size. + dataWriter(data, numElements * 2, mElementSize / 2); + } +} + +template +void CPHDWriter::writeCPHDData(io::SeekableOutputStream& stream, + const T* data, + size_t numElements, + size_t channel) +{ + if (!mMetadata.data.isCompressed()) { if (mElementSize != sizeof(T)) { throw except::Exception(Ctxt("Incorrect buffer data type used for metadata!")); } - writeCPHDDataImpl(static_cast(pData), numElements); } + auto dataWriter = make_DataWriter(stream); + writeCPHDData(*dataWriter, data, numElements, channel); } -// For compressed data -template void CPHDWriter::writeCPHDData(const sys::ubyte* data, - size_t numElements, - size_t channel); -template void CPHDWriter::writeCPHDData(const std::byte* data, - size_t numElements, - size_t channel); - -template void CPHDWriter::writeCPHDData( - const cphd::zint8_t* data, - size_t numElements, - size_t channel); - -template void CPHDWriter::writeCPHDData( - const cphd::zint16_t* data, - size_t numElements, - size_t channel); - -template void CPHDWriter::writeCPHDData( - const cphd::zfloat* data, size_t numElements, size_t channel); +template void CPHDWriter::writeCPHDData(io::SeekableOutputStream&, + const sys::ubyte* data, // For compressed data + size_t numElements, size_t channel); +template void CPHDWriter::writeCPHDData(io::SeekableOutputStream&, + const std::byte* data, + size_t numElements, size_t channel); +template void CPHDWriter::writeCPHDData(io::SeekableOutputStream&, + const cphd::zint8_t* data, + size_t numElements, size_t channel); +template void CPHDWriter::writeCPHDData(io::SeekableOutputStream&, + const cphd::zint16_t* data, + size_t numElements, size_t channel); +template void CPHDWriter::writeCPHDData(io::SeekableOutputStream&, + const cphd::zfloat* data, + size_t numElements, size_t channel); } diff --git a/six/modules/c++/cphd/unittests/test_compressed_signal_block_round.cpp b/six/modules/c++/cphd/unittests/test_compressed_signal_block_round.cpp index b897bd57d..b55216334 100644 --- a/six/modules/c++/cphd/unittests/test_compressed_signal_block_round.cpp +++ b/six/modules/c++/cphd/unittests/test_compressed_signal_block_round.cpp @@ -76,7 +76,7 @@ void writeCompressedCPHD(const std::string& outPathname, size_t numThreads, } } - cphd::CPHDWriter writer(metadata, outPathname, std::vector(), numThreads); + cphd::CPHDWriter writer(metadata, outPathname, nullptr /*pSchemaPaths*/, numThreads); writer.writeMetadata(pvpBlock); diff --git a/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp b/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp index 2a7673b76..51d5bd975 100644 --- a/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp +++ b/six/modules/c++/cphd/unittests/test_pvp_block_round.cpp @@ -128,7 +128,7 @@ void writeCPHD(const std::string& outPathname, cphd::CPHDWriter writer(metadata, outPathname, - std::vector(), + nullptr /*pSchemaPaths*/, numThreads); writer.writeMetadata(pvpBlock); writer.writePVPData(pvpBlock); diff --git a/six/modules/c++/cphd/unittests/test_support_block_round.cpp b/six/modules/c++/cphd/unittests/test_support_block_round.cpp index 9dbb37eec..36899ec5e 100644 --- a/six/modules/c++/cphd/unittests/test_support_block_round.cpp +++ b/six/modules/c++/cphd/unittests/test_support_block_round.cpp @@ -84,7 +84,7 @@ void writeSupportData(const std::string& outPathname, size_t numThreads, cphd::setVectorParameters(ii, jj, pvpBlock); } } - cphd::CPHDWriter writer(metadata, outPathname, std::vector(), numThreads); + cphd::CPHDWriter writer(metadata, outPathname, nullptr /*pSchemaPaths*/, numThreads); writer.writeMetadata(pvpBlock); writer.writeSupportData(writeData); writer.writePVPData(pvpBlock);