Home | History | Annotate | Download | only in bootanimation 
      1 /*
      2  * Copyright (C) 2007 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #define LOG_NDEBUG 0
     18 #define LOG_TAG "BootAnimation"
     19 
     20 #include <stdint.h>
     21 #include <sys/types.h>
     22 #include <math.h>
     23 #include <fcntl.h>
     24 #include <utils/misc.h>
     25 #include <signal.h>
     26 
     27 #include <cutils/properties.h>
     28 
     29 #include <androidfw/AssetManager.h>
     30 #include <binder/IPCThreadState.h>
     31 #include <utils/Atomic.h>
     32 #include <utils/Errors.h>
     33 #include <utils/Log.h>
     34 
     35 #include <ui/PixelFormat.h>
     36 #include <ui/Rect.h>
     37 #include <ui/Region.h>
     38 #include <ui/DisplayInfo.h>
     39 
     40 #include <gui/ISurfaceComposer.h>
     41 #include <gui/Surface.h>
     42 #include <gui/SurfaceComposerClient.h>
     43 
     44 #include <SkBitmap.h>
     45 #include <SkStream.h>
     46 #include <SkImageDecoder.h>
     47 
     48 #include <GLES/gl.h>
     49 #include <GLES/glext.h>
     50 #include <EGL/eglext.h>
     51 
     52 #include "BootAnimation.h"
     53 #include "AudioPlayer.h"
     54 
     55 #define OEM_BOOTANIMATION_FILE "/oem/media/bootanimation.zip"
     56 #define SYSTEM_BOOTANIMATION_FILE "/system/media/bootanimation.zip"
     57 #define SYSTEM_ENCRYPTED_BOOTANIMATION_FILE "/system/media/bootanimation-encrypted.zip"
     58 #define EXIT_PROP_NAME "service.bootanim.exit"
     59 
     60 extern "C" int clock_nanosleep(clockid_t clock_id, int flags,
     61                            const struct timespec *request,
     62                            struct timespec *remain);
     63 
     64 namespace android {
     65 
     66 static const int ANIM_ENTRY_NAME_MAX = 256;
     67 
     68 // ---------------------------------------------------------------------------
     69 
     70 BootAnimation::BootAnimation() : Thread(false), mZip(NULL)
     71 {
     72     mSession = new SurfaceComposerClient();
     73 }
     74 
     75 BootAnimation::~BootAnimation() {
     76     if (mZip != NULL) {
     77         delete mZip;
     78     }
     79 }
     80 
     81 void BootAnimation::onFirstRef() {
     82     status_t err = mSession->linkToComposerDeath(this);
     83     ALOGE_IF(err, "linkToComposerDeath failed (%s) ", strerror(-err));
     84     if (err == NO_ERROR) {
     85         run("BootAnimation", PRIORITY_DISPLAY);
     86     }
     87 }
     88 
     89 sp<SurfaceComposerClient> BootAnimation::session() const {
     90     return mSession;
     91 }
     92 
     93 
     94 void BootAnimation::binderDied(const wp<IBinder>&)
     95 {
     96     // woah, surfaceflinger died!
     97     ALOGD("SurfaceFlinger died, exiting...");
     98 
     99     // calling requestExit() is not enough here because the Surface code
    100     // might be blocked on a condition variable that will never be updated.
    101     kill( getpid(), SIGKILL );
    102     requestExit();
    103     if (mAudioPlayer != NULL) {
    104         mAudioPlayer->requestExit();
    105     }
    106 }
    107 
    108 status_t BootAnimation::initTexture(Texture* texture, AssetManager& assets,
    109         const char* name) {
    110     Asset* asset = assets.open(name, Asset::ACCESS_BUFFER);
    111     if (!asset)
    112         return NO_INIT;
    113     SkBitmap bitmap;
    114     SkImageDecoder::DecodeMemory(asset->getBuffer(false), asset->getLength(),
    115             &bitmap, kUnknown_SkColorType, SkImageDecoder::kDecodePixels_Mode);
    116     asset->close();
    117     delete asset;
    118 
    119     // ensure we can call getPixels(). No need to call unlock, since the
    120     // bitmap will go out of scope when we return from this method.
    121     bitmap.lockPixels();
    122 
    123     const int w = bitmap.width();
    124     const int h = bitmap.height();
    125     const void* p = bitmap.getPixels();
    126 
    127     GLint crop[4] = { 0, h, w, -h };
    128     texture->w = w;
    129     texture->h = h;
    130 
    131     glGenTextures(1, &texture->name);
    132     glBindTexture(GL_TEXTURE_2D, texture->name);
    133 
    134     switch (bitmap.colorType()) {
    135         case kAlpha_8_SkColorType:
    136             glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_ALPHA,
    137                     GL_UNSIGNED_BYTE, p);
    138             break;
    139         case kARGB_4444_SkColorType:
    140             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
    141                     GL_UNSIGNED_SHORT_4_4_4_4, p);
    142             break;
    143         case kN32_SkColorType:
    144             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA,
    145                     GL_UNSIGNED_BYTE, p);
    146             break;
    147         case kRGB_565_SkColorType:
    148             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB,
    149                     GL_UNSIGNED_SHORT_5_6_5, p);
    150             break;
    151         default:
    152             break;
    153     }
    154 
    155     glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
    156     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    157     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    158     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    159     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    160     return NO_ERROR;
    161 }
    162 
    163 status_t BootAnimation::initTexture(const Animation::Frame& frame)
    164 {
    165     //StopWatch watch("blah");
    166 
    167     SkBitmap bitmap;
    168     SkMemoryStream  stream(frame.map->getDataPtr(), frame.map->getDataLength());
    169     SkImageDecoder* codec = SkImageDecoder::Factory(&stream);
    170     if (codec) {
    171         codec->setDitherImage(false);
    172         codec->decode(&stream, &bitmap,
    173                 kN32_SkColorType,
    174                 SkImageDecoder::kDecodePixels_Mode);
    175         delete codec;
    176     }
    177 
    178     // FileMap memory is never released until application exit.
    179     // Release it now as the texture is already loaded and the memory used for
    180     // the packed resource can be released.
    181     frame.map->release();
    182 
    183     // ensure we can call getPixels(). No need to call unlock, since the
    184     // bitmap will go out of scope when we return from this method.
    185     bitmap.lockPixels();
    186 
    187     const int w = bitmap.width();
    188     const int h = bitmap.height();
    189     const void* p = bitmap.getPixels();
    190 
    191     GLint crop[4] = { 0, h, w, -h };
    192     int tw = 1 << (31 - __builtin_clz(w));
    193     int th = 1 << (31 - __builtin_clz(h));
    194     if (tw < w) tw <<= 1;
    195     if (th < h) th <<= 1;
    196 
    197     switch (bitmap.colorType()) {
    198         case kN32_SkColorType:
    199             if (tw != w || th != h) {
    200                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tw, th, 0, GL_RGBA,
    201                         GL_UNSIGNED_BYTE, 0);
    202                 glTexSubImage2D(GL_TEXTURE_2D, 0,
    203                         0, 0, w, h, GL_RGBA, GL_UNSIGNED_BYTE, p);
    204             } else {
    205                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tw, th, 0, GL_RGBA,
    206                         GL_UNSIGNED_BYTE, p);
    207             }
    208             break;
    209 
    210         case kRGB_565_SkColorType:
    211             if (tw != w || th != h) {
    212                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tw, th, 0, GL_RGB,
    213                         GL_UNSIGNED_SHORT_5_6_5, 0);
    214                 glTexSubImage2D(GL_TEXTURE_2D, 0,
    215                         0, 0, w, h, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, p);
    216             } else {
    217                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tw, th, 0, GL_RGB,
    218                         GL_UNSIGNED_SHORT_5_6_5, p);
    219             }
    220             break;
    221         default:
    222             break;
    223     }
    224 
    225     glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);
    226 
    227     return NO_ERROR;
    228 }
    229 
    230 status_t BootAnimation::readyToRun() {
    231     mAssets.addDefaultAssets();
    232 
    233     sp<IBinder> dtoken(SurfaceComposerClient::getBuiltInDisplay(
    234             ISurfaceComposer::eDisplayIdMain));
    235     DisplayInfo dinfo;
    236     status_t status = SurfaceComposerClient::getDisplayInfo(dtoken, &dinfo);
    237     if (status)
    238         return -1;
    239 
    240     // create the native surface
    241     sp<SurfaceControl> control = session()->createSurface(String8("BootAnimation"),
    242             dinfo.w, dinfo.h, PIXEL_FORMAT_RGB_565);
    243 
    244     SurfaceComposerClient::openGlobalTransaction();
    245     control->setLayer(0x40000000);
    246     SurfaceComposerClient::closeGlobalTransaction();
    247 
    248     sp<Surface> s = control->getSurface();
    249 
    250     // initialize opengl and egl
    251     const EGLint attribs[] = {
    252             EGL_RED_SIZE,   8,
    253             EGL_GREEN_SIZE, 8,
    254             EGL_BLUE_SIZE,  8,
    255             EGL_DEPTH_SIZE, 0,
    256             EGL_NONE
    257     };
    258     EGLint w, h, dummy;
    259     EGLint numConfigs;
    260     EGLConfig config;
    261     EGLSurface surface;
    262     EGLContext context;
    263 
    264     EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    265 
    266     eglInitialize(display, 0, 0);
    267     eglChooseConfig(display, attribs, &config, 1, &numConfigs);
    268     surface = eglCreateWindowSurface(display, config, s.get(), NULL);
    269     context = eglCreateContext(display, config, NULL, NULL);
    270     eglQuerySurface(display, surface, EGL_WIDTH, &w);
    271     eglQuerySurface(display, surface, EGL_HEIGHT, &h);
    272 
    273     if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE)
    274         return NO_INIT;
    275 
    276     mDisplay = display;
    277     mContext = context;
    278     mSurface = surface;
    279     mWidth = w;
    280     mHeight = h;
    281     mFlingerSurfaceControl = control;
    282     mFlingerSurface = s;
    283 
    284     // If the device has encryption turned on or is in process
    285     // of being encrypted we show the encrypted boot animation.
    286     char decrypt[PROPERTY_VALUE_MAX];
    287     property_get("vold.decrypt", decrypt, "");
    288 
    289     bool encryptedAnimation = atoi(decrypt) != 0 || !strcmp("trigger_restart_min_framework", decrypt);
    290 
    291     ZipFileRO* zipFile = NULL;
    292     if ((encryptedAnimation &&
    293             (access(SYSTEM_ENCRYPTED_BOOTANIMATION_FILE, R_OK) == 0) &&
    294             ((zipFile = ZipFileRO::open(SYSTEM_ENCRYPTED_BOOTANIMATION_FILE)) != NULL)) ||
    295 
    296             ((access(OEM_BOOTANIMATION_FILE, R_OK) == 0) &&
    297             ((zipFile = ZipFileRO::open(OEM_BOOTANIMATION_FILE)) != NULL)) ||
    298 
    299             ((access(SYSTEM_BOOTANIMATION_FILE, R_OK) == 0) &&
    300             ((zipFile = ZipFileRO::open(SYSTEM_BOOTANIMATION_FILE)) != NULL))) {
    301         mZip = zipFile;
    302     }
    303 
    304     return NO_ERROR;
    305 }
    306 
    307 bool BootAnimation::threadLoop()
    308 {
    309     bool r;
    310     // We have no bootanimation file, so we use the stock android logo
    311     // animation.
    312     if (mZip == NULL) {
    313         r = android();
    314     } else {
    315         r = movie();
    316     }
    317 
    318     eglMakeCurrent(mDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    319     eglDestroyContext(mDisplay, mContext);
    320     eglDestroySurface(mDisplay, mSurface);
    321     mFlingerSurface.clear();
    322     mFlingerSurfaceControl.clear();
    323     eglTerminate(mDisplay);
    324     IPCThreadState::self()->stopProcess();
    325     return r;
    326 }
    327 
    328 bool BootAnimation::android()
    329 {
    330     initTexture(&mAndroid[0], mAssets, "images/android-logo-mask.png");
    331     initTexture(&mAndroid[1], mAssets, "images/android-logo-shine.png");
    332 
    333     // clear screen
    334     glShadeModel(GL_FLAT);
    335     glDisable(GL_DITHER);
    336     glDisable(GL_SCISSOR_TEST);
    337     glClearColor(0,0,0,1);
    338     glClear(GL_COLOR_BUFFER_BIT);
    339     eglSwapBuffers(mDisplay, mSurface);
    340 
    341     glEnable(GL_TEXTURE_2D);
    342     glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    343 
    344     const GLint xc = (mWidth  - mAndroid[0].w) / 2;
    345     const GLint yc = (mHeight - mAndroid[0].h) / 2;
    346     const Rect updateRect(xc, yc, xc + mAndroid[0].w, yc + mAndroid[0].h);
    347 
    348     glScissor(updateRect.left, mHeight - updateRect.bottom, updateRect.width(),
    349             updateRect.height());
    350 
    351     // Blend state
    352     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    353     glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    354 
    355     const nsecs_t startTime = systemTime();
    356     do {
    357         nsecs_t now = systemTime();
    358         double time = now - startTime;
    359         float t = 4.0f * float(time / us2ns(16667)) / mAndroid[1].w;
    360         GLint offset = (1 - (t - floorf(t))) * mAndroid[1].w;
    361         GLint x = xc - offset;
    362 
    363         glDisable(GL_SCISSOR_TEST);
    364         glClear(GL_COLOR_BUFFER_BIT);
    365 
    366         glEnable(GL_SCISSOR_TEST);
    367         glDisable(GL_BLEND);
    368         glBindTexture(GL_TEXTURE_2D, mAndroid[1].name);
    369         glDrawTexiOES(x,                 yc, 0, mAndroid[1].w, mAndroid[1].h);
    370         glDrawTexiOES(x + mAndroid[1].w, yc, 0, mAndroid[1].w, mAndroid[1].h);
    371 
    372         glEnable(GL_BLEND);
    373         glBindTexture(GL_TEXTURE_2D, mAndroid[0].name);
    374         glDrawTexiOES(xc, yc, 0, mAndroid[0].w, mAndroid[0].h);
    375 
    376         EGLBoolean res = eglSwapBuffers(mDisplay, mSurface);
    377         if (res == EGL_FALSE)
    378             break;
    379 
    380         // 12fps: don't animate too fast to preserve CPU
    381         const nsecs_t sleepTime = 83333 - ns2us(systemTime() - now);
    382         if (sleepTime > 0)
    383             usleep(sleepTime);
    384 
    385         checkExit();
    386     } while (!exitPending());
    387 
    388     glDeleteTextures(1, &mAndroid[0].name);
    389     glDeleteTextures(1, &mAndroid[1].name);
    390     return false;
    391 }
    392 
    393 
    394 void BootAnimation::checkExit() {
    395     // Allow surface flinger to gracefully request shutdown
    396     char value[PROPERTY_VALUE_MAX];
    397     property_get(EXIT_PROP_NAME, value, "0");
    398     int exitnow = atoi(value);
    399     if (exitnow) {
    400         requestExit();
    401         if (mAudioPlayer != NULL) {
    402             mAudioPlayer->requestExit();
    403         }
    404     }
    405 }
    406 
    407 // Parse a color represented as an HTML-style 'RRGGBB' string: each pair of
    408 // characters in str is a hex number in [0, 255], which are converted to
    409 // floating point values in the range [0.0, 1.0] and placed in the
    410 // corresponding elements of color.
    411 //
    412 // If the input string isn't valid, parseColor returns false and color is
    413 // left unchanged.
    414 static bool parseColor(const char str[7], float color[3]) {
    415     float tmpColor[3];
    416     for (int i = 0; i < 3; i++) {
    417         int val = 0;
    418         for (int j = 0; j < 2; j++) {
    419             val *= 16;
    420             char c = str[2*i + j];
    421             if      (c >= '0' && c <= '9') val += c - '0';
    422             else if (c >= 'A' && c <= 'F') val += (c - 'A') + 10;
    423             else if (c >= 'a' && c <= 'f') val += (c - 'a') + 10;
    424             else                           return false;
    425         }
    426         tmpColor[i] = static_cast<float>(val) / 255.0f;
    427     }
    428     memcpy(color, tmpColor, sizeof(tmpColor));
    429     return true;
    430 }
    431 
    432 bool BootAnimation::readFile(const char* name, String8& outString)
    433 {
    434     ZipEntryRO entry = mZip->findEntryByName(name);
    435     ALOGE_IF(!entry, "couldn't find %s", name);
    436     if (!entry) {
    437         return false;
    438     }
    439 
    440     FileMap* entryMap = mZip->createEntryFileMap(entry);
    441     mZip->releaseEntry(entry);
    442     ALOGE_IF(!entryMap, "entryMap is null");
    443     if (!entryMap) {
    444         return false;
    445     }
    446 
    447     outString.setTo((char const*)entryMap->getDataPtr(), entryMap->getDataLength());
    448     entryMap->release();
    449     return true;
    450 }
    451 
    452 bool BootAnimation::movie()
    453 {
    454     String8 desString;
    455 
    456     if (!readFile("desc.txt", desString)) {
    457         return false;
    458     }
    459     char const* s = desString.string();
    460 
    461     // Create and initialize an AudioPlayer if we have an audio_conf.txt file
    462     String8 audioConf;
    463     if (readFile("audio_conf.txt", audioConf)) {
    464         mAudioPlayer = new AudioPlayer;
    465         if (!mAudioPlayer->init(audioConf.string())) {
    466             ALOGE("mAudioPlayer.init failed");
    467             mAudioPlayer = NULL;
    468         }
    469     }
    470 
    471     Animation animation;
    472 
    473     // Parse the description file
    474     for (;;) {
    475         const char* endl = strstr(s, "\n");
    476         if (!endl) break;
    477         String8 line(s, endl - s);
    478         const char* l = line.string();
    479         int fps, width, height, count, pause;
    480         char path[ANIM_ENTRY_NAME_MAX];
    481         char color[7] = "000000"; // default to black if unspecified
    482 
    483         char pathType;
    484         if (sscanf(l, "%d %d %d", &width, &height, &fps) == 3) {
    485             // ALOGD("> w=%d, h=%d, fps=%d", width, height, fps);
    486             animation.width = width;
    487             animation.height = height;
    488             animation.fps = fps;
    489         }
    490         else if (sscanf(l, " %c %d %d %s #%6s", &pathType, &count, &pause, path, color) >= 4) {
    491             // ALOGD("> type=%c, count=%d, pause=%d, path=%s, color=%s", pathType, count, pause, path, color);
    492             Animation::Part part;
    493             part.playUntilComplete = pathType == 'c';
    494             part.count = count;
    495             part.pause = pause;
    496             part.path = path;
    497             part.audioFile = NULL;
    498             if (!parseColor(color, part.backgroundColor)) {
    499                 ALOGE("> invalid color '#%s'", color);
    500                 part.backgroundColor[0] = 0.0f;
    501                 part.backgroundColor[1] = 0.0f;
    502                 part.backgroundColor[2] = 0.0f;
    503             }
    504             animation.parts.add(part);
    505         }
    506 
    507         s = ++endl;
    508     }
    509 
    510     // read all the data structures
    511     const size_t pcount = animation.parts.size();
    512     void *cookie = NULL;
    513     if (!mZip->startIteration(&cookie)) {
    514         return false;
    515     }
    516 
    517     ZipEntryRO entry;
    518     char name[ANIM_ENTRY_NAME_MAX];
    519     while ((entry = mZip->nextEntry(cookie)) != NULL) {
    520         const int foundEntryName = mZip->getEntryFileName(entry, name, ANIM_ENTRY_NAME_MAX);
    521         if (foundEntryName > ANIM_ENTRY_NAME_MAX || foundEntryName == -1) {
    522             ALOGE("Error fetching entry file name");
    523             continue;
    524         }
    525 
    526         const String8 entryName(name);
    527         const String8 path(entryName.getPathDir());
    528         const String8 leaf(entryName.getPathLeaf());
    529         if (leaf.size() > 0) {
    530             for (size_t j=0 ; j<pcount ; j++) {
    531                 if (path == animation.parts[j].path) {
    532                     int method;
    533                     // supports only stored png files
    534                     if (mZip->getEntryInfo(entry, &method, NULL, NULL, NULL, NULL, NULL)) {
    535                         if (method == ZipFileRO::kCompressStored) {
    536                             FileMap* map = mZip->createEntryFileMap(entry);
    537                             if (map) {
    538                                 Animation::Part& part(animation.parts.editItemAt(j));
    539                                 if (leaf == "audio.wav") {
    540                                     // a part may have at most one audio file
    541                                     part.audioFile = map;
    542                                 } else {
    543                                     Animation::Frame frame;
    544                                     frame.name = leaf;
    545                                     frame.map = map;
    546                                     part.frames.add(frame);
    547                                 }
    548                             }
    549                         }
    550                     }
    551                 }
    552             }
    553         }
    554     }
    555 
    556     mZip->endIteration(cookie);
    557 
    558     // clear screen
    559     glShadeModel(GL_FLAT);
    560     glDisable(GL_DITHER);
    561     glDisable(GL_SCISSOR_TEST);
    562     glDisable(GL_BLEND);
    563     glClearColor(0,0,0,1);
    564     glClear(GL_COLOR_BUFFER_BIT);
    565 
    566     eglSwapBuffers(mDisplay, mSurface);
    567 
    568     glBindTexture(GL_TEXTURE_2D, 0);
    569     glEnable(GL_TEXTURE_2D);
    570     glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    571     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    572     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    573     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    574     glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    575 
    576     const int xc = (mWidth - animation.width) / 2;
    577     const int yc = ((mHeight - animation.height) / 2);
    578     nsecs_t lastFrame = systemTime();
    579     nsecs_t frameDuration = s2ns(1) / animation.fps;
    580 
    581     Region clearReg(Rect(mWidth, mHeight));
    582     clearReg.subtractSelf(Rect(xc, yc, xc+animation.width, yc+animation.height));
    583 
    584     for (size_t i=0 ; i<pcount ; i++) {
    585         const Animation::Part& part(animation.parts[i]);
    586         const size_t fcount = part.frames.size();
    587         glBindTexture(GL_TEXTURE_2D, 0);
    588 
    589         for (int r=0 ; !part.count || r<part.count ; r++) {
    590             // Exit any non playuntil complete parts immediately
    591             if(exitPending() && !part.playUntilComplete)
    592                 break;
    593 
    594             // only play audio file the first time we animate the part
    595             if (r == 0 && mAudioPlayer != NULL && part.audioFile) {
    596                 mAudioPlayer->playFile(part.audioFile);
    597             }
    598 
    599             glClearColor(
    600                     part.backgroundColor[0],
    601                     part.backgroundColor[1],
    602                     part.backgroundColor[2],
    603                     1.0f);
    604 
    605             for (size_t j=0 ; j<fcount && (!exitPending() || part.playUntilComplete) ; j++) {
    606                 const Animation::Frame& frame(part.frames[j]);
    607                 nsecs_t lastFrame = systemTime();
    608 
    609                 if (r > 0) {
    610                     glBindTexture(GL_TEXTURE_2D, frame.tid);
    611                 } else {
    612                     if (part.count != 1) {
    613                         glGenTextures(1, &frame.tid);
    614                         glBindTexture(GL_TEXTURE_2D, frame.tid);
    615                         glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    616                         glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    617                     }
    618                     initTexture(frame);
    619                 }
    620 
    621                 if (!clearReg.isEmpty()) {
    622                     Region::const_iterator head(clearReg.begin());
    623                     Region::const_iterator tail(clearReg.end());
    624                     glEnable(GL_SCISSOR_TEST);
    625                     while (head != tail) {
    626                         const Rect& r(*head++);
    627                         glScissor(r.left, mHeight - r.bottom,
    628                                 r.width(), r.height());
    629                         glClear(GL_COLOR_BUFFER_BIT);
    630                     }
    631                     glDisable(GL_SCISSOR_TEST);
    632                 }
    633                 glDrawTexiOES(xc, yc, 0, animation.width, animation.height);
    634                 eglSwapBuffers(mDisplay, mSurface);
    635 
    636                 nsecs_t now = systemTime();
    637                 nsecs_t delay = frameDuration - (now - lastFrame);
    638                 //ALOGD("%lld, %lld", ns2ms(now - lastFrame), ns2ms(delay));
    639                 lastFrame = now;
    640 
    641                 if (delay > 0) {
    642                     struct timespec spec;
    643                     spec.tv_sec  = (now + delay) / 1000000000;
    644                     spec.tv_nsec = (now + delay) % 1000000000;
    645                     int err;
    646                     do {
    647                         err = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &spec, NULL);
    648                     } while (err<0 && errno == EINTR);
    649                 }
    650 
    651                 checkExit();
    652             }
    653 
    654             usleep(part.pause * ns2us(frameDuration));
    655 
    656             // For infinite parts, we've now played them at least once, so perhaps exit
    657             if(exitPending() && !part.count)
    658                 break;
    659         }
    660 
    661         // free the textures for this part
    662         if (part.count != 1) {
    663             for (size_t j=0 ; j<fcount ; j++) {
    664                 const Animation::Frame& frame(part.frames[j]);
    665                 glDeleteTextures(1, &frame.tid);
    666             }
    667         }
    668     }
    669 
    670     return false;
    671 }
    672 
    673 // ---------------------------------------------------------------------------
    674 
    675 }
    676 ; // namespace android
    677