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
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_image_decoders_nsPNGDecoder_h
#define mozilla_image_decoders_nsPNGDecoder_h
#include "Decoder.h"
#include "png.h"
#include "StreamingLexer.h"
#include "SurfacePipe.h"
#include "mozilla/gfx/Swizzle.h"
namespace mozilla {
namespace image {
class RasterImage;
class nsPNGDecoder : public Decoder {
public:
virtual ~nsPNGDecoder();
/// @return true if this PNG is a valid ICO resource.
bool IsValidICOResource() const override;
DecoderType GetType() const override { return DecoderType::PNG; }
protected:
nsresult InitInternal() override;
nsresult FinishInternal() override;
LexerResult DoDecode(SourceBufferIterator& aIterator,
IResumable* aOnResume) override;
Maybe<Telemetry::HistogramID> SpeedHistogram() const override;
private:
friend class DecoderFactory;
// Decoders should only be instantiated via DecoderFactory.
explicit nsPNGDecoder(RasterImage* aImage);
/// The information necessary to create a frame.
struct FrameInfo {
OrientedIntRect mFrameRect;
bool mIsInterlaced;
};
nsresult CreateFrame(const FrameInfo& aFrameInfo);
void EndImageFrame();
uint32_t ReadColorProfile(png_structp png_ptr, png_infop info_ptr,
int color_type, bool* sRGBTag);
bool HasAlphaChannel() const { return mChannels == 2 || mChannels == 4; }
enum class TransparencyType { eNone, eAlpha, eFrameRect };
TransparencyType GetTransparencyType(const OrientedIntRect& aFrameRect);
void PostHasTransparencyIfNeeded(TransparencyType aTransparencyType);
void PostInvalidationIfNeeded();
void WriteRow(uint8_t* aRow);
// Convenience methods to make interacting with StreamingLexer from inside
// a libpng callback easier.
void DoTerminate(png_structp aPNGStruct, TerminalState aState);
void DoYield(png_structp aPNGStruct);
enum class State { PNG_DATA, FINISHED_PNG_DATA };
LexerTransition<State> ReadPNGData(const char* aData, size_t aLength);
LexerTransition<State> FinishedPNGData();
StreamingLexer<State> mLexer;
// The next lexer state transition. We need to store it here because we can't
// directly return arbitrary values from libpng callbacks.
LexerTransition<State> mNextTransition;
// We yield to the caller every time we finish decoding a frame. When this
// happens, we need to allocate the next frame after returning from the yield.
// |mNextFrameInfo| is used to store the information needed to allocate the
// next frame.
Maybe<FrameInfo> mNextFrameInfo;
// The length of the last chunk of data passed to ReadPNGData(). We use this
// to arrange to arrive back at the correct spot in the data after yielding.
size_t mLastChunkLength;
public:
png_structp mPNG;
png_infop mInfo;
OrientedIntRect mFrameRect;
uint8_t* mCMSLine;
uint8_t* interlacebuf;
gfx::SurfaceFormat mFormat;
uint8_t mChannels;
uint8_t mPass;
bool mFrameIsHidden;
bool mDisablePremultipliedAlpha;
bool mGotInfoCallback;
bool mUsePipeTransform;
bool mErrorIsRecoverable;
struct AnimFrameInfo {
AnimFrameInfo();
#ifdef PNG_APNG_SUPPORTED
AnimFrameInfo(png_structp aPNG, png_infop aInfo);
#endif
DisposalMethod mDispose;
BlendMethod mBlend;
int32_t mTimeout;
};
AnimFrameInfo mAnimInfo;
SurfacePipe mPipe; /// The SurfacePipe used to write to the output surface.
// The number of frames we've finished.
uint32_t mNumFrames;
// libpng callbacks
// We put these in the class so that they can access protected members.
static void PNGAPI info_callback(png_structp png_ptr, png_infop info_ptr);
static void PNGAPI row_callback(png_structp png_ptr, png_bytep new_row,
png_uint_32 row_num, int pass);
#ifdef PNG_APNG_SUPPORTED
static void PNGAPI frame_info_callback(png_structp png_ptr,
png_uint_32 frame_num);
#endif
static void PNGAPI end_callback(png_structp png_ptr, png_infop info_ptr);
static void PNGAPI error_callback(png_structp png_ptr,
png_const_charp error_msg);
static void PNGAPI warning_callback(png_structp png_ptr,
png_const_charp warning_msg);
// This is defined in the PNG spec as an invariant. We use it to
// do manual validation without libpng.
static const uint8_t pngSignatureBytes[];
};
} // namespace image
} // namespace mozilla
#endif // mozilla_image_decoders_nsPNGDecoder_h
|
