1HEADmaster

1 files changed, 552 insertions, 0 deletions

diff --git a/common/quicktime_win32/ATSUnicodeFlattening.h b/common/quicktime_win32/ATSUnicodeFlattening.h
new file mode 100644
index 0000000..923fda8
--- /dev/null
+++ b/common/quicktime_win32/ATSUnicodeFlattening.h
@@ -0,0 +1,552 @@
+/*
+     File:       ATSUnicodeFlattening.h
+ 
+     Contains:   Public interfaces for Apple Type Services for Unicode Imaging
+ 
+     Version:    QuickTime 7.3
+ 
+     Copyright:  (c) 2007 (c) 2002 by Apple Computer, Inc., all rights reserved.
+ 
+     Bugs?:      For bug reports, consult the following page on
+                 the World Wide Web:
+ 
+                     http://developer.apple.com/bugreporter/
+ 
+*/
+#ifndef __ATSUNICODEFLATTENING__
+#define __ATSUNICODEFLATTENING__
+
+#ifndef __ATSUNICODE__
+#include <ATSUnicode.h>
+#endif
+
+
+
+
+#if PRAGMA_ONCE
+#pragma once
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if PRAGMA_IMPORT
+#pragma import on
+#endif
+
+#if PRAGMA_STRUCT_ALIGN
+    #pragma options align=mac68k
+#elif PRAGMA_STRUCT_PACKPUSH
+    #pragma pack(push, 2)
+#elif PRAGMA_STRUCT_PACK
+    #pragma pack(2)
+#endif
+
+/* ---------------------------------------------------------------------------- */
+/* Constants                                                                    */
+/* ---------------------------------------------------------------------------- */
+/*
+   ATSUFlattenedDataStreamFormat is used to inform the APIs which flatten and
+   unflatten style runs exactly what type of data that they should be generating
+   or parsing.
+*/
+typedef UInt32 ATSUFlattenedDataStreamFormat;
+enum {
+  kATSUDataStreamUnicodeStyledText = FOUR_CHAR_CODE('ustl')
+};
+
+
+/*
+   ATSUFlattenStyleRunOptions is a bitfield list of options that can be passed
+   into the ATSUFlattenStyleRunsToStream API. Currently, there are no options. 
+   This is here for future expansion.
+*/
+typedef UInt32 ATSUFlattenStyleRunOptions;
+enum {
+  kATSUFlattenOptionNoOptionsMask = 0x00000000
+};
+
+/*
+   ATSUUnFlattenStyleRunOptions is a bitfield list of options that can be passed
+   into the ATSUUnFlattenStyleRunsToStream API. Currently, there are no options. 
+   This is here for future expansion.
+*/
+typedef UInt32 ATSUUnFlattenStyleRunOptions;
+enum {
+  kATSUUnFlattenOptionNoOptionsMask = 0x00000000
+};
+
+
+/* ---------------------------------------------------------------------------- */
+/* Data Types                                                                   */
+/* ---------------------------------------------------------------------------- */
+
+/*
+   ATSUStyleRunInfo is a structure that contrains an index into an array of 
+   unique ATSUStyle objects as well as the length of the run that the style run 
+   object covers. This structure is utilized by ATSUUnflattenStyleRunsFromStream() 
+   to return the style run info to the caller. 
+*/
+struct ATSUStyleRunInfo {
+  UniCharCount        runLength;
+  ItemCount           styleObjectIndex;
+};
+typedef struct ATSUStyleRunInfo         ATSUStyleRunInfo;
+/* ---------------------------------------------------------------------------- */
+/* 'ustl' structure data structures and definitions                             */
+/* ---------------------------------------------------------------------------- */
+/*
+   The 'ustl' data structure follows this format:
+   1. Main Data Structure Block Header
+   2. Flattened Text Layout Data
+   3. Flattened Style Run Data
+   4. Flattened Style Data
+   Per the 'ustl' spec, these structures should maintain four-byte alignment. 
+   For things that are variable width (such as font names), padding bytes must
+   be added to ensure that this alignment is always kept.
+*/
+
+/*
+   structure versioning - the version of the 'ustl' that the ATSUI parsing
+   and generating functions will handle is version 2 or greater. Earlier
+   versions were not completly specified and have been obsoleted.
+*/
+enum {
+  kATSFlatDataUstlVersion0      = 0,
+  kATSFlatDataUstlVersion1      = 1,
+  kATSFlatDataUstlVersion2      = 2,
+  kATSFlatDataUstlCurrentVersion = kATSFlatDataUstlVersion2
+};
+
+/* ------------------ */
+/* Block 1 Structures */
+/* ------------------ */
+
+/*
+   This is the main data structure block header. It describes the rest
+   of the data and how it is structured.
+*/
+struct ATSFlatDataMainHeaderBlock {
+
+                                              /* the 'ustl' version number. This needs to be the first item in the*/
+                                              /* data block do as not to confuse parsers of earlier (and possibly*/
+                                              /* later) versions of the spec *|*/
+  UInt32              version;
+
+                                              /* the total size of the stream in bytes, including the four bytes in*/
+                                              /* the version above*/
+  ByteCount           sizeOfDataBlock;
+
+                                              /* offset from the beginning of the stream to the flattened text layout data.*/
+                                              /* This can be set to 0 if there are no text layouts stored in the stream.*/
+  ByteCount           offsetToTextLayouts;
+
+                                              /* offset from the beginning of the stream to the flattened style run data. */
+                                              /* This can be set to 0 if there is no flattened style run data in the stream*/
+  ByteCount           offsetToStyleRuns;
+
+                                              /* offset to the flattened style list data. This can be set to 0 if there*/
+                                              /* is no flattened style list data*/
+  ByteCount           offsetToStyleList;
+};
+typedef struct ATSFlatDataMainHeaderBlock ATSFlatDataMainHeaderBlock;
+/* ------------------ */
+/* Block 2 Structures */
+/* ------------------ */
+/*
+   The Block 2 Structures are not currently used by any of ATSUI's internal parsing
+   or packing routines. They are, however, part of the 'ustl' standard and are put
+   here for developer conveniance, as well as to properly define the standard.
+*/
+
+/*
+   This is the the main header for block 2. If there is a block 2, then there
+   needs to be one of these. This structure is what the offsetToTextLayouts
+   points to in block 1.
+*/
+struct ATSFlatDataTextLayoutDataHeader {
+
+                                              /* the total size of this particular flattened text layout, including any*/
+                                              /* padding bytes and such. */
+  ByteCount           sizeOfLayoutData;
+
+                                              /* the number of characters covered by this flattened text layout*/
+  ByteCount           textLayoutLength;
+
+                                              /* the byte offset relative to the start of this structure to the flattened*/
+                                              /* layout control data. This can be set to zero if there are no layout*/
+                                              /* controls.*/
+  ByteCount           offsetToLayoutControls;
+
+                                              /* the byte offset, relative to the start of this structure to the*/
+                                              /* flattened line info. This can be set to zero if there is no line info */
+                                              /* in this layout.*/
+  ByteCount           offsetToLineInfo;
+
+                                              /* if the offsetToLayoutControls is non-zero, then following this block*/
+                                              /* there will be a ATSFlattenedLayoutDataFlattenedLayoutControlsHeader*/
+                                              /* followed by an array of ATSFlattenedLayoutDataFlattenedLayoutControls*/
+                                              /* structures. If the offsetToLineInfo is non-zero, then following the*/
+                                              /* flattened layout controls will be a ATSFlatDataLineInfoHeader*/
+                                              /* structure.*/
+};
+typedef struct ATSFlatDataTextLayoutDataHeader ATSFlatDataTextLayoutDataHeader;
+/*
+   This is the header for the flattened layout controls structure. This is
+   the structure that a non-zero offsetToLayoutControls points to in the
+   ATSFlatDataTextLayoutDataHeader
+*/
+struct ATSFlatDataLayoutControlsDataHeader {
+
+                                              /* the number of flattened layout controls. It is suggested that there be*/
+                                              /* at least one layout control to output the line direction for the layout*/
+  ItemCount           numberOfLayoutControls;
+
+                                              /* first of possibly many flattened layout controls. There should be one */
+                                              /* of these for each layout control as determined by the*/
+                                              /* numberOfLayoutControls above. Of course, if there are no layout controls,*/
+                                              /* then this structure shouldn't even exist. Each attribute info structure*/
+                                              /* in the array could be followed by additional padding bytes in order*/
+                                              /* to maintain four-byte alignment. These padding bytes are not to be*/
+                                              /* included in the fValueSize member of each structure. */
+  ATSUAttributeInfo   controlArray[1];
+};
+typedef struct ATSFlatDataLayoutControlsDataHeader ATSFlatDataLayoutControlsDataHeader;
+struct ATSFlatDataLineInfoData {
+
+                                              /* the length of this particular line in UniChars*/
+  UniCharCount        lineLength;
+
+                                              /* the number of line controls applied to this line. This can be set*/
+                                              /* to zero if there are no special line controls applied to this line.*/
+  ItemCount           numberOfLineControls;
+
+                                              /* the numberOfLineControls is non-zero, then following this structure*/
+                                              /* must be an array of ATSUAttributeInfo structures. There must be one*/
+                                              /* ATSUAttributeInfo structure for each numberOfLineControls above.*/
+};
+typedef struct ATSFlatDataLineInfoData  ATSFlatDataLineInfoData;
+/*
+   This structure is the main data header for the flattened line info data. This
+   is what a non-zero offsetToLineInfo points to in the 
+   ATSFlatDataTextLayoutDataHeader structure above.
+*/
+struct ATSFlatDataLineInfoHeader {
+
+                                              /* the number of flattened line info structures that are stored in this*/
+                                              /* block. This value should really be equal to the number of soft line*/
+                                              /* breaks in the layout + 1. Of course if numberOfLines is zero, then*/
+                                              /* this structure shouldn't even be used.*/
+  ItemCount           numberOfLines;
+
+                                              /* the first in a array of ATSFlatDataLineInfoData structures. There*/
+                                              /* needs to be a ATSFlatDataLineInfoData for each numberOfLines*/
+                                              /* specified above.*/
+  ATSFlatDataLineInfoData  lineInfoArray[1];
+};
+typedef struct ATSFlatDataLineInfoHeader ATSFlatDataLineInfoHeader;
+/* ------------------ */
+/* Block 3 Structures */
+/* ------------------ */
+/*
+   The block 3 structures are used by ATSUI style run flattening and parsing
+   functions, ATSUFlattenStyleRunsToStream and ATSUUnflattenStyleRunsFromStream
+   to represent flattened style run information. These structures go hand and
+   hand with the block 4 structures.
+*/
+
+/*
+   This is the data header that appears before the style run data structures.
+   This structure is what a non-zero offsetToStyleRuns in the
+   ATSFlatDataMainHeaderBlock points to in block 1.
+*/
+struct ATSFlatDataStyleRunDataHeader {
+
+                                              /* the number of style run data structures stored in this block*/
+  ItemCount           numberOfStyleRuns;
+
+                                              /* the first in an array of ATSUStyleRunInfo structures. There needs to*/
+                                              /* be a ATSUStyleRunInfo structure for each numberOfStyleRuns specified*/
+                                              /* above. This structure is defined in ATSUnicode.h*/
+  ATSUStyleRunInfo    styleRunArray[1];
+};
+typedef struct ATSFlatDataStyleRunDataHeader ATSFlatDataStyleRunDataHeader;
+/* ------------------ */
+/* Block 4 Structures */
+/* ------------------ */
+/*
+   The block 4 structures store flattened ATSUStyle objects. This too, is
+   currently used by the ATSUI style run flattening and parsing functions,
+   ATSUFlattenStyleRunsToStream and ATSUUnflattenStyleRunsFromStream. 
+*/
+
+/*
+   this structure forms the beginning of an individually flattened ATSUStyle
+   object. 
+*/
+struct ATSFlatDataStyleListStyleDataHeader {
+
+                                              /* the size of this flattened style object, including these four bytes and*/
+                                              /* any padding bytes at the end of the structure. Basically, this can be*/
+                                              /* used to determine where the next structure in the array begins.*/
+  ByteCount           sizeOfStyleInfo;
+
+                                              /* the number of attributes set in this flattened style object. This should */
+                                              /* be at least one for the font data, although it can be 0 if this is to be*/
+                                              /* unspecfied.*/
+  ItemCount           numberOfSetAttributes;
+
+                                              /* the number of font features set in the flattened style object. This can*/
+                                              /* be set to 0 if there are no font features set in the style object. */
+  ItemCount           numberOfSetFeatures;
+
+                                              /* the number of font variations set in the flattened style object. This*/
+                                              /* can be set to 0 if there are no font variations set in the style object.*/
+  ItemCount           numberOfSetVariations;
+
+                                              /* after this structure header, there is the following data in this block:*/
+
+                                              /* 1. if the numberOfSetAttributes is non-zero, then there will be an*/
+                                              /*       array of ATSUAttributeInfo structures immediately following the*/
+                                              /*       above header data to store the style attributes. This is a variable*/
+                                              /*       structure array. There must be one ATSUAttributeInfo for*/
+                                              /*       for each numberOfSetAttributes. If numberOfSetAttributes is zero,*/
+                                              /*       then skip to the next data section 2.*/
+
+                                              /* 2. if the numberOfSetFeatures is non-zero, then there will be an array*/
+                                              /*       of ATSFlatDataStyleListFeatureData structures immediately after*/
+                                              /*       the ATSUAttributeInfo array above (if any). There must be one*/
+                                              /*       ATSFlatDataStyleListFeatureData structure for each */
+                                              /*       numberOfSetFeatures set in the header above. If numberOfSetFeatures*/
+                                              /*       is zero, then skip to the next data section 3.*/
+
+                                              /* 3. if the numberOfSetVariations is non-zero, then there will be an*/
+                                              /*       array of ATSFlatDataStyleListVariationData immediately after the*/
+                                              /*       ATSFlatDataStyleListFeatureData array above (if any). There must be*/
+                                              /*       one ATSFlatDataStyleListVariationData structure for each */
+                                              /*       numberOfSetVariations set in the header above.*/
+};
+typedef struct ATSFlatDataStyleListStyleDataHeader ATSFlatDataStyleListStyleDataHeader;
+/*
+   this structure is the main header for this block. This structure is what a
+   non-zero offsetToStyleList in the ATSFlatDataMainHeaderBlock points to in
+   block 1.
+*/
+struct ATSFlatDataStyleListHeader {
+
+                                              /* the total number of flattened style objects stored in this block*/
+  ItemCount           numberOfStyles;
+
+                                              /* the first in an array of flattned style entries. The data stored*/
+                                              /* in them is variably sized, so a simply array access won't do for*/
+                                              /* iterating through these. However, there must be one of these*/
+                                              /* ATSFlatDataStyleListStyleDataHeader structures for each */
+                                              /* numberOfStyles above.*/
+  ATSFlatDataStyleListStyleDataHeader  styleDataArray[1];
+
+};
+typedef struct ATSFlatDataStyleListHeader ATSFlatDataStyleListHeader;
+/*
+   this structure stores flattened font feature data. An array of these comes
+   after the array of font data attributes (if any) if the numberOfSetFeatures is
+   non-zero. There must be one of these structures for each numberOfSetFeatures.
+*/
+struct ATSFlatDataStyleListFeatureData {
+
+                                              /* the font feature type*/
+  ATSUFontFeatureType  theFeatureType;
+
+                                              /* the font feature selector*/
+  ATSUFontFeatureSelector  theFeatureSelector;
+};
+typedef struct ATSFlatDataStyleListFeatureData ATSFlatDataStyleListFeatureData;
+/*
+   this structure stores the flattened font variation data. An array of these 
+   comes after the array of ATSFlatDataStyleListFeatureData structures (if any) 
+   if the numberOfSetVariations is non-zero. There must be one of these
+   structures for each numberOfSetFeatures.
+*/
+struct ATSFlatDataStyleListVariationData {
+
+                                              /* the variation axis*/
+  ATSUFontVariationAxis  theVariationAxis;
+
+                                              /* the variation value*/
+  ATSUFontVariationValue  theVariationValue;
+};
+typedef struct ATSFlatDataStyleListVariationData ATSFlatDataStyleListVariationData;
+/* ------------------------ */
+/* Flattened Font Data Info */
+/* ------------------------ */
+/*
+   This is somewhat of an addendum to the 'ustl' structure above. These flattened 
+   data structures are stored in block 4 as a font attribute with the attribute 
+   tag of kATSUFontTag. They can store font data in a few different ways, such as
+   by a FontSync reference or by simple raw font name data. Just as with the 
+   'ustl' above, this structure must maintain four byte alignment.
+*/
+
+
+/* these are the currenly supported font specifiers. */
+typedef UInt32 ATSFlatDataFontSpeciferType;
+enum {
+                                        /* this specifier allows the storage of font data based on name data. This*/
+                                        /* uses the stuctures below to store the actual data itself.*/
+  kATSFlattenedFontSpecifierRawNameData = FOUR_CHAR_CODE('namd')
+};
+
+/*
+   this is the main header for the font data. It dictates what type of data
+   is stored. The actual data stored must match the type specified by the
+   nameSpecType. 
+*/
+struct ATSFlatDataFontNameDataHeader {
+
+                                              /* the type of data that is flattened in this structure*/
+  ATSFlatDataFontSpeciferType  nameSpecifierType;
+
+                                              /* the size of the data that is flattened in this structre, not including */
+                                              /* any padding bytes that may be necessary to achive the four byte */
+                                              /* alignment of the data, unless they are specified as part of structure, */
+                                              /* such as with the ATSFlatDataFontSpecRawNameData structure.*/
+  ByteCount           nameSpecifierSize;
+
+                                              /* after this header comes the flattened font name data which matches*/
+                                              /* the type specified by the nameSpecifierType above. For instance, if */
+                                              /* the nameSpecType is kATSFlattenedFontNameSpecifierRawNameData, the*/
+                                              /* structure that immediately follows this would be a*/
+                                              /* ATSFlatDataFontNameRawNameDataHeader structure. */
+
+};
+typedef struct ATSFlatDataFontNameDataHeader ATSFlatDataFontNameDataHeader;
+/*
+   the next two structures are only used when the nameSpecType is set to
+   kATSFlattenedFontSpecifierRawNameData. They are setup to store multiple
+   font name table entries for the purposes of reconstructing an ATSUFontID
+   for (hopefully) the same font some time in the future.
+*/
+/* this is the structure in which raw font name data is actually stored. */
+struct ATSFlatDataFontSpecRawNameData {
+
+                                              /* the type of name being specified*/
+  FontNameCode        fontNameType;
+
+                                              /* the platform type of the font name, whether it be Unicode, Mac, etc.  */
+                                              /* This should be specified if known. If not known, then specify*/
+                                              /* kFontNoPlatform, but then all matching will be done based on the first*/
+                                              /* font in the name table matching the other parameters.*/
+  FontPlatformCode    fontNamePlatform;
+
+                                              /* the script code of the font's name based on the platform that was passed*/
+                                              /* in above. If set to kFontNoScript, then the name will be matched based*/
+                                              /* on the first font in the name table matching the other font name*/
+                                              /* parameters.*/
+  FontScriptCode      fontNameScript;
+
+                                              /* the language of the font name. If set to kFontNoLanguage, then the name */
+                                              /* will be matched based on the first font in the name table matching the*/
+                                              /* other font name parameters.*/
+  FontLanguageCode    fontNameLanguage;
+
+                                              /* the length of the font name in bytes, not including any padding bytes*/
+                                              /* added to maintain the four byte alignment*/
+  ByteCount           fontNameLength;
+
+                                              /* after the name length comes the actual font name data itself, plus any*/
+                                              /* padding bytes needed to maintain the four byte alignment.*/
+
+};
+typedef struct ATSFlatDataFontSpecRawNameData ATSFlatDataFontSpecRawNameData;
+/*
+   this is a header structure that defines some things constant throughout
+   the entire search for the font name, as well as the array of
+   ATSFlatDataFontNameData structures. In order to gaurantee that the same font 
+   will be used, more than one name specifer should be stored. The standard ATSUI
+   style run flattening and parsing functions, ATSUFlattenStyleRunsToStream and
+   ATSUUnflattenStyleRunsFromStream. These will store both the font's full name
+   (kFontFullName) as well as the font's manufacturer name (kFontManufacturerName)
+   and match fonts based on both of
+   these. 
+*/
+struct ATSFlatDataFontSpecRawNameDataHeader {
+
+                                              /* the number of flattened font names. There must be at least one flattened */
+                                              /* font name, otherwise the structure is malformed.*/
+  ItemCount           numberOfFlattenedNames;
+
+                                              /* the first in an array of possibly many font name specifiers - depending*/
+                                              /* on how specific the caller wants this. There must be one */
+                                              /* ATSFlatDataFontNameData structure for each numberOfFlattenedNames*/
+                                              /* above.*/
+  ATSFlatDataFontSpecRawNameData  nameDataArray[1];
+
+};
+typedef struct ATSFlatDataFontSpecRawNameDataHeader ATSFlatDataFontSpecRawNameDataHeader;
+/* ---------------------------------------------------------------------------- */
+/* Style Flattening and Parsing Functions                                       */
+/* ---------------------------------------------------------------------------- */
+/*
+ *  ATSUFlattenStyleRunsToStream()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
+ *    Mac OS X:         in version 10.2 and later
+ */
+EXTERN_API_C( OSStatus )
+ATSUFlattenStyleRunsToStream(
+  ATSUFlattenedDataStreamFormat   iStreamFormat,
+  ATSUFlattenStyleRunOptions      iFlattenOptions,
+  ItemCount                       iNumberOfRunInfo,
+  const ATSUStyleRunInfo          iRunInfoArray[],
+  ItemCount                       iNumberOfStyleObjects,
+  const ATSUStyle                 iStyleArray[],
+  ByteCount                       iStreamBufferSize,
+  void *                          oStreamBuffer,
+  ByteCount *                     oActualStreamBufferSize);
+
+
+/*
+ *  ATSUUnflattenStyleRunsFromStream()
+ *  
+ *  Availability:
+ *    Non-Carbon CFM:   not available
+ *    CarbonLib:        not available in CarbonLib 1.x, is available on Mac OS X version 10.2 and later
+ *    Mac OS X:         in version 10.2 and later
+ */
+EXTERN_API_C( OSStatus )
+ATSUUnflattenStyleRunsFromStream(
+  ATSUFlattenedDataStreamFormat   iStreamFormat,
+  ATSUUnFlattenStyleRunOptions    iUnflattenOptions,
+  ByteCount                       iStreamBufferSize,
+  const void *                    iStreamBuffer,
+  ItemCount                       iNumberOfRunInfo,
+  ItemCount                       iNumberOfStyleObjects,
+  ATSUStyleRunInfo                oRunInfoArray[],
+  ATSUStyle                       oStyleArray[],
+  ItemCount *                     oActualNumberOfRunInfo,
+  ItemCount *                     oActualNumberOfStyleObjects);
+
+
+
+#if PRAGMA_STRUCT_ALIGN
+    #pragma options align=reset
+#elif PRAGMA_STRUCT_PACKPUSH
+    #pragma pack(pop)
+#elif PRAGMA_STRUCT_PACK
+    #pragma pack()
+#endif
+
+#ifdef PRAGMA_IMPORT_OFF
+#pragma import off
+#elif PRAGMA_IMPORT
+#pragma import reset
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ATSUNICODEFLATTENING__ */
+