The Tor Browser / file comparison
comparison: gfx/skia/trunk/include/pipe/SkGPipe.h
gfx/skia/trunk/include/pipe/SkGPipe.h
- branch
- TOR_BUG_3246
- changeset 7
- 129ffea94266
equal
deleted
inserted
replaced
| -1:000000000000 | 0:96229170ffcb |
|---|---|
| 1 /* | |
| 2 * Copyright 2011 Google Inc. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license that can be | |
| 5 * found in the LICENSE file. | |
| 6 */ | |
| 7 | |
| 8 | |
| 9 | |
| 10 #ifndef SkGPipe_DEFINED | |
| 11 #define SkGPipe_DEFINED | |
| 12 | |
| 13 #include "SkFlattenable.h" | |
| 14 #include "SkPicture.h" | |
| 15 #include "SkWriter32.h" | |
| 16 | |
| 17 class SkCanvas; | |
| 18 | |
| 19 // XLib.h might have defined Status already (ugh) | |
| 20 #ifdef Status | |
| 21 #undef Status | |
| 22 #endif | |
| 23 | |
| 24 class SkGPipeReader { | |
| 25 public: | |
| 26 SkGPipeReader(); | |
| 27 SkGPipeReader(SkCanvas* target); | |
| 28 ~SkGPipeReader(); | |
| 29 | |
| 30 enum Status { | |
| 31 kDone_Status, //!< no more data expected from reader | |
| 32 kEOF_Status, //!< need more data from reader | |
| 33 kError_Status, //!< encountered error | |
| 34 kReadAtom_Status//!< finished reading an atom | |
| 35 }; | |
| 36 | |
| 37 enum PlaybackFlags { | |
| 38 kReadAtom_PlaybackFlag = 0x1, //!< playback a single command from the stream | |
| 39 kSilent_PlaybackFlag = 0x2, //!< playback without drawing | |
| 40 }; | |
| 41 | |
| 42 void setCanvas(SkCanvas*); | |
| 43 | |
| 44 /** | |
| 45 * Set a function for decoding bitmaps that have encoded data. | |
| 46 */ | |
| 47 void setBitmapDecoder(SkPicture::InstallPixelRefProc proc) { fProc = proc; } | |
| 48 | |
| 49 // data must be 4-byte aligned | |
| 50 // length must be a multiple of 4 | |
| 51 Status playback(const void* data, size_t length, uint32_t playbackFlags = 0, | |
| 52 size_t* bytesRead = NULL); | |
| 53 private: | |
| 54 SkCanvas* fCanvas; | |
| 55 class SkGPipeState* fState; | |
| 56 SkPicture::InstallPixelRefProc fProc; | |
| 57 }; | |
| 58 | |
| 59 /////////////////////////////////////////////////////////////////////////////// | |
| 60 | |
| 61 class SkGPipeCanvas; | |
| 62 | |
| 63 class SkGPipeController { | |
| 64 public: | |
| 65 SkGPipeController() : fCanvas(NULL) {} | |
| 66 virtual ~SkGPipeController(); | |
| 67 | |
| 68 /** | |
| 69 * Called periodically by the writer, to get a working buffer of RAM to | |
| 70 * write into. The actual size of the block is also returned, and must be | |
| 71 * actual >= minRequest. If NULL is returned, then actual is ignored and | |
| 72 * writing will stop. | |
| 73 * | |
| 74 * The returned block must be 4-byte aligned, and actual must be a | |
| 75 * multiple of 4. | |
| 76 * minRequest will always be a multiple of 4. | |
| 77 */ | |
| 78 virtual void* requestBlock(size_t minRequest, size_t* actual) = 0; | |
| 79 | |
| 80 /** | |
| 81 * This is called each time some atomic portion of the data has been | |
| 82 * written to the block (most recently returned by requestBlock()). | |
| 83 * If bytes == 0, then the writer has finished. | |
| 84 * | |
| 85 * bytes will always be a multiple of 4. | |
| 86 */ | |
| 87 virtual void notifyWritten(size_t bytes) = 0; | |
| 88 virtual int numberOfReaders() const { return 1; } | |
| 89 | |
| 90 private: | |
| 91 friend class SkGPipeWriter; | |
| 92 void setCanvas(SkGPipeCanvas*); | |
| 93 | |
| 94 SkGPipeCanvas* fCanvas; | |
| 95 }; | |
| 96 | |
| 97 class SkGPipeWriter { | |
| 98 public: | |
| 99 SkGPipeWriter(); | |
| 100 ~SkGPipeWriter(); | |
| 101 | |
| 102 bool isRecording() const { return NULL != fCanvas; } | |
| 103 | |
| 104 enum Flags { | |
| 105 /** | |
| 106 * Tells the writer that the reader will be in a different process, so | |
| 107 * (for example) we cannot put function pointers in the stream. | |
| 108 */ | |
| 109 kCrossProcess_Flag = 1 << 0, | |
| 110 | |
| 111 /** | |
| 112 * Only meaningful if kCrossProcess_Flag is set. Tells the writer that | |
| 113 * in spite of being cross process, it will have shared address space | |
| 114 * with the reader, so the two can share large objects (like SkBitmaps). | |
| 115 */ | |
| 116 kSharedAddressSpace_Flag = 1 << 1, | |
| 117 | |
| 118 /** | |
| 119 * Tells the writer that there will be multiple threads reading the stream | |
| 120 * simultaneously. | |
| 121 */ | |
| 122 kSimultaneousReaders_Flag = 1 << 2, | |
| 123 }; | |
| 124 | |
| 125 SkCanvas* startRecording(SkGPipeController*, uint32_t flags = 0, | |
| 126 uint32_t width = kDefaultRecordingCanvasSize, | |
| 127 uint32_t height = kDefaultRecordingCanvasSize); | |
| 128 | |
| 129 // called in destructor, but can be called sooner once you know there | |
| 130 // should be no more drawing calls made into the recording canvas. | |
| 131 void endRecording(); | |
| 132 | |
| 133 /** | |
| 134 * Tells the writer to commit all recorded draw commands to the | |
| 135 * controller immediately. | |
| 136 * @param detachCurrentBlock Set to true to request that the next draw | |
| 137 * command be recorded in a new block. | |
| 138 */ | |
| 139 void flushRecording(bool detachCurrentBlock); | |
| 140 | |
| 141 /** | |
| 142 * Return the amount of bytes being used for recording. Note that this | |
| 143 * does not include the amount of storage written to the stream, which is | |
| 144 * controlled by the SkGPipeController. | |
| 145 * Currently only returns the amount used for SkBitmaps, since they are | |
| 146 * potentially unbounded (if the client is not calling playback). | |
| 147 */ | |
| 148 size_t storageAllocatedForRecording() const; | |
| 149 | |
| 150 /** | |
| 151 * Attempt to reduce the storage allocated for recording by evicting | |
| 152 * cache resources. | |
| 153 * @param bytesToFree minimum number of bytes that should be attempted to | |
| 154 * be freed. | |
| 155 * @return number of bytes actually freed. | |
| 156 */ | |
| 157 size_t freeMemoryIfPossible(size_t bytesToFree); | |
| 158 | |
| 159 private: | |
| 160 enum { | |
| 161 kDefaultRecordingCanvasSize = 32767, | |
| 162 }; | |
| 163 | |
| 164 SkGPipeCanvas* fCanvas; | |
| 165 SkWriter32 fWriter; | |
| 166 }; | |
| 167 | |
| 168 #endif |
