C++ DataStreamPtr::size方法代码示例

//----------------------------------------------------------------------------//
int OggBuffer::vorbisSeek(void *datasource, ogg_int64_t offset, int whence)
{
	size_t				spaceToEOF;
	ogg_int64_t			actualOffset;
	Ogre::DataStreamPtr	vorbisData;

	vorbisData = *(Ogre::DataStreamPtr*)datasource;

	switch (whence)
	{
	case SEEK_SET:
		if (vorbisData->size() >= offset)
			actualOffset = offset;
		else
			actualOffset = vorbisData->size();
		vorbisData->seek((int)actualOffset);
		break;
	case SEEK_CUR:
		spaceToEOF = vorbisData->size() - vorbisData->tell();
		if (offset < spaceToEOF)
			actualOffset = (offset);
		else
			actualOffset = spaceToEOF;	
		vorbisData->seek( static_cast<size_t>(vorbisData->tell() + actualOffset));
		break;
	case SEEK_END:
		vorbisData->seek(vorbisData->size());
		break;
	default:
		SoundSystem::getSingleton().logMessage("*** ERROR *** Unknown seek command in VorbisSeek");
		break;
	};

	return 0;
}

// OgreScriptBuilder
int OgreScriptBuilder::LoadScriptSection(const char* full_path_cstr)
{
    // Get filename - required to retrieve file from OGRe's resource system.
    //  This function received filename in older AngelScript versions, but now receives full path
    //      (reconstructed wrong by CScriptBuilder because it doesn't know about OGRE's ZIP files).
    //  TODO: Refactor the entire script building logic 
    //      - create fully RoR-custom builder instead of hacked stock CScriptBuilder + our overload. ~ only_a_ptr, 08/2017

    std::string full_path(full_path_cstr);
    std::string filename;
    size_t slash_pos = full_path.rfind('/'); // AngelScript always uses forward slashes in paths.
    if (slash_pos != std::string::npos)
    {
        filename = full_path.substr(slash_pos+1);
    }
    else
    {
        filename = full_path;
    }

    Ogre::DataStreamPtr ds;
    try
    {
        ds = Ogre::ResourceGroupManager::getSingleton().openResource(filename, Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME);
                 //TODO: do not use `AUTODETECT_RESOURCE_GROUP_NAME`, use specific group, lookups are slow!
                 //see also https://github.com/OGRECave/ogre/blob/master/Docs/1.10-Notes.md#resourcemanager-strict-mode ~ only_a_ptr, 08/2017
    }
    catch (Ogre::Exception e)
    {
        LOG("[RoR|Scripting] exception upon loading script file '"+filename+"', message: " + e.getFullDescription());
        return -1;
    }
    // In some cases (i.e. when fed a full path with '/'-s on Windows), `openResource()` will silently return NULL for datastream. ~ only_a_ptr, 08/2017
    if (ds.isNull())
    {
        LOG("[RoR|Scripting] Failed to load file '"+filename+"', reason unknown.");
        return -1;
    }

    // Read the entire file
    std::string code;
    code.resize(ds->size());
    ds->read(&code[0], ds->size());

    // hash it
    {
        char hash_result[250];
        memset(hash_result, 0, 249);
        RoR::CSHA1 sha1;
        sha1.UpdateHash((uint8_t *)code.c_str(), (uint32_t)code.size());
        sha1.Final();
        sha1.ReportHash(hash_result, RoR::CSHA1::REPORT_HEX_SHORT);
        hash = Ogre::String(hash_result);
    }

    return ProcessScriptSection(code.c_str(), code.length(), filename.c_str(), 0);
}

    void GlobalMap::write(ESM::GlobalMap& map)
    {
        map.mBounds.mMinX = mMinX;
        map.mBounds.mMaxX = mMaxX;
        map.mBounds.mMinY = mMinY;
        map.mBounds.mMaxY = mMaxY;

        Ogre::DataStreamPtr encoded = mOverlayImage.encode("png");
        map.mImageData.resize(encoded->size());
        encoded->read(&map.mImageData[0], encoded->size());
    }

/*void TestStream()
{
	//String fname( "../../media/packs/chiropteraDM.txt");
	std::ifstream* roStream = new std::ifstream;
	roStream ->open	("../../media/packs/chiropteraDM.txt", std::ios::in | std::ios::binary);
	//fptr =  new FileStreamDataStream("tt", roStream, true);
	//fstrm = DataStreamPtr(fptr);
	DataStreamPtr ss = DataStreamPtr(new LodDataStream( Ogre::SharedPtr<std::ifstream>(roStream),	0x203,500));
	std::cout <<  ss -> size() << endl;
	while(!ss->eof())
	{
		cout << ss->getLine(false) << endl;
	}
	cout << 
		ss->getAsString() 
		<< endl;
}*/
void SaveStreamToFile(const Ogre::String& fname, Ogre::DataStreamPtr data)
{
	char*buff = new char[data->size()];
	std::ios::openmode mode = std::ios::binary | std::ios::out;
	std::ofstream rwStream;
	data->read(buff,data->size());
	rwStream.open(fname, mode);
	rwStream.write(buff,data->size());
	rwStream.close();
	delete[] buff;
	std::cout << "Saved: " << fname << " size: "<<data->size() << std::endl;
}

/*
void TextureAsset::RegenerateAllMipLevels()
{
    if (ogreTexture.isNull())
        return;

///\todo This function does not quite work, since ogreTexture->getNumMipmaps() will return 0 to denote a "full mipmap chain".

    for(int f = 0; f < ogreTexture->getNumFaces(); ++f)
        for(int i = 1; i < ogreTexture->getNumMipmaps(); ++i)
        {
            Ogre::HardwarePixelBufferSharedPtr src = ogreTexture->getBuffer(f, i-1);
            Ogre::Box srcSize(0, 0, src->getWidth(), src->getHeight());
            Ogre::HardwarePixelBufferSharedPtr dst = ogreTexture->getBuffer(f, i);
            Ogre::Box dstSize(0, 0, dst->getWidth(), dst->getHeight());
            dst->blit(src, srcSize, dstSize);
        }
}
*/
bool TextureAsset::SerializeTo(std::vector<u8> &data, const QString &serializationParameters) const
{
    if (ogreTexture.isNull())
    {
        LogWarning("SerializeTo: Called on an unloaded texture \"" + Name().toStdString() + "\".");
        return false;
    }

    try
    {
        Ogre::Image new_image;
                
        // From Ogre 1.7 Texture::convertToImage()
        size_t numMips = 1;
        size_t dataSize = Ogre::Image::calculateSize(numMips,
            ogreTexture->getNumFaces(), ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat());
        void* pixData = OGRE_MALLOC(dataSize, Ogre::MEMCATEGORY_GENERAL);
        // if there are multiple faces and mipmaps we must pack them into the data
        // faces, then mips
        void* currentPixData = pixData;
        for (size_t face = 0; face < ogreTexture->getNumFaces(); ++face)
        {
            for (size_t mip = 0; mip < numMips; ++mip)
            {
                size_t mipDataSize = Ogre::PixelUtil::getMemorySize(ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat());
                Ogre::PixelBox pixBox(ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat(), currentPixData);
                ogreTexture->getBuffer(face, mip)->blitToMemory(pixBox);
                currentPixData = (void*)((char*)currentPixData + mipDataSize);
            }
        }
        // load, and tell Image to delete the memory when it's done.
        new_image.loadDynamicImage((Ogre::uchar*)pixData, ogreTexture->getWidth(), ogreTexture->getHeight(), ogreTexture->getDepth(), ogreTexture->getFormat(), true, 
            ogreTexture->getNumFaces(), numMips - 1);

        Ogre::DataStreamPtr imageStream = new_image.encode(serializationParameters.toStdString());
        if (imageStream.get() && imageStream->size() > 0)
        {
            data.resize(imageStream->size());
            imageStream->read(&data[0], data.size());
        }
    } catch (std::exception &e)
    {
        LogError("SerializeTo: Failed to export Ogre texture " + Name().toStdString() + ":");
        if (e.what())
            OgreRenderer::OgreRenderingModule::LogError(e.what());
        return false;
    }
    return true;
}

    Resource::DataStreamPtr ResourceManager::OpenAssetStream(const String& AssetName, const String& AssetGroup)
    {
        /// @todo This entire method is a bit of a hack.  When the resource system gets refactored it should go through our archives or whatever equivalent.
        /// Since we currently have to put up with Ogre's system, we'll use it for now as a hack.

        NamedDataStreamIterator StreamIt = this->NamedDataStreams.find(AssetName);
        if( StreamIt != this->NamedDataStreams.end() )
            return (*StreamIt).second;

        Ogre::DataStreamPtr OgreStream = this->OgreResource->openResource(AssetName,AssetGroup);
        Char8* AssetBuffer = new Char8[ OgreStream->size() ];
        OgreStream->read( (void*)AssetBuffer, OgreStream->size() );

        return this->CreateDataStream(AssetName,AssetBuffer,OgreStream->size());
    }

bool XMLHelper::Load(TiXmlDocument& xmlDoc, Ogre::DataStreamPtr stream)
{
	size_t length(stream->size());

	if ( length )
	{
		// If we have a file, assume it is all one big XML file, and read it in.
		// The document parser may decide the document ends sooner than the entire file, however.
		std::string data(stream->getAsString());

		xmlDoc.Parse( data.c_str());

		if (xmlDoc.Error() ) {
			std::string errorDesc = xmlDoc.ErrorDesc();
			int errorLine =  xmlDoc.ErrorRow();
			int errorColumn =  xmlDoc.ErrorCol();
			std::stringstream ss;
			ss << "Failed to load xml file '" << stream->getName() << "'! Error at column: " << errorColumn << " line: " << errorLine << ". Error message: " << errorDesc;
			S_LOG_FAILURE(ss.str());
			return false;
		} else {
            return true;
		}
	}
	return false;
}

//----------------------------------------------------------------------------//
size_t OggBuffer::vorbisRead(void *ptr, size_t byteSize, size_t sizeToRead, void *datasource )
{
	size_t				spaceToEOF;			// How much more we can read till we hit the EOF marker
	size_t				actualSizeToRead;	// How much data we are actually going to read from memory
	Ogre::DataStreamPtr	vorbisData;			// Our vorbis data, for the typecast

	// Get the data in the right format
	vorbisData = *(Ogre::DataStreamPtr*)datasource;

	// Calculate how much we need to read.  This can be sizeToRead*byteSize or less depending on how near the EOF marker we are
	spaceToEOF = vorbisData->size() - vorbisData->tell();
	if ((sizeToRead * byteSize) < spaceToEOF)
		actualSizeToRead = (sizeToRead * byteSize);
	else
		actualSizeToRead = spaceToEOF;	
	
	// A simple copy of the data from memory to the datastruct that the vorbis libs will use
	if (actualSizeToRead)
	{
		// Copy the data from the start of the file PLUS how much we have already read in
		vorbisData->read(ptr, actualSizeToRead);
	}

	// Return how much we read (in the same way fread would)
	return actualSizeToRead;
}

	void SnowTerrain::defineTerrain(long x, long y, bool flat)
	{
		if (flat)
		{
			mTerrainGroup->defineTerrain(x, y, 0.0f);
		}
		else
		{
			if(StringUtil::endsWith(mSnowConfig->terrainSettings.heightDataFile, "dat"))
			{
				mTerrainGroup->defineTerrain(x, y, mSnowConfig->terrainSettings.heightDataFile);
				mTerrainGroup->loadTerrain(x,y, true);
			}
			else 
			{
				Image *img = new Image();

				if(StringUtil::endsWith(mSnowConfig->terrainSettings.heightDataFile, "raw"))
				{
					Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().openResource(mSnowConfig->terrainSettings.heightDataFile, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);
					size_t size = stream->size();
					img->loadRawData(stream, mTerrainSize-1, mTerrainSize-1, 1, PixelFormat::PF_FLOAT32_R);

					// height data must be square			
					assert(img->getWidth() == img->getHeight());

					// resize the height data if it's the wrong size
					if(img->getWidth() != mTerrainSize)
						img->resize(mTerrainSize, mTerrainSize);

					//img->flipAroundY();

					//mTerrainGroup->defineTerrain(x, y, (float*)img->getPixelBox().data);
					mTerrainGroup->defineTerrain(x, y, img);
					mTerrainGroup->loadTerrain(x,y, true);

				}
				else if(StringUtil::endsWith(mSnowConfig->terrainSettings.heightDataFile, "png")||StringUtil::endsWith(mSnowConfig->terrainSettings.heightDataFile, "bmp"))
				{
 					img->load(mSnowConfig->terrainSettings.heightDataFile, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME);		

					// height data must be square			
					assert(img->getWidth() == img->getHeight());

					// resize the height data if it's the wrong size
					if(img->getWidth() != mTerrainSize)
						img->resize(mTerrainSize, mTerrainSize);

					mTerrainGroup->defineTerrain(x, y, img);
					mTerrainGroup->loadTerrain(x,y, true);
				}


			}
		
			
			mTerrainsImported = true;
		}
	}

	//loader for ScriptSystem
	std::string
		OgreFileLoader(lua_State* pState, std::string strFile)
	{
		if(!Ogre::ResourceGroupManager::getSingleton().resourceExists(Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, strFile))
			return std::string("file not found");
		Ogre::DataStreamPtr ds = Ogre::ResourceGroupManager::getSingleton().openResource(strFile);
		char *buffer = ICE_NEW char[ds->size()];
		ds->read(buffer, ds->size());
		ds->close();

		if(luaL_loadbuffer(pState, buffer, ds->size(), strFile.c_str()) || lua_pcall(pState, 0, 0, 0))
		{
			ICE_DELETE buffer;
			return std::string(lua_tostring(pState, -1));
		}
		ICE_DELETE buffer;
		return std::string();
	}

int64_t OgreResource_Seek(void *user_data, int64_t offset, int whence)
{
    Ogre::DataStreamPtr stream = static_cast<VideoState*>(user_data)->stream;

    whence &= ~AVSEEK_FORCE;
    if(whence == AVSEEK_SIZE)
        return stream->size();
    if(whence == SEEK_SET)
        stream->seek((size_t)offset);
    else if(whence == SEEK_CUR)
		stream->seek((size_t)(stream->tell() + offset));
    else if(whence == SEEK_END)
		stream->seek((size_t)(stream->size() + offset));
    else
        return -1;

    return stream->tell();
}

int64_t FFmpeg_Decoder::seek(void *user_data, int64_t offset, int whence)
{
    Ogre::DataStreamPtr stream = static_cast<FFmpeg_Decoder*>(user_data)->mDataStream;

    whence &= ~AVSEEK_FORCE;
    if(whence == AVSEEK_SIZE)
        return stream->size();
    if(whence == SEEK_SET)
        stream->seek(offset);
    else if(whence == SEEK_CUR)
        stream->seek(stream->tell()+offset);
    else if(whence == SEEK_END)
        stream->seek(stream->size()+offset);
    else
        return -1;

    return stream->tell();
}

//-----------------------------------------------------------------------------------------
QPixmap HeightImageEditorCodec::onBeforeDisplay(Ogre::DataStreamPtr stream)
{
    double file_len = stream->size() / 4;

    unsigned int map_size = sqrt(file_len);

    mBuffer = new unsigned char[map_size * map_size * sizeof(float)];
    float *buf = (float *)mBuffer;

    stream->read(buf, map_size * map_size * 4);

    float max_h = -1000000.0f;
    float min_h = 1000000.0f;

    for(unsigned int i = 0; i < map_size * map_size; i++)
    {
        if(buf[i] > max_h)
            max_h = buf[i];
        if(buf[i] < min_h)
            min_h = buf[i];
    }

    float diff = max_h - min_h;

    if(diff > 0.0f)
    {
        unsigned char *colbuf = (unsigned char *)buf;
        int pos = 0;

        for(unsigned int i = 0; i < map_size * map_size; i++)
        {
            float tval = mapToRange(buf[i], min_h, max_h, 60, 360);

            HSVtoARGB(&colbuf[pos], tval, 1.0f, 1.0f);

            pos += 4;
        }
    }
    else
        memset(buf, 0xFF, map_size * map_size * 4);

    QImage image = QImage((unsigned char *)buf, map_size, map_size, QImage::Format_ARGB32);
    mPixmap = QPixmap(QPixmap::fromImage(image));

    return mPixmap;
}

	int		OOSStreamSeek(void *datasource, ogg_int64_t offset, int whence)
	{
		Ogre::DataStreamPtr dataStream = *reinterpret_cast<Ogre::DataStreamPtr*>(datasource);
		switch(whence)
		{
		case SEEK_SET:
			dataStream->seek(offset);
			break;
		case SEEK_END:
			dataStream->seek(dataStream->size());
			// Falling through purposefully here
		case SEEK_CUR:
			dataStream->skip(offset);
			break;
		}

		return 0;
	}

QByteArray *ResourceManager::read(const char *path, const char *group)
{
    Ogre::String groupName = Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME;
    if (group)
        groupName = group;

    Ogre::DataStreamPtr dataStream = Ogre::ResourceGroupManager::getSingleton().openResource(path, groupName);

    int totalSize = dataStream->size();
    QScopedPointer<QByteArray> result(new QByteArray(totalSize, Qt::Uninitialized));

    int bytesRead = 0;
    char *buffer = result->data();
    while (bytesRead < totalSize) {
        int read = dataStream->read(buffer, totalSize - bytesRead);
        buffer += read;
        bytesRead += read;
    }

    return result.take();
}