Gif maker free download full version Archives

Gif maker free download full version Archives

gif maker free download full version Archives

gif maker free download full version Archives

OverviewSystem RequirementsReviewsRelated

Description

View animated GIF (Graphics Interchange Format) files like movies.  It offers functions such as play/pause, zoom, single step forward or backward (Pro version). This app can be set as the default program for GIF files so it can be launched from Windows File Browser. Download all GIFs on a web page. The Pro version allows saving GIF with changed speed, all image frames of a GIF file, or the current frame (when paused). Slide show is available for the Pro version. It loops through GIFs in a folder indefinitely and has a shuffle mode, ideal for use as a screen saver. Please note: this app is a viewer, not an editor. It displays GIFs strictly according to the information (e.g. delay for each frame) of GIF files. Some old GIF files may have incorrect timing information to accommodate older browsers, so GIF Viewer may not display them in the way as originally expected. Tested with every one of the 50+ inspiring animated GIFs http://www.webdesignerdepot.com/2013/07/50-inspiring-animated-gifs/

Источник: [https://torrent-igruha.org/3551-portal.html]
, gif maker free download full version Archives

GIF

Bitmap image file format family

The Graphics Interchange Format (GIF/dʒɪf/JIF or /ɡɪf/GHIF) is a bitmapimage format that was developed by a team at the online services provider CompuServe led by American computer scientist Steve Wilhite on June 15, 1987.[1] It has since come into widespread usage on the World Wide Web due to its wide support and portability between applications and operating systems.

The format supports up to 8 bits per pixel for each image, allowing a single image to reference its own palette of up to 256 different colors chosen from the 24-bit RGB color space. It also supports animations and allows a separate palette of up to 256 colors for each frame. These palette limitations make GIF less suitable for reproducing color photographs and other images with color gradients, but well-suited for simpler images such as graphics or logos with solid areas of color. Unlike video, the GIF file format does not support audio.

GIF images are compressed using the Lempel–Ziv–Welch (LZW) lossless data compression technique to reduce the file size without degrading the visual quality. This compression technique was patented in 1985. Controversy over the licensing agreement between the software patent holder, Unisys, and CompuServe in 1994 spurred the development of the Portable Network Graphics (PNG) standard. By 2004 all the relevant patents had expired.

History[edit]

CompuServe introduced GIF on June 15, 1987 to provide a color image format for their file downloading areas, replacing their earlier run-length encoding (RLE) format, which was black and white only. GIF became popular because it used LZW data compression, which was more efficient than the run-length encoding that formats such as those used by PCX and MacPaint, and fairly large images could therefore be downloaded in a reasonably short time, even with very slow modems.

The original version of GIF was called 87a.[1] In 1989, CompuServe released an enhanced version, called 89a,[2] which added support for animation delays (multiple images in a stream were already supported in 87a), transparent background colors, and storage of application-specific metadata. The 89a specification also supports incorporating text labels as text (not embedding them in the graphical data), but as there is little control over display fonts, this feature is not widely used. The two versions can be distinguished by looking at the first six bytes of the file (the "magic number" or signature), which, when interpreted as ASCII, read "GIF87a" and "GIF89a", respectively.

CompuServe encouraged the adoption of GIF by providing downloadable conversion utilities for many computers. By December 1987, for example, an Apple IIGS user could view pictures created on an Atari ST or Commodore 64.[3] GIF was one of the first two image formats commonly used on Web sites, the other being the black-and-white XBM.[4]

In September 1995 Netscape Navigator 2.0 added the ability for animated GIFs to loop.

The feature of storing multiple images in one file, accompanied by control data, is used extensively on the Web to produce simple animations. The optional interlacing feature, which stores image scan lines out of order in such a fashion that even a partially downloaded image was somewhat recognizable, also helped GIF's popularity,[5] as a user could abort the download if it was not what was required.

In May 2015 Facebook added support for GIF.[6][7] In January 2018 Instagram also added GIF stickers to the story mode.[8]

Research on the use of GIFs has recently started, by separating them from traditional memes. Albin Wagener notably writes that "GIFs probably represent an entirely new generation of communicative systemic signs that are capable to reenact emotions and transfer the detailed feeling of a mental state: they are completely postdigital, and they work as extensions of users’ emotions and cognitive expressions—without having to use complex sentences".[9]

Terminology[edit]

As a noun, the word GIF is found in the newer editions of many dictionaries. In 2012, the American wing of the Oxford University Press recognized GIF as a verb as well, meaning "to create a GIF file", as in "GIFing was perfect medium for sharing scenes from the Summer Olympics". The press's lexicographers voted it their word of the year, saying that GIFs have evolved into "a tool with serious applications including research and journalism".[10][11]

Pronunciation of GIF[edit]

A humorous image announcing the launch of a White HouseTumblr suggests pronouncing GIF with the hard "G" sound.

The creators of the format pronounced the word as "jif" with a soft "G"/dʒɪf/ as in "gym". Steve Wilhite says that the intended pronunciation deliberately echoes the American peanut butter brand Jif, and CompuServe employees would often say "Choosy developers choose GIF", spoofing this brand's television commercials.[12] The word is now also widely pronounced with a hard "G"/ɡɪf/ as in "gift".[13] In 2017, an informal poll on programming website Stack Overflow showed some numerical preference for hard-"G" pronunciation,[14] especially among respondents in eastern Europe, though both soft-"G" and enunciating each letter individually were found to be popular in Asia and emerging countries.[15]

The American Heritage Dictionary[16] cites both, indicating "jif" as the primary pronunciation, while Cambridge Dictionary of American English[17] offers only the hard-"G" pronunciation. Merriam-Webster's Collegiate Dictionary[18] and the OED cite both pronunciations, but place "gif" in the default position ("\ˈgif, ˈjif\").[19] The New Oxford American Dictionary gave only "jif" in its 2nd edition[20] but updated it to "jif, gif" in its 3rd edition.[21]

The disagreement over the pronunciation led to heated Internet debate. On the occasion of receiving a lifetime achievement award at the 2013 Webby Award ceremony, Wilhite rejected the hard-"G" pronunciation,[13][22][23] and his speech led to 17,000 posts on Twitter and 50 news articles.[24] The White House[13] and TV program Jeopardy! also entered the debate during 2013.[23]

In February 2020, The J.M. Smucker Company, the owners of the Jif peanut butter brand, partnered with animated image database and search engine Giphy to release a limited-edition "Jif vs. GIF" (hashtagged as #JIFvsGIF) jar of Jif peanut butter that has a label humorously declaring the soft-"G" pronunciation to exclusively refer to the peanut butter, and GIF to be exclusively pronounced with the hard-"G" pronunciation.[25]

Usage[edit]

  • GIFs are suitable for sharp-edged line art with a limited number of colors, such as logos. This takes advantage of the format's lossless compression, which favors flat areas of uniform color with well defined edges.[26]
  • GIFs may be used to store low-color sprite data for games.[27]
  • GIFs can be used for small animations and low-resolution video clips.[27]
  • GIFs can be used as a reaction when messaging online, used to convey emotion and feelings, alternative to using words
  • Popular on social media platforms such as Tumblr, Facebook and Twitter.

File format[edit]

Conceptually, a GIF file describes a fixed-sized graphical area (the "logical screen") populated with zero or more "images". Many GIF files have a single image that fills the entire logical screen. Others divide the logical screen into separate sub-images. The images may also function as animation frames in an animated GIF file, but again these need not fill the entire logical screen.

GIF files start with a fixed-length header ("GIF87a" or "GIF89a") giving the version, followed by a fixed-length Logical Screen Descriptor giving the pixel dimensions and other characteristics of the logical screen. The screen descriptor may also specify the presence and size of a Global Color Table, which follows next if present.

0000000047494638396101000100800000000000|GIF89a..........|00000010ffffff21f90401000000002c00000000|...!.......,....|000000200100010000020144003b|.......D.;|0000002a

Thereafter, the file is divided into segments, each introduced by a 1-byte sentinel:

  • An image (introduced by 0x2C, an ASCII comma )
  • An extension block (introduced by 0x21, an ASCII exclamation point )
  • The trailer (a single byte of value 0x3B, an ASCII semicolon ), which should be the last byte of the file.

An image starts with a fixed-length Image Descriptor, which may specify the presence and size of a Local Color Table (which follows next if present). The image data follows: one byte giving the bit width of the unencoded symbols (which must be at least 2 bits wide, even for bi-color images), followed by a linked list of sub-blocks containing the LZW-encoded data.

Extension blocks (blocks that "extend" the 87a definition via a mechanism already defined in the 87a spec) consist of the sentinel, an additional byte specifying the type of extension, and a linked list of sub-blocks with the extension data. Extension blocks that modify an image (like the Graphic Control Extension that specifies the optional animation delay time and optional transparent background color) must immediately precede the segment with the image they refer to.

The linked lists used by the image data and the extension blocks consist of series of sub-blocks, each sub-block beginning with a byte giving the number of subsequent data bytes in the sub-block (1 to 255). The series of sub-blocks is terminated by an empty sub-block (a 0 byte).

This structure allows the file to be parsed even if not all parts are understood. A GIF marked 87a may contain extension blocks; the intent is that a decoder can read and display the file without the features covered in extensions it does not understand.

The full detail of the file format is covered in the GIF specification.[2]

Palettes[edit]

An example of a GIF image saved with a web-safe palette and dithered using the Floyd–Steinberg method. Due to the reduced number of colors in the image, there are display issues.

GIF is palette-based: the colors used in an image (a frame) in the file have their RGB values defined in a palette table that can hold up to 256 entries, and the data for the image refer to the colors by their indices (0–255) in the palette table. The color definitions in the palette can be drawn from a color space of millions of shades (224 shades, 8 bits for each primary), but the maximum number of colors a frame can use is 256. This limitation seemed reasonable when GIF was developed because few people could afford the hardware to display more colors simultaneously. Simple graphics, line drawings, cartoons, and grey-scale photographs typically need fewer than 256 colors.

Each frame can designate one index as a "transparent background color": any pixel assigned this index takes on the color of the pixel in the same position from the background, which may have been determined by a previous frame of animation.

Many techniques, collectively called dithering, have been developed to approximate a wider range of colors with a small color palette by using pixels of two or more colors to approximate in-between colors. These techniques sacrifice spatial resolution to approximate deeper color resolution. While not part of the GIF specification, dithering can be used in images subsequently encoded as GIF images. This is often not an ideal solution for GIF images, both because the loss of spatial resolution typically makes an image look fuzzy on the screen, and because the dithering patterns often interfere with the compressibility of the image data, working against GIF's main purpose.

In the early days of graphical web browsers[when?], graphics cards with 8-bit buffers (allowing only 256 colors) were common and it was fairly common to make GIF images using the websafe palette.[according to whom?] This ensured predictable display, but severely limited the choice of colors. When 24-bit color became the norm palettes could instead be populated with the optimum colors for individual images.

A small color table may suffice for small images, and keeping the color table small allows the file to be downloaded faster. Both the 87a and 89a specifications allow color tables of 2n colors for any n from 1 through 8. Most graphics applications will read and display GIF images with any of these table sizes; but some do not support all sizes when creating images. Tables of 2, 16, and 256 colors are widely supported.

True color[edit]

An animated GIF illustrating a technique for displaying more than the typical limit of 256 colors

Although GIF is almost never used for true color images, it is possible to do so.[28][29] A GIF image can include multiple image blocks, each of which can have its own 256-color palette, and the blocks can be tiled to create a complete image. Alternatively, the GIF89a specification introduced the idea of a "transparent" color where each image block can include its own palette of 255 visible colors plus one transparent color. A complete image can be created by layering image blocks with the visible portion of each layer showing through the transparent portions of the layers above.

To render a full-color image as a GIF, the original image must be broken down into smaller regions having no more than 255 or 256 different colors. Each of these regions is then stored as a separate image block with its own local palette and when the image blocks are displayed together (either by tiling or by layering partially transparent image blocks) the complete, full-color image appears. For example, breaking an image into tiles of 16 by 16 pixels (256 pixels in total) ensures that no tile has more than the local palette limit of 256 colors, although larger tiles may be used and similar colors merged resulting in some loss of color information.[28]

Since each image block can have its own local color table, a GIF file having many image blocks can be very large, limiting the usefulness of full-color GIFs.[29] Additionally, not all GIF rendering programs handle tiled or layered images correctly. Many rendering programs interpret tiles or layers as animation frames and display them in sequence as an endless animation[28] with most web browsers automatically displaying the frames with a delay time of 0.1 seconds or more.[30][31][better source needed]

Example GIF file[edit]

Sample image (enlarged), actual size 3 pixels wide by 5 high
Bytes Dh to 30Ch in the example define a palette of 256 colors.

Microsoft Paint saves a small black-and-white image as the following GIF file. Paint does not make optimal use of GIF; due to the unnecessarily large color table (storing a full 256 colors instead of the used 2) and symbol width, this GIF file is not an efficient representation of the 15-pixel image (illustrated enlarged above).

Although the Graphic Control Extension block declares color index 16 (hexadecimal 10) to be transparent, that index is not used in the image. The only color indexes appearing in the image data are decimal 40 and 255, which the Global Color Table maps to black and white, respectively.

Note that the hex numbers in the following tables are in little-endian byte order, as the format specification prescribes.

byte# hexadecimal text or(hex) value Meaning 0: 47 49 46 38 39 61 GIF89a Header Logical Screen Descriptor 6: 03 00 3 - logical screen width in pixels 8: 05 00 5 - logical screen height in pixels A: F7 - GCT follows for 256 colors with resolution 3 × 

Image coding[edit]

The image pixel data, scanned horizontally from top left, are converted by LZW encoding to codes that are then mapped into bytes for storing in the file. The pixel codes typically don't match the 8-bit size of the bytes, so the codes are packed into bytes by a "little-Endian" scheme: the least significant bit of the first code is stored in the least significant bit of the first byte, higher order bits of the code into higher order bits of the byte, spilling over into the low order bits of the next byte as necessary. Each subsequent code is stored starting at the least significant bit not already used.

This byte stream is stored in the file as a series of "sub-blocks". Each sub-block has a maximum length 255 bytes and is prefixed with a byte indicating the number of data bytes in the sub-block. The series of sub-blocks is terminated by an empty sub-block (a single 0 byte, indicating a sub-block with 0 data bytes).

For the sample image above the reversible mapping between 9-bit codes and bytes is shown below.

9-bit code
(hex)
Binary Bytes
(hex)
00000000|00
100
0101000|151
028
111111|00FC
0FF
00011|0111B
103
0010|100028
102
011|1000070
103
10|100000A0
106
1|1000001C1
107
|1000001183
101
0000000101
0000000|101

A slight compression is evident: pixel colors defined initially by 15 bytes are exactly represented by 12 code bytes including control codes. The encoding process that produces the 9-bit codes is shown below. A local string accumulates pixel color numbers from the palette, with no output action as long as the local string can be found in a code table. There is special treatment of the first two pixels that arrive before the table grows from its initial size by additions of strings. After each output code, the local string is initialized to the latest pixel color (that could not be included in the output code).

Table 9-bitstring --> code code Action

For clarity the table is shown above as being built of strings of increasing length. That scheme can function but the table consumes an unpredictable amount of memory. Memory can be saved in practice by noting that each new string to be stored consists of a previously stored string augmented by one character. It is economical to store at each address only two words: an existing address and one character.

The LZW algorithm requires a search of the table for each pixel. A linear search through up to 4096 addresses would make the coding slow. In practice the codes can be stored in order of numerical value; this allows each search to be done by a SAR (Successive Approximation Register, as used in some ADCs), with only 12 magnitude comparisons. For this efficiency an extra table is needed to convert between codes and actual memory addresses; the extra table upkeeping is needed only when a new code is stored which happens at much less than pixel rate.

Image decoding[edit]

Decoding begins by mapping the stored bytes back to 9-bit codes. These are decoded to recover the pixel colors as shown below. A table identical to the one used in the encoder is built by adding strings by this rule:

Yesadd string for local code followed by first byte of string for incoming code
Noadd string for local code followed by copy of its own first byte
shift9-bit ----> Local Table Pixelcode code code --> string Palette color Action 100h 000h | #0 Initialize root table of 9-bit codes : | palette : | colors 0FFh | #255 100h | clr 101h | end 028h | #40 BLACK Decode 1st pixel 0FFh 028h | Incoming code found in table | #255 WHITE - output string from table 102h | 28 FF - add to table 103h 0FFh | Incoming code not found in table 103h | FF FF - add to table | - output string from table | #255 WHITE | #255 WHITE 102h 103h | Incoming code found in table | - output string from table | #40 BLACK | #255 WHITE 104h | FF FF 28 - add to table 103h 102h | Incoming code found in table | - output string from table | #255 WHITE | #255 WHITE 105h | 28 FF FF - add to table 106h 103h | Incoming code not found in table 106h | FF FF FF - add to table | - output string from table | #255 WHITE | #255 WHITE | #255 WHITE 107h 106h | Incoming code not found in table 107h | FF FF FF FF - add to table | - output string from table | #255 WHITE | #255 WHITE | #255 WHITE | #255 WHITE 101h | End

LZW code lengths[edit]

Shorter code lengths can be used for palettes smaller than the 256 colors in the example. If the palette is only 64 colors (so color indexes are 6 bits wide), the symbols can range from 0 to 63, and the symbol width can be taken to be 6 bits, with codes starting at 7 bits. In fact, the symbol width need not match the palette size: as long as the values decoded are always less than the number of colors in the palette, the symbols can be any width from 2 to 8, and the palette size any power of 2 from 2 to 256. For example, if only the first four colors (values 0 to 3) of the palette are used, the symbols can be taken to be 2 bits wide with codes starting at 3 bits.

Conversely, the symbol width could be set at 8, even if only values 0 and 1 are used; these data would only require a two-color table. Although there would be no point in encoding the file that way, something similar typically happens for bi-color images: the minimum symbol width is 2, even if only values 0 and 1 are used.

The code table initially contains codes that are one bit longer than the symbol size in order to accommodate the two special codes clr and end and codes for strings that are added during the process. When the table is full the code length increases to give space for more strings, up to a maximum code 4095 = FFF(hex). As the decoder builds its table it tracks these increases in code length and it is able to unpack incoming bytes accordingly.

Uncompressed GIF[edit]

A 46×46 uncompressed GIF with 7-bit symbols (128 colors, 8-bit codes). Click on the image for an explanation of the code.

The GIF encoding process can be modified to create a file without LZW compression that is still viewable as a GIF image. This technique was introduced originally as a way to avoid patent infringement. Uncompressed GIF can also be a useful intermediate format for a graphics programmer because individual pixels are accessible for reading or painting. An uncompressed GIF file can be converted to an ordinary GIF file simply by passing it through an image editor.

The modified encoding method ignores building the LZW table and emits only the root palette codes and the codes for CLEAR and STOP. This yields a simpler encoding (a 1-to-1 correspondence between code values and palette codes) but sacrifices all of the compression: each pixel in the image generates an output code indicating its color index. When processing an uncompressed GIF, a standard GIF decoder will not be prevented from writing strings to its dictionary table, but the code width must never increase since that triggers a different packing of bits to bytes.

If the symbol width is n, the codes of width n+1 fall naturally into two blocks: the lower block of 2n codes for coding single symbols, and the upper block of 2n codes that will be used by the decoder for sequences of length greater than one. Of that upper block, the first two codes are already taken: 2n for CLEAR and 2n + 1 for STOP. The decoder must also be prevented from using the last code in the upper block, 2n+1 − 1, because when the decoder fills that slot, it will increase the code width. Thus in the upper block there are 2n − 3 codes available to the decoder that won't trigger an increase in code width. Because the decoder is always one step behind in maintaining the table, it does not generate a table entry upon receiving the first code from the encoder, but will generate one for each succeeding code. Thus the encoder can generate 2n − 2 codes without triggering an increase in code width. Therefore, the encoder must emit extra CLEAR codes at intervals of 2n − 2 codes or less to make the decoder reset the coding dictionary. The GIF standard allows such extra CLEAR codes to be inserted in the image data at any time. The composite data stream is partitioned into sub-blocks that each carry from 1 to 255 bytes.

For the sample 3×5 image above, the following 9-bit codes represent "clear" (100) followed by image pixels in scan order and "stop" (101).

9-bit codes: 100 028 0FF 0FF 0FF 028 0FF 0FF 0FF 0FF 0FF 0FF 0FF 0FF 0FF 0FF 101

After the above codes are mapped to bytes, the uncompressed file differs from the compressed file thus:

: 320: 14 20 20 bytes uncompressed image data follow 321: 00 51 FC FB F7 0F C5 BF 7F FF FE FD FB F7 EF DF BF 7F 01 01 335: 00 - end :

Compression example[edit]

The trivial example of a large image of solid color demonstrates the variable-length LZW compression used in GIF files.

Code Pixels Notes
No.
Ni
Value
Ni + 256
Length
(bits)
This code
Ni
Accumulated
Ni(Ni + 1)/2
Relations using Ni only apply to same-
color pixels until coding table is full.
0 100h 9 Clear code table
1 FFh 1 1 Top left pixel color chosen as the
highest index of a 256-color palette
2 102h 2 3
3

255
103h

1FFh
3

255
6

32640


Last 9-bit code
256

767
200h

3FFh
10 256

767
32896

294528


Last 10-bit code
768

1791
400h

7FFh
11 768

1791
295296

1604736


Last 11-bit code
1792

3839
800h

FFFh
12 1792

3839
1606528

7370880


Code table full
FFFh 3839 The maximum code may repeat for more same-color pixels.
Overall data compression asymptotically approaches
3839 × 8/ 12 = 2559 +1/3
101h End of image data

The code values shown are packed into bytes which are then packed into blocks of up to 255 bytes. A block of image data begins with a byte that declares the number of bytes to follow. The last block of data for an image is marked by a zero block-length byte.

Interlacing[edit]

The GIF Specification allows each image within the logical screen of a GIF file to specify that it is interlaced; i.e., that the order of the raster lines in its data block is not sequential. This allows a partial display of the image that can be recognized before the full image is painted.

An interlaced image is divided from top to bottom into strips 8 pixels high, and the rows of the image are presented in the following order:

  • Pass 1: Line 0 (the top-most line) from each strip.
  • Pass 2: Line 4 from each strip.
  • Pass 3: Lines 2 and 6 from each strip.
  • Pass 4: Lines 1, 3, 5, and 7 from each strip.

The pixels within each line are not interlaced, but presented consecutively from left to right. As with non-interlaced images, there is no break between the data for one line and the data for the next. The indicator that an image is interlaced is a bit set in the corresponding Image Descriptor block.

Animated GIF[edit]

A GIF animation made of two photos, one morphing into the other

Although GIF was not designed as an animation medium, its ability to store multiple images in one file naturally suggested using the format to store the frames of an animation sequence. To facilitate displaying animations, the GIF89a spec added the Graphic Control Extension (GCE), which allows the images (frames) in the file to be painted with time delays, forming a video clip. Each frame in an animation GIF is introduced by its own GCE specifying the time delay to wait after the frame is drawn. Global information at the start of the file applies by default to all frames. The data is stream-oriented, so the file offset of the start of each GCE depends on the length of preceding data. Within each frame the LZW-coded image data is arranged in sub-blocks of up to 255 bytes; the size of each sub-block is declared by the byte that precedes it.

By default, an animation displays the sequence of frames only once, stopping when the last frame is displayed. To enable an animation to loop, Netscape in the 1990s used the Application Extension block (intended to allow vendors to add application-specific information to the GIF file) to implement the Netscape Application Block (NAB).[32] This block, placed immediately before the sequence of animation frames, specifies the number of times the sequence of frames should be played (1 to 65535 times) or that it should repeat continuously (zero indicates loop forever). Support for these repeating animations first appeared in Netscape Navigator version 2.0, and then spread to other browsers.[33] Most browsers now recognize and support NAB, though it is not strictly part of the GIF89a specification.

The following example shows the structure of the animation file Rotating earth (large).gif shown (as a thumbnail) in the article's infobox.

byte# hexadecimal text or(hex) value Meaning 0: 47 49 46 38 39 61 GIF89a HeaderLogical Screen Descriptor 6: 90 01 400 - width in pixels 8: 90 01 400 - height in pixels A: F7 - GCT follows for 256 colors with resolution 3 x 8bits/primary B: 00 0 - background color #0 C: 00 - default pixel aspect ratio D: Global Color Table : 30D: 21 FF Application Extension block 30F: 0B 11 - eleven bytes of data follow 310: 4E 45 54 53 43 41 50 45 NETSCAPE - 8-character application name 32 2E 30 2.0 - application "authentication code" 31B: 03 3 - three more bytes of data 31C: 01 1 - index of the current data sub-block (always 1 for the NETSCAPE block) 31D: FF FF 65535 - unsigned number of repetitions 31F: 00 - end of App Extension block 320: 21 F9 Graphic Control Extension for frame #1 322: 04 4 - four bytes in the current block 323: 04 000..... - reserved; 5 lower bits are bit field ...001.. - disposal method 1: do not dispose ......0. - no user input .......0 - transparent color is not given 324: 09 00 - 0.09 sec delay before painting next frame 326: FF - transparent color index (unused in this frame) 327: 00 - end of GCE block 328: 2C Image Descriptor of frame #1 329: 00 00 00 00 (0,0) - NW corner of frame at 0, 0 32D: 90 01 90 01 (400,400) - Frame width and height: 400 × 400 331: 00 - no local color table; no interlace 332: 08 8 LZW min code size; Image Data of frame #1 beginning 333: FF 255 - 255 bytes of LZW encoded image data follow 334: data 433: FF 255 - 255 bytes of LZW encoded image data follow data : 92C0: 00 - end of LZW data for this frame 92C1: 21 F9 Graphic Control Extension for frame #2 : : EDABD: 21 F9 Graphic Control Extension for frame #44 : F48F5: 3B File terminator

The animation delay for each frame is specified in the GCE in hundredths of a second. Some economy of data is possible where a frame need only rewrite a portion of the pixels of the display, because the Image Descriptor can define a smaller rectangle to be rescanned instead of the whole image. Browsers or other displays that do not support animated GIFs typically show only the first frame.

The size and color quality of animated GIF files can vary significantly depending on the application used to create them. Strategies for minimizing file size include using a common global color table for all frames (rather than a complete local color table for each frame) and minimizing the number of pixels covered in successive frames (so that only the pixels that change from one frame to the next are included in the latter frame). Simply packing a series of independent frame images into a composite animation tends to yield large file sizes.

Internet Explorer slows down GIFs if the frame-rate is 20 frames per second or higher and Microsoft reports that Google Chrome and Safari also slow down some GIF animations.[34]

Starting in early 1995, the University of Ulm used animated GIF as live video streaming format to show a controllable model railroad.

Metadata[edit]

Metadata can be stored in GIF files as a comment block, a plain text block, or an application-specific application extension block. Several graphics editors use unofficial application extension blocks to include the data used to generate the image, so that it can be recovered for further editing.

All of these methods technically require the metadata to be broken into sub-blocks so that applications can navigate the metadata block without knowing its internal structure.

The Extensible Metadata Platform (XMP) metadata standard introduced an unofficial but now widespread "XMP Data" application extension block for including XMP data in GIF files.[35] Since the XMP data is encoded using UTF-8 without NUL characters, there are no 0 bytes in the data. Rather than break the data into formal sub-blocks, the extension block terminates with a "magic trailer" that routes any application treating the data as sub-blocks to a final 0 byte that terminates the sub-block chain.

Unisys and LZW patent enforcement[edit]

In 1977 and 1978, Jacob Ziv and Abraham Lempel published a pair of papers on a new class of lossless data-compression algorithms, now collectively referred to as LZ77 and LZ78. In 1983, Terry Welch developed a fast variant of LZ78 which was named Lempel–Ziv–Welch (LZW).[36][37]

Welch filed a patent application for the LZW method in June 1983. The resulting patent, US 4558302 , granted in December 1985, was assigned to Sperry Corporation who subsequently merged with Burroughs Corporation in 1986 and formed Unisys.[36] Further patents were obtained in the United Kingdom, France, Germany, Italy, Japan and Canada.

In addition to the above patents, Welch's 1983 patent also includes citations to several other patents that influenced it, including two 1980 Japanese patents (JP9343880A and JP17790880A) from NEC's Jun Kanatsu, U.S. Patent 4,021,782 (1974) from John S. Hoerning, U.S. Patent 4,366,551 (1977) from Klaus E. Holtz, and a 1981 Dutch patent (DE19813118676) from Karl Eckhart Heinz.[38]

In June 1984, an article by Welch was published in the IEEE magazine which publicly described the LZW technique for the first time.[39] LZW became a popular data compression technique and, when the patent was granted, Unisys entered into licensing agreements with over a hundred companies.[36][40]

The popularity of LZW led CompuServe to choose it as the compression technique for their version of GIF, developed in 1987. At the time, CompuServe was not aware of the patent.[36] Unisys became aware that the version of GIF used the LZW compression technique and entered into licensing negotiations with CompuServe in January 1993. The subsequent agreement was announced on 24 December 1994.[37] Unisys stated that they expected all major commercial on-line information services companies employing the LZW patent to license the technology from Unisys at a reasonable rate, but that they would not require licensing, or fees to be paid, for non-commercial, non-profit GIF-based applications, including those for use on the on-line services.[40]

Following this announcement, there was widespread condemnation of CompuServe and Unisys, and many software developers threatened to stop using GIF. The PNG format (see below) was developed in 1995 as an intended replacement.[36][37][39] However, obtaining support from the makers of Web browsers and other software for the PNG format proved difficult and it was not possible to replace GIF, although PNG has gradually increased in popularity.[36] Therefore, GIF variations without LZW compression were developed. For instance the libungif library, based on Eric S. Raymond's giflib, allows creation of GIFs that followed the data format but avoided the compression features, thus avoiding use of the Unisys LZW patent.[41] A 2001 Dr. Dobb's article described another alternative to LZW compression, based on square roots.[42]

In August 1999, Unisys changed the details of their licensing practice, announcing the option for owners of certain non-commercial and private websites to obtain licenses on payment of a one-time license fee of $5000 or $7500.[43] Such licenses were not required for website owners or other GIF users who had used licensed software to generate GIFs. Nevertheless, Unisys was subjected to thousands of online attacks and abusive emails from users believing that they were going to be charged $5000 or sued for using GIFs on their websites.[44] Despite giving free licenses to hundreds of non-profit organizations, schools and governments, Unisys was completely unable to generate any good publicity and continued to be condemned by individuals and organizations such as the League for Programming Freedom who started the "Burn All GIFs" campaign in 1999.[45][46]

The United States LZW patent expired on 20 June 2003.[47] The counterpart patents in the United Kingdom, France, Germany and Italy expired on 18 June 2004, the Japanese patents expired on 20 June 2004, and the Canadian patent expired on 7 July 2004.[47] Consequently, while Unisys has further patents and patent applications relating to improvements to the LZW technique,[47] GIF may now be used freely.[48]

Alternatives[edit]

PNG[edit]

Portable Network Graphics (PNG) was designed as a replacement for GIF in order to avoid infringement of Unisys' patent on the LZW compression technique.[36] PNG offers better compression and more features than GIF,[49] animation being the only significant exception. PNG is more suitable than GIF in instances where true-color imaging and alpha transparency are required.

Although support for PNG format came slowly, new web browsers generally support PNG. Older versions of Internet Explorer do not support all features of PNG. Versions 6 and earlier do not support alpha channel transparency without using Microsoft-specific HTML extensions.[50]Gamma correction of PNG images was not supported before version 8, and the display of these images in earlier versions may have the wrong tint.[51]

For identical 8-bit (or lower) image data, PNG files are typically smaller than the equivalent GIFs, due to the more efficient compression techniques used in PNG encoding.[52] Complete support for GIF is complicated chiefly by the complex canvas structure it allows, though this is what enables the compact animation features.

Animation formats[edit]

Videos resolve many issues that GIFs present through common usage on the web. They include drastically smaller file sizes, the ability to surpass the 8-bit color restriction, and better frame-handling and compression through codecs. Virtually universal support for the GIF format in web browsers and a lack of official support for video in the HTML standard caused GIF to rise to prominence for the purpose of displaying short video-like files on the web.

MNG ("Multiple-image Network Graphics") was originally developed as a PNG-based solution for animations. MNG reached version 1.0 in 2001, but few applications support it.

In 2006, an extension to the PNG format called APNG ("Animated Portable Network Graphics") was proposed as alternative to the MNG format by Mozilla. APNG is supported by most browsers as of 2019.[53] APNG provide the ability to animate PNG files, while retaining backwards compatibility in decoders that cannot understand the animation chunk (unlike MNG). Older decoders will simply render the first frame of the animation. The PNG group officially rejected APNG as an official extension on April 20, 2007.[54] There have been several subsequent proposals for a simple animated graphics format based on PNG using several different approaches.[55] Nevertheless, Animated Portable Network Graphics is still under development by Mozilla and is supported in Firefox 3[56][57] while MNG support was dropped.[58][59] APNG is currently supported by all major web browsers including Chrome since version 59.0 and Opera and Firefox and Edge.

Embedded Adobe Flash objects and MPEGs are used on some websites to display simple video, but require the use of an additional browser plugin. WebM and WebP are in development and are supported by some web browsers.[60] Other options for web animation include serving individual frames using AJAX, or animating SVG images using JavaScript or SMIL ("Synchronized Multimedia Integration Language").[citation needed]

With the introduction of widespread support of the HTML5 video () tag in most web browsers, some websites use a looped version of the video tag generated by JavaScript functions. This gives the appearance of a GIF, but with the size and speed advantages of compressed video. Notable examples are Gfycat and Imgur and their GIFV metaformat, which is really a video tag playing a looped MP4 or WebM compressed video.[61]

High Efficiency Image File Format (HEIF) is an image file format, finalized in 2015, which uses a discrete cosine transform (DCT) lossy compression algorithm based on the HEVC video format, and related to the JPEG image format. In contrast to JPEG, HEIF supports animation.[62] Compared to the GIF format, which lacks DCT compression, HEIF allows significantly more efficient compression. HEIF stores more information and produces higher-quality animated images at a small fraction of an equivalent GIF's size.[63]

VP9 only supports alpha compositing with 4:2:0 chroma subsampling[64] in the YUVA420 pixel format, which may be unsuitable for GIFs that combine transparency with rasterisedvector graphics with fine color details.

Uses[edit]

In April 2014, 4chan added support for silent WebM

Источник: [https://torrent-igruha.org/3551-portal.html]
gif maker free download full version Archives

Zip (file format)

Family of archive file formats

ZIP is an archive file format that supports lossless data compression. A ZIP file may contain one or more files or directories that may have been compressed. The ZIP file format permits a number of compression algorithms, though DEFLATE is the most common. This format was originally created in 1989 and was first implemented in PKWARE, Inc.'s PKZIP utility,[2] as a replacement for the previous ARC compression format by Thom Henderson. The ZIP format was then quickly supported by many software utilities other than PKZIP. Microsoft has included built-in ZIP support (under the name "compressed folders") in versions of Microsoft Windows since 1998. Apple has included built-in ZIP support in Mac OS X 10.3 (via BOMArchiveHelper, now Archive Utility) and later. Most free operating systems have built in support for ZIP in similar manners to Windows and Mac OS X.

ZIP files generally use the file extensions.zip or .ZIP and the MIME media type .[1] ZIP is used as a base file format by many programs, usually under a different name. When navigating a file system via a user interface, graphical icons representing ZIP files often appear as a document or other object prominently featuring a zipper.

History[edit]

The .ZIP file format was designed by Phil Katz of PKWARE and Gary Conway of Infinity Design Concepts. The format was created after Systems Enhancement Associates (SEA) filed a lawsuit against PKWARE claiming that the latter's archiving products, named PKARC, were derivatives of SEA's ARC archiving system.[3] The name "zip" (meaning "move at high speed") was suggested by Katz's friend, Robert Mahoney.[citation needed]They wanted to imply that their product would be faster than ARC and other compression formats of the time.[citation needed]The earliest known version of .ZIP File Format Specification was first published as part of PKZIP 0.9 package under the file APPNOTE.TXT in 1989.[citation needed] By distributing the zip file format within APPNOTE.TXT, compatibility with the zip file format proliferated widely on the public Internet during the 1990s.[4]

PKWARE and Infinity Design Concepts made a joint press release on February 14, 1989 releasing the .ZIP file format into the public domain.[5][6][7][8][9]

Version history[edit]

The .ZIP File Format Specification has its own version number, which does not necessarily correspond to the version numbers for the PKZIP tool, especially with PKZIP 6 or later. At various times, PKWARE has added preliminary features that allow PKZIP products to extract archives using advanced features, but PKZIP products that create such archives are not made available until the next major release. Other companies or organizations support the PKWARE specifications at their own pace.

The .ZIP file format specification is formally named "APPNOTE - .ZIP File Format Specification" and it is published on the PKWARE.com website since the late 1990s.[10] Several versions of the specification were not published. Specifications of some features such as BZIP2 compression, strong encryption specification and others were published by PKWARE a few years after their creation. The URL of the online specification was changed several times on the PKWARE website.

A summary of key advances in various versions of the PKWARE specification:

  • 2.0: (1993)[1] File entries can be compressed with DEFLATE and use traditional PKWARE encryption (ZipCrypto).
  • 2.1: (1996) Deflate64 compression
  • 4.5: (2001)[11] Documented 64-bit zip format.
  • 4.6: (2001) BZIP2 compression (not published online until the publication of APPNOTE 5.2)
  • 5.0: (2002) SES: DES, Triple DES, RC2, RC4 supported for encryption (not published online until the publication of APPNOTE 5.2)
  • 5.2: (2003)[12][13] AES encryption support for SES (defined in APPNOTE 5.1 that was not published online) and AES from WinZip ("AE-x"); corrected version of RC2-64 supported for SES encryption.
  • 6.1: (2004)[14] Documented certificate storage.
  • 6.2.0: (2004)[15] Documented Central Directory Encryption.
  • 6.3.0: (2006)[16] Documented Unicode (UTF-8) filename storage. Expanded list of supported hash, compression (LZMA, PPMd+), encryption algorithms.
  • 6.3.1: (2007)[17] Corrected standard hash values for SHA-256/384/512.
  • 6.3.2: (2007)[18] Documented compression method 97 (WavPack).
  • 6.3.3: (2012)[19] Document formatting changes to facilitate referencing the PKWARE Application Note from other standards using methods such as the JTC 1 Referencing Explanatory Report (RER) as directed by JTC 1/SC 34 N 1621.
  • 6.3.4: (2014)[20] Updates the PKWARE, Inc. office address.
  • 6.3.5: (2018)[21] Documented compression methods 16, 96 and 99, DOS timestamp epoch and precision, added extra fields for keys and decryption, as well as typos and clarifications.
  • 6.3.6: (2019)[22] Corrected typographical error.
  • 6.3.7: (2020)[23] Added Zstandard compression method ID 20.
  • 6.3.8: (2020)[24] Moved Zstandard compression method ID from 20 to 93, deprecating the former. Documented method IDs 94 and 95 (MP3 and XZ respectively).
  • 6.3.9: (2020)[25] Corrected a typo in Data Stream Alignment description.

WinZip, starting with version 12.1, uses the extension .zipx for ZIP files that use compression methods newer than DEFLATE; specifically, methods BZip, LZMA, PPMd, Jpeg and Wavpack. The last 2 are applied to appropriate file types when "Best method" compression is selected.[26][27]

Standardization[edit]

In April 2010, ISO/IEC JTC 1 initiated a ballot to determine whether a project should be initiated to create an ISO/IEC International Standard format compatible with ZIP.[28] The proposed project, entitled Document Packaging, envisaged a ZIP-compatible 'minimal compressed archive format' suitable for use with a number of existing standards including OpenDocument, Office Open XML and EPUB.

In 2015, ISO/IEC 21320-1 "Document Container File — Part 1: Core" was published which states that "Document container files are conforming Zip files". It requires the following main restrictions of the ZIP file format:[29]

  • Files in ZIP archives may only be stored uncompressed, or using the "deflate" compression (i.e. compression method may contain the value "0" - stored or "8" - deflated).
  • The encryption features are prohibited.
  • The digital signature features (from SES) are prohibited.
  • The "patched data" features (from PKPatchMaker) are prohibited.
  • Archives may not span multiple volumes or be segmented.

Design[edit]

.ZIP files are archives that store multiple files. ZIP allows contained files to be compressed using many different methods, as well as simply storing a file without compressing it. Each file is stored separately, allowing different files in the same archive to be compressed using different methods. Because the files in a ZIP archive are compressed individually it is possible to extract them, or add new ones, without applying compression or decompression to the entire archive. This contrasts with the format of compressed tar files, for which such random-access processing is not easily possible.

A directory is placed at the end of a ZIP file. This identifies what files are in the ZIP and identifies where in the ZIP that file is located. This allows ZIP readers to load the list of files without reading the entire ZIP archive. ZIP archives can also include extra data that is not related to the ZIP archive. This allows for a ZIP archive to be made into a self-extracting archive (application that decompresses its contained data), by prepending the program code to a ZIP archive and marking the file as executable. Storing the catalog at the end also makes possible hiding a zipped file by appending it to an innocuous file, such as a GIF image file.

The .ZIP format uses a 32-bit CRC algorithm and includes two copies of the directory structure of the archive to provide greater protection against data loss.

Structure[edit]

A ZIP file is correctly identified by the presence of an end of central directory record which is located at the end of the archive structure in order to allow the easy appending of new files. If the end of central directory record indicates a non-empty archive, the name of each file or directory within the archive should be specified in a central directory entry, along with other metadata about the entry, and an offset into the ZIP file, pointing to the actual entry data. This allows a file listing of the archive to be performed relatively quickly, as the entire archive does not have to be read to see the list of files. The entries within the ZIP file also include this information, for redundancy, in a local file header. Because ZIP files may be appended to, only files specified in the central directory at the end of the file are valid. Scanning a ZIP file for local file headers is invalid (except in the case of corrupted archives), as the central directory may declare that some files have been deleted and other files have been updated.

For example, we may start with a ZIP file that contains files A, B and C. File B is then deleted and C updated. This may be achieved by just appending a new file C to the end of the original ZIP file and adding a new central directory that only lists file A and the new file C. When ZIP was first designed, transferring files by floppy disk was common, yet writing to disks was very time consuming. If you had a large zip file, possibly spanning multiple disks, and only needed to update a few files, rather than reading and re-writing all the files, it would be substantially faster to just read the old central directory, append the new files then append an updated central directory.

The order of the file entries in the central directory need not coincide with the order of file entries in the archive.

Each entry stored in a ZIP archive is introduced by a local file header with information about the file such as the comment, file size and file name, followed by optional "extra" data fields, and then the possibly compressed, possibly encrypted file data. The "Extra" data fields are the key to the extensibility of the ZIP format. "Extra" fields are exploited to support the ZIP64 format, WinZip-compatible AES encryption, file attributes, and higher-resolution NTFS or Unix file timestamps. Other extensions are possible via the "Extra" field. ZIP tools are required by the specification to ignore Extra fields they do not recognize.

The ZIP format uses specific 4-byte "signatures" to denote the various structures in the file. Each file entry is marked by a specific signature. The end of central directory record is indicated with its specific signature, and each entry in the central directory starts with the 4-byte central file header signature.

There is no BOF or EOF marker in the ZIP specification. Conventionally the first thing in a ZIP file is a ZIP entry, which can be identified easily by its local file header signature. However, this is not necessarily the case, as this not required by the ZIP specification - most notably, a self-extracting archive will begin with an executable file header.

Tools that correctly read ZIP archives must scan for the end of central directory record signature, and then, as appropriate, the other, indicated, central directory records. They must not scan for entries from the top of the ZIP file, because (as previously mentioned in this section) only the central directory specifies where a file chunk starts and that it has not been deleted. Scanning could lead to false positives, as the format does not forbid other data to be between chunks, nor file data streams from containing such signatures. However, tools that attempt to recover data from damaged ZIP archives will most likely scan the archive for local file header signatures; this is made more difficult by the fact that the compressed size of a file chunk may be stored after the file chunk, making sequential processing difficult.

Most of the signatures end with the short integer 0x4b50, which is stored in little-endian ordering. Viewed as an ASCII string this reads "PK", the initials of the inventor Phil Katz. Thus, when a ZIP file is viewed in a text editor the first two bytes of the file are usually "PK". (DOS, OS/2 and Windows self-extracting ZIPs have an EXE before the ZIP so start with "MZ"; self-extracting ZIPs for other operating systems may similarly be preceded by executable code for extracting the archive's content on that platform.)

The .ZIP specification also supports spreading archives across multiple file-system files. Originally intended for storage of large ZIP files across multiple floppy disks, this feature is now used for sending ZIP archives in parts over email, or over other transports or removable media.

The FAT filesystem of DOS has a timestamp resolution of only two seconds; ZIP file records mimic this. As a result, the built-in timestamp resolution of files in a ZIP archive is only two seconds, though extra fields can be used to store more precise timestamps. The ZIP format has no notion of time zone, so timestamps are only meaningful if it is known what time zone they were created in.

In September 2007, PKWARE released a revision of the ZIP specification providing for the storage of file names using UTF-8, finally adding Unicode compatibility to ZIP.[30]

File headers[edit]

All multi-byte values in the header are stored in little-endian byte order. All length fields count the length in bytes.

Local file header[edit]

OffsetBytesDescription[30]
04Local file header signature = 0x04034b50 (read as a little-endian number)
42Version needed to extract (minimum)
62General purpose bit flag
82Compression method
102File last modification time
122File last modification date
144CRC-32 of uncompressed data
184Compressed size
224Uncompressed size
262File name length (n)
282Extra field length (m)
30nFile name
30+nmExtra field

The extra field contains a variety of optional data such as OS-specific attributes. It is divided into chunks, each with a 16-bit ID code and a 16-bit length.

This is immediately followed by the compressed data.

Data descriptor[edit]

If the bit at offset 3 (0x08) of the general-purpose flags field is set, then the CRC-32 and file sizes are not known when the header is written. The fields in the local header are filled with zero, and the CRC-32 and size are appended in a 12-byte structure (optionally preceded by a 4-byte signature) immediately after the compressed data:

OffsetBytesDescription[30]
00/4Optional data descriptor signature = 0x08074b50
0/44CRC-32 of uncompressed data
4/84Compressed size
8/124Uncompressed size

Central directory file header[edit]

The central directory entry is an expanded form of the local header:

OffsetBytesDescription[30]
04Central directory file header signature = 0x02014b50
42Version made by
62Version needed to extract (minimum)
82General purpose bit flag
102Compression method
122File last modification time
142File last modification date
164CRC-32 of uncompressed data
204Compressed size
244Uncompressed size
282File name length (n)
302Extra field length (m)
322File comment length (k)
342Disk number where file starts
362Internal file attributes
384External file attributes
424Relative offset of local file header. This is the number of bytes between the start of the first disk on which the file occurs, and the start of the local file header. This allows software reading the central directory to locate the position of the file inside the ZIP file.
46nFile name
46+nmExtra field
46+n+mkFile comment

End of central directory record (EOCD)[edit]

After all the central directory entries comes the end of central directory (EOCD) record, which marks the end of the ZIP file:

OffsetBytesDescription[30]
04End of central directory signature = 0x06054b50
42Number of this disk
62Disk where central directory starts
82Number of central directory records on this disk
102Total number of central directory records
124Size of central directory (bytes)
164Offset of start of central directory, relative to start of archive
202Comment length (n)
22nComment

This ordering allows a ZIP file to be created in one pass, but the central directory is also placed at the end of the file in order to facilitate easy removal of files from multiple-part (e.g. "multiple floppy-disk") archives, as previously discussed.

Compression methods[edit]

The .ZIP File Format Specification documents the following compression methods: Store (no compression), Shrink (LZW), Reduce (levels 1-4; RLE + probabilistic), Implode, Deflate, Deflate64, bzip2, LZMA, WavPack, PPMd, and a LZ77 variant provided by IBM z/OS CMPSC instruction.[31][21] The most commonly used compression method is DEFLATE, which is described in IETF RFC 1951.

Other methods mentioned, but not documented in detail in the specification include: PKWARE DCL Implode (old IBM TERSE), new IBM TERSE, IBM LZ77 z Architecture (PFS), and a JPEG variant. A "Tokenize" method was reserved for a third party, but support was never added.[21]

The word Implode is overused by PKWARE: the DCL/TERSE Implode is distinct from the old PKZIP Implode, a predecessor to Deflate. The DCL Implode is undocumented partially due to its proprietrary nature held by IBM, but Mark Adler has nevertheless provided a decompressor called "blast" alongside zlib.[32]

Encryption[edit]

ZIP supports a simple password-based symmetric encryption system generally known as ZipCrypto. It is documented in the ZIP specification, and known to be seriously flawed. In particular, it is vulnerable to known-plaintext attacks, which are in some cases made worse by poor implementations of random-number generators.[4]

New features including new compression and encryption (e.g. AES) methods have been documented in the ZIP File Format Specification since version 5.2. A WinZip-developed AES-based open standard ("AE-x" in APPNOTE) is used also by 7-Zip and Xceed, but some vendors use other formats.[33] PKWARE SecureZIP (SES, proprietary) also supports RC2, RC4, DES, Triple DES encryption methods, Digital Certificate-based encryption and authentication (X.509), and archive header encryption. It is, however, patented (see § Strong encryption controversy).[34]

File nameencryption is introduced in .ZIP File Format Specification 6.2, which encrypts metadata stored in Central Directory portion of an archive, but Local Header sections remain unencrypted. A compliant archiver can falsify the Local Header data when using Central Directory Encryption. As of version 6.2 of the specification, the Compression Method and Compressed Size fields within Local Header are not yet masked.

ZIP64[edit]

The original .ZIP format had a 4 GiB (232 bytes) limit on various things (uncompressed size of a file, compressed size of a file, and total size of the archive), as well as a limit of 65,535 (216) entries in a ZIP archive. In version 4.5 of the specification (which is not the same as v4.5 of any particular tool), PKWARE introduced the "ZIP64" format extensions to get around these limitations, increasing the limits to 16 EiB (264 bytes). In essence, it uses a "normal" central directory entry for a file, followed by an optional "zip64" directory entry, which has the larger fields.[35]

The File Explorer in Windows XP does not support ZIP64, but the Explorer in Windows Vista and later do.[citation needed] Likewise, some extension libraries support ZIP64, such as DotNetZip, QuaZIP[36] and IO::Compress::Zip in Perl. Python's built-in zipfile supports it since 2.5 and defaults to it since 3.4.[37] OpenJDK's built-in java.util.zip supports ZIP64 from version Java 7.[38]Android Java API support ZIP64 since Android 6.0.[39] Mac OS Sierra's Archive Utility notably does not support ZIP64, and can create corrupt archives when ZIP64 would be required.[40] However, the ditto command shipped with Mac OS will unzip ZIP64 files.[41] More recent[when?] versions of Mac OS ship with info-zip's zip and unzip command line tools which do support Zip64: to verify run zip -v and look for "ZIP64_SUPPORT".

Combination with other file formats[edit]

The .ZIP file format allows for a comment containing up to 65,535 (216−1) bytes of data to occur at the end of the file after the central directory.[30] Also, because the central directory specifies the offset of each file in the archive with respect to the start, it is possible for the first file entry to start at an offset other than zero, although some tools, for example gzip, will not process archive files that do not start with a file entry at offset zero.

This allows arbitrary data to occur in the file both before and after the ZIP archive data, and for the archive to still be read by a ZIP application. A side-effect of this is that it is possible to author a file that is both a working ZIP archive and another format, provided that the other format tolerates arbitrary data at its end, beginning, or middle. Self-extracting archives (SFX), of the form supported by WinZip, take advantage of this, in that they are executable (.exe) files that conform to the PKZIP AppNote.txt specification, and can be read by compliant zip tools or libraries.

This property of the .ZIP format, and of the JAR format which is a variant of ZIP, can be exploited to hide rogue content (such as harmful Java classes) inside a seemingly harmless file, such as a GIF image uploaded to the web. This so-called GIFAR exploit has been demonstrated as an effective attack against web applications such as Facebook.[42]

Limits[edit]

The minimum size of a .ZIP file is 22 bytes. Such an empty zip file contains only an End of Central Directory Record (EOCD):

The maximum size for both the archive file and the individual files inside it is 4,294,967,295 bytes (232−1 bytes, or 4 GiB minus 1 byte) for standard ZIP. For ZIP64, the maximum size is 18,446,744,073,709,551,615 bytes (264−1 bytes, or 16 EiB minus 1 byte).[43]

Proprietary extensions[edit]

Extra field[edit]

.ZIP file format includes an extra field facility within file headers, which can be used to store extra data not defined by existing ZIP specifications, and which allow compliant archivers that do not recognize the fields to safely skip them. Header IDs 0–31 are reserved for use by PKWARE. The remaining IDs can be used by third-party vendors for proprietary usage.

Strong encryption controversy[edit]

When WinZip 9.0 public beta was released in 2003, WinZip introduced its own AES-256 encryption, using a different file format, along with the documentation for the new specification.[44] The encryption standards themselves were not proprietary, but PKWARE had not updated APPNOTE.TXT to include Strong Encryption Specification (SES) since 2001, which had been used by PKZIP versions 5.0 and 6.0. WinZip technical consultant Kevin Kearney and StuffIt product manager Mathew Covington accused PKWARE of withholding SES, but PKZIP chief technology officer Jim Peterson claimed that certificate-based encryption was still incomplete.

In another controversial move, PKWare applied for a patent on 16 July 2003 describing a method for combining ZIP and strong encryption to create a secure file.[45]

In the end, PKWARE and WinZip agreed to support each other's products. On 21 January 2004, PKWARE announced the support of WinZip-based AES compression format.[46] In a later version of WinZip beta, it was able to support SES-based ZIP files.[47] PKWARE eventually released version 5.2 of the .ZIP File Format Specification to the public, which documented SES. The Free Software project 7-Zip also supports AES, but not SES in ZIP files (as does its POSIXportp7zip).

When using AES encryption under WinZip, the compression method is always set to 99, with the actual compression method stored in an AES extra data field.[48] In contrast, Strong Encryption Specification stores the compression method in the basic file header segment of Local Header and Central Directory, unless Central Directory Encryption is used to mask/encrypt metadata.

Implementation[edit]

There are numerous .ZIP tools available, and numerous .ZIP libraries for various programming environments; licenses used include proprietary and free software. WinZip, WinRAR, Info-ZIP, 7-Zip, PeaZip and B1 Free Archiver are well-known .ZIP tools, available on various platforms. Some of those tools have library or programmatic interfaces.

Some development libraries licensed under open source agreement are libzip, libarchive, and Info-ZIP. For Java: Java Platform, Standard Edition contains the package "java.util.zip" to handle standard .ZIP files; the Zip64File library specifically supports large files (larger than 4 GB) and treats .ZIP files using random access; and the Apache Ant tool contains a more complete implementation released under the Apache Software License.

The Info-ZIP implementations of the .ZIP format adds support for Unix filesystem features, such as user and group IDs, file permissions, and support for symbolic links. The Apache Ant implementation is aware of these to the extent that it can create files with predefined Unix permissions. The Info-ZIP implementations also know how to use the error correction capabilities built into the .ZIP compression format. Some programs do not, and will fail on a file that has errors.

The Info-ZIP Windows tools also support NTFSfilesystem permissions, and will make an attempt to translate from NTFS permissions to Unix permissions or vice versa when extracting files. This can result in potentially unintended combinations, e.g. .exe files being created on NTFS volumes with executable permission denied.

Versions of Microsoft Windows have included support for .ZIP compression in Explorer since the Microsoft Plus! pack was released for Windows 98. Microsoft calls this feature "Compressed Folders". Not all .ZIP features are supported by the Windows Compressed Folders capability. For example, encryption is not supported in Windows 10 Home edition,[49] although it can decrypt. Unicode entry encoding is not supported until Windows 7, while split and spanned archives are not readable or writable by the Compressed Folders feature, nor is AES Encryption supported.[50]

Microsoft Office started using the zip archive format in 2006 for their Office Open XML .docx, .xlsx, .pptx, etc. files, which became the default file format with Microsoft Office 2007.

Legacy[edit]

There are numerous other standards and formats using "zip" as part of their name. For example, zip is distinct from gzip, and the latter is defined in an IETFRFC (RFC 1952). Both zip and gzip primarily use the DEFLATE algorithm for compression. Likewise, the ZLIB format (IETF RFC 1950) also uses the DEFLATE compression algorithm, but specifies different headers for error and consistency checking. Other common, similarly named formats and programs with different native formats include 7-Zip, bzip2, and rzip.

Concerns[edit]

The theoretical maximum compression factor for a raw DEFLATE stream is about 1032 to one,[51] but by exploiting the ZIP format in unintended ways, ZIP archives with compression ratios of billions to one can be constructed. These zip bombs unzip to extremely large sizes, overwhelming the capacity of the computer they are decompressed on.[52]

See also[edit]

References[edit]

  1. ^ abcRegistration of a new MIME Content-Type/Subtype - application/zip, IANA, 20 July 1993, retrieved 5 January 2012
  2. ^"Phillip Katz, Computer Software Pioneer, 37". The New York Times'. 1 May 2000. Retrieved 14 June 2009.
  3. ^Murray, Matt; Tannenbaum, Jeffrey A. (15 August 1997). "The Rise and Fall of a Software Star; Phil Katz Loved Code -- and Liquor". The Wall Street Journal (online ed.). Archived from the original on 4 March 2016.Alt URL Updated 2000-06-19.
  4. ^ abStay, Michael. "ZIP Attacks with Reduced Known Plaintext"(PDF). Math.ucr.edu. Archived from the original(PDF) on 28 October 2017. Retrieved 9 September 2017.
  5. ^Brian Livingston (8 September 2003), PKZip Must Open Up, retrieved 5 January 2012,
  6. ^Where Did Zip Files Come From Anyway?, Infinity Design Concepts, Inc., retrieved 5 January 2012
  7. ^Press Release, 1989, retrieved 5 January 2012
  8. ^Our Founder - Phil Katz, PKWARE, archived from the original on 1 October 2010, retrieved 5 January 2012
  9. ^Gareth Horton; Rob Weir; Alex Brown (2 November 2010), sc34-wg1, retrieved 5 January 2012
  10. ^.ZIP Application Note, retrieved 20 July 2012
  11. ^File: APPNOTE.TXT - .ZIP File Format Specification Version: 4.5 Revised: 11/01/2001, 3 December 2001, archived from the original on 3 December 2001, retrieved 21 April 2012
  12. ^APPNOTE.TXT - .ZIP File Format Specification, Version: 5.2 - Notification of Change, 16 July 2003, retrieved 5 January 2012
  13. ^File: APPNOTE.TXT - .ZIP File Format Specification Version: 5.2 - Notification of Change – Revised: 06/02/2003, 2 July 2003, archived from the original on 2 July 2003, retrieved 21 April 2012
  14. ^File: APPNOTE - .ZIP File Format Specification Version: 6.1.0 - Notification of Change – Revised: 01/20/2004, 19 August 2004, archived from the original on 19 August 2004, retrieved 21 April 2012
  15. ^APPNOTE.TXT - .ZIP File Format Specification, Version: 6.2.0 - Notification of Change, 26 April 2004, retrieved 5 January 2012
  16. ^APPNOTE.TXT - .ZIP File Format Specification, Version: 6.3.0, 29 September 2006, retrieved 5 January 2012
  17. ^APPNOTE.TXT - .ZIP File Format Specification, Version: 6.3.1, 11 April 2007, retrieved 25 June 2018
  18. ^APPNOTE.TXT - .ZIP File Format Specification Version: 6.3.2, 28 September 2007, retrieved 25 June 2018
  19. ^APPNOTE.TXT - .ZIP File Format Specification Version: 6.3.3, 1 September 2012, retrieved 25 June 2018
  20. ^APPNOTE.TXT - .ZIP File Format Specification Version: 6.3.4, 1 October 2014, retrieved 25 June 2018
  21. ^ abcAPPNOTE.TXT - .ZIP File Format Specification Version: 6.3.5, 20 December 2018, retrieved 3 January 2019
  22. ^APPNOTE.TXT - .ZIP File Format Specification Version: 6.3.6, 26 April 2019, retrieved 3 January 2019
  23. ^APPNOTE.TXT - .ZIP File Format Specification Version: 6.3.7, 1 June 2020, retrieved 6 June 2020
  24. ^APPNOTE.TXT - .ZIP File Format Specification Version: 6.3.8, 15 June 2020, retrieved 7 July 2020
  25. ^APPNOTE.TXT - .ZIP File Format Specification Version: 6.3.9, 15 July 2020, retrieved 8 August 2020
  26. ^"Additional Compression Methods Specification". WinZip. Mansfield, CT: WinZip Computing, S.L. 19 May 2009. Retrieved 24 May 2009.
  27. ^"What is a Zipx File?". Winzip: Knowledgebase. Mansfield, CT: WinZip Computing, S.L. 13 August 2010. Retrieved 17 August 2010.
  28. ^"ISO/IEC JTC 1/SC 34 — Document Description and Processing Languages"(PDF). 12 April 2010. Archived from the original(PDF) on 12 May 2014. Retrieved 10 May 2014.
  29. ^"ISO/IEC 21320-1:2015 Document Container File — Part 1: Core". ITTF. 2015.
  30. ^ abcdef"File : APPNOTE.TXT - .ZIP File Format Specification : Version: 6.3.4"(TXT). Pkware.com. Retrieved 9 September 2017.
  31. ^Adler, Mark. "How are zlib, gzip and zip related? What do they have in common and how are they different?". Retrieved 27 November 2018.
  32. ^"Frequently Asked Questions about zlib". zlib. (contrib/blast)
  33. ^"AES Encryption Information: Encryption Specification AE-1 and AE-2". Winzip.com. Retrieved 9 September 2017.
  34. ^"APPNOTE - PKZIP/SecureZIP - PKWARE Support Site". Pkware.com. Retrieved 9 September 2017.
  35. ^"File : APPNOTE.TXT - .ZIP File Format Specification : Version: 6.3.4"(TXT). Pkware.cachefly.net. Retrieved 9 September 2017.
  36. ^"QuaZIP changes". 22 January 2014. Retrieved 25 January 2014.
  37. ^"Python enhancement: Use allowZip64=True by default (3.4)". Retrieved 6 May 2014.
  38. ^Shen, Xueming (17 April 2009).
Источник: [https://torrent-igruha.org/3551-portal.html]
.

What’s New in the gif maker free download full version Archives?

Screen Shot

System Requirements for Gif maker free download full version Archives

Add a Comment

Your email address will not be published. Required fields are marked *