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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkJpegCodec_DEFINED
#define SkJpegCodec_DEFINED
#include "SkCodec.h"
#include "SkColorSpace.h"
#include "SkColorSpaceXform.h"
#include "SkImageInfo.h"
#include "SkSwizzler.h"
#include "SkStream.h"
#include "SkTemplates.h"
class JpegDecoderMgr;
/*
*
* This class implements the decoding for jpeg images
*
*/
class SkJpegCodec : public SkCodec {
public:
static bool IsJpeg(const void*, size_t);
/*
* Assumes IsJpeg was called and returned true
* Takes ownership of the stream
*/
static std::unique_ptr<SkCodec> MakeFromStream(std::unique_ptr<SkStream>, Result*);
protected:
/*
* Recommend a set of destination dimensions given a requested scale
*/
SkISize onGetScaledDimensions(float desiredScale) const override;
/*
* Initiates the jpeg decode
*/
Result onGetPixels(const SkImageInfo& dstInfo, void* dst, size_t dstRowBytes, const Options&,
int*) override;
bool onQueryYUV8(SkYUVSizeInfo* sizeInfo, SkYUVColorSpace* colorSpace) const override;
Result onGetYUV8Planes(const SkYUVSizeInfo& sizeInfo, void* planes[3]) override;
SkEncodedImageFormat onGetEncodedFormat() const override {
return SkEncodedImageFormat::kJPEG;
}
bool onRewind() override;
bool onDimensionsSupported(const SkISize&) override;
bool conversionSupported(const SkImageInfo&, SkColorType, bool,
const SkColorSpace*) const override {
// This class checks for conversion after creating colorXform.
return true;
}
private:
/*
* Allows SkRawCodec to communicate the color space from the exif data.
*/
static std::unique_ptr<SkCodec> MakeFromStream(std::unique_ptr<SkStream>, Result*,
sk_sp<SkColorSpace> defaultColorSpace);
/*
* Read enough of the stream to initialize the SkJpegCodec.
* Returns a bool representing success or failure.
*
* @param codecOut
* If this returns true, and codecOut was not nullptr,
* codecOut will be set to a new SkJpegCodec.
*
* @param decoderMgrOut
* If this returns true, and codecOut was nullptr,
* decoderMgrOut must be non-nullptr and decoderMgrOut will be set to a new
* JpegDecoderMgr pointer.
*
* @param stream
* Deleted on failure.
* codecOut will take ownership of it in the case where we created a codec.
* Ownership is unchanged when we set decoderMgrOut.
*
* @param defaultColorSpace
* If the jpeg does not have an embedded color space, the image data should
* be tagged with this color space.
*/
static Result ReadHeader(SkStream* stream, SkCodec** codecOut,
JpegDecoderMgr** decoderMgrOut, sk_sp<SkColorSpace> defaultColorSpace);
/*
* Creates an instance of the decoder
* Called only by NewFromStream
*
* @param info contains properties of the encoded data
* @param stream the encoded image data
* @param decoderMgr holds decompress struct, src manager, and error manager
* takes ownership
*/
SkJpegCodec(int width, int height, const SkEncodedInfo& info, std::unique_ptr<SkStream> stream,
JpegDecoderMgr* decoderMgr, sk_sp<SkColorSpace> colorSpace, SkEncodedOrigin origin);
/*
* Checks if the conversion between the input image and the requested output
* image has been implemented.
*
* Sets the output color space.
*/
bool setOutputColorSpace(const SkImageInfo& dst);
void initializeSwizzler(const SkImageInfo& dstInfo, const Options& options,
bool needsCMYKToRGB);
void allocateStorage(const SkImageInfo& dstInfo);
int readRows(const SkImageInfo& dstInfo, void* dst, size_t rowBytes, int count, const Options&);
/*
* Scanline decoding.
*/
SkSampler* getSampler(bool createIfNecessary) override;
Result onStartScanlineDecode(const SkImageInfo& dstInfo,
const Options& options) override;
int onGetScanlines(void* dst, int count, size_t rowBytes) override;
bool onSkipScanlines(int count) override;
std::unique_ptr<JpegDecoderMgr> fDecoderMgr;
// We will save the state of the decompress struct after reading the header.
// This allows us to safely call onGetScaledDimensions() at any time.
const int fReadyState;
SkAutoTMalloc<uint8_t> fStorage;
uint8_t* fSwizzleSrcRow;
uint32_t* fColorXformSrcRow;
// libjpeg-turbo provides some subsetting. In the case that libjpeg-turbo
// cannot take the exact the subset that we need, we will use the swizzler
// to further subset the output from libjpeg-turbo.
SkIRect fSwizzlerSubset;
std::unique_ptr<SkSwizzler> fSwizzler;
friend class SkRawCodec;
typedef SkCodec INHERITED;
};
#endif
|
