StationAccessPoint
Esp8266WiFiPhy::GetConnectedStationAP(bool flashStored){
string ATCommand;
testprintf("\r\nEntering %s ...", __PRETTY_FUNCTION__);
// header
ATCommand = "AT+CWJAP_";
if (flashStored){
ATCommand += "DEF";
}
else {
ATCommand += "CUR";
}
ATCommand +="\?\r\n";
// resets the buffer from any spurious previous output and send
m_UART->rxBufferFlush();
UART_TX(ATCommand);
dbgprintf("SEND:\r\n%s",ATCommand.c_str());
if(!WaitFor("OK")){
printf("Error: Missed OK reply - AT+CWJAP\?\r\n");
return StationAccessPoint("","","");
}
size_t from = 0;
string ssid = StringUnescape(GetStringBetweenTokens(':',',',m_lastATreply, from));
string bssid = StringUnescape(GetStringBetweenTokens(',',',',m_lastATreply, from));
string channel = GetStringBetweenTokens(',',',',m_lastATreply, from);
string rssi = GetStringBetweenTokens(',','\r',m_lastATreply, from);
dbgprintf("AccessPoint: <%s>,<%s>,<%s>,<%s>\r\n", ssid.c_str(), bssid.c_str(), channel.c_str(), rssi.c_str());
testprintf("Ended!\r\n");
return StationAccessPoint(ssid,bssid,StringToInteger(channel),StringToInteger(rssi));
}
/** Parses a string containing a range in which both values are optional ("<MinHeight>|<MaxHeight>") into Min, Range.
Returns true if successful, false on failure.
If a_LogWarnings is true, outputs failure reasons to console.
The range is returned in a_Min and a_Range, they are left unchanged if the range value is not present in the string. */
static bool ParseRange(const AString & a_Params, int & a_Min, int & a_Range, bool a_LogWarnings)
{
auto params = StringSplitAndTrim(a_Params, "|");
if (params.size() == 0)
{
// No params, generate directly on top:
return true;
}
if (!StringToInteger(params[0], a_Min))
{
// Failed to parse the min rel height:
CONDWARNING(a_LogWarnings, "Cannot parse minimum height from string \"%s\"!", params[0].c_str());
return false;
}
if (params.size() == 1)
{
// Only one param was given, there's no range
return true;
}
int maxHeight = a_Min;
if (!StringToInteger(params[1], maxHeight))
{
CONDWARNING(a_LogWarnings, "Cannot parse maximum height from string \"%s\"!", params[1].c_str());
return false;
}
if (maxHeight < a_Min)
{
std::swap(maxHeight, a_Min);
}
a_Range = maxHeight - a_Min + 1;
return true;
}
RationalExpression::RationalExpression(Scanner& s) {
this->numerator = StringToInteger(s.nextToken());
string lookahead = s.nextToken();
if (lookahead == "/") {
this->denominator = StringToInteger(s.nextToken());
} else {
s.saveToken(lookahead);
this->denominator = 1;
}
reduce();
}
PRBool
nsAttrValue::ParseSpecialIntValue(const nsAString& aString)
{
ResetIfSet();
PRInt32 ec;
PRBool strict;
PRBool isPercent = PR_FALSE;
nsAutoString tmp(aString);
PRInt32 originalVal = StringToInteger(aString, &strict, &ec, PR_TRUE, &isPercent);
if (NS_FAILED(ec)) {
return PR_FALSE;
}
PRInt32 val = NS_MAX(originalVal, 0);
// % (percent)
if (isPercent || tmp.RFindChar('%') >= 0) {
isPercent = PR_TRUE;
}
strict = strict && (originalVal == val);
SetIntValueAndType(val,
isPercent ? ePercent : eInteger,
strict ? nsnull : &aString);
return PR_TRUE;
}
ship_p GetData(FILE *infile,class_p *class_p_p,ship_p *ship_p_p,int *ship_num_p)
{
int n,m,i,k;
string clas;
fscanf(infile,"Num Classes: %d\n",&n);
*class_p_p=GetBlock( n * sizeof(**class_p_p));
for (i=0;i<=n-1;i++)
{
(*class_p_p+i)->name=ReadLine(infile);
(*class_p_p+i)->length=StringToInteger(ReadLine(infile));
(*class_p_p+i)->color=ReadLine(infile);
(*class_p_p+i)->sound=ReadLine(infile);
(*class_p_p+i)->num=0;
ReadLine(infile);
}
fscanf(infile,"Num Ships: %d\n",&m);
*ship_num_p=m;
*ship_p_p=GetBlock( m * sizeof(**ship_p_p));
for (i=0;i<=m-1;i++)
{
(*ship_p_p+i)->name=ReadLine(infile);
clas=ReadLine(infile);
for (k=0;k<=n-1;k++)
{
if ( StringEqual( clas,(*class_p_p+k)->name ) )
{
(*ship_p_p+i)->clas=k;
( (*class_p_p+k)->num )++;
(*ship_p_p+i)->contain=GetBlock( (*class_p_p+k)->length * sizeof(coord) );
}
}
ReadLine(infile);
}
return *ship_p_p;
}
void cHTTPMessage::AddHeader(const AString & a_Key, const AString & a_Value)
{
AString Key = StrToLower(a_Key);
cNameValueMap::iterator itr = m_Headers.find(Key);
if (itr == m_Headers.end())
{
m_Headers[Key] = a_Value;
}
else
{
// The header-field key is specified multiple times, combine into comma-separated list (RFC 2616 @ 4.2)
itr->second.append(", ");
itr->second.append(a_Value);
}
// Special processing for well-known headers:
if (Key == "content-type")
{
m_ContentType = m_Headers[Key];
}
else if (Key == "content-length")
{
if (!StringToInteger(m_Headers[Key], m_ContentLength))
{
m_ContentLength = 0;
}
}
}
bool cServer::Start(void)
{
for (auto port: m_Ports)
{
UInt16 PortNum;
if (!StringToInteger(port, PortNum))
{
LOGWARNING("Invalid port specified for server: \"%s\". Ignoring.", port.c_str());
continue;
}
auto Handle = cNetwork::Listen(PortNum, std::make_shared<cServerListenCallbacks>(*this, PortNum));
if (Handle->IsListening())
{
m_ServerHandles.push_back(Handle);
}
} // for port - Ports[]
if (m_ServerHandles.empty())
{
LOGERROR("Couldn't open any ports. Aborting the server");
return false;
}
if (!m_TickThread.Start())
{
return false;
}
return true;
}
bool ResolveItem(const AString & a_ItemName, cItem & a_Item)
{
// Split into parts divided by either ':' or '^'
AStringVector Split = StringSplitAndTrim(a_ItemName, ":^");
if (Split.empty())
{
return false;
}
ItemMap::iterator itr = m_Map.find(Split[0]);
if (itr != m_Map.end())
{
// Resolved as a string, assign the type and the default damage / count
a_Item.m_ItemType = itr->second.first;
a_Item.m_ItemDamage = itr->second.second;
if (a_Item.m_ItemDamage == -1)
{
a_Item.m_ItemDamage = 0;
}
}
else
{
// Not a resolvable string, try pure numbers: "45:6", "45^6" etc.
if (!StringToInteger(Split[0], a_Item.m_ItemType))
{
// Parsing the number failed
return false;
}
}
// Parse the damage, if present:
if (Split.size() < 2)
{
// Not present, set the item as valid and return success:
a_Item.m_ItemCount = 1;
return true;
}
if (!StringToInteger(Split[1], a_Item.m_ItemDamage))
{
// Parsing the number failed
return false;
}
a_Item.m_ItemCount = 1;
return true;
}
int main(int argc, char ** argv)
{
// Initialize logging subsystem:
auto consoleLogListener = MakeConsoleListener(false);
auto consoleAttachment = cLogger::GetInstance().AttachListener(std::move(consoleLogListener));
auto fileLogListenerRet = MakeFileListener();
if (!fileLogListenerRet.first)
{
LOGERROR("Failed to open log file, aborting");
return EXIT_FAILURE;
}
auto fileAttachment = cLogger::GetInstance().AttachListener(std::move(fileLogListenerRet.second));
cLogger::InitiateMultithreading();
UInt16 ListenPort = 25564;
UInt16 ConnectPort = 25565;
if (argc > 1)
{
if (!StringToInteger(argv[1], ListenPort))
{
LOGERROR("Invalid argument 1, expected port number, got \"%s\". Aborting.", argv[1]);
return 1;
}
if (argc > 2)
{
if (!StringToInteger(argv[2], ConnectPort))
{
LOGERROR("Invalid argument 2, expected port number, got \"%s\". Aborting.", argv[2]);
return 2;
}
}
}
cServer Server;
int res = Server.Init(ListenPort, ConnectPort);
if (res != 0)
{
LOGERROR("Server initialization failed: %d", res);
return res;
}
Server.Run();
return 0;
}
int GetPointSize()
{
if (TcpClient == NULL) Error("Graphics not initialized");
string resp = TcpClient->ExchangeMsg("GETPOINTSIZE");
int val;
try { val = StringToInteger(resp); }
catch (ErrorException e) { Error("GetPointSize: " + resp); }
return val;
}
virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
{
// Params: "<Height>", compulsory
if (!StringToInteger(a_Params, m_Height))
{
CONDWARNING(a_LogWarnings, "Cannot parse the fixed height from string \"%s\"!", a_Params.c_str());
return false;
}
return true;
}
Vector<int> getInput() {
int* pointer;
Vector<int> vect;
while(true) {
cout << "Enter value (enter to quit): " ;
string input = GetLine();
if (input == "") break;
int value = StringToInteger(input);
vect.add(value);
}
return vect;
}
virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) override
{
// Params: "<MinHeight>|<MaxHeight>", all compulsory
auto params = StringSplitAndTrim(a_Params, "|");
if (params.size() != 2)
{
CONDWARNING(a_LogWarnings, "Cannot parse the range parameters from string \"%s\"!", a_Params.c_str());
return false;
}
int Max = 0;
if (!StringToInteger(params[0], m_Min) || !StringToInteger(params[1], Max))
{
CONDWARNING(a_LogWarnings, "Cannot parse the minimum or maximum height from string \"%s\"!", a_Params.c_str());
return false;
}
if (m_Min > Max)
{
std::swap(m_Min, Max);
}
m_Range = Max - m_Min + 1;
return true;
}
static void SelectionOperation(dataBlockT db, string lhs)
{
string var;
int pos;
if (lhs != NULL) Error("NthElement result cannot be assigned");
CheckForToken(db->scanner, "(");
var = ConvertToLowerCase(ReadToken(db->scanner));
CheckForToken(db->scanner, ",");
pos = StringToInteger(ReadToken(db->scanner));
CheckForToken(db->scanner, ")");
printf("%s\n", NthElement(GetValue(db, var), pos));
}
SoftAccessPoint
Esp8266WiFiPhy::GetConfigurationSoftAP(bool flashStored){
string ATCommand;
testprintf("\r\nEntering %s ...", __PRETTY_FUNCTION__);
// header
ATCommand = "AT+CWSAP_";
// store
if (flashStored){
ATCommand += "DEF";
}
else {
ATCommand += "CUR";
}
ATCommand +="\?\r\n";
// resets the buffer from any spurious previous output and send
m_UART->rxBufferFlush();
UART_TX(ATCommand);
dbgprintf("SEND:\r\n%s",ATCommand.c_str());
if(!WaitFor("OK")){
printf("Error: Missed OK reply - AT+CWSAP\?\r\n");
return SoftAccessPoint("","",-1,-1,-1,-1);
}
size_t from = 0;
string ssid = StringUnescape(GetStringBetweenTokens(':',',',m_lastATreply, from));
string password = StringUnescape(GetStringBetweenTokens(',',',',m_lastATreply, from));
string channel = GetStringBetweenTokens(',',',',m_lastATreply, from);
string encryption = GetStringBetweenTokens(',',',',m_lastATreply, from);
string max_conn = GetStringBetweenTokens(',',',',m_lastATreply, from);
string ssid_bcast = GetStringBetweenTokens(',','\r',m_lastATreply, from);
dbgprintf("AccessPoint: <%s>,<%s>,<%s>,<%s>,<%s>,<%s>\r\n", ssid.c_str(), password.c_str(), channel.c_str(), encryption.c_str(), max_conn.c_str(), ssid_bcast.c_str());
testprintf("Ended!\r\n");
return SoftAccessPoint(ssid,password,StringToInteger(channel),StringToInteger(encryption),StringToInteger(max_conn),StringToInteger(ssid_bcast));
}
void AddToMap(const AString & a_Name, const AString & a_Value)
{
AStringVector Split = StringSplit(a_Value, ":");
if (Split.size() == 1)
{
Split = StringSplit(a_Value, "^");
}
if (Split.empty())
{
return;
}
short ItemType;
if (!StringToInteger(Split[0], ItemType))
{
ASSERT(!"Invalid item type");
}
short ItemDamage = -1;
if (Split.size() > 1 && !StringToInteger(Split[1], ItemDamage))
{
ASSERT(!"Invalid item damage");
}
m_Map[a_Name] = std::make_pair(ItemType, ItemDamage);
}
PRBool
nsAttrValue::ParsePositiveIntValue(const nsAString& aString)
{
ResetIfSet();
PRInt32 ec;
PRBool strict;
PRInt32 originalVal = StringToInteger(aString, &strict, &ec);
if (NS_FAILED(ec) || originalVal <= 0) {
return PR_FALSE;
}
SetIntValueAndType(originalVal, eInteger, nsnull);
return PR_TRUE;
}
/*
Function: DevelopHistogram
Usage: DevelopHistogram(scores, histo, n)
-----------------------------------------
Upon receiving a vector of numeric strings 'scores', which range as
0 <= score <= 99, we examine the number that start with any given digit,
updating the counts within the array 'histo'. 'histo' will have 'n'
different categories/slots, could probably hardcode as 10 since 0<n<100.
*/
void DevelopHistogram(scoresV scores, int histo[], int n) {
// Initialize the histogram
for (int i = 0; i < n; i++) {
histo[i] = 0;
}
for (int i = 0; i < scores.size(); i++) {
// get first char of score
if (scores[i].length() > 1) {
//tens_char.push_back( (scores[i])[0] ); // from earlier efforts...
histo[ StringToInteger(string ("") + (scores[i])[0]) ] ++;
}
else {
histo[0] ++;
}
}
}
static bool ReadOneQuestion(FILE *infile, courseDB course)
{
questionT question;
string line;
int qnum;
line = ReadLine(infile);
if (line == NULL) return (FALSE);
qnum = StringToInteger(line);
if (qnum < 1 || qnum > MaxQuestions) {
Error("Question number %d out of range", qnum);
}
question = New(questionT);
ReadQuestionText(infile, question);
ReadAnswers(infile, question);
course->questions[qnum] = question;
return (TRUE);
}
/*
Function: DevelopHistogram
Usage: DevelopHistogram(scores, histo, n)
-----------------------------------------
Upon receiving a vector of numeric strings 'scores', which range as
0 <= score <= 99, we examine the number that start with any given digit,
updating the counts within the array 'histo'. 'histo' will have 'n'
different categories/slots, could probably hardcode as 10 since 0<n<100.
*/
void DevelopHistogram(scoresV scores, int histo[], int n) {
// Initialize the histogram
for (int i = 0; i < n; i++) {
histo[i] = 0;
}
for (int i = 0; i < scores.size(); i++) {
// get first char of score
if (scores[i].length() > 1) {
string tens_char = "";
tens_char.push_back( (scores[i])[0] );
histo[ StringToInteger(tens_char) ] ++;
}
else {
histo[0] ++;
}
}
}
void ReadScores1(ifstream &in1, Vector<int> &scores) {
while (true) {
string line;
getline(in1, line);
if (in1.fail()) {
break; // no more lines to read
}
cout << line << endl;
//Input line must be well form. Only digits. No letters, punctuation or whitespace.
int x = StringToInteger(line);
if (x >= 0 && x <= 99) {
scores[x / 10] += 1;
}
}
}
static void ReadAnswers(FILE *infile, questionT q)
{
string line, ans;
int len, cpos, nextq, nAnswers;
nAnswers = 0;
while ((line = ReadLine(infile)) != NULL
&& (len = StringLength(line)) != 0) {
cpos = FindChar(':', line, 0);
if (cpos == -1) Error("Illegal answer format");
ans = SubString(line, 0, cpos - 1);
nextq = StringToInteger(SubString(line, cpos+1, len-1));
q->answers[nAnswers].ans = ConvertToUpperCase(ans);
q->answers[nAnswers].nextq = nextq;
nAnswers++;
}
q->nAnswers = nAnswers;
}
bool Encoding::compress(ibstream &inStream, obstream &outStream){
buildEncodingForInput(inStream);
int input;
string code;
map<int, string>::iterator it;
outStream.put(mp.size());
outStream.put('|');
for (it = mp.begin(); it != mp.end(); it++){
outStream.put(it->first);
//cout << it->first << " has the code ";
for (int i = 0; i < it->second.size(); i++){
outStream.put(it->second[i]);
//cout << it->second[i];
}
outStream.put('|');
//cout << endl;
}
inStream.rewind();
string temp;
int letter;
int temps;
for (int i = 0; i < inStream.size(); i++){
temps = inStream.size();
input = inStream.get();
code = mp[input];
for (int i = 0; i < code.length(); i++){
temp = code[i];
outStream.writebit(StringToInteger(temp));
//cout << code[i];
}
//cout << endl;
}
outStream.put(_EOF_);
outStream.close();
return true;
}
PRBool
nsAttrValue::ParseIntWithBounds(const nsAString& aString,
PRInt32 aMin, PRInt32 aMax)
{
NS_PRECONDITION(aMin < aMax, "bad boundaries");
ResetIfSet();
PRInt32 ec;
PRBool strict;
PRInt32 originalVal = StringToInteger(aString, &strict, &ec);
if (NS_FAILED(ec)) {
return PR_FALSE;
}
PRInt32 val = NS_MAX(originalVal, aMin);
val = NS_MIN(val, aMax);
strict = strict && (originalVal == val);
SetIntValueAndType(val, eInteger, strict ? nsnull : &aString);
return PR_TRUE;
}
bool cHTTPServer::Start(cCallbacks & a_Callbacks, const AStringVector & a_Ports)
{
m_Callbacks = &a_Callbacks;
// Open up requested ports:
for (auto port : a_Ports)
{
UInt16 PortNum;
if (!StringToInteger(port, PortNum))
{
LOGWARNING("WebServer: Invalid port value: \"%s\". Ignoring.", port.c_str());
continue;
}
auto Handle = cNetwork::Listen(PortNum, std::make_shared<cHTTPServerListenCallbacks>(*this, PortNum));
if (Handle->IsListening())
{
m_ServerHandles.push_back(Handle);
}
} // for port - a_Ports[]
// Report success if at least one port opened successfully:
return !m_ServerHandles.empty();
}
bool cHTTPServer::Start(cCallbacks & a_Callbacks, const AStringVector & a_Ports)
{
m_Callbacks = &a_Callbacks;
// Open up requested ports:
AStringVector ports;
for (auto port : a_Ports)
{
UInt16 PortNum;
if (!StringToInteger(port, PortNum))
{
LOGWARNING("WebServer: Invalid port value: \"%s\". Ignoring.", port.c_str());
continue;
}
auto Handle = cNetwork::Listen(PortNum, std::make_shared<cHTTPServerListenCallbacks>(*this, PortNum));
if (Handle->IsListening())
{
m_ServerHandles.push_back(Handle);
ports.push_back(port);
}
} // for port - a_Ports[]
// Inform the admin about the ports opened:
AString reportPorts;
for (const auto & port: ports)
{
if (!reportPorts.empty())
{
reportPorts.append(", ");
}
reportPorts.append(port);
}
LOGINFO("WebAdmin is running on port(s) %s", reportPorts.c_str());
// Report success if at least one port opened successfully:
return !m_ServerHandles.empty();
}
eDimension StringToDimension(const AString & a_DimensionString)
{
// First try decoding as a number
int res;
if (StringToInteger(a_DimensionString, res))
{
// It was a valid number
return static_cast<eDimension>(res);
}
// Decode using a built-in map:
static struct
{
eDimension m_Dimension;
const char * m_String;
} DimensionMap [] =
{
{ dimOverworld, "Overworld"},
{ dimOverworld, "Normal"},
{ dimOverworld, "World"},
{ dimNether, "Nether"},
{ dimNether, "Hell"}, // Alternate name for Nether
{ dimEnd, "End"},
{ dimEnd, "Sky"}, // Old name for End
} ;
for (size_t i = 0; i < ARRAYCOUNT(DimensionMap); i++)
{
if (NoCaseCompare(DimensionMap[i].m_String, a_DimensionString) == 0)
{
return DimensionMap[i].m_Dimension;
}
} // for i - DimensionMap[]
// Not found
LOGWARNING("Unknown dimension: \"%s\". Setting to Overworld", a_DimensionString.c_str());
return dimOverworld;
}
void cEnchantments::AddFromString(const AString & a_StringSpec)
{
// Add enchantments in the stringspec; if a specified enchantment already exists, overwrites it
// Split the StringSpec into separate declarations, each in the form "id=lvl":
AStringVector Decls = StringSplit(a_StringSpec, ";");
for (AStringVector::const_iterator itr = Decls.begin(), end = Decls.end(); itr != end; ++itr)
{
// Split each declaration into the id and lvl part:
if (itr->empty())
{
// The decl is empty (may happen if there's an extra semicolon at the end), ignore silently
continue;
}
AStringVector Split = StringSplitAndTrim(*itr, "=");
if (Split.size() != 2)
{
// Malformed decl
LOG("%s: Malformed enchantment decl: \"%s\", skipping.", __FUNCTION__, itr->c_str());
continue;
}
int id = StringToEnchantmentID(Split[0]);
if (id < 0)
{
LOG("%s: Failed to parse enchantment \"%s\", skipping.", __FUNCTION__, Split[0].c_str());
continue;
}
unsigned int lvl;
if (!StringToInteger(Split[1], lvl))
{
// Level failed to parse
LOG("%s: Failed to parse enchantment level \"%s\", skipping.", __FUNCTION__, Split[1].c_str());
continue;
}
SetLevel(id, lvl);
} // for itr - Decls[]
}
/// Translates a damage type string to damage type. Takes either a number or a damage type alias (built-in). Returns -1 on failure
eDamageType StringToDamageType(const AString & a_DamageTypeString)
{
// First try decoding as a number:
int res;
if (!StringToInteger(a_DamageTypeString, res))
{
// It was a valid number
return static_cast<eDamageType>(res);
}
// Decode using a built-in map:
static struct
{
eDamageType m_DamageType;
const char * m_String;
} DamageTypeMap [] =
{
// Cannonical names:
{ dtAttack, "dtAttack"},
{ dtRangedAttack, "dtRangedAttack"},
{ dtLightning, "dtLightning"},
{ dtFalling, "dtFalling"},
{ dtDrowning, "dtDrowning"},
{ dtSuffocating, "dtSuffocation"},
{ dtStarving, "dtStarving"},
{ dtCactusContact, "dtCactusContact"},
{ dtLavaContact, "dtLavaContact"},
{ dtPoisoning, "dtPoisoning"},
{ dtWithering, "dtWithering"},
{ dtOnFire, "dtOnFire"},
{ dtFireContact, "dtFireContact"},
{ dtInVoid, "dtInVoid"},
{ dtPotionOfHarming, "dtPotionOfHarming"},
{ dtAdmin, "dtAdmin"},
{ dtExplosion, "dtExplosion"},
// Common synonyms:
{ dtAttack, "dtPawnAttack"},
{ dtAttack, "dtEntityAttack"},
{ dtAttack, "dtMob"},
{ dtAttack, "dtMobAttack"},
{ dtRangedAttack, "dtArrowAttack"},
{ dtRangedAttack, "dtArrow"},
{ dtRangedAttack, "dtProjectile"},
{ dtFalling, "dtFall"},
{ dtDrowning, "dtDrown"},
{ dtSuffocating, "dtSuffocation"},
{ dtStarving, "dtStarvation"},
{ dtStarving, "dtHunger"},
{ dtCactusContact, "dtCactus"},
{ dtCactusContact, "dtCactuses"},
{ dtCactusContact, "dtCacti"},
{ dtLavaContact, "dtLava"},
{ dtPoisoning, "dtPoison"},
{ dtWithering, "dtWither"},
{ dtOnFire, "dtBurning"},
{ dtFireContact, "dtInFire"},
{ dtAdmin, "dtPlugin"},
} ;
for (size_t i = 0; i < ARRAYCOUNT(DamageTypeMap); i++)
{
if (NoCaseCompare(DamageTypeMap[i].m_String, a_DamageTypeString) == 0)
{
return DamageTypeMap[i].m_DamageType;
}
} // for i - DamageTypeMap[]
// Not found:
return static_cast<eDamageType>(-1);
}
static Image *ReadJP2Image(const ImageInfo *image_info,ExceptionInfo *exception)
{
const char
*option;
Image
*image;
int
jp2_status;
MagickBooleanType
status;
opj_codec_t
*jp2_codec;
opj_codestream_index_t
*codestream_index = (opj_codestream_index_t *) NULL;
opj_dparameters_t
parameters;
opj_image_t
*jp2_image;
opj_stream_t
*jp2_stream;
register ssize_t
i;
ssize_t
y;
unsigned char
sans[4];
/*
Open image file.
*/
assert(image_info != (const ImageInfo *) NULL);
assert(image_info->signature == MagickCoreSignature);
if (image_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
image_info->filename);
assert(exception != (ExceptionInfo *) NULL);
assert(exception->signature == MagickCoreSignature);
image=AcquireImage(image_info,exception);
status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
if (status == MagickFalse)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
/*
Initialize JP2 codec.
*/
if (ReadBlob(image,4,sans) != 4)
{
image=DestroyImageList(image);
return((Image *) NULL);
}
(void) SeekBlob(image,SEEK_SET,0);
if (LocaleCompare(image_info->magick,"JPT") == 0)
jp2_codec=opj_create_decompress(OPJ_CODEC_JPT);
else
if (IsJ2K(sans,4) != MagickFalse)
jp2_codec=opj_create_decompress(OPJ_CODEC_J2K);
else
jp2_codec=opj_create_decompress(OPJ_CODEC_JP2);
opj_set_warning_handler(jp2_codec,JP2WarningHandler,exception);
opj_set_error_handler(jp2_codec,JP2ErrorHandler,exception);
opj_set_default_decoder_parameters(¶meters);
option=GetImageOption(image_info,"jp2:reduce-factor");
if (option != (const char *) NULL)
parameters.cp_reduce=StringToInteger(option);
option=GetImageOption(image_info,"jp2:quality-layers");
if (option != (const char *) NULL)
parameters.cp_layer=StringToInteger(option);
if (opj_setup_decoder(jp2_codec,¶meters) == 0)
{
opj_destroy_codec(jp2_codec);
ThrowReaderException(DelegateError,"UnableToManageJP2Stream");
}
jp2_stream=opj_stream_create(OPJ_J2K_STREAM_CHUNK_SIZE,1);
opj_stream_set_read_function(jp2_stream,JP2ReadHandler);
opj_stream_set_write_function(jp2_stream,JP2WriteHandler);
opj_stream_set_seek_function(jp2_stream,JP2SeekHandler);
opj_stream_set_skip_function(jp2_stream,JP2SkipHandler);
opj_stream_set_user_data(jp2_stream,image,NULL);
opj_stream_set_user_data_length(jp2_stream,GetBlobSize(image));
if (opj_read_header(jp2_stream,jp2_codec,&jp2_image) == 0)
{
opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
jp2_status=1;
if ((image->columns != 0) && (image->rows != 0))
{
/*
Extract an area from the image.
*/
jp2_status=opj_set_decode_area(jp2_codec,jp2_image,
(OPJ_INT32) image->extract_info.x,(OPJ_INT32) image->extract_info.y,
(OPJ_INT32) (image->extract_info.x+(ssize_t) image->columns),
(OPJ_INT32) (image->extract_info.y+(ssize_t) image->rows));
if (jp2_status == 0)
{
opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
}
if ((image_info->number_scenes != 0) && (image_info->scene != 0))
jp2_status=opj_get_decoded_tile(jp2_codec,jp2_stream,jp2_image,
(unsigned int) image_info->scene-1);
else
if (image->ping == MagickFalse)
{
jp2_status=opj_decode(jp2_codec,jp2_stream,jp2_image);
if (jp2_status != 0)
jp2_status=opj_end_decompress(jp2_codec,jp2_stream);
}
if (jp2_status == 0)
{
opj_stream_destroy(jp2_stream);
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
ThrowReaderException(DelegateError,"UnableToDecodeImageFile");
}
opj_stream_destroy(jp2_stream);
for (i=0; i < (ssize_t) jp2_image->numcomps; i++)
{
if ((jp2_image->comps[i].dx == 0) || (jp2_image->comps[i].dy == 0))
{
opj_destroy_codec(jp2_codec);
opj_image_destroy(jp2_image);
ThrowReaderException(CoderError,"IrregularChannelGeometryNotSupported")
}
}
