#include <stdio.h>
#include <iostream>
#include <sstream>
#include <map>
#include <a_util/strings.h>
{
});
{
std::string adtf_version("ADTF 3 and higher");
if (ifhd_version < ifhd::v400::version_id)
{
adtf_version = "below ADTF 3";
}
std::cout << std::endl << "File Header" << std::endl;
std::cout << "------------------------------------------------------------------------------" << std::endl;
std::cout <<
"File version : " << reader.
getFileVersion() <<
" - " << adtf_version << std::endl;
auto adtf_file_reader = dynamic_cast<ADTFDatFileReader*>(&reader);
if (adtf_file_reader)
{
std::cout << "Date : " << adtf_file_reader->getDateTime().format("%d.%m.%y - %H:%M:%S") << std::endl;
}
std::cout <<
"Chunk count : " << *reader.
getItemCount() << std::endl;
std::cout <<
"Extension count : " << reader.
getExtensions().size() << std::endl;
std::cout <<
"Stream count : " << reader.
getStreams().size() << std::endl;
std::cout << std::endl << "Streams" << std::endl;
std::cout << "------------------------------------------------------------------------------" << std::endl;
for (const auto& current_stream : streams)
{
auto property_stream_type = std::dynamic_pointer_cast<const PropertyStreamType>(current_stream.initial_type);
if (property_stream_type)
{
std::string stream_meta_type = property_stream_type->getMetaType();
std::cout << "Stream #" << current_stream.stream_id << " : " << current_stream.name << std::endl;
std::cout << " MetaType : " << stream_meta_type << std::endl;
property_stream_type->iterateProperties(
[&](const char* name,
const char* ,
const char* value) -> void
{
std::cout << " " << name << " - " << value << std::endl;
});
}
}
}
class StreamsInfo
{
typedef std::map<uint16_t, std::chrono::nanoseconds> LastTimesMap;
typedef std::map<uint16_t, std::string> StreamNameMap;
public:
{
for (const auto& current_stream : streams)
{
_map_stream_name[current_stream.stream_id] = current_stream.name;
UpdateType(current_stream.stream_id, current_stream.initial_type);
}
}
~StreamsInfo() = default;
std::string GetDiffToLastChunkTime(const uint16_t& stream_id, const std::chrono::nanoseconds& current_time)
{
return GetLastTimeStamp(_map_last_chunk_time, stream_id, current_time);
}
std::string GetDiffToLastSampleStreamTime(const uint16_t& stream_id, const std::chrono::nanoseconds& current_time)
{
return GetLastTimeStamp(_map_last_stream_time, stream_id, current_time);
}
std::string GetStreamName(const uint16_t& stream_id)
{
return _map_stream_name[stream_id];
}
void UpdateType(const uint16_t& stream_id, const std::shared_ptr<const adtf_file::StreamType>& type)
{
auto property_stream_type = std::dynamic_pointer_cast<const adtf_file::PropertyStreamType>(type);
if (property_stream_type)
{
_map_stream_meta_type[stream_id] = property_stream_type->getMetaType();
}
}
std::string GetLastStreamMetaType(const uint16_t& stream_id)
{
return _map_stream_meta_type[stream_id];
}
private:
std::string GetLastTimeStamp(LastTimesMap& map_last_times,
const uint16_t& stream_id,
const std::chrono::nanoseconds& current_time)
{
std::chrono::nanoseconds result(-1);
LastTimesMap::iterator it = map_last_times.find(stream_id);
if (it != map_last_times.end())
{
result = current_time - it->second;
it->second = current_time;
}
else
{
if (current_time.count() != -1)
{
map_last_times[stream_id] = current_time;
}
}
if (result.count() >= 0)
{
return a_util::strings::format("%lld", result.count());
}
else
{
return "";
}
}
LastTimesMap _map_last_chunk_time;
LastTimesMap _map_last_stream_time;
StreamNameMap _map_stream_name;
StreamNameMap _map_stream_meta_type;
};
{
StreamsInfo stream_info(reader);
std::cout << std::endl << "File data" << std::endl;
std::cout << "------------------------------------------------------------------------------" << std::endl;
csv_file.
writeLine(
"stream;stream_name;chunk_type;stream_type;chunk_time;samplestream_time;chunk_time_delta_to_lastofstream;samplestream_time_delta_to_lastofstream");
size_t item_count = 0;
for (;; ++item_count)
{
try
{
std::string chunk_type;
auto type = std::dynamic_pointer_cast<const StreamType>(item.stream_item);
auto data = std::dynamic_pointer_cast<const Sample>(item.stream_item);
auto trigger = std::dynamic_pointer_cast<const Trigger>(item.stream_item);
std::chrono::nanoseconds sample_time(-1);
std::string sample_time_string("");
if (type)
{
chunk_type = "stream_type";
stream_info.UpdateType(item.stream_id,
type);
}
else if (data)
{
chunk_type = "sample";
auto sample_data = std::dynamic_pointer_cast<const DefaultSample>(data);
if (sample_data)
{
sample_time = sample_data->getTimeStamp();
sample_time_string = a_util::strings::format("%lld", sample_time.count());
}
}
else if (trigger)
{
chunk_type = "trigger";
}
csv_file.
writeLine(a_util::strings::format(
"%d;%s;%s;%s;%lld;%s;%s;%s",
static_cast<int>(item.stream_id),
stream_info.GetStreamName(item.stream_id).c_str(),
chunk_type.c_str(),
stream_info.GetLastStreamMetaType(item.stream_id).c_str(),
chunk_time.count(),
sample_time_string.c_str(),
stream_info.GetDiffToLastChunkTime(item.stream_id, chunk_time).c_str(),
stream_info.GetDiffToLastSampleStreamTime(item.stream_id, sample_time).c_str()
));
}
{
break;
}
}
}
{
auto factories = adtf_file::getFactories<adtf_file::ReaderFactories, adtf_file::ReaderFactory>();
factories.add(std::make_shared<adtf_file::ADTFDatFileReaderFactory>());
return factories;
}
std::shared_ptr<adtf_file::Reader> create_reader(const a_util::filesystem::Path& adtfdat_file_path)
{
return get_reader_factories().openReader(adtfdat_file_path);
}
int main(int argc, char* argv[])
{
if (argc < 3 || argv[1] == NULL || argv[2] == NULL)
{
std::cerr << "usage: " << argv[0] << " <adtfdat> <csv> [<adtffileplugin> ...]" << std::endl;
return -1;
}
a_util::filesystem::Path adtfdat_file = argv[1];
a_util::filesystem::Path csv_file = argv[2];
try
{
if (("adtfdat" != adtfdat_file.getExtension())
&& ("dat" != adtfdat_file.getExtension()))
{
throw std::runtime_error(adtfdat_file + " is not valid, please use .adtfdat (ADTF 3.x) or .dat (ADTF 2.x).");
}
if ("csv" != csv_file.getExtension())
{
throw std::runtime_error(csv_file + " is not valid, please use .csv for sample data export.");
}
for (int i = 3; i < argc; i++)
{
a_util::filesystem::Path adtffileplugin = argv[i];
if ("adtffileplugin" == adtffileplugin.getExtension())
{
}
}
auto reader = create_reader(adtfdat_file);
query_file_info(*reader);
access_file_data(*reader, csv_file);
}
catch (const std::exception& ex)
{
std::cerr << ex.what() << std::endl;
return -2;
}
return 0;
}
std::chrono::nanoseconds time_stamp
time stamp of the file item
Definition: reader.h:161
container for objects. this object container can be retrieved as objects singleton of the library via...
Definition: object.h:43
Plugin initializer class to use within a ADTF File Library plugin.
Definition: object.h:104
virtual std::string getDescription() const
Definition: reader.h:219
virtual uint32_t getFileVersion() const
Definition: reader.h:211
virtual std::optional< uint64_t > getItemCount() const
Get the Item Count. This gets the overall count of all items (samples, stream types and triggers) of ...
Definition: reader.h:248
virtual std::vector< Stream > getStreams() const
Get the Streams.
Definition: reader.h:237
virtual std::vector< Extension > getExtensions() const
Get the Extensions if any.
Definition: reader.h:228
virtual FileItem getNextItem()=0
void writeLine(const std::string &string)
void open(const a_util::filesystem::Path &filename, uint32_t mode)
@ om_write
Definition: file.h:133
@ om_append
Append data to existing file. Sets seeking position to the end of the file stream.
Definition: file.h:136
namespace for ADTF File library
Definition: adtf2_adtf_core_media_sample_deserializer.h:25
std::string getLongDescription(const std::string &description)
helper fuction to retrieve long description out of description
Definition: adtf_file_reader.h:400
void loadPlugin(const std::string &file_name)
Loads a ADTF File Library plugin.
void add_standard_objects()
Adds all default implementation objects provided by the ADTF File Library.
Definition: standard_factories.h:130
std::string getShortDescription(const std::string &description)
helper fuction to retrieve short description out of description
Definition: adtf_file_reader.h:390
utils5ext::exceptions::EndOfFile EndOfFile
Exception to indicate the end of file was reached.
Definition: indexedfile_types.h:114