get_images_from_skps.cpp File Reference

#include "include/codec/SkCodec.h"
#include "include/codec/SkEncodedImageFormat.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkData.h"
#include "include/core/SkImage.h"
#include "include/core/SkPicture.h"
#include "include/core/SkSerialProcs.h"
#include "include/core/SkStream.h"
#include "src/core/SkMD5.h"
#include "src/core/SkOSFile.h"
#include "src/core/SkTHash.h"
#include "src/utils/SkJSONWriter.h"
#include "src/utils/SkOSPath.h"
#include "tools/flags/CommandLineFlags.h"
#include <iostream>
#include <map>

Go to the source code of this file.

Classes
struct	Sniffer

Functions
static	DEFINE_string2 (skps, s, "skps", "A path to a directory of skps or a single skp.")
static	DEFINE_string2 (out, o, "img-out", "A path to an output directory.")
static	DEFINE_bool (testDecode, false, "Indicates if we want to test that the images decode successfully.")
static	DEFINE_bool (writeImages, true, "Indicates if we want to write out supported/decoded images.")
static	DEFINE_bool (writeFailedImages, false, "Indicates if we want to write out unsupported/failed to decode images.")
static	DEFINE_string2 (failuresJsonPath, j, "", "Dump SKP and count of unknown images to the specified JSON file. Will not be " "written anywhere if empty.")
static bool	get_images_from_file (const SkString &file)
int	main (int argc, char **argv)

Variables
static int	gKnown
static const char *	gOutputDir
static std::map< std::string, unsigned int >	gSkpToUnknownCount = {}
static std::map< std::string, unsigned int >	gSkpToUnsupportedCount
static THashSet< SkMD5::Digest >	gSeen

Function Documentation

DEFINE_bool() [1/3]

static DEFINE_bool ( testDecode  , false  , "Indicates if we want to test that the images decode successfully."    )

static

DEFINE_bool() [2/3]

static DEFINE_bool ( writeFailedImages  , false  , "Indicates if we want to write out unsupported/failed to decode images."    )

static

DEFINE_bool() [3/3]

static DEFINE_bool ( writeImages  , true  , "Indicates if we want to write out supported/decoded images."    )

static

DEFINE_string2() [1/3]

static DEFINE_string2 ( failuresJsonPath  , j  , ""  , "Dump SKP and count of unknown images to the specified JSON file. Will not be " "written anywhere if empty."    )

static

DEFINE_string2() [2/3]

static DEFINE_string2 ( out  , o  , "img-out"  , "A path to an output directory."    )

static

DEFINE_string2() [3/3]

static DEFINE_string2 ( skps  , s  , "skps"  , "A path to a directory of skps or a single skp."    )

static

get_images_from_file()

static bool get_images_from_file ( const SkString &  file )

static

Definition at line 130 of file get_images_from_skps.cpp.

                                                       {
    Sniffer sniff(file.c_str());
    auto stream = SkStream::MakeFromFile(file.c_str());
 
    SkDeserialProcs procs;
    procs.fImageProc = [](const void* data, size_t size, void* ctx) -> sk_sp<SkImage> {
        ((Sniffer*)ctx)->sniff(data, size);
        return nullptr;
    };
    procs.fImageCtx = &sniff;
    return SkPicture::MakeFromStream(stream.get(), &procs) != nullptr;
}

main()

int main	(	int	argc,
		char **	argv
	)

JSON results are written out in the following format: { "failures": { "skp1": 12, "skp4": 2, ... }, "unsupported": { "skp9": 13, "skp17": 3, ... } "totalFailures": 32, "totalUnsupported": 9, "totalSuccesses": 21, }

Definition at line 143 of file get_images_from_skps.cpp.

                                {
    CommandLineFlags::SetUsage(
            "Usage: get_images_from_skps -s <dir of skps> -o <dir for output images> --testDecode "
            "-j <output JSON path> --writeImages, --writeFailedImages\n");
 
    CommandLineFlags::Parse(argc, argv);
    const char* inputs = FLAGS_skps[0];
    gOutputDir = FLAGS_out[0];
 
    if (!sk_isdir(gOutputDir)) {
        CommandLineFlags::PrintUsage();
        return 1;
    }
 
    if (sk_isdir(inputs)) {
        SkOSFile::Iter iter(inputs, "skp");
        for (SkString file; iter.next(&file); ) {
            if (!get_images_from_file(SkOSPath::Join(inputs, file.c_str()))) {
                return 2;
            }
        }
    } else {
        if (!get_images_from_file(SkString(inputs))) {
            return 2;
        }
    }
    /**
     JSON results are written out in the following format:
     {
       "failures": {
         "skp1": 12,
         "skp4": 2,
         ...
       },
       "unsupported": {
        "skp9": 13,
        "skp17": 3,
        ...
       }
       "totalFailures": 32,
       "totalUnsupported": 9,
       "totalSuccesses": 21,
     }
     */
 
    unsigned int totalFailures = 0,
              totalUnsupported = 0;
    SkDynamicMemoryWStream memStream;
    SkJSONWriter writer(&memStream, SkJSONWriter::Mode::kPretty);
    writer.beginObject();
    {
        writer.beginObject("failures");
        {
            for (const auto& failure : gSkpToUnknownCount) {
                SkDebugf("%s %u\n", failure.first.c_str(), failure.second);
                totalFailures += failure.second;
                writer.appendU32(failure.first.c_str(), failure.second);
            }
        }
        writer.endObject();
        writer.appendU32("totalFailures", totalFailures);
 
#ifdef SK_DEBUG
        writer.beginObject("unsupported");
        {
            for (const auto& unsupported : gSkpToUnsupportedCount) {
                SkDebugf("%s %u\n", unsupported.first.c_str(), unsupported.second);
                totalUnsupported += unsupported.second;
                writer.appendHexU32(unsupported.first.c_str(), unsupported.second);
            }
        }
        writer.endObject();
        writer.appendU32("totalUnsupported", totalUnsupported);
#endif
 
        writer.appendS32("totalSuccesses", gKnown);
        SkDebugf("%d known, %u failures, %u unsupported\n",
                 gKnown, totalFailures, totalUnsupported);
    }
    writer.endObject();
    writer.flush();
 
    if (totalFailures > 0 || totalUnsupported > 0) {
        if (!FLAGS_failuresJsonPath.isEmpty()) {
            SkDebugf("Writing failures to %s\n", FLAGS_failuresJsonPath[0]);
            SkFILEWStream stream(FLAGS_failuresJsonPath[0]);
            auto jsonStream = memStream.detachAsStream();
            stream.writeStream(jsonStream.get(), jsonStream->getLength());
        }
    }
 
    return 0;
}

Variable Documentation

gKnown

int gKnown

static

Definition at line 41 of file get_images_from_skps.cpp.

gOutputDir

const char* gOutputDir

static

Definition at line 42 of file get_images_from_skps.cpp.

gSeen

THashSet<SkMD5::Digest> gSeen

static

Definition at line 46 of file get_images_from_skps.cpp.

gSkpToUnknownCount

std::map<std::string, unsigned int> gSkpToUnknownCount = {}

static

Definition at line 43 of file get_images_from_skps.cpp.

{};

gSkpToUnsupportedCount

std::map<std::string, unsigned int> gSkpToUnsupportedCount

static

Definition at line 44 of file get_images_from_skps.cpp.