blob: a1faadcc830f03056e71c3796ee6b7b73c7593f3 [file] [log] [blame]
/*
* Copyright 2014 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "experimental/ffmpeg/SkVideoEncoder.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkGraphics.h"
#include "include/core/SkStream.h"
#include "include/core/SkSurface.h"
#include "include/core/SkTime.h"
#include "include/private/base/SkTPin.h"
#include "modules/skottie/include/Skottie.h"
#include "modules/skresources/include/SkResources.h"
#include "src/utils/SkOSPath.h"
#include "tools/flags/CommandLineFlags.h"
#include "tools/gpu/GrContextFactory.h"
#include "include/gpu/GrContextOptions.h"
static DEFINE_string2(input, i, "", "skottie animation to render");
static DEFINE_string2(output, o, "", "mp4 file to create");
static DEFINE_string2(assetPath, a, "", "path to assets needed for json file");
static DEFINE_int_2(fps, f, 25, "fps");
static DEFINE_bool2(verbose, v, false, "verbose mode");
static DEFINE_bool2(loop, l, false, "loop mode for profiling");
static DEFINE_int(set_dst_width, 0, "set destination width (height will be computed)");
static DEFINE_bool2(gpu, g, false, "use GPU for rendering");
static void produce_frame(SkSurface* surf, skottie::Animation* anim, double frame) {
anim->seekFrame(frame);
surf->getCanvas()->clear(SK_ColorWHITE);
anim->render(surf->getCanvas());
}
struct AsyncRec {
SkImageInfo info;
SkVideoEncoder* encoder;
};
int main(int argc, char** argv) {
SkGraphics::Init();
CommandLineFlags::SetUsage("Converts skottie to a mp4");
CommandLineFlags::Parse(argc, argv);
if (FLAGS_input.size() == 0) {
SkDebugf("-i input_file.json argument required\n");
return -1;
}
auto contextType = sk_gpu_test::GrContextFactory::kGL_ContextType;
GrContextOptions grCtxOptions;
sk_gpu_test::GrContextFactory factory(grCtxOptions);
SkString assetPath;
if (FLAGS_assetPath.size() > 0) {
assetPath.set(FLAGS_assetPath[0]);
} else {
assetPath = SkOSPath::Dirname(FLAGS_input[0]);
}
SkDebugf("assetPath %s\n", assetPath.c_str());
auto animation = skottie::Animation::Builder()
.setResourceProvider(skresources::FileResourceProvider::Make(assetPath))
.makeFromFile(FLAGS_input[0]);
if (!animation) {
SkDebugf("failed to load %s\n", FLAGS_input[0]);
return -1;
}
SkISize dim = animation->size().toRound();
double duration = animation->duration();
int fps = SkTPin(FLAGS_fps, 1, 240);
double fps_scale = animation->fps() / fps;
float scale = 1;
if (FLAGS_set_dst_width > 0) {
scale = FLAGS_set_dst_width / (float)dim.width();
dim = { FLAGS_set_dst_width, SkScalarRoundToInt(scale * dim.height()) };
}
const int frames = SkScalarRoundToInt(duration * fps);
const double frame_duration = 1.0 / fps;
if (FLAGS_verbose) {
SkDebugf("Size %dx%d duration %g, fps %d, frame_duration %g\n",
dim.width(), dim.height(), duration, fps, frame_duration);
}
SkVideoEncoder encoder;
GrDirectContext* grctx = nullptr;
sk_sp<SkSurface> surf;
sk_sp<SkData> data;
const auto info = SkImageInfo::MakeN32Premul(dim);
do {
double loop_start = SkTime::GetSecs();
if (!encoder.beginRecording(dim, fps)) {
SkDEBUGF("Invalid video stream configuration.\n");
return -1;
}
// lazily allocate the surfaces
if (!surf) {
if (FLAGS_gpu) {
grctx = factory.getContextInfo(contextType).directContext();
surf = SkSurface::MakeRenderTarget(grctx,
skgpu::Budgeted::kNo,
info,
0,
GrSurfaceOrigin::kTopLeft_GrSurfaceOrigin,
nullptr);
if (!surf) {
grctx = nullptr;
}
}
if (!surf) {
surf = SkSurface::MakeRaster(info);
}
surf->getCanvas()->scale(scale, scale);
}
for (int i = 0; i <= frames; ++i) {
const double frame = i * fps_scale;
if (FLAGS_verbose) {
SkDebugf("rendering frame %g\n", frame);
}
produce_frame(surf.get(), animation.get(), frame);
AsyncRec asyncRec = { info, &encoder };
if (grctx) {
auto read_pixels_cb = [](SkSurface::ReadPixelsContext ctx,
std::unique_ptr<const SkSurface::AsyncReadResult> result) {
if (result && result->count() == 1) {
AsyncRec* rec = reinterpret_cast<AsyncRec*>(ctx);
rec->encoder->addFrame({rec->info, result->data(0), result->rowBytes(0)});
}
};
surf->asyncRescaleAndReadPixels(info, {0, 0, info.width(), info.height()},
SkSurface::RescaleGamma::kSrc,
SkImage::RescaleMode::kNearest,
read_pixels_cb, &asyncRec);
grctx->submit();
} else {
SkPixmap pm;
SkAssertResult(surf->peekPixels(&pm));
encoder.addFrame(pm);
}
}
if (grctx) {
// ensure all pending reads are completed
grctx->flushAndSubmit(true);
}
data = encoder.endRecording();
if (FLAGS_loop) {
double loop_dur = SkTime::GetSecs() - loop_start;
SkDebugf("recording secs %g, frames %d, recording fps %d\n",
loop_dur, frames, (int)(frames / loop_dur));
}
} while (FLAGS_loop);
if (FLAGS_output.size() == 0) {
SkDebugf("missing -o output_file.mp4 argument\n");
return 0;
}
SkFILEWStream ostream(FLAGS_output[0]);
if (!ostream.isValid()) {
SkDebugf("Can't create output file %s\n", FLAGS_output[0]);
return -1;
}
ostream.write(data->data(), data->size());
return 0;
}