start to plumb ttcIndex into fonthost. For now just add to SkFontStream and its callers.

trunk/src/core/SkFontStream.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkEndian.h"
 #include "SkFontStream.h"
 #include "SkStream.h"
@@ skipping 25 matching lines @@
     uint32_t    fLength;
 };
 
 /** Return the number of tables, or if this is a TTC (collection), return the
     number of tables in the first element of the collection. In either case,
     if offsetToDir is not-null, set it to the offset to the beginning of the
     table headers (SkSFNTDirEntry), relative to the start of the stream.
 
     On an error, return 0 for number of tables, and ignore offsetToDir
  */
-static int count_tables(SkStream* stream, size_t* offsetToDir = NULL) {
+static int count_tables(SkStream* stream, int ttcIndex, size_t* offsetToDir) {

[bungeman-skia, 2013/03/05 22:07:33]

ttcIndex may well be perfectly well served by an int, but why not unsigned?
You're already casting it to unsigned below anyway, asserting below, and
obviously it can't reasonably be negative.

+    SkASSERT(ttcIndex >= 0);
+
     SkSharedTTHeader shared;
     if (stream->read(&shared, sizeof(shared)) != sizeof(shared)) {
         return 0;
     }
 
     // by default, SkSFNTHeader is at the start of the stream
     size_t offset = 0;
 
     // if we're really a collection, the first 4-bytes will be 'ttcf'
     uint32_t tag = SkEndian_SwapBE32(shared.fCollection.fTag);
     if (SkSetFourByteTag('t', 't', 'c', 'f') == tag) {
-        if (shared.fCollection.fNumOffsets == 0) {
+        unsigned count = SkEndian_SwapBE32(shared.fCollection.fNumOffsets);
+        if ((unsigned)ttcIndex >= count) {
             return 0;
         }
-        // this is the offset to the first local SkSFNTHeader
-        offset = SkEndian_SwapBE32(shared.fCollection.fOffset0);
+        
+        if (ttcIndex > 0) { // need to read more of the shared header
+            stream->rewind();
+            size_t amount = sizeof(shared) + ttcIndex * sizeof(uint32_t);
+            if (stream->read(&shared, amount) != amount) {
+                return 0;
+            }
+        }
+        // this is the offset to the local SkSFNTHeader
+        offset = SkEndian_SwapBE32((&shared.fCollection.fOffset0)[ttcIndex]);
         stream->rewind();
         if (stream->skip(offset) != offset) {
             return 0;
         }
         if (stream->read(&shared, sizeof(shared)) != sizeof(shared)) {
             return 0;
         }
     }
 
     if (offsetToDir) {
         // add the size of the header, so we will point to the DirEntries
         *offsetToDir = offset + sizeof(SkSFNTHeader);
     }
     return SkEndian_SwapBE16(shared.fSingle.fNumTables);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 struct SfntHeader {
     SfntHeader() : fCount(0), fDir(NULL) {}
     ~SfntHeader() { sk_free(fDir); }
 
     /** If it returns true, then fCount and fDir are properly initialized.
         Note: fDir will point to the raw array of SkSFNTDirEntry values,
         meaning they will still be in the file's native endianness (BE).
 
         fDir will be automatically freed when this object is destroyed
      */
-    bool init(SkStream* stream) {
+    bool init(SkStream* stream, int ttcIndex) {
         stream->rewind();
 
         size_t offsetToDir;
-        fCount = count_tables(stream, &offsetToDir);
+        fCount = count_tables(stream, ttcIndex, &offsetToDir);
         if (0 == fCount) {
             return false;
         }
 
         stream->rewind();
         if (stream->skip(offsetToDir) != offsetToDir) {
             return false;
         }
 
         size_t size = fCount * sizeof(SkSFNTDirEntry);
         fDir = reinterpret_cast<SkSFNTDirEntry*>(sk_malloc_throw(size));
         return stream->read(fDir, size) == size;
     }
 
     int             fCount;
     SkSFNTDirEntry* fDir;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
-int SkFontStream::GetTableTags(SkStream* stream, SkFontTableTag tags[]) {
+int SkFontStream::CountTTCEntries(SkStream* stream) {
+    stream->rewind();
+
+    SkSharedTTHeader shared;
+    if (stream->read(&shared, sizeof(shared)) != sizeof(shared)) {
+        return -1;
+    }
+
+    // if we're really a collection, the first 4-bytes will be 'ttcf'
+    uint32_t tag = SkEndian_SwapBE32(shared.fCollection.fTag);
+    if (SkSetFourByteTag('t', 't', 'c', 'f') == tag) {
+        return SkEndian_SwapBE32(shared.fCollection.fNumOffsets);
+    } else {
+        return 0;

[bungeman-skia, 2013/03/05 22:07:33]

The doc says return 0 for sfnt, but this returns 0 for everything > ~20 bytes?
Just return 0 for "Doesn't look like a TTC"?

+    }        
+}
+
+int SkFontStream::GetTableTags(SkStream* stream, int ttcIndex,
+                               SkFontTableTag tags[]) {
     SfntHeader  header;
-    if (!header.init(stream)) {
+    if (!header.init(stream, ttcIndex)) {
         return 0;
     }
 
     if (tags) {
         for (int i = 0; i < header.fCount; i++) {
             tags[i] = SkEndian_SwapBE32(header.fDir[i].fTag);
         }
     }
     return header.fCount;
 }
 
-size_t SkFontStream::GetTableData(SkStream* stream, SkFontTableTag tag,
+size_t SkFontStream::GetTableData(SkStream* stream, int ttcIndex,
+                                  SkFontTableTag tag,
                                   size_t offset, size_t length, void* data) {
     SfntHeader  header;
-    if (!header.init(stream)) {
+    if (!header.init(stream, ttcIndex)) {
         return 0;
     }
 
     for (int i = 0; i < header.fCount; i++) {
         if (SkEndian_SwapBE32(header.fDir[i].fTag) == tag) {
             size_t realOffset = SkEndian_SwapBE32(header.fDir[i].fOffset);
             size_t realLength = SkEndian_SwapBE32(header.fDir[i].fLength);
             // now sanity check the caller's offset/length
             if (offset >= realLength) {
                 return 0;
@@ skipping 16 matching lines @@
                 }
                 if (stream->read(data, length) != length) {
                     return 0;
                 }
             }
             return length;
         }
     }
     return 0;
 }