DEF_TEST(DiscardablePixelRef_SecondLockColorTableCheck, r) {
SkString resourceDir = GetResourcePath();
SkString path = SkOSPath::Join(resourceDir.c_str(), "randPixels.gif");
if (!sk_exists(path.c_str())) {
return;
}
SkAutoDataUnref encoded(SkData::NewFromFileName(path.c_str()));
SkBitmap bitmap;
if (!SkInstallDiscardablePixelRef(
SkDecodingImageGenerator::Create(
encoded, SkDecodingImageGenerator::Options()), &bitmap)) {
#ifndef SK_BUILD_FOR_WIN
ERRORF(r, "SkInstallDiscardablePixelRef [randPixels.gif] failed.");
#endif
return;
}
if (kIndex_8_SkColorType != bitmap.colorType()) {
return;
}
{
SkAutoLockPixels alp(bitmap);
REPORTER_ASSERT(r, bitmap.getColorTable() && "first pass");
}
{
SkAutoLockPixels alp(bitmap);
REPORTER_ASSERT(r, bitmap.getColorTable() && "second pass");
}
}
bool sk_mkdir(const char* path)
{
if (sk_isdir(path)) {
return true;
}
if (sk_exists(path)) {
fprintf(stderr,
"sk_mkdir: path '%s' already exists but is not a directory\n",
path);
return false;
}
int retval;
#ifdef _WIN32
retval = _mkdir(path);
#else
retval = mkdir(path, 0777);
#endif
if (0 == retval) {
return true;
} else {
fprintf(stderr, "sk_mkdir: error %d creating dir '%s'\n", errno, path);
return false;
}
}
int tool_main(int argc, char** argv) {
SkCommandLineFlags::SetUsage("Decode files, and optionally write the results to files.");
SkCommandLineFlags::Parse(argc, argv);
if (FLAGS_readPath.count() < 1) {
SkDebugf("Folder(s) or image(s) to decode are required.\n");
return -1;
}
SkAutoGraphics ag;
for (int i = 0; i < FLAGS_readPath.count(); i++) {
const char* readPath = FLAGS_readPath[i];
if (strlen(readPath) < 1) {
break;
}
if (sk_isdir(readPath)) {
const char* dir = readPath;
SkOSFile::Iter iter(dir);
SkString filename;
while (iter.next(&filename)) {
if (!is_image_file(filename.c_str())) {
continue;
}
SkString fullname = SkOSPath::SkPathJoin(dir, filename.c_str());
decodeFileAndWrite(fullname.c_str());
}
} else if (sk_exists(readPath) && is_image_file(readPath)) {
decodeFileAndWrite(readPath);
}
}
return 0;
}
static SkString get_in_path(int dirNo, const char* filename) {
SkString path;
SkASSERT(dirNo);
path.appendf("%s%d%s", IN_DIR_PRE, dirNo, DIR_POST);
if (!sk_exists(path.c_str())) {
SkDebugf("could not read %s\n", path.c_str());
return SkString();
}
if (filename) {
path.appendf("%s%s", PATH_SLASH, filename);
if (!sk_exists(path.c_str())) {
SkDebugf("could not read %s\n", path.c_str());
return SkString();
}
}
return path;
}
static SkString make_in_dir_name(int dirIndex) {
SkString dirName(IN_DIR);
dirName.appendf("%d", dirIndex);
if (!sk_exists(dirName.c_str())) {
SkDebugf("could not read dir %s\n", dirName.c_str());
return SkString();
}
return dirName;
}
void load_config_by_pattern(char *section_pattern, char *key_pattern, struct config_handle a_conf_handle){
char *cur_section_name;
LOGI("checking : %s\n",section_pattern );
cur_section_name = get_first_section_name( section_pattern,&a_conf_handle);
while (cur_section_name &&(sk_exists(cur_section_name, key_pattern, &a_conf_handle))){
LOGI("storing config for :%s\n", cur_section_name);
store_config(cur_section_name, a_conf_handle);
cur_section_name = get_next_section_name( section_pattern,&a_conf_handle);
}
}
/**
* A test for the SkDecodingImageGenerator::Create and
* SkInstallDiscardablePixelRef functions.
*/
DEF_TEST(ImprovedBitmapFactory, reporter) {
SkString pngFilename = GetResourcePath("randPixels.png");
SkAutoTDelete<SkStreamRewindable> stream(SkStream::NewFromFile(pngFilename.c_str()));
if (sk_exists(pngFilename.c_str())) {
SkBitmap bm;
SkAssertResult(bm.setInfo(SkImageInfo::MakeN32Premul(1, 1)));
REPORTER_ASSERT(reporter,
install_pixel_ref(&bm, stream.detach(), 1, true));
SkAutoLockPixels alp(bm);
REPORTER_ASSERT(reporter, bm.getPixels());
}
}
PreParser(int dirNo)
: fDirNo(dirNo)
, fIndex(0)
, fStatusPath(makeStatusString(dirNo)) {
if (!sk_exists(fStatusPath.c_str())) {
return;
}
SkFILEStream reader;
reader.setPath(fStatusPath.c_str());
while (fetch(reader, &fResults.push_back()))
;
fResults.pop_back();
}
/**
* A test for the SkDecodingImageGenerator::Create and
* SkInstallDiscardablePixelRef functions.
*/
DEF_TEST(ImprovedBitmapFactory, reporter) {
SkString resourcePath = GetResourcePath();
SkString path = SkOSPath::SkPathJoin(
resourcePath.c_str(), "randPixels.png");
SkAutoTUnref<SkStreamRewindable> stream(
SkStream::NewFromFile(path.c_str()));
if (sk_exists(path.c_str())) {
SkBitmap bm;
SkAssertResult(bm.setInfo(SkImageInfo::MakeN32Premul(1, 1)));
REPORTER_ASSERT(reporter,
NULL != install_pixel_ref(&bm, stream.detach(), 1, true));
SkAutoLockPixels alp(bm);
REPORTER_ASSERT(reporter, NULL != bm.getPixels());
}
}
bool CollectImages(SkCommandLineFlags::StringArray images, SkTArray<SkString>* output) {
SkASSERT(output);
static const char* const exts[] = {
"bmp", "gif", "jpg", "jpeg", "png", "webp", "ktx", "astc", "wbmp", "ico",
"BMP", "GIF", "JPG", "JPEG", "PNG", "WEBP", "KTX", "ASTC", "WBMP", "ICO",
#ifdef SK_CODEC_DECODES_RAW
"arw", "cr2", "dng", "nef", "nrw", "orf", "raf", "rw2", "pef", "srw",
"ARW", "CR2", "DNG", "NEF", "NRW", "ORF", "RAF", "RW2", "PEF", "SRW",
#endif
};
for (int i = 0; i < images.count(); ++i) {
const char* flag = images[i];
if (!sk_exists(flag)) {
SkDebugf("%s does not exist!\n", flag);
return false;
}
if (sk_isdir(flag)) {
// If the value passed in is a directory, add all the images
bool foundAnImage = false;
for (const char* ext : exts) {
SkOSFile::Iter it(flag, ext);
SkString file;
while (it.next(&file)) {
foundAnImage = true;
output->push_back() = SkOSPath::Join(flag, file.c_str());
}
}
if (!foundAnImage) {
SkDebugf("No supported images found in %s!\n", flag);
return false;
}
} else {
// Also add the value if it is a single image
output->push_back() = flag;
}
}
return true;
}
static void generate_fonts(FILE* out) {
for (int index = 0; index < gFontsCount; ++index) {
FontDesc& fontDesc = gFonts[index];
int fontIndex = written_index(fontDesc);
if (fontIndex >= 0) {
fontDesc.fFontIndex = fontIndex;
continue;
}
SkTypeface* systemTypeface = SkTypeface::CreateFromName(fontDesc.fFont, fontDesc.fStyle);
SkASSERT(systemTypeface);
SkString filepath(GetResourcePath(fontDesc.fFile));
SkASSERT(sk_exists(filepath.c_str()));
SkTypeface* resourceTypeface = SkTypeface::CreateFromFile(filepath.c_str());
SkASSERT(resourceTypeface);
output_font(resourceTypeface, fontDesc.fFont, fontDesc.fStyle, fontDesc.fCharsUsed, out);
fontDesc.fFontIndex = gWritten.count();
FontWritten* writ = gWritten.append();
writ->fName = fontDesc.fFont;
writ->fStyle = fontDesc.fStyle;
}
}
static void make_recursive_dir(const SkString& path) {
if (sk_exists(path.c_str())) {
return;
}
const char* pathStr = path.c_str();
int last = (int) path.size();
do {
while (last > 0 && pathStr[--last] != PATH_SLASH[0])
;
SkASSERT(last > 0);
SkString shorter(pathStr, last);
if (sk_mkdir(shorter.c_str())) {
break;
}
} while (true);
do {
while (last < (int) path.size() && pathStr[++last] != PATH_SLASH[0])
;
SkString shorter(pathStr, last);
SkAssertResult(sk_mkdir(shorter.c_str()));
} while (last < (int) path.size());
}
static bool make_out_dirs() {
SkString outDir = make_filepath(0, OUT_DIR, "");
if (!sk_exists(outDir.c_str())) {
if (!sk_mkdir(outDir.c_str())) {
SkDebugf("could not create dir %s\n", outDir.c_str());
return false;
}
}
SkString grDir = make_filepath(0, outGrDir, "");
if (!sk_exists(grDir.c_str())) {
if (!sk_mkdir(grDir.c_str())) {
SkDebugf("could not create dir %s\n", grDir.c_str());
return false;
}
}
SkString skDir = make_filepath(0, outSkDir, "");
if (!sk_exists(skDir.c_str())) {
if (!sk_mkdir(skDir.c_str())) {
SkDebugf("could not create dir %s\n", skDir.c_str());
return false;
}
}
SkString skpDir = make_filepath(0, outSkpDir, "");
if (!sk_exists(skpDir.c_str())) {
if (!sk_mkdir(skpDir.c_str())) {
SkDebugf("could not create dir %s\n", skpDir.c_str());
return false;
}
}
SkString diffDir = make_filepath(0, outDiffDir, "");
if (!sk_exists(diffDir.c_str())) {
if (!sk_mkdir(diffDir.c_str())) {
SkDebugf("could not create dir %s\n", diffDir.c_str());
return false;
}
}
SkString statusDir = make_filepath(0, outStatusDir, "");
if (!sk_exists(statusDir.c_str())) {
if (!sk_mkdir(statusDir.c_str())) {
SkDebugf("could not create dir %s\n", statusDir.c_str());
return false;
}
}
return true;
}
void SkDiffContext::diffDirectories(const char baselinePath[], const char testPath[]) {
// Get the files in the baseline, we will then look for those inside the test path
SkTArray<SkString> baselineEntries;
if (!get_directory(baselinePath, &baselineEntries)) {
SkDebugf("Unable to open path \"%s\"\n", baselinePath);
return;
}
for (int baselineIndex = 0; baselineIndex < baselineEntries.count(); baselineIndex++) {
const char* baseFilename = baselineEntries[baselineIndex].c_str();
// Find the real location of each file to compare
SkString baselineFile = SkOSPath::SkPathJoin(baselinePath, baseFilename);
SkString testFile = SkOSPath::SkPathJoin(testPath, baseFilename);
// Check that the test file exists and is a file
if (sk_exists(testFile.c_str()) && !sk_isdir(testFile.c_str())) {
// Queue up the comparison with the differ
this->addDiff(baselineFile.c_str(), testFile.c_str());
} else {
SkDebugf("Baseline file \"%s\" has no corresponding test file\n", baselineFile.c_str());
}
}
}
void WriteTask::draw() {
SkString md5;
{
SkAutoLockPixels lock(fBitmap);
md5 = fData ? get_md5(fData)
: get_md5(fBitmap.getPixels(), fBitmap.getSize());
}
SkASSERT(fSuffixes.count() > 0);
SkString config = fSuffixes.back();
SkString mode("direct");
if (fSuffixes.count() > 1) {
mode = fSuffixes.fromBack(1);
}
JsonData entry = { fBaseName, config, mode, fSourceType, md5 };
{
SkAutoMutexAcquire lock(&gJsonDataLock);
gJsonData.push_back(entry);
}
SkString dir(FLAGS_writePath[0]);
#if defined(SK_BUILD_FOR_IOS)
if (dir.equals("@")) {
dir.set(FLAGS_resourcePath[0]);
}
#endif
this->makeDirOrFail(dir);
SkString path;
if (FLAGS_nameByHash) {
// Flat directory of hash-named files.
path = SkOSPath::Join(dir.c_str(), md5.c_str());
path.append(fExtension);
// We're content-addressed, so it's possible two threads race to write
// this file. We let the first one win. This also means we won't
// overwrite identical files from previous runs.
if (sk_exists(path.c_str())) {
return;
}
} else {
// Nested by mode, config, etc.
for (int i = 0; i < fSuffixes.count(); i++) {
dir = SkOSPath::Join(dir.c_str(), fSuffixes[i].c_str());
this->makeDirOrFail(dir);
}
path = SkOSPath::Join(dir.c_str(), fBaseName.c_str());
path.append(fExtension);
// The path is unique, so two threads can't both write to the same file.
// If already present we overwrite here, since the content may have changed.
}
SkFILEWStream file(path.c_str());
if (!file.isValid()) {
return this->fail("Can't open file.");
}
bool ok = fData ? write_asset(fData, &file)
: SkImageEncoder::EncodeStream(&file, fBitmap, SkImageEncoder::kPNG_Type, 100);
if (!ok) {
return this->fail("Can't write to file.");
}
}
DEF_TEST(SkpSkGrThreaded, reporter) {
if (!initTest()) {
return;
}
SkpSkGrThreadedTestRunner testRunner(reporter);
for (int dirIndex = 1; dirIndex <= 100; ++dirIndex) {
SkString pictDir = make_in_dir_name(dirIndex);
if (pictDir.size() == 0) {
continue;
}
SkOSFile::Iter iter(pictDir.c_str(), "skp");
SkString filename;
while (iter.next(&filename)) {
SkString pngName = make_png_name(filename.c_str());
SkString oldPng = make_filepath(dirIndex, outSkDir, pngName.c_str());
SkString newPng = make_filepath(dirIndex, outGrDir, pngName.c_str());
if (sk_exists(oldPng.c_str()) && sk_exists(newPng.c_str())) {
bumpCount(reporter, true);
continue;
}
for (size_t index = 0; index < skipOverSkGrCount; ++index) {
if (skipOverSkGr[index].directory == dirIndex
&& strcmp(filename.c_str(), skipOverSkGr[index].filename) == 0) {
bumpCount(reporter, true);
goto skipOver;
}
}
*testRunner.fRunnables.append() = new SkpSkGrThreadedRunnable(
&testSkGrMain, dirIndex, filename.c_str(), &testRunner);
skipOver:
;
}
}
testRunner.render();
SkpSkGrThreadState& max = testRunner.fRunnables[0]->fState;
for (int dirIndex = 2; dirIndex <= 100; ++dirIndex) {
SkpSkGrThreadState& state = testRunner.fRunnables[dirIndex - 1]->fState;
for (int index = 0; index < state.fFoundCount; ++index) {
int maxIdx = max.fFoundCount;
if (maxIdx < kMaxFiles) {
max.fError[maxIdx] = state.fError[index];
strcpy(max.fFilesFound[maxIdx], state.fFilesFound[index]);
max.fDirsFound[maxIdx] = state.fDirsFound[index];
++max.fFoundCount;
continue;
}
for (maxIdx = 0; maxIdx < max.fFoundCount; ++maxIdx) {
if (max.fError[maxIdx] < state.fError[index]) {
max.fError[maxIdx] = state.fError[index];
strcpy(max.fFilesFound[maxIdx], state.fFilesFound[index]);
max.fDirsFound[maxIdx] = state.fDirsFound[index];
break;
}
}
}
}
TestResult encoder;
encoder.fTestStep = kEncodeFiles;
for (int index = 0; index < max.fFoundCount; ++index) {
encoder.fDirNo = max.fDirsFound[index];
strcpy(encoder.fFilename, max.fFilesFound[index]);
encoder.testOne();
SkDebugf("+");
}
}
/**
* SkDecodingImageGenerator has an Options struct which lets the
* client of the generator set sample size, dithering, and bitmap
* config. This test loops through many possible options and tries
* them on a set of 5 small encoded images (each in a different
* format). We test both SkData and SkStreamRewindable decoding.
*/
DEF_TEST(ImageDecoderOptions, reporter) {
const char* files[] = {
"randPixels.bmp",
"randPixels.jpg",
"randPixels.png",
"randPixels.webp",
#if !defined(SK_BUILD_FOR_WIN)
// TODO(halcanary): Find out why this fails sometimes.
"randPixels.gif",
#endif
};
SkString resourceDir = GetResourcePath();
if (!sk_exists(resourceDir.c_str())) {
return;
}
int scaleList[] = {1, 2, 3, 4};
bool ditherList[] = {true, false};
SkColorType colorList[] = {
kAlpha_8_SkColorType,
kRGB_565_SkColorType,
kARGB_4444_SkColorType, // Most decoders will fail on 4444.
kN32_SkColorType
// Note that indexed color is left out of the list. Lazy
// decoding doesn't do indexed color.
};
const bool useDataList[] = {true, false};
for (size_t fidx = 0; fidx < SK_ARRAY_COUNT(files); ++fidx) {
SkString path = SkOSPath::SkPathJoin(resourceDir.c_str(), files[fidx]);
if (!sk_exists(path.c_str())) {
continue;
}
SkAutoDataUnref encodedData(SkData::NewFromFileName(path.c_str()));
REPORTER_ASSERT(reporter, encodedData.get() != NULL);
SkAutoTUnref<SkStreamRewindable> encodedStream(
SkStream::NewFromFile(path.c_str()));
REPORTER_ASSERT(reporter, encodedStream.get() != NULL);
for (size_t i = 0; i < SK_ARRAY_COUNT(scaleList); ++i) {
for (size_t j = 0; j < SK_ARRAY_COUNT(ditherList); ++j) {
for (size_t m = 0; m < SK_ARRAY_COUNT(useDataList); ++m) {
for (size_t k = 0; k < SK_ARRAY_COUNT(colorList); ++k) {
SkDecodingImageGenerator::Options opts(scaleList[i],
ditherList[j],
colorList[k]);
test_options(reporter, opts, encodedStream, encodedData,
useDataList[m], path);
}
SkDecodingImageGenerator::Options options(scaleList[i],
ditherList[j]);
test_options(reporter, options, encodedStream, encodedData,
useDataList[m], path);
}
}
}
}
}
void load_config(){
struct stat info;
char cur_extra_section[PATHMAX];
struct config_handle my_conf_handle;
int i_tmp;
long l_tmp;
//Check if config file exists
if (stat(CRASHLOG_CONF_PATH, &info) == 0) {
LOGI("Loading specific crashlog config\n");
my_conf_handle.first=NULL;
my_conf_handle.current=NULL;
if (init_config_file(CRASHLOG_CONF_PATH, &my_conf_handle)>=0){
//General config - uptime
//TO IMPROVE : general config strategy to define properly
if (sk_exists(GENERAL_CONF_PATTERN,"uptime_frequency",&my_conf_handle)){
char *tmp = get_value(GENERAL_CONF_PATTERN,"uptime_frequency",&my_conf_handle);
if (tmp){
i_tmp = atoi(tmp);
if (i_tmp > 0){
gcurrent_uptime_hour_frequency = i_tmp;
}
}
}
if (sk_exists(GENERAL_CONF_PATTERN,"sd_size_limit",&my_conf_handle)){
char *tmp = get_value(GENERAL_CONF_PATTERN,"sd_size_limit",&my_conf_handle);
if (tmp){
l_tmp = atol(tmp);
if (l_tmp > 0){
current_sd_size_limit = l_tmp;
}
}
}
if (sk_exists(GENERAL_CONF_PATTERN,"serial_device_id",&my_conf_handle)){
char *tmp = get_value(GENERAL_CONF_PATTERN,"serial_device_id",&my_conf_handle);
if (tmp){
i_tmp = atoi(tmp);
if (i_tmp > 0){
g_current_serial_device_id = 1;
}
}
}
if (sk_exists(GENERAL_CONF_PATTERN,"check_modem_version",&my_conf_handle)){
char *tmp = get_value(GENERAL_CONF_PATTERN,"check_modem_version",&my_conf_handle);
if (tmp){
i_tmp = atoi(tmp);
if (i_tmp > 0){
check_modem_version = 1;
} else {
check_modem_version = 0;
}
LOGI("Check modem version: %d", check_modem_version);
}
}
load_config_by_pattern(NOTIFY_CONF_PATTERN,"matching_pattern",my_conf_handle);
//ADD other config pattern HERE
free_config_file(&my_conf_handle);
}else{
LOGI("specific crashlog config not found\n");
}
}
}