1/*
2 * Copyright (C) 2010 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#include "Caches.h"
18
19#include "GammaFontRenderer.h"
20#include "GlLayer.h"
21#include "Properties.h"
22#include "renderstate/RenderState.h"
23#include "ShadowTessellator.h"
24#ifdef BUGREPORT_FONT_CACHE_USAGE
25#include "font/FontCacheHistoryTracker.h"
26#endif
27#include "utils/GLUtils.h"
28
29#include <cutils/properties.h>
30#include <utils/Log.h>
31#include <utils/String8.h>
32
33namespace android {
34namespace uirenderer {
35
36Caches* Caches::sInstance = nullptr;
37
38///////////////////////////////////////////////////////////////////////////////
39// Macros
40///////////////////////////////////////////////////////////////////////////////
41
42#if DEBUG_CACHE_FLUSH
43    #define FLUSH_LOGD(...) ALOGD(__VA_ARGS__)
44#else
45    #define FLUSH_LOGD(...)
46#endif
47
48///////////////////////////////////////////////////////////////////////////////
49// Constructors/destructor
50///////////////////////////////////////////////////////////////////////////////
51
52Caches::Caches(RenderState& renderState)
53        : gradientCache(mExtensions)
54        , patchCache(renderState)
55        , programCache(mExtensions)
56        , mRenderState(&renderState)
57        , mInitialized(false) {
58    INIT_LOGD("Creating OpenGL renderer caches");
59    init();
60    initConstraints();
61    initStaticProperties();
62    initExtensions();
63}
64
65bool Caches::init() {
66    if (mInitialized) return false;
67
68    ATRACE_NAME("Caches::init");
69
70    mRegionMesh = nullptr;
71    mProgram = nullptr;
72
73    mInitialized = true;
74
75    mPixelBufferState = new PixelBufferState();
76    mTextureState = new TextureState();
77    mTextureState->constructTexture(*this);
78
79    return true;
80}
81
82void Caches::initExtensions() {
83    if (mExtensions.hasDebugMarker()) {
84        eventMark = glInsertEventMarkerEXT;
85
86        startMark = glPushGroupMarkerEXT;
87        endMark = glPopGroupMarkerEXT;
88    } else {
89        eventMark = eventMarkNull;
90        startMark = startMarkNull;
91        endMark = endMarkNull;
92    }
93}
94
95void Caches::initConstraints() {
96    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTextureSize);
97}
98
99void Caches::initStaticProperties() {
100    // OpenGL ES 3.0+ specific features
101    gpuPixelBuffersEnabled = mExtensions.hasPixelBufferObjects()
102            && property_get_bool(PROPERTY_ENABLE_GPU_PIXEL_BUFFERS, true);
103}
104
105void Caches::terminate() {
106    if (!mInitialized) return;
107    mRegionMesh.reset(nullptr);
108
109    fboCache.clear();
110
111    programCache.clear();
112    mProgram = nullptr;
113
114    patchCache.clear();
115
116    clearGarbage();
117
118    delete mPixelBufferState;
119    mPixelBufferState = nullptr;
120    delete mTextureState;
121    mTextureState = nullptr;
122    mInitialized = false;
123}
124
125void Caches::setProgram(const ProgramDescription& description) {
126    setProgram(programCache.get(description));
127}
128
129void Caches::setProgram(Program* program) {
130    if (!program || !program->isInUse()) {
131        if (mProgram) {
132            mProgram->remove();
133        }
134        if (program) {
135            program->use();
136        }
137        mProgram = program;
138    }
139}
140
141///////////////////////////////////////////////////////////////////////////////
142// Debug
143///////////////////////////////////////////////////////////////////////////////
144
145uint32_t Caches::getOverdrawColor(uint32_t amount) const {
146    static uint32_t sOverdrawColors[2][4] = {
147            { 0x2f0000ff, 0x2f00ff00, 0x3fff0000, 0x7fff0000 },
148            { 0x2f0000ff, 0x4fffff00, 0x5fff8ad8, 0x7fff0000 }
149    };
150    if (amount < 1) amount = 1;
151    if (amount > 4) amount = 4;
152
153    int overdrawColorIndex = static_cast<int>(Properties::overdrawColorSet);
154    return sOverdrawColors[overdrawColorIndex][amount - 1];
155}
156
157void Caches::dumpMemoryUsage() {
158    String8 stringLog;
159    dumpMemoryUsage(stringLog);
160    ALOGD("%s", stringLog.string());
161}
162
163void Caches::dumpMemoryUsage(String8 &log) {
164    uint32_t total = 0;
165    log.appendFormat("Current memory usage / total memory usage (bytes):\n");
166    log.appendFormat("  TextureCache         %8d / %8d\n",
167            textureCache.getSize(), textureCache.getMaxSize());
168    if (mRenderState) {
169        int memused = 0;
170        for (std::set<Layer*>::iterator it = mRenderState->mActiveLayers.begin();
171                it != mRenderState->mActiveLayers.end(); it++) {
172            const Layer* layer = *it;
173            LOG_ALWAYS_FATAL_IF(layer->getApi() != Layer::Api::OpenGL);
174            const GlLayer* glLayer = static_cast<const GlLayer*>(layer);
175            log.appendFormat("    GlLayer size %dx%d; texid=%u refs=%d\n",
176                    layer->getWidth(), layer->getHeight(),
177                    glLayer->getTextureId(),
178                    layer->getStrongCount());
179            memused += layer->getWidth() * layer->getHeight() * 4;
180        }
181        log.appendFormat("  Layers total   %8d (numLayers = %zu)\n",
182                memused, mRenderState->mActiveLayers.size());
183        total += memused;
184    }
185    log.appendFormat("  RenderBufferCache    %8d / %8d\n",
186            renderBufferCache.getSize(), renderBufferCache.getMaxSize());
187    log.appendFormat("  GradientCache        %8d / %8d\n",
188            gradientCache.getSize(), gradientCache.getMaxSize());
189    log.appendFormat("  PathCache            %8d / %8d\n",
190            pathCache.getSize(), pathCache.getMaxSize());
191    log.appendFormat("  TessellationCache    %8d / %8d\n",
192            tessellationCache.getSize(), tessellationCache.getMaxSize());
193    log.appendFormat("  TextDropShadowCache  %8d / %8d\n", dropShadowCache.getSize(),
194            dropShadowCache.getMaxSize());
195    log.appendFormat("  PatchCache           %8d / %8d\n",
196            patchCache.getSize(), patchCache.getMaxSize());
197
198    fontRenderer.dumpMemoryUsage(log);
199
200    log.appendFormat("Other:\n");
201    log.appendFormat("  FboCache             %8d / %8d\n",
202            fboCache.getSize(), fboCache.getMaxSize());
203
204    total += textureCache.getSize();
205    total += renderBufferCache.getSize();
206    total += gradientCache.getSize();
207    total += pathCache.getSize();
208    total += tessellationCache.getSize();
209    total += dropShadowCache.getSize();
210    total += patchCache.getSize();
211    total += fontRenderer.getSize();
212
213    log.appendFormat("Total memory usage:\n");
214    log.appendFormat("  %d bytes, %.2f MB\n", total, total / 1024.0f / 1024.0f);
215
216#ifdef BUGREPORT_FONT_CACHE_USAGE
217    fontRenderer.getFontRenderer().historyTracker().dump(log);
218#endif
219}
220
221///////////////////////////////////////////////////////////////////////////////
222// Memory management
223///////////////////////////////////////////////////////////////////////////////
224
225void Caches::clearGarbage() {
226    pathCache.clearGarbage();
227    patchCache.clearGarbage();
228}
229
230void Caches::flush(FlushMode mode) {
231    FLUSH_LOGD("Flushing caches (mode %d)", mode);
232
233    switch (mode) {
234        case FlushMode::Full:
235            textureCache.clear();
236            patchCache.clear();
237            dropShadowCache.clear();
238            gradientCache.clear();
239            fontRenderer.clear();
240            fboCache.clear();
241            // fall through
242        case FlushMode::Moderate:
243            fontRenderer.flush();
244            textureCache.flush();
245            pathCache.clear();
246            tessellationCache.clear();
247            // fall through
248        case FlushMode::Layers:
249            renderBufferCache.clear();
250            break;
251    }
252
253    clearGarbage();
254    glFinish();
255    // Errors during cleanup should be considered non-fatal, dump them and
256    // and move on. TODO: All errors or just errors like bad surface?
257    GLUtils::dumpGLErrors();
258}
259
260///////////////////////////////////////////////////////////////////////////////
261// Regions
262///////////////////////////////////////////////////////////////////////////////
263
264TextureVertex* Caches::getRegionMesh() {
265    // Create the mesh, 2 triangles and 4 vertices per rectangle in the region
266    if (!mRegionMesh) {
267        mRegionMesh.reset(new TextureVertex[kMaxNumberOfQuads * 4]);
268    }
269
270    return mRegionMesh.get();
271}
272
273///////////////////////////////////////////////////////////////////////////////
274// Temporary Properties
275///////////////////////////////////////////////////////////////////////////////
276
277}; // namespace uirenderer
278}; // namespace android
279