@include eet-basic.c
-@section format What does an Eet file look like?
-
-The file format is very simple. There is a directory block at the start of
-the file listing entries and offsets into the file where they are stored,
-their sizes, compression flags etc. followed by all the entry data strung one
-element after the other.
-
-All Eet files start with t a 4 byte magic number. It is written using network
-byte-order (big endian, or from most significant byte first to least
-significant byte last) and is 0x1ee7ff00 (or byte by byte 0:1e 1:e7 2:ff
-3:00). The next 4 bytes are an integer (in big endian notation) indicating
-how many entries are stored in the Eet file. 0 indicates it is empty. This is
-a signed integer and thus values less than 0 are invalid, limiting the number
-of entries in an Eet file to 0x7fffffff entries at most. The next 4 bytes is
-the size of the directory table, in bytes, encoded in big-endian format. This
-is a signed integer and cannot be less than 0.
-
-The directory table for the file follows immediately, with a continuous list
-of all entries in the Eet file, their offset in the file etc. The order of
-these entries is not important, but convention would have them be from first
-to last entry in the file. Each directory entry consiste of 5 integers, one
-after the other, each stored as a signed, big endian integer. The first is
-the offset in the file that the data for this entry is stored at (based from
-the very start of the file, not relative to the end of the directory block).
-The second integer holds flags for the entry. currently only the least
-significant bit (bit 0) holds any useful information, and it is set to 1 if
-the entry is compressed using zlib compression calls, or 0 if it is not
-compressed. The next integer is the size of the entry in bytes stored in the
-file. The next integer is the size of the data when decompressed (if it was
-compressed) in bytes. This may be the same as the previous integer if the
-entry was not compressed. The final integer is the number of bytes used by
-the string identifier for the entry, without the NUL byte terminator, which
-is not stored. The next series of bytes is the string name of the entry, with
-the number of bytes being the same as specified in the last integer above.
-This list of entries continues until there are no more entries left to list.
-To read an entry from an Eet file, simply find the appropriate entry in the
-directory table, find it's offset and size, and read it into memory. If it is
-compressed, decompress it using zlib and then use that data.
-
-Here is a data map of an Eet file. All integers are encoded using big-endian
-notation (most significant byte first) and are signed. There is no alignment
-of data, so all data types follow immediately on, one after the other. All
-compressed data is compressed using the zlib compress2() function, and
-decompressed using the zlib uncompress() function. Please see zlib
-documentation for more information as to the encoding of compressed data.
-
-@verbatim
-HEADER:
-[INT] Magic number (0x1ee7ff00)
-[INT] Number of entries in the directory table
-[INT] The size of the directory table, in bytes
-
-DIRECTORY TABLE ENTRIES (as many as specified in the header):
-[INT] Offest from file start at which entry is stored (in bytes)
-[INT] Entry flags (1 = compressed, 0 = not compressed)
-[INT] Size of data chunk in file (in bytes)
-[INT] Size of the data chunk once decompressed (or the same as above, if not)
-[INT] The length of the string itendifier, in bytes, without NUL terminator
-[STR] Series of bytes for the string identifier, no NUL terminator
-... more directory entries
-
-DATA STORED, ONE AFTER ANOTHER:
-[DAT] DATA ENTRY 1...
-[DAT] DATA ENTRY 2...
-[DAT] DATA ENTRY 3...
-... more data chunks
-@endverbatim
-
-The contents of each entry in an Eet file has no defined format as such. It
-is an opaque chunk of data, that is up to the application to deocde, unless
-it is an image, ecoded by Eet, or a data structure encoded by Eet. The data
-itself for these entries can be encoded and decoded by Eet with extra helper
-functions in Eet. eet_data_image_read() and eet_data_image_write() are used
-to handle reading and writing image data from a known Eet file entry name.
-eet_data_read() and eet_data_write() are used to decode and encode program
-data structures from an Eet file, making the loading and saving of program
-information stored in data structures a simple 1 function call process.
-
-Please see src/lib/eet_data.c for information on the format of these
-specially encoded data entries in an Eet file (for now).
-
-
@section compiling How to compile using Eet ?
Eet is a library your application links to. The procedure for this is very
projects / platform / upstream / efl.git / commitdiff