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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_BOOTANIMATION_H
#define ANDROID_BOOTANIMATION_H
#include <stdint.h>
#include <sys/types.h>
#include <androidfw/AssetManager.h>
#include <utils/Thread.h>
#include <EGL/egl.h>
#include <GLES/gl.h>
#include <utils/Thread.h>
class SkBitmap;
namespace android {
class AudioPlayer;
class Surface;
class SurfaceComposerClient;
class SurfaceControl;
#ifdef MULTITHREAD_DECODE
class FrameManager;
#endif
// ---------------------------------------------------------------------------
class BootAnimation : public Thread, public IBinder::DeathRecipient
{
#ifdef MULTITHREAD_DECODE
friend class FrameManager;
#endif
public:
enum {
eOrientationDefault = 0,
eOrientation90 = 1,
eOrientation180 = 2,
eOrientation270 = 3,
};
BootAnimation();
virtual ~BootAnimation();
sp<SurfaceComposerClient> session() const;
private:
virtual bool threadLoop();
virtual status_t readyToRun();
virtual void onFirstRef();
virtual void binderDied(const wp<IBinder>& who);
struct Texture {
GLint w;
GLint h;
GLuint name;
};
struct Animation {
struct Frame {
String8 name;
FileMap* map;
mutable GLuint tid;
bool operator < (const Frame& rhs) const {
return name < rhs.name;
}
};
struct Part {
int count;
int pause;
String8 path;
SortedVector<Frame> frames;
bool playUntilComplete;
float backgroundColor[3];
FileMap* audioFile;
};
int fps;
int width;
int height;
Vector<Part> parts;
};
status_t initTexture(Texture* texture, AssetManager& asset, const char* name);
status_t initTexture(const Animation::Frame& frame);
status_t initTexture(SkBitmap *bitmap);
bool android();
bool readFile(const char* name, String8& outString);
bool movie();
enum ImageID { IMG_DATA = 0, IMG_SYS = 1, IMG_ENC = 2, IMG_THM = 3 };
const char *getAnimationFileName(ImageID image);
const char *getBootRingtoneFileName(ImageID image);
void playBackgroundMusic();
bool checkBootState();
void checkExit();
void checkShowAndroid();
static SkBitmap *decode(const Animation::Frame& frame);
sp<SurfaceComposerClient> mSession;
sp<AudioPlayer> mAudioPlayer;
AssetManager mAssets;
Texture mAndroid[3];
int mWidth;
int mHeight;
EGLDisplay mDisplay;
EGLDisplay mContext;
EGLDisplay mSurface;
sp<SurfaceControl> mFlingerSurfaceControl;
sp<Surface> mFlingerSurface;
ZipFileRO *mZip;
};
#ifdef MULTITHREAD_DECODE
class FrameManager {
public:
struct DecodeWork {
const BootAnimation::Animation::Frame *frame;
SkBitmap *bitmap;
size_t idx;
};
FrameManager(int numThreads, size_t maxSize, const SortedVector<BootAnimation::Animation::Frame>& frames);
virtual ~FrameManager();
SkBitmap* next();
protected:
DecodeWork getWork();
void completeWork(DecodeWork work);
private:
class DecodeThread : public Thread {
public:
DecodeThread(FrameManager* manager);
virtual ~DecodeThread() {}
private:
virtual bool threadLoop();
FrameManager *mManager;
};
size_t mMaxSize;
size_t mFrameCounter;
size_t mNextIdx;
const SortedVector<BootAnimation::Animation::Frame>& mFrames;
Vector<DecodeWork> mDecodedFrames;
pthread_mutex_t mBitmapsMutex;
pthread_cond_t mSpaceAvailableCondition;
pthread_cond_t mBitmapReadyCondition;
bool mExit;
Vector<sp<DecodeThread> > mThreads;
};
#endif
// ---------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_BOOTANIMATION_H
|
