1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
/*
* Copyright 2018 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "include/codec/SkCodec.h"
#include "include/core/SkData.h"
#include "include/core/SkImage.h"
#include "include/utils/SkAnimCodecPlayer.h"
#include "src/codec/SkCodecImageGenerator.h"
#include <algorithm>
SkAnimCodecPlayer::SkAnimCodecPlayer(std::unique_ptr<SkCodec> codec) : fCodec(std::move(codec)) {
fImageInfo = fCodec->getInfo();
fFrameInfos = fCodec->getFrameInfo();
fImages.resize(fFrameInfos.size());
// change the interpretation of fDuration to a end-time for that frame
size_t dur = 0;
for (auto& f : fFrameInfos) {
dur += f.fDuration;
f.fDuration = dur;
}
fTotalDuration = dur;
if (!fTotalDuration) {
// Static image -- may or may not have returned a single frame info.
fFrameInfos.clear();
fImages.clear();
fImages.push_back(SkImage::MakeFromGenerator(
SkCodecImageGenerator::MakeFromCodec(std::move(fCodec))));
}
}
SkAnimCodecPlayer::~SkAnimCodecPlayer() {}
SkISize SkAnimCodecPlayer::dimensions() {
return { fImageInfo.width(), fImageInfo.height() };
}
sk_sp<SkImage> SkAnimCodecPlayer::getFrameAt(int index) {
SkASSERT((unsigned)index < fFrameInfos.size());
if (fImages[index]) {
return fImages[index];
}
size_t rb = fImageInfo.minRowBytes();
size_t size = fImageInfo.computeByteSize(rb);
auto data = SkData::MakeUninitialized(size);
SkCodec::Options opts;
opts.fFrameIndex = index;
const int requiredFrame = fFrameInfos[index].fRequiredFrame;
if (requiredFrame != SkCodec::kNoFrame) {
auto requiredImage = fImages[requiredFrame];
SkPixmap requiredPM;
if (requiredImage && requiredImage->peekPixels(&requiredPM)) {
sk_careful_memcpy(data->writable_data(), requiredPM.addr(), size);
opts.fPriorFrame = requiredFrame;
}
}
if (SkCodec::kSuccess == fCodec->getPixels(fImageInfo, data->writable_data(), rb, &opts)) {
return fImages[index] = SkImage::MakeRasterData(fImageInfo, std::move(data), rb);
}
return nullptr;
}
sk_sp<SkImage> SkAnimCodecPlayer::getFrame() {
SkASSERT(fTotalDuration > 0 || fImages.size() == 1);
return fTotalDuration > 0
? this->getFrameAt(fCurrIndex)
: fImages.front();
}
bool SkAnimCodecPlayer::seek(uint32_t msec) {
if (!fTotalDuration) {
return false;
}
msec %= fTotalDuration;
auto lower = std::lower_bound(fFrameInfos.begin(), fFrameInfos.end(), msec,
[](const SkCodec::FrameInfo& info, uint32_t msec) {
return (uint32_t)info.fDuration < msec;
});
int prevIndex = fCurrIndex;
fCurrIndex = lower - fFrameInfos.begin();
return fCurrIndex != prevIndex;
}
|
