C++ NPT_DataBuffer::GetBufferSize方法代码示例

int CStreamCtrl::Read(void* buffer, unsigned int bytes_to_read, unsigned int* bytes_read)
{
	int ret=0;
	if (m_type==1)
	{
		*bytes_read=fread(buffer,1,bytes_to_read,m_openFile);
	}
	else if (m_type==2)
	{
		_pbyte_t pHeaderBuffer = NULL;
		_uint32_t ui32HeaderBufferSize = 0;
		m_sSequence->getHeaderBuffer(&pHeaderBuffer,&ui32HeaderBufferSize);
		if (m_curPos<ui32HeaderBufferSize)
		{
			unsigned int tmp_bytes=ui32HeaderBufferSize-static_cast<unsigned int>(m_curPos);
			*bytes_read= (bytes_to_read>tmp_bytes) ? tmp_bytes : bytes_to_read;
			pHeaderBuffer+=m_curPos;
			memcpy(buffer,pHeaderBuffer,*bytes_read);
			m_curPos+=*bytes_read;
		}
		else
		{
			_uint32_t pos=static_cast<unsigned int>(m_curPos);
			_uint32_t startclipnum = 0;
			_uint32_t endclipnum = 0;

			if (pos + bytes_to_read <= m_fileSize)
				m_sSequence->TranslateSectionRange(pos, pos+bytes_to_read, &startclipnum, &endclipnum);
			else
				m_sSequence->TranslateSectionRange(pos, m_fileSize, &startclipnum, &endclipnum);
			unsigned int index(0);
			for (_uint32_t j = startclipnum; j <= endclipnum; j++)
			{
				ClipOfRangeInfo sClipInfo;
				m_sSequence->getSectionInfoByIndex(j, &sClipInfo);
				char query[10]={};

				NPT_String path="/";
				path+=m_openFileName;

				NPT_HttpUrl url=NPT_HttpUrl(P2PIPAddress, 8082, path);
				_itoa_s(j,query,10);
				url.SetQuery(query);

				NPT_DataBuffer mediadata;
				RecvMediaData(url,sClipInfo.StartOffset,sClipInfo.EndOffset,mediadata);	

				memcpy((unsigned char*)buffer+index,mediadata.GetData(),mediadata.GetBufferSize());
				index+=mediadata.GetBufferSize();
				m_curPos+=mediadata.GetBufferSize();
			}
			*bytes_read=index;
		}
	}
	return ret;
}

/*----------------------------------------------------------------------
|   NPT_Zip::Inflate
+---------------------------------------------------------------------*/
NPT_Result
NPT_Zip::Inflate(const NPT_DataBuffer& in,
                 NPT_DataBuffer&       out,
                 bool                  raw)
{
    // assume an output buffer twice the size of the input plus a bit
    NPT_CHECK_WARNING(out.Reserve(32+2*in.GetDataSize()));

    // setup the stream
    z_stream stream;
    stream.next_in   = (Bytef*)in.GetData();
    stream.avail_in  = (uInt)in.GetDataSize();
    stream.next_out  = out.UseData();
    stream.avail_out = (uInt)out.GetBufferSize();

    // setup the memory functions
    stream.zalloc = (alloc_func)0;
    stream.zfree = (free_func)0;
    stream.opaque = (voidpf)0;

    // initialize the decompressor
    int err = inflateInit2(&stream, raw?-15:15+32); // 15 = default window bits, +32 = automatic header
    if (err != Z_OK) return MapError(err);

    // decompress until the end
    do {
        err = inflate(&stream, Z_SYNC_FLUSH);
        if (err == Z_STREAM_END || err == Z_OK || err == Z_BUF_ERROR) {
            out.SetDataSize((NPT_Size)stream.total_out);
            if ((err == Z_OK && stream.avail_out == 0) || err == Z_BUF_ERROR) {
                // grow the output buffer
                out.Reserve(out.GetBufferSize()*2);
                stream.next_out = out.UseData()+stream.total_out;
                stream.avail_out = out.GetBufferSize()-(NPT_Size)stream.total_out;
            }
        }
    } while (err == Z_OK);

    // check for errors
    if (err != Z_STREAM_END) {
        inflateEnd(&stream);
        return MapError(err);
    }

    // cleanup
    err = inflateEnd(&stream);
    return MapError(err);
}

/*----------------------------------------------------------------------
|   NPT_Zip::Deflate
+---------------------------------------------------------------------*/
NPT_Result 
NPT_Zip::Deflate(const NPT_DataBuffer& in,
                 NPT_DataBuffer&       out,
                 int                   compression_level,
                 Format                format /* = ZLIB */)
{
    // default return state
    out.SetDataSize(0);
    
    // check parameters
    if (compression_level < NPT_ZIP_COMPRESSION_LEVEL_DEFAULT ||
        compression_level > NPT_ZIP_COMPRESSION_LEVEL_MAX) {
        return NPT_ERROR_INVALID_PARAMETERS;
    }
                
    // setup the stream
    z_stream stream;
    NPT_SetMemory(&stream, 0, sizeof(stream));
    stream.next_in   = (Bytef*)in.GetData();
    stream.avail_in  = (uInt)in.GetDataSize();
    
    // setup the memory functions
    stream.zalloc = (alloc_func)0;
    stream.zfree = (free_func)0;
    stream.opaque = (voidpf)0;

    // initialize the compressor
    int err = deflateInit2(&stream, 
                           compression_level,
                           Z_DEFLATED,
                           15 + (format == GZIP ? 16 : 0),
                           8,
                           Z_DEFAULT_STRATEGY);
    if (err != Z_OK) return MapError(err);

    // reserve an output buffer known to be large enough
    out.Reserve(deflateBound(&stream, stream.avail_in) + (format==GZIP?10:0));
    stream.next_out  = out.UseData();
    stream.avail_out = out.GetBufferSize();

    // decompress
    err = deflate(&stream, Z_FINISH);
    if (err != Z_STREAM_END) {
        deflateEnd(&stream);
        return MapError(err);
    }
    
    // update the output size
    out.SetDataSize(stream.total_out);

    // cleanup
    err = deflateEnd(&stream);
    return MapError(err);
}