42 namespace ALEMBIC_VERSION_NS {
44 class IStreams::PrivateData
63 if (!fileName.empty())
65 std::vector<std::istream *>::iterator it;
66 for (it = streams.begin(); it != streams.end(); ++it)
68 std::ifstream * filestream =
dynamic_cast<std::ifstream *
>(*it);
78 std::vector<std::istream *> streams;
79 std::vector<Alembic::Util::uint64_t> offsets;
80 Alembic::Util::mutex * locks;
84 Alembic::Util::uint16_t version;
87 IStreams::IStreams(
const std::string & iFileName, std::size_t iNumStreams) :
88 mData(new IStreams::PrivateData())
91 std::ifstream * filestream =
new std::ifstream;
92 filestream->open(iFileName.c_str(), std::ios::binary);
94 if (filestream->is_open())
96 mData->fileName = iFileName;
104 mData->streams.push_back(filestream);
106 if (!mData->valid || mData->version != 1)
108 mData->streams.clear();
115 mData->streams.resize(iNumStreams, NULL);
116 mData->offsets.resize(iNumStreams, 0);
118 mData->locks =
new Alembic::Util::mutex[mData->streams.size()];
121 IStreams::IStreams(
const std::vector< std::istream * > & iStreams) :
122 mData(new IStreams::PrivateData())
124 mData->streams = iStreams;
126 if (!mData->valid || mData->version != 1)
128 mData->streams.clear();
132 mData->locks =
new Alembic::Util::mutex[mData->streams.size()];
135 void IStreams::init()
147 throw std::runtime_error(
148 "Ogawa currently only supports little-endian reading.");
151 if (mData->streams.empty())
156 Alembic::Util::uint64_t firstGroupPos = 0;
158 for (std::size_t i = 0; i < mData->streams.size(); ++i)
160 char header[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
161 mData->offsets.push_back(mData->streams[i]->tellg());
162 mData->streams[i]->read(header, 16);
163 std::string magicStr(header, 5);
164 if (magicStr !=
"Ogawa")
166 mData->frozen =
false;
167 mData->valid =
false;
171 bool frozen = (header[5] == char(0xff));
172 Alembic::Util::uint16_t version = (header[6] << 8) | header[7];
173 Alembic::Util::uint64_t groupPos =
174 *((Alembic::Util::uint64_t *)(&(header[8])));
178 firstGroupPos = groupPos;
179 mData->frozen = frozen;
180 mData->version = version;
183 else if (firstGroupPos != groupPos || mData->frozen != frozen ||
184 mData->version != version)
186 mData->frozen =
false;
187 mData->valid =
false;
195 IStreams::~IStreams()
199 bool IStreams::isValid()
204 bool IStreams::isFrozen()
206 return mData->frozen;
209 Alembic::Util::uint16_t IStreams::getVersion()
211 return mData->version;
214 void IStreams::read(std::size_t iThreadId, Alembic::Util::uint64_t iPos,
215 Alembic::Util::uint64_t iSize,
void * oBuf)
222 std::size_t threadId = 0;
223 if (iThreadId < mData->streams.size())
225 threadId = iThreadId;
229 Alembic::Util::scoped_lock l(mData->locks[threadId]);
230 std::istream * stream = mData->streams[threadId];
233 if (stream == NULL && !mData->fileName.empty())
235 std::ifstream * filestream =
new std::ifstream;
236 filestream->open(mData->fileName.c_str(), std::ios::binary);
238 if (filestream->is_open())
241 mData->streams[threadId] = filestream;
242 mData->offsets[threadId] = filestream->tellg();
252 read(0, iPos, iSize, oBuf);
257 stream->seekg(iPos + mData->offsets[threadId]);
258 stream->read((
char *)oBuf, iSize);