void DoParseUri(const TPtrCType& aUri, TPtrCType aComponent[])
{
// Parse the components
TPtrCType uri = aUri;
TInt consumed = 0;
TPtrCType& scheme = aComponent[EUriScheme];
if( (consumed = ParseScheme(uri, scheme)) > 0 )
{
uri.Set(uri.Mid(consumed));
}
if( (consumed = ParseAuthority(uri, aComponent[EUriUserinfo],
aComponent[EUriHost], aComponent[EUriPort], IsNetworkScheme(scheme))) > 0 )
{
uri.Set(uri.Mid(consumed));
}
if( (consumed = ParsePath(uri, aComponent[EUriPath])) > 0 )
{
uri.Set(uri.Mid(consumed));
}
if( (consumed = ParseQuery(uri, aComponent[EUriQuery])) > 0 )
{
uri.Set(uri.Mid(consumed));
}
if( (consumed = ParseFragment(uri, aComponent[EUriFragment])) > 0 )
{
uri.Set(uri.Mid(consumed));
}
}
const wxChar* wxURI::Parse(const wxChar* uri)
{
uri = ParseScheme(uri);
uri = ParseAuthority(uri);
uri = ParsePath(uri);
uri = ParseQuery(uri);
return ParseFragment(uri);
}
bool wxURI::Parse(const char *uri)
{
uri = ParseScheme(uri);
if ( uri )
uri = ParseAuthority(uri);
if ( uri )
uri = ParsePath(uri);
if ( uri )
uri = ParseQuery(uri);
if ( uri )
uri = ParseFragment(uri);
// we only succeed if we parsed the entire string
return uri && *uri == '\0';
}
static ParseStatus ParseVP8XChunks(WebPDemuxer* const dmux) {
const int is_animation = !!(dmux->feature_flags_ & ANIMATION_FLAG);
MemBuffer* const mem = &dmux->mem_;
int anim_chunks = 0;
ParseStatus status = PARSE_OK;
do {
int store_chunk = 1;
const size_t chunk_start_offset = mem->start_;
const uint32_t fourcc = ReadLE32(mem);
const uint32_t chunk_size = ReadLE32(mem);
const uint32_t chunk_size_padded = chunk_size + (chunk_size & 1);
if (chunk_size > MAX_CHUNK_PAYLOAD) return PARSE_ERROR;
if (SizeIsInvalid(mem, chunk_size_padded)) return PARSE_ERROR;
switch (fourcc) {
case MKFOURCC('V', 'P', '8', 'X'): {
return PARSE_ERROR;
}
case MKFOURCC('A', 'L', 'P', 'H'):
case MKFOURCC('V', 'P', '8', ' '):
case MKFOURCC('V', 'P', '8', 'L'): {
// check that this isn't an animation (all frames should be in an ANMF).
if (anim_chunks > 0 || is_animation) return PARSE_ERROR;
Rewind(mem, CHUNK_HEADER_SIZE);
status = ParseSingleImage(dmux);
break;
}
case MKFOURCC('A', 'N', 'I', 'M'): {
if (chunk_size_padded < ANIM_CHUNK_SIZE) return PARSE_ERROR;
if (MemDataSize(mem) < chunk_size_padded) {
status = PARSE_NEED_MORE_DATA;
} else if (anim_chunks == 0) {
++anim_chunks;
dmux->bgcolor_ = ReadLE32(mem);
dmux->loop_count_ = ReadLE16s(mem);
Skip(mem, chunk_size_padded - ANIM_CHUNK_SIZE);
} else {
store_chunk = 0;
goto Skip;
}
break;
}
case MKFOURCC('A', 'N', 'M', 'F'): {
if (anim_chunks == 0) return PARSE_ERROR; // 'ANIM' precedes frames.
status = ParseAnimationFrame(dmux, chunk_size_padded);
break;
}
#ifdef WEBP_EXPERIMENTAL_FEATURES
case MKFOURCC('F', 'R', 'G', 'M'): {
status = ParseFragment(dmux, chunk_size_padded);
break;
}
#endif
case MKFOURCC('I', 'C', 'C', 'P'): {
store_chunk = !!(dmux->feature_flags_ & ICCP_FLAG);
goto Skip;
}
case MKFOURCC('E', 'X', 'I', 'F'): {
store_chunk = !!(dmux->feature_flags_ & EXIF_FLAG);
goto Skip;
}
case MKFOURCC('X', 'M', 'P', ' '): {
store_chunk = !!(dmux->feature_flags_ & XMP_FLAG);
goto Skip;
}
Skip:
default: {
if (chunk_size_padded <= MemDataSize(mem)) {
if (store_chunk) {
// Store only the chunk header and unpadded size as only the payload
// will be returned to the user.
if (!StoreChunk(dmux, chunk_start_offset,
CHUNK_HEADER_SIZE + chunk_size)) {
return PARSE_ERROR;
}
}
Skip(mem, chunk_size_padded);
} else {
status = PARSE_NEED_MORE_DATA;
}
}
}
if (mem->start_ == mem->riff_end_) {
break;
} else if (MemDataSize(mem) < CHUNK_HEADER_SIZE) {
status = PARSE_NEED_MORE_DATA;
}
} while (status == PARSE_OK);
return status;
}
CPass* CMaterialLoader::ParsePass(Json::Value& json, Json::Value& root) {
const char* szVertexProgram = json["vertex_program"].asCString();
const char* szFragmentProgram = json["fragment_program"].asCString();
Json::Value& diffuseJson = json["diffuse"];
Json::Value& ambientJson = json["ambient"];
Json::Value& specularJson = json["specular"];
Json::Value& emissiveJson = json["emissive"];
Json::Value& textureUnitJson = json["texture_unit"];
// 创建颜色
CColorF diffuse = CColorF(diffuseJson[0].asFloat(),
diffuseJson[1].asFloat(),
diffuseJson[2].asFloat(),
diffuseJson[3].asFloat());
CColorF ambient = CColorF(ambientJson[0].asFloat(),
ambientJson[1].asFloat(),
ambientJson[2].asFloat(),
ambientJson[3].asFloat());
CColorF specular = CColorF(specularJson[0].asFloat(),
specularJson[1].asFloat(),
specularJson[2].asFloat(),
specularJson[3].asFloat());
CColorF emissive = CColorF(emissiveJson[0].asFloat(),
emissiveJson[1].asFloat(),
emissiveJson[2].asFloat(),
emissiveJson[3].asFloat());
// 创建纹理
CTexture* pTexture = NULL;
if (!textureUnitJson.isNull()) {
const char* texture = textureUnitJson["texture"].asCString();
std::string filter_mode = textureUnitJson["filter_mode"].asString();
std::string address_mode = textureUnitJson["address_mode"].asString();
pTexture = XENEW(CTexture);
if (!pTexture) {
return NULL;
}
if (filter_mode == "nearest") {
pTexture->SetFilter(ITexture::E_Nearest);
} else if (filter_mode == "linear") {
pTexture->SetFilter(ITexture::E_Linear);
}
if (address_mode == "repeat") {
pTexture->SetAddress(ITexture::E_Repeat);
} else if (address_mode == "clamp") {
pTexture->SetAddress(ITexture::E_Clamp);
}
if (!pTexture->Load(texture)) {
XELOG("material parse pass load texture error: %s", texture);
XEDELETE(pTexture);
return NULL;
}
}
// 创建program
CCgProgram* pProgram = XENEW(CCgProgram);
if (!pProgram) {
XEDELETE(pTexture);
return NULL;
}
// 创建vertex
CCg* pVertex = ParseVertex(szVertexProgram, root);
if (!pVertex) {
XELOG("material parse pass load vertex error: %s", szVertexProgram);
XEDELETE(pTexture);
XEDELETE(pProgram);
return NULL;
}
pProgram->AddCg(pVertex);
// 创建fragment
CCg* pFragment = ParseFragment(szFragmentProgram, root);
if (!pFragment) {
XELOG("material parse pass load fragment error: %s", szFragmentProgram);
XEDELETE(pTexture);
XEDELETE(pProgram);
XEDELETE(pVertex);
return NULL;
}
pProgram->AddCg(pFragment);
pProgram->Compile();
// 创建pass
CPass* pPass = XENEW(CPass);
if (!pPass) {
XEDELETE(pTexture);
XEDELETE(pProgram);
XEDELETE(pVertex);
XEDELETE(pFragment);
return NULL;
}
pPass->Init(pTexture, diffuse, ambient, specular, emissive, pProgram);
return pPass;
}
static ParseStatus ParseVP8X(WebPDemuxer* const dmux) {
MemBuffer* const mem = &dmux->mem_;
int anim_chunks = 0;
uint32_t vp8x_size;
ParseStatus status = PARSE_OK;
if (MemDataSize(mem) < CHUNK_HEADER_SIZE) return PARSE_NEED_MORE_DATA;
dmux->is_ext_format_ = 1;
Skip(mem, TAG_SIZE); // VP8X
vp8x_size = ReadLE32(mem);
if (vp8x_size > MAX_CHUNK_PAYLOAD) return PARSE_ERROR;
if (vp8x_size < VP8X_CHUNK_SIZE) return PARSE_ERROR;
vp8x_size += vp8x_size & 1;
if (SizeIsInvalid(mem, vp8x_size)) return PARSE_ERROR;
if (MemDataSize(mem) < vp8x_size) return PARSE_NEED_MORE_DATA;
dmux->feature_flags_ = ReadByte(mem);
Skip(mem, 3); // Reserved.
dmux->canvas_width_ = 1 + ReadLE24s(mem);
dmux->canvas_height_ = 1 + ReadLE24s(mem);
if (dmux->canvas_width_ * (uint64_t)dmux->canvas_height_ >= MAX_IMAGE_AREA) {
return PARSE_ERROR; // image final dimension is too large
}
Skip(mem, vp8x_size - VP8X_CHUNK_SIZE); // skip any trailing data.
dmux->state_ = WEBP_DEMUX_PARSED_HEADER;
if (SizeIsInvalid(mem, CHUNK_HEADER_SIZE)) return PARSE_ERROR;
if (MemDataSize(mem) < CHUNK_HEADER_SIZE) return PARSE_NEED_MORE_DATA;
do {
int store_chunk = 1;
const size_t chunk_start_offset = mem->start_;
const uint32_t fourcc = ReadLE32(mem);
const uint32_t chunk_size = ReadLE32(mem);
const uint32_t chunk_size_padded = chunk_size + (chunk_size & 1);
if (chunk_size > MAX_CHUNK_PAYLOAD) return PARSE_ERROR;
if (SizeIsInvalid(mem, chunk_size_padded)) return PARSE_ERROR;
switch (fourcc) {
case MKFOURCC('V', 'P', '8', 'X'): {
return PARSE_ERROR;
}
case MKFOURCC('A', 'L', 'P', 'H'):
case MKFOURCC('V', 'P', '8', ' '):
case MKFOURCC('V', 'P', '8', 'L'): {
// check that this isn't an animation (all frames should be in an ANMF).
if (anim_chunks > 0) return PARSE_ERROR;
Rewind(mem, CHUNK_HEADER_SIZE);
status = ParseSingleImage(dmux);
break;
}
case MKFOURCC('A', 'N', 'I', 'M'): {
if (chunk_size_padded < ANIM_CHUNK_SIZE) return PARSE_ERROR;
if (MemDataSize(mem) < chunk_size_padded) {
status = PARSE_NEED_MORE_DATA;
} else if (anim_chunks == 0) {
++anim_chunks;
dmux->bgcolor_ = ReadLE32(mem);
dmux->loop_count_ = ReadLE16s(mem);
Skip(mem, chunk_size_padded - ANIM_CHUNK_SIZE);
} else {
store_chunk = 0;
goto Skip;
}
break;
}
case MKFOURCC('A', 'N', 'M', 'F'): {
if (anim_chunks == 0) return PARSE_ERROR; // 'ANIM' precedes frames.
status = ParseAnimationFrame(dmux, chunk_size_padded);
break;
}
#ifdef WEBP_EXPERIMENTAL_FEATURES
case MKFOURCC('F', 'R', 'G', 'M'): {
status = ParseFragment(dmux, chunk_size_padded);
break;
}
#endif
case MKFOURCC('I', 'C', 'C', 'P'): {
store_chunk = !!(dmux->feature_flags_ & ICCP_FLAG);
goto Skip;
}
case MKFOURCC('X', 'M', 'P', ' '): {
store_chunk = !!(dmux->feature_flags_ & XMP_FLAG);
goto Skip;
}
case MKFOURCC('E', 'X', 'I', 'F'): {
store_chunk = !!(dmux->feature_flags_ & EXIF_FLAG);
goto Skip;
}
Skip:
default: {
if (chunk_size_padded <= MemDataSize(mem)) {
if (store_chunk) {
// Store only the chunk header and unpadded size as only the payload
// will be returned to the user.
if (!StoreChunk(dmux, chunk_start_offset,
CHUNK_HEADER_SIZE + chunk_size)) {
return PARSE_ERROR;
}
}
Skip(mem, chunk_size_padded);
} else {
status = PARSE_NEED_MORE_DATA;
}
}
}
if (mem->start_ == mem->riff_end_) {
break;
} else if (MemDataSize(mem) < CHUNK_HEADER_SIZE) {
status = PARSE_NEED_MORE_DATA;
}
} while (status == PARSE_OK);
return status;
}
