SkottieTool.cpp File Reference

#include "include/codec/SkCodec.h"
#include "include/codec/SkJpegDecoder.h"
#include "include/codec/SkPngDecoder.h"
#include "include/codec/SkWebpDecoder.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkData.h"
#include "include/core/SkFontMgr.h"
#include "include/core/SkGraphics.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkStream.h"
#include "include/core/SkString.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTypes.h"
#include "include/encode/SkPngEncoder.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTo.h"
#include "modules/skottie/include/ExternalLayer.h"
#include "modules/skottie/include/Skottie.h"
#include "modules/skottie/utils/SkottieUtils.h"
#include "modules/skresources/include/SkResources.h"
#include "modules/skshaper/utils/FactoryHelpers.h"
#include "src/core/SkOSFile.h"
#include "src/core/SkTaskGroup.h"
#include "src/utils/SkOSPath.h"
#include "tools/flags/CommandLineFlags.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrTypes.h"
#include "include/gpu/ganesh/SkSurfaceGanesh.h"
#include "tools/gpu/ContextType.h"
#include "tools/gpu/GrContextFactory.h"
#include "include/core/SkPicture.h"
#include "include/core/SkPictureRecorder.h"
#include "include/core/SkSerialProcs.h"
#include "src/image/SkImage_Base.h"
#include <algorithm>
#include <chrono>
#include <cstdio>
#include <cstring>
#include <functional>
#include <memory>
#include <numeric>
#include <utility>
#include <vector>
#include "include/ports/SkFontMgr_empty.h"

Go to the source code of this file.

Functions
static	DEFINE_string2 (input, i, nullptr, "Input .json file.")
static	DEFINE_string2 (writePath, w, nullptr, "Output directory. Frames are names [0-9]{6}.png.")
static	DEFINE_string2 (format, f, "png", formats_help)
static	DEFINE_double (t0, 0, "Timeline start [0..1].")
static	DEFINE_double (t1, 1, "Timeline stop [0..1].")
static	DEFINE_double (fps, 0, "Decode frames per second (default is animation native fps).")
static	DEFINE_int (width, 800, "Render width.")
static	DEFINE_int (height, 600, "Render height.")
static	DEFINE_int (threads, 0, "Number of worker threads (0 -> cores count).")
static	DEFINE_bool2 (gpu, g, false, "Enable GPU rasterization.")
int	main (int argc, char **argv)

Variables
const char *	formats_help = "Output format (png, skp, or null)"
bool	gSkUseThreadLocalStrikeCaches_IAcknowledgeThisIsIncrediblyExperimental

Function Documentation

DEFINE_bool2()

static DEFINE_bool2 ( gpu  , g  , false  , "Enable GPU rasterization."    )

static

DEFINE_double() [1/3]

static DEFINE_double ( fps  , 0  , "Decode frames per second (default is animation native fps)."    )

static

DEFINE_double() [2/3]

static DEFINE_double ( t0  , 0  , "Timeline start ."  [0..1]  )

static

DEFINE_double() [3/3]

static DEFINE_double ( t1  , 1  , "Timeline stop ."  [0..1]  )

static

DEFINE_int() [1/3]

static DEFINE_int ( height  , 600  , "Render height."    )

static

DEFINE_int() [2/3]

static DEFINE_int ( threads  , 0  , "Number of worker threads (0 -> cores count)."    )

static

DEFINE_int() [3/3]

static DEFINE_int ( width  , 800  , "Render width."    )

static

DEFINE_string2() [1/3]

static DEFINE_string2 ( format  , f  , "png"  , formats_help    )

static

DEFINE_string2() [2/3]

static DEFINE_string2 ( input  , i  , nullptr  , "Input .json file."    )

static

DEFINE_string2() [3/3]

static DEFINE_string2 ( writePath  , w  , nullptr  , "Output directory. Frames are names {6}.png."  [0-9]  )

static

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 472 of file SkottieTool.cpp.

                                {
    gSkUseThreadLocalStrikeCaches_IAcknowledgeThisIsIncrediblyExperimental = true;
    CommandLineFlags::Parse(argc, argv);
    SkGraphics::Init();
 
    if (FLAGS_input.isEmpty() || FLAGS_writePath.isEmpty()) {
        SkDebugf("Missing required 'input' and 'writePath' args.\n");
        return 1;
    }
 
    OutputFormat fmt;
    if (0 == std::strcmp(FLAGS_format[0], "png")) {
        fmt = OutputFormat::kPNG;
    } else if (0 == std::strcmp(FLAGS_format[0], "skp")) {
        fmt = OutputFormat::kSKP;
    } else if (0 == std::strcmp(FLAGS_format[0], "null")) {
        fmt = OutputFormat::kNull;
#if defined(HAVE_VIDEO_ENCODER)
    } else if (0 == std::strcmp(FLAGS_format[0], "mp4")) {
        fmt = OutputFormat::kMP4;
#endif
    } else {
        fprintf(stderr, "Unknown format: %s\n", FLAGS_format[0]);
        return 1;
    }
 
    if (fmt != OutputFormat::kMP4 && !sk_mkdir(FLAGS_writePath[0])) {
        return 1;
    }
 
    SkCodecs::Register(SkPngDecoder::Decoder());
    SkCodecs::Register(SkJpegDecoder::Decoder());
    SkCodecs::Register(SkWebpDecoder::Decoder());
 
    // If necessary, clients should use a font manager that would load fonts from the system.
#if defined(SK_BUILD_FOR_MAC) && defined(SK_FONTMGR_CORETEXT_AVAILABLE)
    sk_sp<SkFontMgr> fontMgr = SkFontMgr_New_CoreText(nullptr);
#elif defined(SK_BUILD_FOR_ANDROID) && defined(SK_FONTMGR_ANDROID_AVAILABLE)
    sk_sp<SkFontMgr> fontMgr = SkFontMgr_New_Android(nullptr, std::make_unique<SkFontScanner_FreeType>());
#elif defined(SK_BUILD_FOR_UNIX) && defined(SK_FONTMGR_FONTCONFIG_AVAILABLE)
    sk_sp<SkFontMgr> fontMgr = SkFontMgr_New_FontConfig(nullptr);
#else
    sk_sp<SkFontMgr> fontMgr = SkFontMgr_New_Custom_Empty();
#endif
 
    auto predecode = skresources::ImageDecodeStrategy::kPreDecode;
    auto logger = sk_make_sp<Logger>();
    auto rp = skresources::CachingResourceProvider::Make(
            skresources::DataURIResourceProviderProxy::Make(
                    skresources::FileResourceProvider::Make(SkOSPath::Dirname(FLAGS_input[0]),
                                                            predecode),
                    predecode,
                    fontMgr));
    auto data   = SkData::MakeFromFileName(FLAGS_input[0]);
    auto precomp_interceptor =
            sk_make_sp<skottie_utils::ExternalAnimationPrecompInterceptor>(rp, "__");
 
    if (!data) {
        SkDebugf("Could not load %s.\n", FLAGS_input[0]);
        return 1;
    }
 
    // Instantiate an animation on the main thread for two reasons:
    //   - we need to know its duration upfront
    //   - we want to only report parsing errors once
    auto anim = skottie::Animation::Builder()
            .setFontManager(fontMgr)
            .setLogger(logger)
            .setResourceProvider(rp)
            .setTextShapingFactory(SkShapers::BestAvailable())
            .make(static_cast<const char*>(data->data()), data->size());
    if (!anim) {
        SkDebugf("Could not parse animation: '%s'.\n", FLAGS_input[0]);
        return 1;
    }
 
    const auto scale_matrix = SkMatrix::RectToRect(SkRect::MakeSize(anim->size()),
                                                   SkRect::MakeIWH(FLAGS_width, FLAGS_height),
                                                   SkMatrix::kCenter_ScaleToFit);
    logger->report();
 
    const auto t0 = SkTPin(FLAGS_t0, 0.0, 1.0),
               t1 = SkTPin(FLAGS_t1,  t0, 1.0),
       native_fps = anim->fps(),
           frame0 = anim->duration() * t0 * native_fps,
         duration = anim->duration() * (t1 - t0);
 
    double fps = FLAGS_fps > 0 ? FLAGS_fps : native_fps;
    if (fps <= 0) {
        SkDebugf("Invalid fps: %f.\n", fps);
        return 1;
    }
 
    auto frame_count = static_cast<int>(duration * fps);
    static constexpr int kMaxFrames = 10000;
    if (frame_count > kMaxFrames) {
        frame_count = kMaxFrames;
        fps = frame_count / duration;
    }
    const auto fps_scale = native_fps / fps;
 
    printf("Rendering %f seconds (%d frames @%f fps).\n", duration, frame_count, fps);
 
    const auto sink = FrameSink::Make(fmt, frame_count);
 
    std::vector<double> frames_ms(frame_count);
 
    const auto thread_count = FLAGS_gpu ? 0 : FLAGS_threads - 1;
    SkTaskGroup::Enabler enabler(thread_count);
 
    SkTaskGroup tg;
    {
        // Depending on type (gpu vs. everything else), we use either a single generator
        // or one generator per worker thread, respectively.
        // Scoping is important for the single generator case because we want its destructor to
        // flush out any pending async operations.
        std::unique_ptr<FrameGenerator> singleton_generator;
        if (FLAGS_gpu) {
            singleton_generator = FrameGenerator::Make(sink.get(), fmt, scale_matrix);
        }
 
        tg.batch(frame_count, [&](int i) {
            // SkTaskGroup::Enabler creates a LIFO work pool,
            // but we want our early frames to start first.
            i = frame_count - 1 - i;
 
            const auto start = std::chrono::steady_clock::now();
            thread_local static auto* anim =
                    skottie::Animation::Builder()
                        .setResourceProvider(rp)
                        .setPrecompInterceptor(precomp_interceptor)
                        .make(static_cast<const char*>(data->data()), data->size())
                        .release();
            thread_local static auto* gen = singleton_generator
                    ? singleton_generator.get()
                    : FrameGenerator::Make(sink.get(), fmt, scale_matrix).release();
 
            if (gen && anim) {
                anim->seekFrame(frame0 + i * fps_scale);
                gen->generateFrame(anim, SkToSizeT(i));
            } else {
                sink->writeFrame(nullptr, SkToSizeT(i));
            }
 
            frames_ms[i] = ms_since(start);
        });
    }
 
    sink->finalize(fps);
    tg.wait();
 
 
    std::sort(frames_ms.begin(), frames_ms.end());
    double sum = std::accumulate(frames_ms.begin(), frames_ms.end(), 0);
    printf("Frame time stats: min %gms, med %gms, avg %gms, max %gms, sum %gms\n",
           frames_ms[0], frames_ms[frame_count/2], sum/frame_count, frames_ms.back(), sum);
 
    return 0;
}

Variable Documentation

formats_help

const char* formats_help = "Output format (png, skp, or null)"

Definition at line 72 of file SkottieTool.cpp.

gSkUseThreadLocalStrikeCaches_IAcknowledgeThisIsIncrediblyExperimental

bool gSkUseThreadLocalStrikeCaches_IAcknowledgeThisIsIncrediblyExperimental

extern

Definition at line 28 of file SkStrikeCache.cpp.