DisplayListRenderer.h revision ffac7fc5042296a459d0f5a450dbfe20917093dc
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#ifndef ANDROID_HWUI_DISPLAY_LIST_RENDERER_H 18#define ANDROID_HWUI_DISPLAY_LIST_RENDERER_H 19 20#include <SkChunkAlloc.h> 21#include <SkFlattenable.h> 22#include <SkMatrix.h> 23#include <SkPaint.h> 24#include <SkPath.h> 25#include <SkPictureFlat.h> 26#include <SkRefCnt.h> 27#include <SkTDArray.h> 28#include <SkTSearch.h> 29 30#include "OpenGLRenderer.h" 31 32namespace android { 33namespace uirenderer { 34 35/////////////////////////////////////////////////////////////////////////////// 36// Defines 37/////////////////////////////////////////////////////////////////////////////// 38 39#define MIN_WRITER_SIZE 16384 40#define HEAP_BLOCK_SIZE 4096 41 42// Debug 43#if DEBUG_DISPLAY_LIST 44 #define DISPLAY_LIST_LOGD(...) LOGD(__VA_ARGS__) 45#else 46 #define DISPLAY_LIST_LOGD(...) 47#endif 48 49/////////////////////////////////////////////////////////////////////////////// 50// Helpers 51/////////////////////////////////////////////////////////////////////////////// 52 53class PathHeap: public SkRefCnt { 54public: 55 PathHeap(); 56 PathHeap(SkFlattenableReadBuffer& buffer); 57 ~PathHeap(); 58 59 int append(const SkPath& path); 60 61 int count() const { return mPaths.count(); } 62 63 SkPath& operator[](int index) const { 64 return *mPaths[index]; 65 } 66 67 void flatten(SkFlattenableWriteBuffer& buffer) const; 68 69private: 70 SkChunkAlloc mHeap; 71 SkTDArray<SkPath*> mPaths; 72}; 73 74/////////////////////////////////////////////////////////////////////////////// 75// Display list 76/////////////////////////////////////////////////////////////////////////////// 77 78class DisplayListRenderer; 79 80/** 81 * Replays recorded drawing commands. 82 */ 83class DisplayList { 84public: 85 DisplayList(const DisplayListRenderer& recorder); 86 ~DisplayList(); 87 88 // IMPORTANT: Update the intialization of OP_NAMES in the .cpp file 89 // when modifying this file 90 enum Op { 91 AcquireContext = 0, 92 ReleaseContext, 93 Save, 94 Restore, 95 RestoreToCount, 96 SaveLayer, 97 SaveLayerAlpha, 98 Translate, 99 Rotate, 100 Scale, 101 SetMatrix, 102 ConcatMatrix, 103 ClipRect, 104 DrawDisplayList, 105 DrawLayer, 106 DrawBitmap, 107 DrawBitmapMatrix, 108 DrawBitmapRect, 109 DrawPatch, 110 DrawColor, 111 DrawRect, 112 DrawPath, 113 DrawLines, 114 DrawText, 115 ResetShader, 116 SetupShader, 117 ResetColorFilter, 118 SetupColorFilter, 119 ResetShadow, 120 SetupShadow, 121 }; 122 123 static const char* OP_NAMES[]; 124 125 void initFromDisplayListRenderer(const DisplayListRenderer& recorder); 126 127 void replay(OpenGLRenderer& renderer, uint32_t level = 0); 128 129private: 130 void init(); 131 132 class TextContainer { 133 public: 134 size_t length() const { 135 return mByteLength; 136 } 137 138 const char* text() const { 139 return (const char*) mText; 140 } 141 142 size_t mByteLength; 143 const char* mText; 144 }; 145 146 SkBitmap* getBitmap() { 147 return (SkBitmap*) getInt(); 148 } 149 150 SkiaShader* getShader() { 151 return (SkiaShader*) getInt(); 152 } 153 154 SkiaColorFilter* getColorFilter() { 155 return (SkiaColorFilter*) getInt(); 156 } 157 158 inline int getIndex() { 159 return mReader.readInt(); 160 } 161 162 inline int getInt() { 163 return mReader.readInt(); 164 } 165 166 SkMatrix* getMatrix() { 167 return (SkMatrix*) getInt(); 168 } 169 170 SkPath* getPath() { 171 return &(*mPathHeap)[getInt() - 1]; 172 } 173 174 SkPaint* getPaint() { 175 return (SkPaint*) getInt(); 176 } 177 178 DisplayList* getDisplayList() { 179 return (DisplayList*) getInt(); 180 } 181 182 inline float getFloat() { 183 return mReader.readScalar(); 184 } 185 186 int32_t* getInts(uint32_t& count) { 187 count = getInt(); 188 return (int32_t*) mReader.skip(count * sizeof(int32_t)); 189 } 190 191 uint32_t* getUInts(int8_t& count) { 192 count = getInt(); 193 return (uint32_t*) mReader.skip(count * sizeof(uint32_t)); 194 } 195 196 float* getFloats(int& count) { 197 count = getInt(); 198 return (float*) mReader.skip(count * sizeof(float)); 199 } 200 201 void getText(TextContainer* text) { 202 size_t length = text->mByteLength = getInt(); 203 text->mText = (const char*) mReader.skip(length); 204 } 205 206 PathHeap* mPathHeap; 207 208 Vector<SkBitmap*> mBitmapResources; 209 Vector<SkiaShader*> mShaderResources; 210 Vector<SkiaColorFilter*> mFilterResources; 211 212 Vector<SkPaint*> mPaints; 213 Vector<SkMatrix*> mMatrices; 214 215 mutable SkFlattenableReadBuffer mReader; 216 217 SkRefCntPlayback mRCPlayback; 218 SkTypefacePlayback mTFPlayback; 219}; 220 221/////////////////////////////////////////////////////////////////////////////// 222// Renderer 223/////////////////////////////////////////////////////////////////////////////// 224 225/** 226 * Records drawing commands in a display list for latter playback. 227 */ 228class DisplayListRenderer: public OpenGLRenderer { 229public: 230 DisplayListRenderer(); 231 ~DisplayListRenderer(); 232 233 DisplayList* getDisplayList(); 234 235 void setViewport(int width, int height); 236 void prepare(bool opaque); 237 238 void acquireContext(); 239 void releaseContext(); 240 241 int save(int flags); 242 void restore(); 243 void restoreToCount(int saveCount); 244 245 int saveLayer(float left, float top, float right, float bottom, 246 SkPaint* p, int flags); 247 int saveLayerAlpha(float left, float top, float right, float bottom, 248 int alpha, int flags); 249 250 void translate(float dx, float dy); 251 void rotate(float degrees); 252 void scale(float sx, float sy); 253 254 void setMatrix(SkMatrix* matrix); 255 void concatMatrix(SkMatrix* matrix); 256 257 bool clipRect(float left, float top, float right, float bottom, SkRegion::Op op); 258 259 void drawDisplayList(DisplayList* displayList, uint32_t level = 0); 260 void drawLayer(Layer* layer, float x, float y, SkPaint* paint); 261 void drawBitmap(SkBitmap* bitmap, float left, float top, SkPaint* paint); 262 void drawBitmap(SkBitmap* bitmap, SkMatrix* matrix, SkPaint* paint); 263 void drawBitmap(SkBitmap* bitmap, float srcLeft, float srcTop, 264 float srcRight, float srcBottom, float dstLeft, float dstTop, 265 float dstRight, float dstBottom, SkPaint* paint); 266 void drawPatch(SkBitmap* bitmap, const int32_t* xDivs, const int32_t* yDivs, 267 const uint32_t* colors, uint32_t width, uint32_t height, int8_t numColors, 268 float left, float top, float right, float bottom, SkPaint* paint); 269 void drawColor(int color, SkXfermode::Mode mode); 270 void drawRect(float left, float top, float right, float bottom, SkPaint* paint); 271 void drawPath(SkPath* path, SkPaint* paint); 272 void drawLines(float* points, int count, SkPaint* paint); 273 void drawText(const char* text, int bytesCount, int count, float x, float y, SkPaint* paint); 274 275 void resetShader(); 276 void setupShader(SkiaShader* shader); 277 278 void resetColorFilter(); 279 void setupColorFilter(SkiaColorFilter* filter); 280 281 void resetShadow(); 282 void setupShadow(float radius, float dx, float dy, int color); 283 284 void reset(); 285 286 const SkWriter32& writeStream() const { 287 return mWriter; 288 } 289 290 const Vector<SkBitmap*>& getBitmapResources() const { 291 return mBitmapResources; 292 } 293 294 const Vector<SkiaShader*>& getShaderResources() const { 295 return mShaderResources; 296 } 297 298 const Vector<SkPaint*>& getPaints() const { 299 return mPaints; 300 } 301 302 const Vector<SkMatrix*>& getMatrices() const { 303 return mMatrices; 304 } 305 306 const Vector<SkiaColorFilter*>& getFilterResources() const { 307 return mFilterResources; 308 } 309 310private: 311 inline void addOp(DisplayList::Op drawOp) { 312 mWriter.writeInt(drawOp); 313 } 314 315 inline void addInt(int value) { 316 mWriter.writeInt(value); 317 } 318 319 void addInts(const int32_t* values, uint32_t count) { 320 mWriter.writeInt(count); 321 for (uint32_t i = 0; i < count; i++) { 322 mWriter.writeInt(values[i]); 323 } 324 } 325 326 void addUInts(const uint32_t* values, int8_t count) { 327 mWriter.writeInt(count); 328 for (int8_t i = 0; i < count; i++) { 329 mWriter.writeInt(values[i]); 330 } 331 } 332 333 inline void addFloat(float value) { 334 mWriter.writeScalar(value); 335 } 336 337 void addFloats(const float* values, int count) { 338 mWriter.writeInt(count); 339 for (int i = 0; i < count; i++) { 340 mWriter.writeScalar(values[i]); 341 } 342 } 343 344 inline void addPoint(float x, float y) { 345 mWriter.writeScalar(x); 346 mWriter.writeScalar(y); 347 } 348 349 inline void addBounds(float left, float top, float right, float bottom) { 350 mWriter.writeScalar(left); 351 mWriter.writeScalar(top); 352 mWriter.writeScalar(right); 353 mWriter.writeScalar(bottom); 354 } 355 356 inline void addText(const void* text, size_t byteLength) { 357 mWriter.writeInt(byteLength); 358 mWriter.writePad(text, byteLength); 359 } 360 361 inline void addPath(const SkPath* path) { 362 if (mPathHeap == NULL) { 363 mPathHeap = new PathHeap(); 364 } 365 addInt(mPathHeap->append(*path)); 366 } 367 368 inline void addPaint(SkPaint* paint) { 369 if (paint == NULL) { 370 addInt((int) NULL); 371 return; 372 } 373 374 SkPaint *paintCopy = mPaintMap.valueFor(paint); 375 if (paintCopy == NULL || paintCopy->getGenerationID() != paint->getGenerationID()) { 376 paintCopy = new SkPaint(*paint); 377 mPaintMap.add(paint, paintCopy); 378 mPaints.add(paintCopy); 379 } 380 381 addInt((int) paintCopy); 382 } 383 384 inline void addDisplayList(DisplayList* displayList) { 385 // TODO: To be safe, the display list should be ref-counted in the 386 // resources cache, but we rely on the caller (UI toolkit) to 387 // do the right thing for now 388 addInt((int) displayList); 389 } 390 391 inline void addMatrix(SkMatrix* matrix) { 392 // Copying the matrix is cheap and prevents against the user changing the original 393 // matrix before the operation that uses it 394 addInt((int) new SkMatrix(*matrix)); 395 } 396 397 inline void addBitmap(SkBitmap* bitmap) { 398 // Note that this assumes the bitmap is immutable. There are cases this won't handle 399 // correctly, such as creating the bitmap from scratch, drawing with it, changing its 400 // contents, and drawing again. The only fix would be to always copy it the first time, 401 // which doesn't seem worth the extra cycles for this unlikely case. 402 addInt((int) bitmap); 403 mBitmapResources.add(bitmap); 404 Caches& caches = Caches::getInstance(); 405 caches.resourceCache.incrementRefcount(bitmap); 406 } 407 408 inline void addShader(SkiaShader* shader) { 409 addInt((int) shader); 410 mShaderResources.add(shader); 411 Caches& caches = Caches::getInstance(); 412 caches.resourceCache.incrementRefcount(shader); 413 } 414 415 inline void addColorFilter(SkiaColorFilter* colorFilter) { 416 addInt((int) colorFilter); 417 mFilterResources.add(colorFilter); 418 Caches& caches = Caches::getInstance(); 419 caches.resourceCache.incrementRefcount(colorFilter); 420 } 421 422 SkChunkAlloc mHeap; 423 424 Vector<SkBitmap*> mBitmapResources; 425 Vector<SkiaShader*> mShaderResources; 426 Vector<SkiaColorFilter*> mFilterResources; 427 428 Vector<SkPaint*> mPaints; 429 DefaultKeyedVector<SkPaint*, SkPaint*> mPaintMap; 430 Vector<SkMatrix*> mMatrices; 431 432 PathHeap* mPathHeap; 433 SkWriter32 mWriter; 434 435 SkRefCntRecorder mRCRecorder; 436 SkRefCntRecorder mTFRecorder; 437 438 DisplayList *mDisplayList; 439 440 friend class DisplayList; 441 442}; // class DisplayListRenderer 443 444}; // namespace uirenderer 445}; // namespace android 446 447#endif // ANDROID_HWUI_DISPLAY_LIST_RENDERER_H 448