cTerrainCompositionGenPtr cTerrainCompositionGen::CreateCompositionGen(cIniFile & a_IniFile, cBiomeGenPtr a_BiomeGen, cTerrainShapeGenPtr a_ShapeGen, int a_Seed)
{
AString CompoGenName = a_IniFile.GetValueSet("Generator", "CompositionGen", "");
if (CompoGenName.empty())
{
LOGWARN("[Generator] CompositionGen value not set in world.ini, using \"Biomal\".");
CompoGenName = "Biomal";
}
// Compositor list is alpha-sorted
cTerrainCompositionGenPtr res;
if (NoCaseCompare(CompoGenName, "Biomal") == 0)
{
res = CreateCompoGenBiomal(a_Seed);
}
else if (NoCaseCompare(CompoGenName, "BiomalNoise3D") == 0)
{
// The composition that used to be provided with BiomalNoise3D is now provided by the Biomal compositor:
res = CreateCompoGenBiomal(a_Seed);
}
else if (NoCaseCompare(CompoGenName, "Classic") == 0)
{
res = std::make_shared<cCompoGenClassic>();
}
else if (NoCaseCompare(CompoGenName, "DebugBiomes") == 0)
{
res = std::make_shared<cCompoGenDebugBiomes>();
}
else if (NoCaseCompare(CompoGenName, "DistortedHeightmap") == 0)
{
// The composition that used to be provided with DistortedHeightmap is now provided by the Biomal compositor:
res = CreateCompoGenBiomal(a_Seed);
}
else if (NoCaseCompare(CompoGenName, "End") == 0)
{
res = std::make_shared<cEndGen>(a_Seed);
}
else if (NoCaseCompare(CompoGenName, "Nether") == 0)
{
res = std::make_shared<cCompoGenNether>(a_Seed);
}
else if (NoCaseCompare(CompoGenName, "Noise3D") == 0)
{
// The composition that used to be provided with Noise3D is now provided by the Biomal compositor:
res = CreateCompoGenBiomal(a_Seed);
}
else if (NoCaseCompare(CompoGenName, "SameBlock") == 0)
{
res = std::make_shared<cCompoGenSameBlock>();
}
else
{
LOGWARN("Unknown CompositionGen \"%s\", using \"Biomal\" instead.", CompoGenName.c_str());
a_IniFile.SetValue("Generator", "CompositionGen", "Biomal");
return CreateCompositionGen(a_IniFile, a_BiomeGen, a_ShapeGen, a_Seed);
}
ASSERT(res != nullptr);
// Read the settings from the ini file:
res->InitializeCompoGen(a_IniFile);
return cTerrainCompositionGenPtr(res);
}
status_t MediaCodecList::addLimit(const char **attrs) {
sp<AMessage> msg = new AMessage();
size_t i = 0;
while (attrs[i] != NULL) {
if (attrs[i + 1] == NULL) {
return -EINVAL;
}
// attributes with values
if (!strcmp(attrs[i], "name")
|| !strcmp(attrs[i], "default")
|| !strcmp(attrs[i], "in")
|| !strcmp(attrs[i], "max")
|| !strcmp(attrs[i], "min")
|| !strcmp(attrs[i], "range")
|| !strcmp(attrs[i], "ranges")
|| !strcmp(attrs[i], "scale")
|| !strcmp(attrs[i], "value")) {
msg->setString(attrs[i], attrs[i + 1]);
++i;
} else {
return -EINVAL;
}
++i;
}
AString name;
if (!msg->findString("name", &name)) {
ALOGE("limit with no 'name' attribute");
return -EINVAL;
}
// size, blocks, bitrate, frame-rate, blocks-per-second, aspect-ratio: range
// quality: range + default + [scale]
// complexity: range + default
bool found;
if (name == "aspect-ratio" || name == "bitrate" || name == "block-count"
|| name == "blocks-per-second" || name == "complexity"
|| name == "frame-rate" || name == "quality" || name == "size") {
AString min, max;
if (msg->findString("min", &min) && msg->findString("max", &max)) {
min.append("-");
min.append(max);
if (msg->contains("range") || msg->contains("value")) {
return limitError(name, "has 'min' and 'max' as well as 'range' or "
"'value' attributes");
}
msg->setString("range", min);
} else if (msg->contains("min") || msg->contains("max")) {
return limitError(name, "has only 'min' or 'max' attribute");
} else if (msg->findString("value", &max)) {
min = max;
min.append("-");
min.append(max);
if (msg->contains("range")) {
return limitError(name, "has both 'range' and 'value' attributes");
}
msg->setString("range", min);
}
AString range, scale = "linear", def, in_;
if (!msg->findString("range", &range)) {
return limitError(name, "with no 'range', 'value' or 'min'/'max' attributes");
}
if ((name == "quality" || name == "complexity") ^
(found = msg->findString("default", &def))) {
return limitFoundMissingAttr(name, "default", found);
}
if (name != "quality" && msg->findString("scale", &scale)) {
return limitFoundMissingAttr(name, "scale");
}
if ((name == "aspect-ratio") ^ (found = msg->findString("in", &in_))) {
return limitFoundMissingAttr(name, "in", found);
}
if (name == "aspect-ratio") {
if (!(in_ == "pixels") && !(in_ == "blocks")) {
return limitInvalidAttr(name, "in", in_);
}
in_.erase(5, 1); // (pixel|block)-aspect-ratio
in_.append("-");
in_.append(name);
name = in_;
}
if (name == "quality") {
mCurrentInfo->addDetail("quality-scale", scale);
}
if (name == "quality" || name == "complexity") {
AString tag = name;
tag.append("-default");
mCurrentInfo->addDetail(tag, def);
}
AString tag = name;
tag.append("-range");
mCurrentInfo->addDetail(tag, range);
} else {
AString max, value, ranges;
if (msg->contains("default")) {
return limitFoundMissingAttr(name, "default");
} else if (msg->contains("in")) {
return limitFoundMissingAttr(name, "in");
} else if ((name == "channel-count") ^
(found = msg->findString("max", &max))) {
return limitFoundMissingAttr(name, "max", found);
} else if (msg->contains("min")) {
return limitFoundMissingAttr(name, "min");
} else if (msg->contains("range")) {
return limitFoundMissingAttr(name, "range");
} else if ((name == "sample-rate") ^
(found = msg->findString("ranges", &ranges))) {
return limitFoundMissingAttr(name, "ranges", found);
} else if (msg->contains("scale")) {
return limitFoundMissingAttr(name, "scale");
} else if ((name == "alignment" || name == "block-size") ^
(found = msg->findString("value", &value))) {
return limitFoundMissingAttr(name, "value", found);
}
if (max.size()) {
AString tag = "max-";
tag.append(name);
mCurrentInfo->addDetail(tag, max);
} else if (value.size()) {
mCurrentInfo->addDetail(name, value);
} else if (ranges.size()) {
AString tag = name;
tag.append("-ranges");
mCurrentInfo->addDetail(tag, ranges);
} else {
ALOGW("Ignoring unrecognized limit '%s'", name.c_str());
}
}
return OK;
}
status_t Converter::initEncoder() {
AString inputMIME;
CHECK(mInputFormat->findString("mime", &inputMIME));
AString outputMIME;
bool isAudio = false;
if (!strcasecmp(inputMIME.c_str(), MEDIA_MIMETYPE_AUDIO_RAW)) {
if (mIsPCMAudio) {
outputMIME = MEDIA_MIMETYPE_AUDIO_RAW;
} else {
outputMIME = MEDIA_MIMETYPE_AUDIO_AAC;
}
isAudio = true;
} else if (!strcasecmp(inputMIME.c_str(), MEDIA_MIMETYPE_VIDEO_RAW)) {
outputMIME = MEDIA_MIMETYPE_VIDEO_AVC;
} else {
TRESPASS();
}
if (!mIsPCMAudio) {
mEncoder = MediaCodec::CreateByType(
mCodecLooper, outputMIME.c_str(), true /* encoder */);
if (mEncoder == NULL) {
return ERROR_UNSUPPORTED;
}
}
mOutputFormat = mInputFormat->dup();
if (mIsPCMAudio) {
return OK;
}
mOutputFormat->setString("mime", outputMIME.c_str());
int32_t audioBitrate = getBitrate("media.wfd.audio-bitrate", 128000);
int32_t videoBitrate = getBitrate("media.wfd.video-bitrate", 5000000);
ALOGI("using audio bitrate of %d bps, video bitrate of %d bps",
audioBitrate, videoBitrate);
if (isAudio) {
mOutputFormat->setInt32("bitrate", audioBitrate);
} else {
mOutputFormat->setInt32("bitrate", videoBitrate);
mOutputFormat->setInt32("bitrate-mode", OMX_Video_ControlRateConstant);
mOutputFormat->setInt32("frame-rate", 30);
mOutputFormat->setInt32("i-frame-interval", 15); // Iframes every 15 secs
// Configure encoder to use intra macroblock refresh mode
mOutputFormat->setInt32("intra-refresh-mode", OMX_VIDEO_IntraRefreshCyclic);
int width, height, mbs;
if (!mOutputFormat->findInt32("width", &width)
|| !mOutputFormat->findInt32("height", &height)) {
return ERROR_UNSUPPORTED;
}
// Update macroblocks in a cyclic fashion with 10% of all MBs within
// frame gets updated at one time. It takes about 10 frames to
// completely update a whole video frame. If the frame rate is 30,
// it takes about 333 ms in the best case (if next frame is not an IDR)
// to recover from a lost/corrupted packet.
mbs = (((width + 15) / 16) * ((height + 15) / 16) * 10) / 100;
mOutputFormat->setInt32("intra-refresh-CIR-mbs", mbs);
}
ALOGV("output format is '%s'", mOutputFormat->debugString(0).c_str());
mNeedToManuallyPrependSPSPPS = false;
status_t err = NO_INIT;
if (!isAudio) {
sp<AMessage> tmp = mOutputFormat->dup();
tmp->setInt32("prepend-sps-pps-to-idr-frames", 1);
err = mEncoder->configure(
tmp,
NULL /* nativeWindow */,
NULL /* crypto */,
MediaCodec::CONFIGURE_FLAG_ENCODE);
if (err == OK) {
// Encoder supported prepending SPS/PPS, we don't need to emulate
// it.
mOutputFormat = tmp;
} else {
mNeedToManuallyPrependSPSPPS = true;
ALOGI("We going to manually prepend SPS and PPS to IDR frames.");
}
}
if (err != OK) {
// We'll get here for audio or if we failed to configure the encoder
// to automatically prepend SPS/PPS in the case of video.
err = mEncoder->configure(
mOutputFormat,
NULL /* nativeWindow */,
NULL /* crypto */,
MediaCodec::CONFIGURE_FLAG_ENCODE);
}
if (err != OK) {
return err;
}
err = mEncoder->start();
if (err != OK) {
return err;
}
err = mEncoder->getInputBuffers(&mEncoderInputBuffers);
if (err != OK) {
return err;
}
return mEncoder->getOutputBuffers(&mEncoderOutputBuffers);
}
void cBioGenConstant::InitializeBiomeGen(cIniFile & a_IniFile)
{
AString Biome = a_IniFile.GetValueSet("Generator", "ConstantBiome", "Plains");
m_Biome = StringToBiome(Biome);
if (m_Biome == biInvalidBiome)
{
LOGWARN("[Generator]::ConstantBiome value \"%s\" not recognized, using \"Plains\".", Biome.c_str());
m_Biome = biPlains;
}
}
static status_t limitError(AString name, const char *msg) {
ALOGE("limit '%s' %s", name.c_str(), msg);
return -EINVAL;
}
// cHTTPResponseParser::cCallbacks overrides:
virtual void OnError(const AString & a_ErrorDescription) override
{
printf("Error: \"%s\"\n", a_ErrorDescription.c_str());
}
/** Called when a single header line is parsed. */
virtual void OnHeaderLine(const AString & a_Key, const AString & a_Value) override
{
printf("Header line: \"%s\": \"%s\"\n", a_Key.c_str(), a_Value.c_str());
}
void cWebAdmin::HandleWebadminRequest(cHTTPConnection & a_Connection, cHTTPRequest & a_Request)
{
if (!a_Request.HasAuth())
{
a_Connection.SendNeedAuth("MCServer WebAdmin");
return;
}
// Check auth:
AString UserPassword = m_IniFile.GetValue("User:"******"Password", "");
if ((UserPassword == "") || (a_Request.GetAuthPassword() != UserPassword))
{
a_Connection.SendNeedAuth("MCServer WebAdmin - bad username or password");
return;
}
// Check if the contents should be wrapped in the template:
AString URL = a_Request.GetBareURL();
ASSERT(URL.length() > 0);
bool ShouldWrapInTemplate = ((URL.length() > 1) && (URL[1] != '~'));
// Retrieve the request data:
cWebadminRequestData * Data = (cWebadminRequestData *)(a_Request.GetUserData());
if (Data == NULL)
{
a_Connection.SendStatusAndReason(500, "Bad UserData");
return;
}
// Wrap it all up for the Lua call:
AString Template;
HTTPTemplateRequest TemplateRequest;
TemplateRequest.Request.Username = a_Request.GetAuthUsername();
TemplateRequest.Request.Method = a_Request.GetMethod();
TemplateRequest.Request.Path = URL.substr(1);
if (Data->m_Form.Finish())
{
for (cHTTPFormParser::const_iterator itr = Data->m_Form.begin(), end = Data->m_Form.end(); itr != end; ++itr)
{
HTTPFormData HTTPfd;
HTTPfd.Value = itr->second;
HTTPfd.Type = "";
HTTPfd.Name = itr->first;
TemplateRequest.Request.FormData[itr->first] = HTTPfd;
TemplateRequest.Request.PostParams[itr->first] = itr->second;
} // for itr - Data->m_Form[]
// Parse the URL into individual params:
size_t idxQM = a_Request.GetURL().find('?');
if (idxQM != AString::npos)
{
cHTTPFormParser URLParams(cHTTPFormParser::fpkURL, a_Request.GetURL().c_str() + idxQM + 1, a_Request.GetURL().length() - idxQM - 1, *Data);
URLParams.Finish();
for (cHTTPFormParser::const_iterator itr = URLParams.begin(), end = URLParams.end(); itr != end; ++itr)
{
TemplateRequest.Request.Params[itr->first] = itr->second;
} // for itr - URLParams[]
}
}
// Try to get the template from the Lua template script
if (ShouldWrapInTemplate)
{
if (m_TemplateScript.Call("ShowPage", this, &TemplateRequest, cLuaState::Return, Template))
{
cHTTPResponse Resp;
Resp.SetContentType("text/html");
a_Connection.Send(Resp);
a_Connection.Send(Template.c_str(), Template.length());
return;
}
a_Connection.SendStatusAndReason(500, "m_TemplateScript failed");
return;
}
AString BaseURL = GetBaseURL(URL);
AString Menu;
Template = "{CONTENT}";
AString FoundPlugin;
for (PluginList::iterator itr = m_Plugins.begin(); itr != m_Plugins.end(); ++itr)
{
cWebPlugin * WebPlugin = *itr;
std::list< std::pair<AString, AString> > NameList = WebPlugin->GetTabNames();
for (std::list< std::pair<AString, AString> >::iterator Names = NameList.begin(); Names != NameList.end(); ++Names)
{
Menu += "<li><a href='" + BaseURL + WebPlugin->GetWebTitle().c_str() + "/" + (*Names).second + "'>" + (*Names).first + "</a></li>";
}
}
sWebAdminPage Page = GetPage(TemplateRequest.Request);
AString Content = Page.Content;
FoundPlugin = Page.PluginName;
if (!Page.TabName.empty())
{
FoundPlugin += " - " + Page.TabName;
}
if (FoundPlugin.empty()) // Default page
{
Content = GetDefaultPage();
}
if (ShouldWrapInTemplate && (URL.size() > 1))
{
Content += "\n<p><a href='" + BaseURL + "'>Go back</a></p>";
}
int MemUsageKiB = GetMemoryUsage();
if (MemUsageKiB > 0)
{
ReplaceString(Template, "{MEM}", Printf("%.02f", (double)MemUsageKiB / 1024));
ReplaceString(Template, "{MEMKIB}", Printf("%d", MemUsageKiB));
}
else
{
ReplaceString(Template, "{MEM}", "unknown");
ReplaceString(Template, "{MEMKIB}", "unknown");
}
ReplaceString(Template, "{USERNAME}", a_Request.GetAuthUsername());
ReplaceString(Template, "{MENU}", Menu);
ReplaceString(Template, "{PLUGIN_NAME}", FoundPlugin);
ReplaceString(Template, "{CONTENT}", Content);
ReplaceString(Template, "{TITLE}", "MCServer");
AString NumChunks;
Printf(NumChunks, "%d", cRoot::Get()->GetTotalChunkCount());
ReplaceString(Template, "{NUMCHUNKS}", NumChunks);
cHTTPResponse Resp;
Resp.SetContentType("text/html");
a_Connection.Send(Resp);
a_Connection.Send(Template.c_str(), Template.length());
}
bool cPlayer::LoadFromDisk()
{
LoadPermissionsFromDisk();
// Log player permissions, cause it's what the cool kids do
LOGINFO("Player %s has permissions:", m_PlayerName.c_str() );
for( PermissionMap::iterator itr = m_ResolvedPermissions.begin(); itr != m_ResolvedPermissions.end(); ++itr )
{
if( itr->second ) LOG(" - %s", itr->first.c_str() );
}
AString SourceFile;
Printf(SourceFile, "players/%s.json", m_PlayerName.c_str() );
cFile f;
if (!f.Open(SourceFile, cFile::fmRead))
{
// This is a new player whom we haven't seen yet, bail out, let them have the defaults
return false;
}
AString buffer;
if (f.ReadRestOfFile(buffer) != f.GetSize())
{
LOGWARNING("Cannot read player data from file \"%s\"", SourceFile.c_str());
return false;
}
f.Close(); //cool kids play nice
Json::Value root;
Json::Reader reader;
if (!reader.parse(buffer, root, false))
{
LOGWARNING("Cannot parse player data in file \"%s\", player will be reset", SourceFile.c_str());
}
Json::Value & JSON_PlayerPosition = root["position"];
if (JSON_PlayerPosition.size() == 3)
{
SetPosX(JSON_PlayerPosition[(unsigned int)0].asDouble());
SetPosY(JSON_PlayerPosition[(unsigned int)1].asDouble());
SetPosZ(JSON_PlayerPosition[(unsigned int)2].asDouble());
m_LastPosX = GetPosX();
m_LastPosY = GetPosY();
m_LastPosZ = GetPosZ();
m_LastFoodPos = GetPosition();
}
Json::Value & JSON_PlayerRotation = root["rotation"];
if (JSON_PlayerRotation.size() == 3)
{
SetYaw ((float)JSON_PlayerRotation[(unsigned int)0].asDouble());
SetPitch ((float)JSON_PlayerRotation[(unsigned int)1].asDouble());
SetRoll ((float)JSON_PlayerRotation[(unsigned int)2].asDouble());
}
m_Health = root.get("health", 0).asInt();
m_AirLevel = root.get("air", MAX_AIR_LEVEL).asInt();
m_FoodLevel = root.get("food", MAX_FOOD_LEVEL).asInt();
m_FoodSaturationLevel = root.get("foodSaturation", MAX_FOOD_LEVEL).asDouble();
m_FoodTickTimer = root.get("foodTickTimer", 0).asInt();
m_FoodExhaustionLevel = root.get("foodExhaustion", 0).asDouble();
m_LifetimeTotalXp = (short) root.get("xpTotal", 0).asInt();
m_CurrentXp = (short) root.get("xpCurrent", 0).asInt();
m_IsFlying = root.get("isflying", 0).asBool();
m_GameMode = (eGameMode) root.get("gamemode", eGameMode_NotSet).asInt();
if (m_GameMode == eGameMode_Creative)
{
m_CanFly = true;
}
m_Inventory.LoadFromJson(root["inventory"]);
m_LoadedWorldName = root.get("world", "world").asString();
LOGD("Player \"%s\" was read from file, spawning at {%.2f, %.2f, %.2f} in world \"%s\"",
m_PlayerName.c_str(), GetPosX(), GetPosY(), GetPosZ(), m_LoadedWorldName.c_str()
);
return true;
}
bool cChunkGenerator::Start(cWorld * a_World, cIniFile & a_IniFile)
{
MTRand rnd;
m_World = a_World;
m_Seed = a_IniFile.GetValueSetI("Seed", "Seed", rnd.randInt());
AString GeneratorName = a_IniFile.GetValueSet("Generator", "Generator", "Composable");
if (NoCaseCompare(GeneratorName, "Noise3D") == 0)
{
m_Generator = new cNoise3DGenerator(*this);
}
else
{
if (NoCaseCompare(GeneratorName, "composable") != 0)
{
LOGWARN("[Generator]::Generator value \"%s\" not recognized, using \"Composable\".", GeneratorName.c_str());
}
m_Generator = new cComposableGenerator(*this);
}
if (m_Generator == NULL)
{
LOGERROR("Generator could not start, aborting the server");
return false;
}
m_Generator->Initialize(a_World, a_IniFile);
return super::Start();
}
Bool CExcelExporterDlg::ExportExcel(IllusionExcelFile& sExcel, const AString& sSheetName)
{
int iRow = sExcel.GetRowCount();
int iCol = sExcel.GetColumnCount();
//第一行: 数据类型(int, float, uchar[n])
//第二行: 字段名
//第三行: 字段注释
HawkAssert(iRow >= 3 && iCol > 0);
if (iRow >= 3 && iCol > 0)
{
CString sVariable;
AStringVector vTypes;
AString sSheet = sSheetName;
HawkAssert(sSheet.size());
if (!sSheet.size())
return false;
//计算导出的数据格式
for (int i=1;i<=iCol;i++)
{
if (!sExcel.GetCellString(1, i).GetLength() || !sExcel.GetCellString(2, i).GetLength())
return false;
AString sTypeName = sExcel.GetCellString(1, i).GetBuffer(0);
AString sVarName = sExcel.GetCellString(2, i).GetBuffer(0);
AString sVarDesc = sExcel.GetCellString(3, i).GetBuffer(0);
vTypes.push_back(sTypeName);
if (sTypeName != "int" && sTypeName != "float" && sTypeName.find("uchar") == AString::npos)
return false;
//字符数组转换-> unsigned char ***[n]
if ( sTypeName.find("uchar") != AString::npos)
{
int iCap = HawkStringUtil::StringToInt<AString>(sTypeName.c_str() + strlen("uchar["));
sVariable.Format("%s\t//%s\r\n\tunsigned char %s[%d];\r\n", CString(sVariable).GetBuffer(0), sVarDesc.c_str(), sVarName.c_str(), iCap);
}
else
{
sVariable.Format("%s\t//%s\r\n\t%s %s;\r\n", CString(sVariable).GetBuffer(0), sVarDesc.c_str(), sTypeName.c_str(), sVarName.c_str());
}
}
//保存原始名字
AString sSheetName = sSheet;
HawkStringUtil::UpCase<AString>(sSheet);
//格式化导出模式文件
CString sStructFmt;
sStructFmt.Format(STRUCT_FORMAT, sSheet.c_str(), sSheet.c_str(), sSheetName.c_str(), sVariable.GetBuffer(0));
OutputDebugString(sStructFmt.GetBuffer(0));
//存储模式文件
HawkDiskFile struct_file;
char szExportFile[PAGE_SIZE] = {0};
sprintf(szExportFile, "Pattern/C++/%s.h", sSheetName.c_str());
_chmod(szExportFile, _S_IREAD | _S_IWRITE);
if (struct_file.Open(szExportFile, HawkFile::OPEN_WRITE))
{
struct_file.Write(sStructFmt.GetBuffer(0), sStructFmt.GetLength());
struct_file.Close();
}
else
{
return false;
}
//二进制excel数据
OctetsStream xOS;
//记录项数目
Int32 iCount = iRow - 3;
xOS.Push<Int32>(iCount);
for (int i=4; i<=iRow; i++)
{
for (int j=1;j<=iCol;j++)
{
AString sCellText = sExcel.GetCellString(i, j).GetBuffer(0);
if (vTypes[j-1] == "int")
{
if (!sCellText.size())
sCellText = "0";
Int32 iVal = HawkStringUtil::StringToInt<AString>(sCellText);
xOS.Push<Int32>(iVal);
}
else if (vTypes[j-1] == "float")
{
if (!sCellText.size())
sCellText = "0";
Float fVal = HawkStringUtil::StringToFloat<AString>(sCellText);
xOS.Push<Float>(fVal);
}
else if (vTypes[j-1].find("uchar") != AString::npos)
{
UString sVal = HawkStringUtil::ToUtf8(sCellText);
int iCap = HawkStringUtil::StringToInt<AString>(vTypes[j-1].c_str() + strlen("uchar["));
UChar* pBuf = new UChar[iCap];
memset(pBuf, 0, iCap);
memcpy(pBuf, sVal.c_str(), sVal.size());
xOS.Push(pBuf, iCap);
HAWK_DELETE_ARRAY(pBuf);
}
}
}
//数据压缩
UInt32 iSrcSize = xOS.Size();
ULong lComSize = HawkZip::GetRequiredSize(iSrcSize);
Char* pComBuf = new Char[lComSize];
memset(pComBuf, 0, lComSize);
HawkScope::DataArrayPtr scope(pComBuf);
if (!HawkZip::Compress(pComBuf, lComSize, xOS.Begin(), iSrcSize))
return false;
//压缩后做位反运算
for (ULong i=0;i<lComSize;i++)
pComBuf[i] = (~pComBuf[i]);
//压缩后的CRC校验
UInt32 iCrc = HawkStringUtil::CalcHash(pComBuf, lComSize);
HawkDiskFile bin_file;
sprintf(szExportFile, "BinCfg/%s.bin", sSheetName.c_str());
_chmod(szExportFile, _S_IREAD | _S_IWRITE);
if (bin_file.Open(szExportFile, HawkFile::OPEN_WRITE))
{
bin_file.Write(&iSrcSize, sizeof(iSrcSize));
bin_file.Write(&iCrc, sizeof(iCrc));
bin_file.Write(pComBuf, lComSize, true);
bin_file.Close();
}
else
{
return false;
}
return true;
}
return false;
}
bool cPluginManager::CallHookChat(cPlayer & a_Player, AString & a_Message)
{
// Check if the message contains a command, execute it:
switch (HandleCommand(a_Player, a_Message, true))
{
case crExecuted:
{
// The command has executed successfully
return true;
}
case crBlocked:
{
// The command was blocked by a plugin using HOOK_EXECUTE_COMMAND
// The plugin has most likely sent a message to the player already
return true;
}
case crError:
{
// An error in the plugin has prevented the command from executing. Report the error to the player:
a_Player.SendMessageFailure(Printf("Something went wrong while executing command \"%s\"", a_Message.c_str()));
return true;
}
case crNoPermission:
{
// The player is not allowed to execute this command
a_Player.SendMessageFailure(Printf("Forbidden command; insufficient privileges: \"%s\"", a_Message.c_str()));
return true;
}
case crUnknownCommand:
{
// This was not a known command, keep processing as a message
break;
}
}
// Check if the message is a command (starts with a slash). If it is, we know that it wasn't recognised:
if (!a_Message.empty() && (a_Message[0] == '/'))
{
AStringVector Split(StringSplit(a_Message, " "));
ASSERT(!Split.empty()); // This should not happen - we know there's at least one char in the message so the split needs to be at least one item long
a_Player.SendMessageInfo(Printf("Unknown command: \"%s\"", a_Message.c_str()));
LOGINFO("Player %s issued an unknown command: \"%s\"", a_Player.GetName().c_str(), a_Message.c_str());
return true; // Cancel sending
}
FIND_HOOK(HOOK_CHAT);
VERIFY_HOOK;
for (PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr)
{
if ((*itr)->OnChat(a_Player, a_Message))
{
return true;
}
}
return false;
}
bool cPluginManager::BindConsoleCommand(
const AString & a_Command,
cPlugin * a_Plugin,
cCommandHandlerPtr a_Handler,
const AString & a_HelpString
)
{
CommandMap::iterator cmd = m_ConsoleCommands.find(a_Command);
if (cmd != m_ConsoleCommands.end())
{
if (cmd->second.m_Plugin == nullptr)
{
LOGWARNING("Console command \"%s\" is already bound internally by Cuberite, cannot bind in plugin \"%s\".", a_Command.c_str(), a_Plugin->GetName().c_str());
}
else
{
LOGWARNING("Console command \"%s\" is already bound to plugin \"%s\", cannot bind in plugin \"%s\".", a_Command.c_str(), cmd->second.m_Plugin->GetName().c_str(), a_Plugin->GetName().c_str());
}
return false;
}
auto & reg = m_ConsoleCommands[a_Command];
reg.m_Plugin = a_Plugin;
reg.m_Handler = a_Handler;
reg.m_Permission = "";
reg.m_HelpString = a_HelpString;
return true;
}
bool cSchematicFileSerializer::LoadFromSchematicNBT(cBlockArea & a_BlockArea, cParsedNBT & a_NBT)
{
int TMaterials = a_NBT.FindChildByName(a_NBT.GetRoot(), "Materials");
if ((TMaterials > 0) && (a_NBT.GetType(TMaterials) == TAG_String))
{
AString Materials = a_NBT.GetString(TMaterials);
if (Materials.compare("Alpha") != 0)
{
LOG("Materials tag is present and \"%s\" instead of \"Alpha\". Possibly a wrong-format schematic file.", Materials.c_str());
return false;
}
}
int TSizeX = a_NBT.FindChildByName(a_NBT.GetRoot(), "Width");
int TSizeY = a_NBT.FindChildByName(a_NBT.GetRoot(), "Height");
int TSizeZ = a_NBT.FindChildByName(a_NBT.GetRoot(), "Length");
if (
(TSizeX < 0) || (TSizeY < 0) || (TSizeZ < 0) ||
(a_NBT.GetType(TSizeX) != TAG_Short) ||
(a_NBT.GetType(TSizeY) != TAG_Short) ||
(a_NBT.GetType(TSizeZ) != TAG_Short)
)
{
LOG("Dimensions are missing from the schematic file (%d, %d, %d), (%d, %d, %d)",
TSizeX, TSizeY, TSizeZ,
(TSizeX >= 0) ? a_NBT.GetType(TSizeX) : -1,
(TSizeY >= 0) ? a_NBT.GetType(TSizeY) : -1,
(TSizeZ >= 0) ? a_NBT.GetType(TSizeZ) : -1
);
return false;
}
int SizeX = a_NBT.GetShort(TSizeX);
int SizeY = a_NBT.GetShort(TSizeY);
int SizeZ = a_NBT.GetShort(TSizeZ);
if ((SizeX < 1) || (SizeX > 65535) || (SizeY < 1) || (SizeY > cChunkDef::Height) || (SizeZ < 1) || (SizeZ > 65535))
{
LOG("Dimensions are invalid in the schematic file: %d, %d, %d", SizeX, SizeY, SizeZ);
return false;
}
int TBlockTypes = a_NBT.FindChildByName(a_NBT.GetRoot(), "Blocks");
int TBlockMetas = a_NBT.FindChildByName(a_NBT.GetRoot(), "Data");
if ((TBlockTypes < 0) || (a_NBT.GetType(TBlockTypes) != TAG_ByteArray))
{
LOG("BlockTypes are invalid in the schematic file: %d", TBlockTypes);
return false;
}
bool AreMetasPresent = (TBlockMetas > 0) && (a_NBT.GetType(TBlockMetas) == TAG_ByteArray);
a_BlockArea.Clear();
a_BlockArea.SetSize(SizeX, SizeY, SizeZ, AreMetasPresent ? (cBlockArea::baTypes | cBlockArea::baMetas) : cBlockArea::baTypes);
int TOffsetX = a_NBT.FindChildByName(a_NBT.GetRoot(), "WEOffsetX");
int TOffsetY = a_NBT.FindChildByName(a_NBT.GetRoot(), "WEOffsetY");
int TOffsetZ = a_NBT.FindChildByName(a_NBT.GetRoot(), "WEOffsetZ");
if (
(TOffsetX < 0) || (TOffsetY < 0) || (TOffsetZ < 0) ||
(a_NBT.GetType(TOffsetX) != TAG_Int) ||
(a_NBT.GetType(TOffsetY) != TAG_Int) ||
(a_NBT.GetType(TOffsetZ) != TAG_Int)
)
{
// Not every schematic file has an offset, so we shoudn't give a warn message.
a_BlockArea.SetWEOffset(0, 0, 0);
}
else
{
a_BlockArea.SetWEOffset(a_NBT.GetInt(TOffsetX), a_NBT.GetInt(TOffsetY), a_NBT.GetInt(TOffsetZ));
}
// Copy the block types and metas:
size_t NumTypeBytes = a_BlockArea.GetBlockCount();
if (a_NBT.GetDataLength(TBlockTypes) < NumTypeBytes)
{
LOG("BlockTypes truncated in the schematic file (exp %u, got %u bytes). Loading partial.",
static_cast<unsigned>(NumTypeBytes), static_cast<unsigned>(a_NBT.GetDataLength(TBlockTypes))
);
NumTypeBytes = a_NBT.GetDataLength(TBlockTypes);
}
memcpy(a_BlockArea.GetBlockTypes(), a_NBT.GetData(TBlockTypes), NumTypeBytes);
if (AreMetasPresent)
{
size_t NumMetaBytes = a_BlockArea.GetBlockCount();
if (a_NBT.GetDataLength(TBlockMetas) < NumMetaBytes)
{
LOG("BlockMetas truncated in the schematic file (exp %u, got %u bytes). Loading partial.",
static_cast<unsigned>(NumMetaBytes), static_cast<unsigned>(a_NBT.GetDataLength(TBlockMetas))
);
NumMetaBytes = a_NBT.GetDataLength(TBlockMetas);
}
memcpy(a_BlockArea.GetBlockMetas(), a_NBT.GetData(TBlockMetas), NumMetaBytes);
}
return true;
}
void cInputStream::LineError(const AString & a_ErrorMsg)
{
Error(Printf("Error while parsing line %d: %s", m_LineNum, a_ErrorMsg.c_str()));
}
bool cPlayer::SaveToDisk()
{
cFile::CreateFolder(FILE_IO_PREFIX + AString("players"));
// create the JSON data
Json::Value JSON_PlayerPosition;
JSON_PlayerPosition.append(Json::Value(GetPosX()));
JSON_PlayerPosition.append(Json::Value(GetPosY()));
JSON_PlayerPosition.append(Json::Value(GetPosZ()));
Json::Value JSON_PlayerRotation;
JSON_PlayerRotation.append(Json::Value(GetYaw()));
JSON_PlayerRotation.append(Json::Value(GetPitch()));
JSON_PlayerRotation.append(Json::Value(GetRoll()));
Json::Value JSON_Inventory;
m_Inventory.SaveToJson(JSON_Inventory);
Json::Value root;
root["position"] = JSON_PlayerPosition;
root["rotation"] = JSON_PlayerRotation;
root["inventory"] = JSON_Inventory;
root["health"] = m_Health;
root["xpTotal"] = m_LifetimeTotalXp;
root["xpCurrent"] = m_CurrentXp;
root["air"] = m_AirLevel;
root["food"] = m_FoodLevel;
root["foodSaturation"] = m_FoodSaturationLevel;
root["foodTickTimer"] = m_FoodTickTimer;
root["foodExhaustion"] = m_FoodExhaustionLevel;
root["world"] = GetWorld()->GetName();
root["isflying"] = IsFlying();
if (m_GameMode == GetWorld()->GetGameMode())
{
root["gamemode"] = (int) eGameMode_NotSet;
}
else
{
root["gamemode"] = (int) m_GameMode;
}
Json::StyledWriter writer;
std::string JsonData = writer.write(root);
AString SourceFile;
Printf(SourceFile, "players/%s.json", m_PlayerName.c_str() );
cFile f;
if (!f.Open(SourceFile, cFile::fmWrite))
{
LOGERROR("ERROR WRITING PLAYER \"%s\" TO FILE \"%s\" - cannot open file", m_PlayerName.c_str(), SourceFile.c_str());
return false;
}
if (f.Write(JsonData.c_str(), JsonData.size()) != (int)JsonData.size())
{
LOGERROR("ERROR WRITING PLAYER JSON TO FILE \"%s\"", SourceFile.c_str());
return false;
}
return true;
}
void cForgeHandshake::SetError(const AString & message)
{
LOGD("Forge handshake error: %s", message.c_str());
m_Errored = true;
}
cPlayer::cPlayer(cClientHandle* a_Client, const AString & a_PlayerName)
: super(etPlayer, 0.6, 1.8)
, m_bVisible(true)
, m_FoodLevel(MAX_FOOD_LEVEL)
, m_FoodSaturationLevel(5)
, m_FoodTickTimer(0)
, m_FoodExhaustionLevel(0)
, m_FoodPoisonedTicksRemaining(0)
, m_LastJumpHeight(0)
, m_LastGroundHeight(0)
, m_bTouchGround(false)
, m_Stance(0.0)
, m_Inventory(*this)
, m_CurrentWindow(NULL)
, m_InventoryWindow(NULL)
, m_Color('-')
, m_GameMode(eGameMode_NotSet)
, m_IP("")
, m_ClientHandle(a_Client)
, m_NormalMaxSpeed(1.0)
, m_SprintingMaxSpeed(1.3)
, m_FlyingMaxSpeed(1.0)
, m_IsCrouched(false)
, m_IsSprinting(false)
, m_IsFlying(false)
, m_IsSwimming(false)
, m_IsSubmerged(false)
, m_IsFishing(false)
, m_CanFly(false)
, m_EatingFinishTick(-1)
, m_LifetimeTotalXp(0)
, m_CurrentXp(0)
, m_bDirtyExperience(false)
, m_IsChargingBow(false)
, m_BowCharge(0)
, m_FloaterID(-1)
, m_Team(NULL)
{
LOGD("Created a player object for \"%s\" @ \"%s\" at %p, ID %d",
a_PlayerName.c_str(), a_Client->GetIPString().c_str(),
this, GetUniqueID()
);
m_InventoryWindow = new cInventoryWindow(*this);
m_CurrentWindow = m_InventoryWindow;
m_InventoryWindow->OpenedByPlayer(*this);
SetMaxHealth(MAX_HEALTH);
m_Health = MAX_HEALTH;
cTimer t1;
m_LastPlayerListTime = t1.GetNowTime();
m_TimeLastTeleportPacket = 0;
m_PlayerName = a_PlayerName;
m_bDirtyPosition = true; // So chunks are streamed to player at spawn
if (!LoadFromDisk())
{
m_Inventory.Clear();
SetPosX(cRoot::Get()->GetDefaultWorld()->GetSpawnX());
SetPosY(cRoot::Get()->GetDefaultWorld()->GetSpawnY());
SetPosZ(cRoot::Get()->GetDefaultWorld()->GetSpawnZ());
LOGD("Player \"%s\" is connecting for the first time, spawning at default world spawn {%.2f, %.2f, %.2f}",
a_PlayerName.c_str(), GetPosX(), GetPosY(), GetPosZ()
);
}
m_LastJumpHeight = (float)(GetPosY());
m_LastGroundHeight = (float)(GetPosY());
m_Stance = GetPosY() + 1.62;
if (m_GameMode == gmNotSet)
{
cWorld * World = cRoot::Get()->GetWorld(GetLoadedWorldName());
if (World == NULL)
{
World = cRoot::Get()->GetDefaultWorld();
}
if (World->IsGameModeCreative())
{
m_CanFly = true;
}
}
cRoot::Get()->GetServer()->PlayerCreated(this);
}
/** Called when the first line (request / status) is fully parsed. */
virtual void OnFirstLine(const AString & a_FirstLine) override
{
printf("First line: \"%s\"\n", a_FirstLine.c_str());
}
void MediaCodecList::parseTopLevelXMLFile(const char *codecs_xml) {
// get href_base
char *href_base_end = strrchr(codecs_xml, '/');
if (href_base_end != NULL) {
mHrefBase = AString(codecs_xml, href_base_end - codecs_xml + 1);
}
mInitCheck = OK; // keeping this here for safety
mCurrentSection = SECTION_TOPLEVEL;
mDepth = 0;
OMXClient client;
mInitCheck = client.connect();
if (mInitCheck != OK) {
return;
}
mOMX = client.interface();
parseXMLFile(codecs_xml);
mOMX.clear();
if (mInitCheck != OK) {
mCodecInfos.clear();
return;
}
for (size_t i = mCodecInfos.size(); i-- > 0;) {
const MediaCodecInfo &info = *mCodecInfos.itemAt(i).get();
if (info.mCaps.size() == 0) {
// No types supported by this component???
ALOGW("Component %s does not support any type of media?",
info.mName.c_str());
mCodecInfos.removeAt(i);
#if LOG_NDEBUG == 0
} else {
for (size_t type_ix = 0; type_ix < info.mCaps.size(); ++type_ix) {
AString mime = info.mCaps.keyAt(type_ix);
const sp<MediaCodecInfo::Capabilities> &caps = info.mCaps.valueAt(type_ix);
ALOGV("%s codec info for %s: %s", info.mName.c_str(), mime.c_str(),
caps->getDetails()->debugString().c_str());
ALOGV(" flags=%d", caps->getFlags());
{
Vector<uint32_t> colorFormats;
caps->getSupportedColorFormats(&colorFormats);
AString nice;
for (size_t ix = 0; ix < colorFormats.size(); ix++) {
if (ix > 0) {
nice.append(", ");
}
nice.append(colorFormats.itemAt(ix));
}
ALOGV(" colors=[%s]", nice.c_str());
}
{
Vector<MediaCodecInfo::ProfileLevel> profileLevels;
caps->getSupportedProfileLevels(&profileLevels);
AString nice;
for (size_t ix = 0; ix < profileLevels.size(); ix++) {
if (ix > 0) {
nice.append(", ");
}
const MediaCodecInfo::ProfileLevel &pl =
profileLevels.itemAt(ix);
nice.append(pl.mProfile);
nice.append("/");
nice.append(pl.mLevel);
}
ALOGV(" levels=[%s]", nice.c_str());
}
}
#endif
}
}
// for CTS
#ifdef MTK_AOSP_ENHANCEMENT
#ifndef MTK_WMA_PLAYBACK_SUPPORT
const char* wma_name = "OMX.MTK.AUDIO.DECODER.WMA";
deleteByType(wma_name);
#endif
#ifndef MTK_SWIP_WMAPRO
const char* wmapro_name = "OMX.MTK.AUDIO.DECODER.WMAPRO";
deleteByType(wmapro_name);
#endif
#ifndef MTK_AUDIO_RAW_SUPPORT
const char* pcm_name = "OMX.MTK.AUDIO.DECODER.RAW";
deleteByType(pcm_name);
#endif
#ifndef MTK_AUDIO_DDPLUS_SUPPORT
const char* DDPLUS_name1 = "OMX.dolby.ac3.decoder";
deleteByType(DDPLUS_name1);
const char* DDPLUS_name2 = "OMX.dolby.ec3.decoder";
deleteByType(DDPLUS_name2);
#endif
#ifndef MTK_AUDIO_APE_SUPPORT
const char* ape_name = "OMX.MTK.AUDIO.DECODER.APE";
deleteByType(ape_name);
#endif
#endif
#if 0
for (size_t i = 0; i < mCodecInfos.size(); ++i) {
const CodecInfo &info = mCodecInfos.itemAt(i);
AString line = info.mName;
line.append(" supports ");
for (size_t j = 0; j < mTypes.size(); ++j) {
uint32_t value = mTypes.valueAt(j);
if (info.mTypes & (1ul << value)) {
line.append(mTypes.keyAt(j));
line.append(" ");
}
}
ALOGI("%s", line.c_str());
}
#endif
}
/** Called for each chunk of the incoming body data. */
virtual void OnBodyData(const void * a_Data, size_t a_Size) override
{
AString hexDump;
CreateHexDump(hexDump, a_Data, a_Size, 16);
printf("Body data: %u bytes\n%s", static_cast<unsigned>(a_Size), hexDump.c_str());
}
MediaCodecList::MediaCodecList()
: mInitCheck(NO_INIT) {
FILE *file = fopen("/etc/media_codecs.xml", "r");
if (file == NULL) {
ALOGW("unable to open media codecs configuration xml file.");
return;
}
parseXMLFile(file);
if (mInitCheck == OK) {
// These are currently still used by the video editing suite.
addMediaCodec(true /* encoder */, "AACEncoder", "audio/mp4a-latm");
addMediaCodec(
false /* encoder */, "OMX.google.raw.decoder", "audio/raw");
}
// for CTS
#ifndef ANDROID_DEFAULT_CODE
#ifndef MTK_WMA_PLAYBACK_SUPPORT
ALOGD("WMA BUILD OPTION IS CLOSED");
const char* wma_name2 = "OMX.MTK.AUDIO.DECODER.WMA";
size_t indexForWma2 = findCodecByName(wma_name2);
if(indexForWma2 >= 0)
mCodecInfos.removeAt(indexForWma2);
#endif
#ifndef MTK_WMA_PLAYBACK_SUPPORT
ALOGD("ASF BUILD OPTION IS CLOSED");
const char* wma_name = "OMX.MTK.AUDIO.DECODER.WMA";
size_t indexForWma = findCodecByName(wma_name);
if(indexForWma >= 0)
mCodecInfos.removeAt(indexForWma);
#endif
#ifndef MTK_SWIP_WMAPRO
ALOGD("WMA PRO BUILD OPTION IS CLOSED");
const char* wmapro_name = "OMX.MTK.AUDIO.DECODER.WMAPRO";
size_t indexForWmapro = findCodecByName(wmapro_name);
if(indexForWmapro >= 0)
mCodecInfos.removeAt(indexForWmapro);
#endif
#ifndef MTK_AUDIO_RAW_SUPPORT
ALOGD("PCM Component BUILD OPTION IS CLOSED");
const char* pcm_name = "OMX.MTK.AUDIO.DECODER.RAW";
size_t indexForRaw = findCodecByName(pcm_name);
if(indexForRaw >= 0)
mCodecInfos.removeAt(indexForRaw);
#endif
#ifndef MTK_AUDIO_DDPLUS_SUPPORT
ALOGD("DDPLUS Component BUILD OPTION IS CLOSED");
ssize_t indexForDDPus = findCodecByName("OMX.dolby.ac3.decoder");
if (indexForDDPus >= 0)
mCodecInfos.removeAt(indexForDDPus);
indexForDDPus = findCodecByName("OMX.dolby.ec3.decoder");
if (indexForDDPus >= 0)
mCodecInfos.removeAt(indexForDDPus);
#endif
#ifndef MTK_AUDIO_APE_SUPPORT
ALOGD("APE Component BUILD OPTION IS CLOSED");
const char* ape_name = "OMX.MTK.AUDIO.DECODER.APE";
size_t indexForApe = findCodecByName(ape_name);
if(indexForApe >= 0)
mCodecInfos.removeAt(indexForApe);
#endif
#endif
#if 0
for (size_t i = 0; i < mCodecInfos.size(); ++i) {
const CodecInfo &info = mCodecInfos.itemAt(i);
AString line = info.mName;
line.append(" supports ");
for (size_t j = 0; j < mTypes.size(); ++j) {
uint32_t value = mTypes.valueAt(j);
if (info.mTypes & (1ul << value)) {
line.append(mTypes.keyAt(j));
line.append(" ");
}
}
ALOGI("%s", line.c_str());
}
#endif
fclose(file);
file = NULL;
}
static status_t limitFoundMissingAttr(AString name, const char *attr, bool found = true) {
ALOGE("limit '%s' with %s'%s' attribute", name.c_str(),
(found ? "" : "no "), attr);
return -EINVAL;
}
bool cFile::DeleteFile(const AString & a_FileName)
{
return (remove(a_FileName.c_str()) == 0);
}
static status_t limitInvalidAttr(AString name, const char *attr, AString value) {
ALOGE("limit '%s' with invalid '%s' attribute (%s)", name.c_str(),
attr, value.c_str());
return -EINVAL;
}
bool cFile::Rename(const AString & a_OrigFileName, const AString & a_NewFileName)
{
return (rename(a_OrigFileName.c_str(), a_NewFileName.c_str()) == 0);
}
OMX_ERRORTYPE SoftOMXPlugin::makeComponentInstance(
const char *name,
const OMX_CALLBACKTYPE *callbacks,
OMX_PTR appData,
OMX_COMPONENTTYPE **component) {
ALOGV("makeComponentInstance '%s'", name);
for (size_t i = 0; i < kNumComponents; ++i) {
if (strcmp(name, kComponents[i].mName)) {
continue;
}
AString libName = "libstagefright_soft_";
libName.append(kComponents[i].mLibNameSuffix);
libName.append(".so");
void *libHandle = dlopen(libName.c_str(), RTLD_NOW);
if (libHandle == NULL) {
ALOGE("unable to dlopen %s", libName.c_str());
return OMX_ErrorComponentNotFound;
}
typedef SoftOMXComponent *(*CreateSoftOMXComponentFunc)(
const char *, const OMX_CALLBACKTYPE *,
OMX_PTR, OMX_COMPONENTTYPE **);
CreateSoftOMXComponentFunc createSoftOMXComponent =
(CreateSoftOMXComponentFunc)dlsym(
libHandle,
"_Z22createSoftOMXComponentPKcPK16OMX_CALLBACKTYPE"
"PvPP17OMX_COMPONENTTYPE");
if (createSoftOMXComponent == NULL) {
dlclose(libHandle);
libHandle = NULL;
return OMX_ErrorComponentNotFound;
}
sp<SoftOMXComponent> codec =
(*createSoftOMXComponent)(name, callbacks, appData, component);
if (codec == NULL) {
dlclose(libHandle);
libHandle = NULL;
return OMX_ErrorInsufficientResources;
}
OMX_ERRORTYPE err = codec->initCheck();
if (err != OMX_ErrorNone) {
dlclose(libHandle);
libHandle = NULL;
return err;
}
codec->incStrong(this);
codec->setLibHandle(libHandle);
return OMX_ErrorNone;
}
return OMX_ErrorInvalidComponentName;
}
int main(int argc, char **argv) {
using namespace android;
ProcessState::self()->startThreadPool();
DataSource::RegisterDefaultSniffers();
AString connectToHost;
int32_t connectToPort = -1;
AString uri;
AString listenOnAddr;
int32_t listenOnPort = -1;
AString path;
///M: @{
int isFastSetup = 0;
///@}
int res;
while ((res = getopt(argc, argv, "hpic:b:l:t:f:r:u:e:s:d")) >= 0) {
switch (res) {
case 'b':
{
const char *colonPos = strrchr(optarg, ':');
if (colonPos == NULL) {
connectToHost = optarg;
connectToPort = WFD_UIBC_SERVER_PORT;
} else {
connectToHost.setTo(optarg, colonPos - optarg);
char *end;
connectToPort = strtol(colonPos + 1, &end, 10);
if (*end != '\0' || end == colonPos + 1
|| connectToPort < 1 || connectToPort > 65535) {
fprintf(stderr, "Illegal port specified.\n");
exit(1);
}
}
connectUibc(connectToHost.c_str(), connectToPort);
exit(1);
break;
}
case 't':
{
isFastSetup = 1;
}
case 'f':
{
path = optarg;
break;
}
case 'u':
{
uri = optarg;
break;
}
case 'l':
{
const char *colonPos = strrchr(optarg, ':');
if (colonPos == NULL) {
listenOnAddr = optarg;
listenOnPort = WifiDisplaySource::kWifiDisplayDefaultPort;
} else {
listenOnAddr.setTo(optarg, colonPos - optarg);
char *end;
listenOnPort = strtol(colonPos + 1, &end, 10);
if (*end != '\0' || end == colonPos + 1
|| listenOnPort < 1 || listenOnPort > 65535) {
fprintf(stderr, "Illegal port specified.\n");
exit(1);
}
}
break;
}
case 'r':
{
enableFastRtpRemoteDisplay(optarg);
exit(0);
break;
}
case 'e':
{
enableDisableRemoteDisplay(optarg);
exit(0);
break;
}
case 'd':
{
enableDisableRemoteDisplay(NULL);
exit(0);
break;
}
case 's':
{
setStreamMode(optarg);
exit(0);
break;
}
case '?':
case 'h':
default:
testUibcCmd(argv[1]);
usage(argv[0]);
exit(1);
}
}
if (listenOnPort >= 0) {
if (path.empty()) {
createSource(listenOnAddr, listenOnPort);
} else {
createFileSource(listenOnAddr, listenOnPort, path.c_str());
}
exit(0);
}
usage(argv[0]);
return 0;
}
void Converter::onMessageReceived(const sp<AMessage> &msg) {
switch (msg->what()) {
case kWhatMediaPullerNotify:
{
int32_t what;
CHECK(msg->findInt32("what", &what));
if (!mIsPCMAudio && mEncoder == NULL) {
ALOGV("got msg '%s' after encoder shutdown.",
msg->debugString().c_str());
if (what == MediaPuller::kWhatAccessUnit) {
sp<ABuffer> accessUnit;
CHECK(msg->findBuffer("accessUnit", &accessUnit));
void *mbuf;
if (accessUnit->meta()->findPointer("mediaBuffer", &mbuf)
&& mbuf != NULL) {
ALOGV("releasing mbuf %p", mbuf);
accessUnit->meta()->setPointer("mediaBuffer", NULL);
static_cast<MediaBuffer *>(mbuf)->release();
mbuf = NULL;
}
}
break;
}
if (what == MediaPuller::kWhatEOS) {
mInputBufferQueue.push_back(NULL);
feedEncoderInputBuffers();
scheduleDoMoreWork();
} else {
CHECK_EQ(what, (status_t)MediaPuller::kWhatAccessUnit);
sp<ABuffer> accessUnit;
CHECK(msg->findBuffer("accessUnit", &accessUnit));
#if 0
void *mbuf;
if (accessUnit->meta()->findPointer("mediaBuffer", &mbuf)
&& mbuf != NULL) {
ALOGI("queueing mbuf %p", mbuf);
}
#endif
#if ENABLE_SILENCE_DETECTION
if (!mIsVideo) {
if (IsSilence(accessUnit)) {
if (mInSilentMode) {
break;
}
int64_t nowUs = ALooper::GetNowUs();
if (mFirstSilentFrameUs < 0ll) {
mFirstSilentFrameUs = nowUs;
} else if (nowUs >= mFirstSilentFrameUs + 10000000ll) {
mInSilentMode = true;
ALOGI("audio in silent mode now.");
break;
}
} else {
if (mInSilentMode) {
ALOGI("audio no longer in silent mode.");
}
mInSilentMode = false;
mFirstSilentFrameUs = -1ll;
}
}
#endif
mInputBufferQueue.push_back(accessUnit);
feedEncoderInputBuffers();
scheduleDoMoreWork();
}
break;
}
case kWhatEncoderActivity:
{
#if 0
int64_t whenUs;
if (msg->findInt64("whenUs", &whenUs)) {
int64_t nowUs = ALooper::GetNowUs();
ALOGI("[%s] kWhatEncoderActivity after %lld us",
mIsVideo ? "video" : "audio", nowUs - whenUs);
}
#endif
mDoMoreWorkPending = false;
if (mEncoder == NULL) {
break;
}
status_t err = doMoreWork();
if (err != OK) {
notifyError(err);
} else {
scheduleDoMoreWork();
}
break;
}
case kWhatRequestIDRFrame:
{
if (mEncoder == NULL) {
break;
}
if (mIsVideo) {
ALOGI("requesting IDR frame");
mEncoder->requestIDRFrame();
}
break;
}
case kWhatShutdown:
{
ALOGI("shutting down encoder");
if (mEncoder != NULL) {
mEncoder->release();
mEncoder.clear();
}
AString mime;
CHECK(mInputFormat->findString("mime", &mime));
ALOGI("encoder (%s) shut down.", mime.c_str());
break;
}
default:
TRESPASS();
}
}
bool ASessionDescription::parse(const void *data, size_t size) {
mTracks.clear();
mFormats.clear();
mTracks.push(Attribs());
mFormats.push(AString("[root]"));
AString desc((const char *)data, size);
size_t i = 0;
for (;;) {
ssize_t eolPos = desc.find("\n", i);
if (eolPos < 0) {
break;
}
AString line;
if ((size_t)eolPos > i && desc.c_str()[eolPos - 1] == '\r') {
// We accept both '\n' and '\r\n' line endings, if it's
// the latter, strip the '\r' as well.
line.setTo(desc, i, eolPos - i - 1);
} else {
line.setTo(desc, i, eolPos - i);
}
if (line.size() < 2 || line.c_str()[1] != '=') {
return false;
}
LOGI("%s", line.c_str());
switch (line.c_str()[0]) {
case 'v':
{
if (strcmp(line.c_str(), "v=0")) {
return false;
}
break;
}
case 'a':
case 'b':
{
AString key, value;
ssize_t colonPos = line.find(":", 2);
if (colonPos < 0) {
key = line;
} else {
key.setTo(line, 0, colonPos);
if (key == "a=fmtp" || key == "a=rtpmap"
|| key == "a=framesize") {
ssize_t spacePos = line.find(" ", colonPos + 1);
if (spacePos < 0) {
return false;
}
key.setTo(line, 0, spacePos);
colonPos = spacePos;
}
value.setTo(line, colonPos + 1, line.size() - colonPos - 1);
}
key.trim();
value.trim();
LOGV("adding '%s' => '%s'", key.c_str(), value.c_str());
mTracks.editItemAt(mTracks.size() - 1).add(key, value);
break;
}
case 'm':
{
LOGV("new section '%s'",
AString(line, 2, line.size() - 2).c_str());
mTracks.push(Attribs());
mFormats.push(AString(line, 2, line.size() - 2));
break;
}
default:
{
AString key, value;
ssize_t equalPos = line.find("=");
key = AString(line, 0, equalPos + 1);
value = AString(line, equalPos + 1, line.size() - equalPos - 1);
key.trim();
value.trim();
LOGV("adding '%s' => '%s'", key.c_str(), value.c_str());
mTracks.editItemAt(mTracks.size() - 1).add(key, value);
break;
}
}
i = eolPos + 1;
}
return true;
}