Home | History | Annotate | Download | only in core 
      1 
      2 /*
      3  * Copyright 2006 The Android Open Source Project
      4  *
      5  * Use of this source code is governed by a BSD-style license that can be
      6  * found in the LICENSE file.
      7  */
      8 
      9 
     10 #ifndef SkDescriptor_DEFINED
     11 #define SkDescriptor_DEFINED
     12 
     13 #include "SkChecksum.h"
     14 #include "SkTypes.h"
     15 
     16 class SkDescriptor : SkNoncopyable {
     17 public:
     18     static size_t ComputeOverhead(int entryCount) {
     19         SkASSERT(entryCount >= 0);
     20         return sizeof(SkDescriptor) + entryCount * sizeof(Entry);
     21     }
     22 
     23     static SkDescriptor* Alloc(size_t length) {
     24         SkASSERT(SkAlign4(length) == length);
     25         SkDescriptor* desc = (SkDescriptor*)sk_malloc_throw(length);
     26         return desc;
     27     }
     28 
     29     static void Free(SkDescriptor* desc) {
     30         sk_free(desc);
     31     }
     32 
     33     void init() {
     34         fLength = sizeof(SkDescriptor);
     35         fCount  = 0;
     36     }
     37 
     38     uint32_t getLength() const { return fLength; }
     39 
     40     void* addEntry(uint32_t tag, size_t length, const void* data = NULL) {
     41         SkASSERT(tag);
     42         SkASSERT(SkAlign4(length) == length);
     43         SkASSERT(this->findEntry(tag, NULL) == NULL);
     44 
     45         Entry*  entry = (Entry*)((char*)this + fLength);
     46         entry->fTag = tag;
     47         entry->fLen = SkToU32(length);
     48         if (data) {
     49             memcpy(entry + 1, data, length);
     50         }
     51 
     52         fCount += 1;
     53         fLength += sizeof(Entry) + length;
     54         return (entry + 1); // return its data
     55     }
     56 
     57     void computeChecksum() {
     58         fChecksum = SkDescriptor::ComputeChecksum(this);
     59     }
     60 
     61 #ifdef SK_DEBUG
     62     void assertChecksum() const {
     63         SkASSERT(SkDescriptor::ComputeChecksum(this) == fChecksum);
     64     }
     65 #endif
     66 
     67     const void* findEntry(uint32_t tag, uint32_t* length) const {
     68         const Entry* entry = (const Entry*)(this + 1);
     69         int          count = fCount;
     70 
     71         while (--count >= 0) {
     72             if (entry->fTag == tag) {
     73                 if (length) {
     74                     *length = entry->fLen;
     75                 }
     76                 return entry + 1;
     77             }
     78             entry = (const Entry*)((const char*)(entry + 1) + entry->fLen);
     79         }
     80         return NULL;
     81     }
     82 
     83     SkDescriptor* copy() const {
     84         SkDescriptor* desc = SkDescriptor::Alloc(fLength);
     85         memcpy(desc, this, fLength);
     86         return desc;
     87     }
     88 
     89     bool equals(const SkDescriptor& other) const {
     90         // probe to see if we have a good checksum algo
     91 //        SkASSERT(a.fChecksum != b.fChecksum || memcmp(&a, &b, a.fLength) == 0);
     92 
     93         // the first value we should look at is the checksum, so this loop
     94         // should terminate early if they descriptors are different.
     95         // NOTE: if we wrote a sentinel value at the end of each, we chould
     96         //       remove the aa < stop test in the loop...
     97         const uint32_t* aa = (const uint32_t*)this;
     98         const uint32_t* bb = (const uint32_t*)&other;
     99         const uint32_t* stop = (const uint32_t*)((const char*)aa + fLength);
    100         do {
    101             if (*aa++ != *bb++)
    102                 return false;
    103         } while (aa < stop);
    104         return true;
    105     }
    106 
    107     uint32_t getChecksum() const { return fChecksum; }
    108 
    109     struct Entry {
    110         uint32_t fTag;
    111         uint32_t fLen;
    112     };
    113 
    114 #ifdef SK_DEBUG
    115     uint32_t getCount() const { return fCount; }
    116 #endif
    117 
    118 private:
    119     uint32_t fChecksum;  // must be first
    120     uint32_t fLength;    // must be second
    121     uint32_t fCount;
    122 
    123     static uint32_t ComputeChecksum(const SkDescriptor* desc) {
    124         const uint32_t* ptr = (const uint32_t*)desc + 1; // skip the checksum field
    125         size_t len = desc->fLength - sizeof(uint32_t);
    126         return SkChecksum::Compute(ptr, len);
    127     }
    128 
    129     // private so no one can create one except our factories
    130     SkDescriptor() {}
    131 };
    132 
    133 #include "SkScalerContext.h"
    134 
    135 class SkAutoDescriptor : SkNoncopyable {
    136 public:
    137     SkAutoDescriptor(size_t size) {
    138         if (size <= sizeof(fStorage)) {
    139             fDesc = (SkDescriptor*)(void*)fStorage;
    140         } else {
    141             fDesc = SkDescriptor::Alloc(size);
    142         }
    143     }
    144 
    145     ~SkAutoDescriptor() {
    146         if (fDesc != (SkDescriptor*)(void*)fStorage) {
    147             SkDescriptor::Free(fDesc);
    148         }
    149     }
    150 
    151     SkDescriptor* getDesc() const { return fDesc; }
    152 private:
    153     enum {
    154         kStorageSize =  sizeof(SkDescriptor)
    155                         + sizeof(SkDescriptor::Entry) + sizeof(SkScalerContext::Rec)    // for rec
    156                         + sizeof(SkDescriptor::Entry) + sizeof(void*)                   // for typeface
    157                         + 32   // slop for occational small extras
    158     };
    159     SkDescriptor*   fDesc;
    160     uint32_t        fStorage[(kStorageSize + 3) >> 2];
    161 };
    162 #define SkAutoDescriptor(...) SK_REQUIRE_LOCAL_VAR(SkAutoDescriptor)
    163 
    164 
    165 #endif
    166