google.patch - Issue 1258673007: Add jpeg_skip_scanlines() API to libjpeg-turbo

Unified Diff: google.patch

Issue 1258673007: Add jpeg_skip_scanlines() API to libjpeg-turbo (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/libjpeg_turbo.git@master

Patch Set: Updating google.patch Created 5 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: google.patch

diff --git a/google.patch b/google.patch

index f12156b4eecc5f5d219844cce2c54c60b1e6d4f3..fcb53b443086670ad83f4abbac4187bb530ffeca 100644

--- a/google.patch

+++ b/google.patch

@@ -1,174 +1,9613 @@

-Index: jdmarker.c

+Index: README

===================================================================

---- jdmarker.c (revision 829)

-+++ jdmarker.c (working copy)

-@@ -910,7 +910,7 @@

+--- README (revision 829)

++++ README (working copy)

+@@ -1,26 +1,26 @@

++libjpeg-turbo note: This file has been modified by The libjpeg-turbo Project

++to include only information relevant to libjpeg-turbo, to wordsmith certain

++sections, and to remove impolitic language that existed in the libjpeg v8

++README. It is included only for reference. Please see README-turbo.txt for

++information specific to libjpeg-turbo.

+ The Independent JPEG Group's JPEG software

+ ==========================================

+-README for release 6b of 27-Mar-1998

+-====================================

++This distribution contains a release of the Independent JPEG Group's free JPEG

++software. You are welcome to redistribute this software and to use it for any

++purpose, subject to the conditions under LEGAL ISSUES, below.

+-This distribution contains the sixth public release of the Independent JPEG

+-Group's free JPEG software. You are welcome to redistribute this software and

+-to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.

++This software is the work of Tom Lane, Guido Vollbeding, Philip Gladstone,

++Bill Allombert, Jim Boucher, Lee Crocker, Bob Friesenhahn, Ben Jackson,

++Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Ge' Weijers,

++and other members of the Independent JPEG Group.

+-Serious users of this software (particularly those incorporating it into

+-larger programs) should contact IJG at jpeg-info@uunet.uu.net to be added to

+-our electronic mailing list. Mailing list members are notified of updates

+-and have a chance to participate in technical discussions, etc.

++IJG is not affiliated with the ISO/IEC JTC1/SC29/WG1 standards committee

++(also known as JPEG, together with ITU-T SG16).

+-This software is the work of Tom Lane, Philip Gladstone, Jim Boucher,

+-Lee Crocker, Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi,

+-Guido Vollbeding, Ge' Weijers, and other members of the Independent JPEG

+-Group.

+-IJG is not affiliated with the official ISO JPEG standards committee.

+ DOCUMENTATION ROADMAP

+ =====================

+@@ -30,7 +30,6 @@

+ LEGAL ISSUES Copyright, lack of warranty, terms of distribution.

+ REFERENCES Where to learn more about JPEG.

+ ARCHIVE LOCATIONS Where to find newer versions of this software.

+-RELATED SOFTWARE Other stuff you should get.

+ FILE FORMAT WARS Software *not* to get.

+ TO DO Plans for future IJG releases.

+@@ -37,20 +36,19 @@

+ Other documentation files in the distribution are:

+ User documentation:

+- install.doc How to configure and install the IJG software.

+- usage.doc Usage instructions for cjpeg, djpeg, jpegtran,

++ install.txt How to configure and install the IJG software.

++ usage.txt Usage instructions for cjpeg, djpeg, jpegtran,

+ rdjpgcom, and wrjpgcom.

+- *.1 Unix-style man pages for programs (same info as usage.doc).

+- wizard.doc Advanced usage instructions for JPEG wizards only.

++ *.1 Unix-style man pages for programs (same info as usage.txt).

++ wizard.txt Advanced usage instructions for JPEG wizards only.

+ change.log Version-to-version change highlights.

+ Programmer and internal documentation:

+- libjpeg.doc How to use the JPEG library in your own programs.

++ libjpeg.txt How to use the JPEG library in your own programs.

+ example.c Sample code for calling the JPEG library.

+- structure.doc Overview of the JPEG library's internal structure.

+- filelist.doc Road map of IJG files.

+- coderules.doc Coding style rules --- please read if you contribute code.

++ structure.txt Overview of the JPEG library's internal structure.

++ coderules.txt Coding style rules --- please read if you contribute code.

+-Please read at least the files install.doc and usage.doc. Useful information

++Please read at least the files install.txt and usage.txt. Some information

+ can also be found in the JPEG FAQ (Frequently Asked Questions) article. See

+ ARCHIVE LOCATIONS below to find out where to obtain the FAQ article.

+@@ -62,24 +60,27 @@

+ OVERVIEW

+ ========

+-This package contains C software to implement JPEG image compression and

+-decompression. JPEG (pronounced "jay-peg") is a standardized compression

+-method for full-color and gray-scale images. JPEG is intended for compressing

+-"real-world" scenes; line drawings, cartoons and other non-realistic images

+-are not its strong suit. JPEG is lossy, meaning that the output image is not

+-exactly identical to the input image. Hence you must not use JPEG if you

+-have to have identical output bits. However, on typical photographic images,

+-very good compression levels can be obtained with no visible change, and

+-remarkably high compression levels are possible if you can tolerate a

+-low-quality image. For more details, see the references, or just experiment

+-with various compression settings.

++This package contains C software to implement JPEG image encoding, decoding,

++and transcoding. JPEG (pronounced "jay-peg") is a standardized compression

++method for full-color and gray-scale images. JPEG's strong suit is compressing

++photographic images or other types of images that have smooth color and

++brightness transitions between neighboring pixels. Images with sharp lines or

++other abrupt features may not compress well with JPEG, and a higher JPEG

++quality may have to be used to avoid visible compression artifacts with such

++images.

++JPEG is lossy, meaning that the output pixels are not necessarily identical to

++the input pixels. However, on photographic content and other "smooth" images,

++very good compression ratios can be obtained with no visible compression

++artifacts, and extremely high compression ratios are possible if you are

++willing to sacrifice image quality (by reducing the "quality" setting in the

++compressor.)

+ This software implements JPEG baseline, extended-sequential, and progressive

+ compression processes. Provision is made for supporting all variants of these

+ processes, although some uncommon parameter settings aren't implemented yet.

+-For legal reasons, we are not distributing code for the arithmetic-coding

+-variants of JPEG; see LEGAL ISSUES. We have made no provision for supporting

+-the hierarchical or lossless processes defined in the standard.

++We have made no provision for supporting the hierarchical or lossless

++processes defined in the standard.

+ We provide a set of library routines for reading and writing JPEG image files,

+ plus two sample applications "cjpeg" and "djpeg", which use the library to

+@@ -91,11 +92,12 @@

+ for example, the color quantization modules are not strictly part of JPEG

+ decoding, but they are essential for output to colormapped file formats or

+ colormapped displays. These extra functions can be compiled out of the

+-library if not required for a particular application. We have also included

+-"jpegtran", a utility for lossless transcoding between different JPEG

+-processes, and "rdjpgcom" and "wrjpgcom", two simple applications for

+-inserting and extracting textual comments in JFIF files.

++library if not required for a particular application.

++We have also included "jpegtran", a utility for lossless transcoding between

++different JPEG processes, and "rdjpgcom" and "wrjpgcom", two simple

++applications for inserting and extracting textual comments in JFIF files.

+ The emphasis in designing this software has been on achieving portability and

+ flexibility, while also making it fast enough to be useful. In particular,

+ the software is not intended to be read as a tutorial on JPEG. (See the

+@@ -127,7 +129,7 @@

+ fitness for a particular purpose. This software is provided "AS IS", and you,

+ its user, assume the entire risk as to its quality and accuracy.

+ Permission is hereby granted to use, copy, modify, and distribute this

+@@ -158,30 +160,12 @@

+ assumed by the product vendor.

+-ansi2knr.c is included in this distribution by permission of L. Peter Deutsch,

+-sole proprietor of its copyright holder, Aladdin Enterprises of Menlo Park, CA.

+-ansi2knr.c is NOT covered by the above copyright and conditions, but instead

+-by the usual distribution terms of the Free Software Foundation; principally,

+-that you must include source code if you redistribute it. (See the file

+-ansi2knr.c for full details.) However, since ansi2knr.c is not needed as part

+-of any program generated from the IJG code, this does not limit you more than

+-the foregoing paragraphs do.

+ The Unix configuration script "configure" was produced with GNU Autoconf.

+ It is copyright by the Free Software Foundation but is freely distributable.

+ The same holds for its supporting scripts (config.guess, config.sub,

+-ltconfig, ltmain.sh). Another support script, install-sh, is copyright

+-by M.I.T. but is also freely distributable.

++ltmain.sh). Another support script, install-sh, is copyright by X Consortium

++but is also freely distributable.

+-It appears that the arithmetic coding option of the JPEG spec is covered by

+-patents owned by IBM, AT&T, and Mitsubishi. Hence arithmetic coding cannot

+-legally be used without obtaining one or more licenses. For this reason,

+-support for arithmetic coding has been removed from the free JPEG software.

+-(Since arithmetic coding provides only a marginal gain over the unpatented

+-Huffman mode, it is unlikely that very many implementations will support it.)

+-So far as we are aware, there are no patent restrictions on the remaining

+-code.

+ The IJG distribution formerly included code to read and write GIF files.

+ To avoid entanglement with the Unisys LZW patent, GIF reading support has

+ been removed altogether, and the GIF writer has been simplified to produce

+@@ -198,7 +182,7 @@

+ REFERENCES

+ ==========

+-We highly recommend reading one or more of these references before trying to

++We recommend reading one or more of these references before trying to

+ understand the innards of the JPEG software.

+ The best short technical introduction to the JPEG compression algorithm is

+@@ -207,7 +191,7 @@

+ (Adjacent articles in that issue discuss MPEG motion picture compression,

+ applications of JPEG, and related topics.) If you don't have the CACM issue

+ handy, a PostScript file containing a revised version of Wallace's article is

+-available at ftp://ftp.uu.net/graphics/jpeg/wallace.ps.gz. The file (actually

++available at http://www.ijg.org/files/wallace.ps.gz. The file (actually

+ a preprint for an article that appeared in IEEE Trans. Consumer Electronics)

+ omits the sample images that appeared in CACM, but it includes corrections

+ and some added material. Note: the Wallace article is copyright ACM and IEEE,

+@@ -222,45 +206,29 @@

+ sample code is far from industrial-strength, but when you are ready to look

+ at a full implementation, you've got one here...

+-The best full description of JPEG is the textbook "JPEG Still Image Data

+-Compression Standard" by William B. Pennebaker and Joan L. Mitchell, published

+-by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1. Price US$59.95, 638 pp.

+-The book includes the complete text of the ISO JPEG standards (DIS 10918-1

+-and draft DIS 10918-2). This is by far the most complete exposition of JPEG

+-in existence, and we highly recommend it.

++The best currently available description of JPEG is the textbook "JPEG Still

++Image Data Compression Standard" by William B. Pennebaker and Joan L.

++Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.

++Price US$59.95, 638 pp. The book includes the complete text of the ISO JPEG

++standards (DIS 10918-1 and draft DIS 10918-2).

+-The JPEG standard itself is not available electronically; you must order a

+-paper copy through ISO or ITU. (Unless you feel a need to own a certified

+-official copy, we recommend buying the Pennebaker and Mitchell book instead;

+-it's much cheaper and includes a great deal of useful explanatory material.)

+-In the USA, copies of the standard may be ordered from ANSI Sales at (212)

+-642-4900, or from Global Engineering Documents at (800) 854-7179. (ANSI

+-doesn't take credit card orders, but Global does.) It's not cheap: as of

+-1992, ANSI was charging $95 for Part 1 and $47 for Part 2, plus 7%

+-shipping/handling. The standard is divided into two parts, Part 1 being the

+-actual specification, while Part 2 covers compliance testing methods. Part 1

+-is titled "Digital Compression and Coding of Continuous-tone Still Images,

++The original JPEG standard is divided into two parts, Part 1 being the actual

++specification, while Part 2 covers compliance testing methods. Part 1 is

++titled "Digital Compression and Coding of Continuous-tone Still Images,

+ Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS

+ 10918-1, ITU-T T.81. Part 2 is titled "Digital Compression and Coding of

+ Continuous-tone Still Images, Part 2: Compliance testing" and has document

+ numbers ISO/IEC IS 10918-2, ITU-T T.83.

+-Some extensions to the original JPEG standard are defined in JPEG Part 3,

+-a newer ISO standard numbered ISO/IEC IS 10918-3 and ITU-T T.84. IJG

+-currently does not support any Part 3 extensions.

+ The JPEG standard does not specify all details of an interchangeable file

+ format. For the omitted details we follow the "JFIF" conventions, revision

+-1.02. A copy of the JFIF spec is available from:

+- Literature Department

+- C-Cube Microsystems, Inc.

+- 1778 McCarthy Blvd.

+- Milpitas, CA 95035

+- phone (408) 944-6300, fax (408) 944-6314

+-A PostScript version of this document is available by FTP at

+-ftp://ftp.uu.net/graphics/jpeg/jfif.ps.gz. There is also a plain text

+-version at ftp://ftp.uu.net/graphics/jpeg/jfif.txt.gz, but it is missing

+-the figures.

++1.02. JFIF 1.02 has been adopted as an Ecma International Technical Report

++and thus received a formal publication status. It is available as a free

++download in PDF format from

++http://www.ecma-international.org/publications/techreports/E-TR-098.htm.

++A PostScript version of the JFIF document is available at

++http://www.ijg.org/files/jfif.ps.gz. There is also a plain text version at

++http://www.ijg.org/files/jfif.txt.gz, but it is missing the figures.

+ The TIFF 6.0 file format specification can be obtained by FTP from

+ ftp://ftp.sgi.com/graphics/tiff/TIFF6.ps.gz. The JPEG incorporation scheme

+@@ -267,37 +235,24 @@

+ found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems.

+ IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6).

+ Instead, we recommend the JPEG design proposed by TIFF Technical Note #2

+-(Compression tag 7). Copies of this Note can be obtained from ftp.sgi.com or

+-from ftp://ftp.uu.net/graphics/jpeg/. It is expected that the next revision

++(Compression tag 7). Copies of this Note can be obtained from

++http://www.ijg.org/files/. It is expected that the next revision

+ of the TIFF spec will replace the 6.0 JPEG design with the Note's design.

+ Although IJG's own code does not support TIFF/JPEG, the free libtiff library

+-uses our library to implement TIFF/JPEG per the Note. libtiff is available

+-from ftp://ftp.sgi.com/graphics/tiff/.

++uses our library to implement TIFF/JPEG per the Note.

+ ARCHIVE LOCATIONS

+ =================

+-The "official" archive site for this software is ftp.uu.net (Internet

+-address 192.48.96.9). The most recent released version can always be found

+-there in directory graphics/jpeg. This particular version will be archived

+-as ftp://ftp.uu.net/graphics/jpeg/jpegsrc.v6b.tar.gz. If you don't have

+-direct Internet access, UUNET's archives are also available via UUCP; contact

+-help@uunet.uu.net for information on retrieving files that way.

++The "official" archive site for this software is www.ijg.org.

++The most recent released version can always be found there in

++directory "files". This particular version will be archived as

++http://www.ijg.org/files/jpegsrc.v8d.tar.gz, and in Windows-compatible

++"zip" archive format as http://www.ijg.org/files/jpegsr8d.zip.

+-Numerous Internet sites maintain copies of the UUNET files. However, only

+-ftp.uu.net is guaranteed to have the latest official version.

+-You can also obtain this software in DOS-compatible "zip" archive format from

+-the SimTel archives (ftp://ftp.simtel.net/pub/simtelnet/msdos/graphics/), or

+-on CompuServe in the Graphics Support forum (GO CIS:GRAPHSUP), library 12

+-"JPEG Tools". Again, these versions may sometimes lag behind the ftp.uu.net

+-release.

+-The JPEG FAQ (Frequently Asked Questions) article is a useful source of

+-general information about JPEG. It is updated constantly and therefore is

+-not included in this distribution. The FAQ is posted every two weeks to

+-Usenet newsgroups comp.graphics.misc, news.answers, and other groups.

++The JPEG FAQ (Frequently Asked Questions) article is a source of some

++general information about JPEG.

+ It is available on the World Wide Web at http://www.faqs.org/faqs/jpeg-faq/

+ and other news.answers archive sites, including the official news.answers

+ archive at rtfm.mit.edu: ftp://rtfm.mit.edu/pub/usenet/news.answers/jpeg-faq/.

+@@ -307,79 +262,21 @@

+ send usenet/news.answers/jpeg-faq/part2

+-RELATED SOFTWARE

+-================

+-Numerous viewing and image manipulation programs now support JPEG. (Quite a

+-few of them use this library to do so.) The JPEG FAQ described above lists

+-some of the more popular free and shareware viewers, and tells where to

+-obtain them on Internet.

+-If you are on a Unix machine, we highly recommend Jef Poskanzer's free

+-PBMPLUS software, which provides many useful operations on PPM-format image

+-files. In particular, it can convert PPM images to and from a wide range of

+-other formats, thus making cjpeg/djpeg considerably more useful. The latest

+-version is distributed by the NetPBM group, and is available from numerous

+-sites, notably ftp://wuarchive.wustl.edu/graphics/graphics/packages/NetPBM/.

+-Unfortunately PBMPLUS/NETPBM is not nearly as portable as the IJG software is;

+-you are likely to have difficulty making it work on any non-Unix machine.

+-A different free JPEG implementation, written by the PVRG group at Stanford,

+-is available from ftp://havefun.stanford.edu/pub/jpeg/. This program

+-is designed for research and experimentation rather than production use;

+-it is slower, harder to use, and less portable than the IJG code, but it

+-is easier to read and modify. Also, the PVRG code supports lossless JPEG,

+-which we do not. (On the other hand, it doesn't do progressive JPEG.)

+ FILE FORMAT WARS

+ ================

+-Some JPEG programs produce files that are not compatible with our library.

+-The root of the problem is that the ISO JPEG committee failed to specify a

+-concrete file format. Some vendors "filled in the blanks" on their own,

+-creating proprietary formats that no one else could read. (For example, none

+-of the early commercial JPEG implementations for the Macintosh were able to

+-exchange compressed files.)

++The ISO/IEC JTC1/SC29/WG1 standards committee (also known as JPEG, together

++with ITU-T SG16) currently promotes different formats containing the name

++"JPEG" which are incompatible with original DCT-based JPEG. IJG therefore does

++not support these formats (see REFERENCES). Indeed, one of the original

++reasons for developing this free software was to help force convergence on

++common, interoperable format standards for JPEG files.

++Don't use an incompatible file format!

++(In any case, our decoder will remain capable of reading existing JPEG

++image files indefinitely.)

+-The file format we have adopted is called JFIF (see REFERENCES). This format

+-has been agreed to by a number of major commercial JPEG vendors, and it has

+-become the de facto standard. JFIF is a minimal or "low end" representation.

+-We recommend the use of TIFF/JPEG (TIFF revision 6.0 as modified by TIFF

+-Technical Note #2) for "high end" applications that need to record a lot of

+-additional data about an image. TIFF/JPEG is fairly new and not yet widely

+-supported, unfortunately.

+-The upcoming JPEG Part 3 standard defines a file format called SPIFF.

+-SPIFF is interoperable with JFIF, in the sense that most JFIF decoders should

+-be able to read the most common variant of SPIFF. SPIFF has some technical

+-advantages over JFIF, but its major claim to fame is simply that it is an

+-official standard rather than an informal one. At this point it is unclear

+-whether SPIFF will supersede JFIF or whether JFIF will remain the de-facto

+-standard. IJG intends to support SPIFF once the standard is frozen, but we

+-have not decided whether it should become our default output format or not.

+-(In any case, our decoder will remain capable of reading JFIF indefinitely.)

+-Various proprietary file formats incorporating JPEG compression also exist.

+-We have little or no sympathy for the existence of these formats. Indeed,

+-one of the original reasons for developing this free software was to help

+-force convergence on common, open format standards for JPEG files. Don't

+-use a proprietary file format!

+ TO DO

+ =====

+-The major thrust for v7 will probably be improvement of visual quality.

+-The current method for scaling the quantization tables is known not to be

+-very good at low Q values. We also intend to investigate block boundary

+-smoothing, "poor man's variable quantization", and other means of improving

+-quality-vs-file-size performance without sacrificing compatibility.

+-In future versions, we are considering supporting some of the upcoming JPEG

+-Part 3 extensions --- principally, variable quantization and the SPIFF file

+-format.

+-As always, speeding things up is of great interest.

+-Please send bug reports, offers of help, etc. to jpeg-info@uunet.uu.net.

++Please send bug reports, offers of help, etc. to jpeg-info@jpegclub.org.

+Index: bmp.c

+===================================================================

+--- bmp.c (revision 829)

++++ bmp.c (working copy)

+@@ -1,370 +1,274 @@

++/*

+ *

+- * This library is free software and may be redistributed and/or modified under

+- * the terms of the wxWindows Library License, Version 3.1 or (at your option)

+- * any later version. The full license is in the LICENSE.txt file included

+- * with this distribution.

++ * Redistribution and use in source and binary forms, with or without

++ * modification, are permitted provided that the following conditions are met:

+ *

+- * This library is distributed in the hope that it will be useful,

+- * but WITHOUT ANY WARRANTY; without even the implied warranty of

+- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+- * wxWindows Library License for more details.

+-*/

++ * - Redistributions of source code must retain the above copyright notice,

++ * this list of conditions and the following disclaimer.

++ * - Redistributions in binary form must reproduce the above copyright notice,

++ * this list of conditions and the following disclaimer in the documentation

++ * and/or other materials provided with the distribution.

++ * - Neither the name of the libjpeg-turbo Project nor the names of its

++ * contributors may be used to endorse or promote products derived from this

++ * software without specific prior written permission.

++ *

++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS",

++ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

++ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE

++ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

++ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

++ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

++ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

++ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

++ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

++ * POSSIBILITY OF SUCH DAMAGE.

++ */

+-#include <fcntl.h>

+-#include <sys/types.h>

+-#include <sys/stat.h>

+-#include <errno.h>

+-#include <stdlib.h>

+ #include <stdio.h>

+ #include <string.h>

+-#ifdef _WIN32

+- #include <io.h>

+-#else

+- #include <unistd.h>

+-#endif

+-#include "./rrutil.h"

+-#include "./bmp.h"

++#include <setjmp.h>

++#include <errno.h>

++#include "cdjpeg.h"

++#include <jpeglib.h>

++#include <jpegint.h>

++#include "tjutil.h"

++#include "bmp.h"

+-#ifndef BI_BITFIELDS

+-#define BI_BITFIELDS 3L

+-#endif

+-#ifndef BI_RGB

+-#define BI_RGB 0L

+-#endif

+-#define BMPHDRSIZE 54

+-typedef struct _bmphdr

+-{

+- unsigned short bfType;

+- unsigned int bfSize;

+- unsigned short bfReserved1, bfReserved2;

+- unsigned int bfOffBits;

++/* This duplicates the functionality of the VirtualGL bitmap library using

++ the components from cjpeg and djpeg */

+- unsigned int biSize;

+- int biWidth, biHeight;

+- unsigned short biPlanes, biBitCount;

+- unsigned int biCompression, biSizeImage;

+- int biXPelsPerMeter, biYPelsPerMeter;

+- unsigned int biClrUsed, biClrImportant;

+-} bmphdr;

+-static const char *__bmperr="No error";

++/* Error handling (based on example in example.c) */

+-static const int ps[BMPPIXELFORMATS]={3, 4, 3, 4, 4, 4};

+-static const int roffset[BMPPIXELFORMATS]={0, 0, 2, 2, 3, 1};

+-static const int goffset[BMPPIXELFORMATS]={1, 1, 1, 1, 2, 2};

+-static const int boffset[BMPPIXELFORMATS]={2, 2, 0, 0, 1, 3};

++static char errStr[JMSG_LENGTH_MAX]="No error";

+-#define _throw(m) {__bmperr=m; retcode=-1; goto finally;}

+-#define _unix(f) {if((f)==-1) _throw(strerror(errno));}

+-#define _catch(f) {if((f)==-1) {retcode=-1; goto finally;}}

++struct my_error_mgr

++{

++ struct jpeg_error_mgr pub;

++ jmp_buf setjmp_buffer;

++};

++typedef struct my_error_mgr *my_error_ptr;

+-#define readme(fd, addr, size) \

+- if((bytesread=read(fd, addr, (size)))==-1) _throw(strerror(errno)); \

+- if(bytesread!=(size)) _throw("Read error");

+-void pixelconvert(unsigned char *srcbuf, enum BMPPIXELFORMAT srcformat,

+- int srcpitch, unsigned char *dstbuf, enum BMPPIXELFORMAT dstformat, int dstpitch,

+- int w, int h, int flip)

++static void my_error_exit(j_common_ptr cinfo)

+ {

+- unsigned char *srcptr, *srcptr0, *dstptr, *dstptr0;

+- int i, j;

+- srcptr=flip? &srcbuf[srcpitch*(h-1)]:srcbuf;

+- for(j=0, dstptr=dstbuf; j<h; j++,

+- srcptr+=flip? -srcpitch:srcpitch, dstptr+=dstpitch)

+- {

+- for(i=0, srcptr0=srcptr, dstptr0=dstptr; i<w; i++,

+- srcptr0+=ps[srcformat], dstptr0+=ps[dstformat])

+- {

+- dstptr0[roffset[dstformat]]=srcptr0[roffset[srcformat]];

+- dstptr0[goffset[dstformat]]=srcptr0[goffset[srcformat]];

+- dstptr0[boffset[dstformat]]=srcptr0[boffset[srcformat]];

+- }

++ my_error_ptr myerr=(my_error_ptr)cinfo->err;

++ (*cinfo->err->output_message)(cinfo);

++ longjmp(myerr->setjmp_buffer, 1);

+ }

+-int loadppm(int *fd, unsigned char **buf, int *w, int *h,

+- enum BMPPIXELFORMAT f, int align, int dstbottomup, int ascii)

++/* Based on output_message() in jerror.c */

++static void my_output_message(j_common_ptr cinfo)

+ {

+- FILE *fs=NULL; int retcode=0, scalefactor, dstpitch;

+- unsigned char *tempbuf=NULL; char temps[255], temps2[255];

+- int numread=0, totalread=0, pixel[3], i, j;

++ (*cinfo->err->format_message)(cinfo, errStr);

++}

+- if((fs=fdopen(*fd, "r"))==NULL) _throw(strerror(errno));

++#define _throw(m) {snprintf(errStr, JMSG_LENGTH_MAX, "%s", m); \

++ retval=-1; goto bailout;}

++#define _throwunix(m) {snprintf(errStr, JMSG_LENGTH_MAX, "%s\n%s", m, \

++ strerror(errno)); retval=-1; goto bailout;}

+- do

+- {

+- if(!fgets(temps, 255, fs)) _throw("Read error");

+- if(strlen(temps)==0 || temps[0]=='\n') continue;

+- if(sscanf(temps, "%s", temps2)==1 && temps2[1]=='#') continue;

+- switch(totalread)

+- {

+- case 0:

+- if((numread=sscanf(temps, "%d %d %d", w, h, &scalefactor))==EOF)

+- _throw("Read error");

+- break;

+- case 1:

+- if((numread=sscanf(temps, "%d %d", h, &scalefactor))==EOF)

+- _throw("Read error");

+- break;

+- case 2:

+- if((numread=sscanf(temps, "%d", &scalefactor))==EOF)

+- _throw("Read error");

+- break;

+- }

+- totalread+=numread;

+- } while(totalread<3);

+- if((*w)<1 || (*h)<1 || scalefactor<1) _throw("Corrupt PPM header");

+- dstpitch=(((*w)*ps[f])+(align-1))&(~(align-1));

+- if((*buf=(unsigned char *)malloc(dstpitch*(*h)))==NULL)

+- _throw("Memory allocation error");

+- if(ascii)

++static void pixelconvert(unsigned char *srcbuf, int srcpf, int srcbottomup,

++ unsigned char *dstbuf, int dstpf, int dstbottomup, int w, int h)

++{

++ unsigned char *srcptr=srcbuf, *srcptr2;

++ int srcps=tjPixelSize[srcpf];

++ int srcstride=srcbottomup? -w*srcps:w*srcps;

++ unsigned char *dstptr=dstbuf, *dstptr2;

++ int dstps=tjPixelSize[dstpf];

++ int dststride=dstbottomup? -w*dstps:w*dstps;

++ int row, col;

++ if(srcbottomup) srcptr=&srcbuf[w*srcps*(h-1)];

++ if(dstbottomup) dstptr=&dstbuf[w*dstps*(h-1)];

++ for(row=0; row<h; row++, srcptr+=srcstride, dstptr+=dststride)

+ {

+- for(j=0; j<*h; j++)

++ for(col=0, srcptr2=srcptr, dstptr2=dstptr; col<w; col++, srcptr2+=srcps,

++ dstptr2+=dstps)

+ {

+- for(i=0; i<*w; i++)

+- {

+- if(fscanf(fs, "%d%d%d", &pixel[0], &pixel[1], &pixel[2])!=3)

+- _throw("Read error");

+- (*buf)[j*dstpitch+i*ps[f]+roffset[f]]=(unsigned char)(pixel[0]*255/scalefactor);

+- (*buf)[j*dstpitch+i*ps[f]+goffset[f]]=(unsigned char)(pixel[1]*255/scalefactor);

+- (*buf)[j*dstpitch+i*ps[f]+boffset[f]]=(unsigned char)(pixel[2]*255/scalefactor);

+- }

++ dstptr2[tjRedOffset[dstpf]]=srcptr2[tjRedOffset[srcpf]];

++ dstptr2[tjGreenOffset[dstpf]]=srcptr2[tjGreenOffset[srcpf]];

++ dstptr2[tjBlueOffset[dstpf]]=srcptr2[tjBlueOffset[srcpf]];

+ }

+- else

+- {

+- if(scalefactor!=255)

+- _throw("Binary PPMs must have 8-bit components");

+- if((tempbuf=(unsigned char *)malloc((*w)*(*h)*3))==NULL)

+- _throw("Memory allocation error");

+- if(fread(tempbuf, (*w)*(*h)*3, 1, fs)!=1) _throw("Read error");

+- pixelconvert(tempbuf, BMP_RGB, (*w)*3, *buf, f, dstpitch, *w, *h, dstbottomup);

+- }

+- finally:

+- if(fs) {fclose(fs); *fd=-1;}

+- if(tempbuf) free(tempbuf);

+- return retcode;

+ }

+ int loadbmp(char *filename, unsigned char **buf, int *w, int *h,

+- enum BMPPIXELFORMAT f, int align, int dstbottomup)

++ int dstpf, int bottomup)

+ {

+- int fd=-1, bytesread, srcpitch, srcbottomup=1, srcps, dstpitch,

+- retcode=0;

+- unsigned char *tempbuf=NULL;

+- bmphdr bh; int flags=O_RDONLY;

++ int retval=0, dstps, srcpf, tempc;

++ struct jpeg_compress_struct cinfo;

++ struct my_error_mgr jerr;

++ cjpeg_source_ptr src;

++ FILE *file=NULL;

+- dstbottomup=dstbottomup? 1:0;

+- #ifdef _WIN32

+- flags|=O_BINARY;

+- #endif

+- if(!filename || !buf || !w || !h || f<0 || f>BMPPIXELFORMATS-1 || align<1)

+- _throw("invalid argument to loadbmp()");

+- if((align&(align-1))!=0)

+- _throw("Alignment must be a power of 2");

+- _unix(fd=open(filename, flags));

++ memset(&cinfo, 0, sizeof(struct jpeg_compress_struct));

+- readme(fd, &bh.bfType, sizeof(unsigned short));

+- if(!littleendian()) bh.bfType=byteswap16(bh.bfType);

++ if(!filename || !buf || !w || !h || dstpf<0 || dstpf>=TJ_NUMPF)

++ _throw("loadbmp(): Invalid argument");

+- if(bh.bfType==0x3650)

++ if((file=fopen(filename, "rb"))==NULL)

++ _throwunix("loadbmp(): Cannot open input file");

++ cinfo.err=jpeg_std_error(&jerr.pub);

++ jerr.pub.error_exit=my_error_exit;

++ jerr.pub.output_message=my_output_message;

++ if(setjmp(jerr.setjmp_buffer))

+ {

+- _catch(loadppm(&fd, buf, w, h, f, align, dstbottomup, 0));

+- goto finally;

++ /* If we get here, the JPEG code has signaled an error. */

++ retval=-1; goto bailout;

+ }

+- if(bh.bfType==0x3350)

+- {

+- _catch(loadppm(&fd, buf, w, h, f, align, dstbottomup, 1));

+- goto finally;

+- }

+- readme(fd, &bh.bfSize, sizeof(unsigned int));

+- readme(fd, &bh.bfReserved1, sizeof(unsigned short));

+- readme(fd, &bh.bfReserved2, sizeof(unsigned short));

+- readme(fd, &bh.bfOffBits, sizeof(unsigned int));

+- readme(fd, &bh.biSize, sizeof(unsigned int));

+- readme(fd, &bh.biWidth, sizeof(int));

+- readme(fd, &bh.biHeight, sizeof(int));

+- readme(fd, &bh.biPlanes, sizeof(unsigned short));

+- readme(fd, &bh.biBitCount, sizeof(unsigned short));

+- readme(fd, &bh.biCompression, sizeof(unsigned int));

+- readme(fd, &bh.biSizeImage, sizeof(unsigned int));

+- readme(fd, &bh.biXPelsPerMeter, sizeof(int));

+- readme(fd, &bh.biYPelsPerMeter, sizeof(int));

+- readme(fd, &bh.biClrUsed, sizeof(unsigned int));

+- readme(fd, &bh.biClrImportant, sizeof(unsigned int));

++ jpeg_create_compress(&cinfo);

++ if((tempc=getc(file))<0 || ungetc(tempc, file)==EOF)

++ _throwunix("loadbmp(): Could not read input file")

++ else if(tempc==EOF) _throw("loadbmp(): Input file contains no data");

+- if(!littleendian())

++ if(tempc=='B')

+ {

+- bh.bfSize=byteswap(bh.bfSize);

+- bh.bfOffBits=byteswap(bh.bfOffBits);

+- bh.biSize=byteswap(bh.biSize);

+- bh.biWidth=byteswap(bh.biWidth);

+- bh.biHeight=byteswap(bh.biHeight);

+- bh.biPlanes=byteswap16(bh.biPlanes);

+- bh.biBitCount=byteswap16(bh.biBitCount);

+- bh.biCompression=byteswap(bh.biCompression);

+- bh.biSizeImage=byteswap(bh.biSizeImage);

+- bh.biXPelsPerMeter=byteswap(bh.biXPelsPerMeter);

+- bh.biYPelsPerMeter=byteswap(bh.biYPelsPerMeter);

+- bh.biClrUsed=byteswap(bh.biClrUsed);

+- bh.biClrImportant=byteswap(bh.biClrImportant);

++ if((src=jinit_read_bmp(&cinfo))==NULL)

++ _throw("loadbmp(): Could not initialize bitmap loader");

+ }

++ else if(tempc=='P')

++ {

++ if((src=jinit_read_ppm(&cinfo))==NULL)

++ _throw("loadbmp(): Could not initialize bitmap loader");

++ }

++ else _throw("loadbmp(): Unsupported file type");

+- if(bh.bfType!=0x4d42 || bh.bfOffBits<BMPHDRSIZE

+- || bh.biWidth<1 || bh.biHeight==0)

+- _throw("Corrupt bitmap header");

+- if((bh.biBitCount!=24 && bh.biBitCount!=32) || bh.biCompression!=BI_RGB)

+- _throw("Only uncompessed RGB bitmaps are supported");

++ src->input_file=file;

++ (*src->start_input)(&cinfo, src);

++ (*cinfo.mem->realize_virt_arrays)((j_common_ptr)&cinfo);

+- *w=bh.biWidth; *h=bh.biHeight; srcps=bh.biBitCount/8;

+- if(*h<0) {*h=-(*h); srcbottomup=0;}

+- srcpitch=(((*w)*srcps)+3)&(~3);

+- dstpitch=(((*w)*ps[f])+(align-1))&(~(align-1));

++ *w=cinfo.image_width; *h=cinfo.image_height;

+- if(srcpitch*(*h)+bh.bfOffBits!=bh.bfSize) _throw("Corrupt bitmap header");

+- if((tempbuf=(unsigned char *)malloc(srcpitch*(*h)))==NULL

+- || (*buf=(unsigned char *)malloc(dstpitch*(*h)))==NULL)

+- _throw("Memory allocation error");

+- if(lseek(fd, (long)bh.bfOffBits, SEEK_SET)!=(long)bh.bfOffBits)

+- _throw(strerror(errno));

+- _unix(bytesread=read(fd, tempbuf, srcpitch*(*h)));

+- if(bytesread!=srcpitch*(*h)) _throw("Read error");

++ if(cinfo.input_components==1 && cinfo.in_color_space==JCS_RGB)

++ srcpf=TJPF_GRAY;

++ else srcpf=TJPF_RGB;

+- pixelconvert(tempbuf, BMP_BGR, srcpitch, *buf, f, dstpitch, *w, *h,

+- srcbottomup!=dstbottomup);

++ dstps=tjPixelSize[dstpf];

++ if((*buf=(unsigned char *)malloc((*w)*(*h)*dstps))==NULL)

++ _throw("loadbmp(): Memory allocation failure");

+- finally:

+- if(tempbuf) free(tempbuf);

+- if(fd!=-1) close(fd);

+- return retcode;

++ while(cinfo.next_scanline<cinfo.image_height)

++ {

++ int i, nlines=(*src->get_pixel_rows)(&cinfo, src);

++ for(i=0; i<nlines; i++)

++ {

++ unsigned char *outbuf; int row;

++ row=cinfo.next_scanline+i;

++ if(bottomup) outbuf=&(*buf)[((*h)-row-1)*(*w)*dstps];

++ else outbuf=&(*buf)[row*(*w)*dstps];

++ pixelconvert(src->buffer[i], srcpf, 0, outbuf, dstpf, bottomup, *w,

++ nlines);

++ }

++ cinfo.next_scanline+=nlines;

++ }

++ (*src->finish_input)(&cinfo, src);

++ bailout:

++ jpeg_destroy_compress(&cinfo);

++ if(file) fclose(file);

++ if(retval<0 && buf && *buf) {free(*buf); *buf=NULL;}

++ return retval;

+ }

+-#define writeme(fd, addr, size) \

+- if((byteswritten=write(fd, addr, (size)))==-1) _throw(strerror(errno)); \

+- if(byteswritten!=(size)) _throw("Write error");

+-int saveppm(char *filename, unsigned char *buf, int w, int h,

+- enum BMPPIXELFORMAT f, int srcpitch, int srcbottomup)

++int savebmp(char *filename, unsigned char *buf, int w, int h, int srcpf,

++ int bottomup)

+ {

+- FILE *fs=NULL; int retcode=0;

+- unsigned char *tempbuf=NULL;

++ int retval=0, srcps, dstpf;

++ struct jpeg_decompress_struct dinfo;

++ struct my_error_mgr jerr;

++ djpeg_dest_ptr dst;

++ FILE *file=NULL;

++ char *ptr=NULL;

+- if((fs=fopen(filename, "wb"))==NULL) _throw(strerror(errno));

+- if(fprintf(fs, "P6\n")<1) _throw("Write error");

+- if(fprintf(fs, "%d %d\n", w, h)<1) _throw("Write error");

+- if(fprintf(fs, "255\n")<1) _throw("Write error");

++ memset(&dinfo, 0, sizeof(struct jpeg_decompress_struct));

+- if((tempbuf=(unsigned char *)malloc(w*h*3))==NULL)

+- _throw("Memory allocation error");

++ if(!filename || !buf || w<1 || h<1 || srcpf<0 || srcpf>=TJ_NUMPF)

++ _throw("savebmp(): Invalid argument");

+- pixelconvert(buf, f, srcpitch, tempbuf, BMP_RGB, w*3, w, h,

+- srcbottomup);

++ if((file=fopen(filename, "wb"))==NULL)

++ _throwunix("savebmp(): Cannot open output file");

+- if((fwrite(tempbuf, w*h*3, 1, fs))!=1) _throw("Write error");

++ dinfo.err=jpeg_std_error(&jerr.pub);

++ jerr.pub.error_exit=my_error_exit;

++ jerr.pub.output_message=my_output_message;

+- finally:

+- if(tempbuf) free(tempbuf);

+- if(fs) fclose(fs);

+- return retcode;

+-}

++ if(setjmp(jerr.setjmp_buffer))

++ {

++ /* If we get here, the JPEG code has signaled an error. */

++ retval=-1; goto bailout;

++ }

+-int savebmp(char *filename, unsigned char *buf, int w, int h,

+- enum BMPPIXELFORMAT f, int srcpitch, int srcbottomup)

+-{

+- int fd=-1, byteswritten, dstpitch, retcode=0;

+- int flags=O_RDWR|O_CREAT|O_TRUNC;

+- unsigned char *tempbuf=NULL; char *temp;

+- bmphdr bh; int mode;

++ jpeg_create_decompress(&dinfo);

++ if(srcpf==TJPF_GRAY)

++ {

++ dinfo.out_color_components=dinfo.output_components=1;

++ dinfo.out_color_space=JCS_GRAYSCALE;

++ }

++ else

++ {

++ dinfo.out_color_components=dinfo.output_components=3;

++ dinfo.out_color_space=JCS_RGB;

++ }

++ dinfo.image_width=w; dinfo.image_height=h;

++ dinfo.global_state=DSTATE_READY;

++ dinfo.scale_num=dinfo.scale_denom=1;

+- #ifdef _WIN32

+- flags|=O_BINARY; mode=_S_IREAD|_S_IWRITE;

+- #else

+- #endif

+- if(!filename || !buf || w<1 || h<1 || f<0 || f>BMPPIXELFORMATS-1 || srcpitch<0)

+- _throw("bad argument to savebmp()");

+- if(srcpitch==0) srcpitch=w*ps[f];

+- if((temp=strrchr(filename, '.'))!=NULL)

++ ptr=strrchr(filename, '.');

++ if(ptr && !strcasecmp(ptr, ".bmp"))

+ {

+- if(!stricmp(temp, ".ppm"))

+- return saveppm(filename, buf, w, h, f, srcpitch, srcbottomup);

++ if((dst=jinit_write_bmp(&dinfo, 0))==NULL)

++ _throw("savebmp(): Could not initialize bitmap writer");

+ }

++ else

++ {

++ if((dst=jinit_write_ppm(&dinfo))==NULL)

++ _throw("savebmp(): Could not initialize PPM writer");

++ }

+- _unix(fd=open(filename, flags, mode));

+- dstpitch=((w*3)+3)&(~3);

++ dst->output_file=file;

++ (*dst->start_output)(&dinfo, dst);

++ (*dinfo.mem->realize_virt_arrays)((j_common_ptr)&dinfo);

+- bh.bfType=0x4d42;

+- bh.bfSize=BMPHDRSIZE+dstpitch*h;

+- bh.bfReserved1=0; bh.bfReserved2=0;

+- bh.bfOffBits=BMPHDRSIZE;

+- bh.biSize=40;

+- bh.biWidth=w; bh.biHeight=h;

+- bh.biPlanes=0; bh.biBitCount=24;

+- bh.biCompression=BI_RGB; bh.biSizeImage=0;

+- bh.biXPelsPerMeter=0; bh.biYPelsPerMeter=0;

+- bh.biClrUsed=0; bh.biClrImportant=0;

++ if(srcpf==TJPF_GRAY) dstpf=srcpf;

++ else dstpf=TJPF_RGB;

++ srcps=tjPixelSize[srcpf];

+- if(!littleendian())

++ while(dinfo.output_scanline<dinfo.output_height)

+ {

+- bh.bfType=byteswap16(bh.bfType);

+- bh.bfSize=byteswap(bh.bfSize);

+- bh.bfOffBits=byteswap(bh.bfOffBits);

+- bh.biSize=byteswap(bh.biSize);

+- bh.biWidth=byteswap(bh.biWidth);

+- bh.biHeight=byteswap(bh.biHeight);

+- bh.biPlanes=byteswap16(bh.biPlanes);

+- bh.biBitCount=byteswap16(bh.biBitCount);

+- bh.biCompression=byteswap(bh.biCompression);

+- bh.biSizeImage=byteswap(bh.biSizeImage);

+- bh.biXPelsPerMeter=byteswap(bh.biXPelsPerMeter);

+- bh.biYPelsPerMeter=byteswap(bh.biYPelsPerMeter);

+- bh.biClrUsed=byteswap(bh.biClrUsed);

+- bh.biClrImportant=byteswap(bh.biClrImportant);

++ int i, nlines=dst->buffer_height;

++ for(i=0; i<nlines; i++)

++ {

++ unsigned char *inbuf; int row;

++ row=dinfo.output_scanline+i;

++ if(bottomup) inbuf=&buf[(h-row-1)*w*srcps];

++ else inbuf=&buf[row*w*srcps];

++ pixelconvert(inbuf, srcpf, bottomup, dst->buffer[i], dstpf, 0, w,

++ nlines);

++ }

++ (*dst->put_pixel_rows)(&dinfo, dst, nlines);

++ dinfo.output_scanline+=nlines;

+ }

+- writeme(fd, &bh.bfType, sizeof(unsigned short));

+- writeme(fd, &bh.bfSize, sizeof(unsigned int));

+- writeme(fd, &bh.bfReserved1, sizeof(unsigned short));

+- writeme(fd, &bh.bfReserved2, sizeof(unsigned short));

+- writeme(fd, &bh.bfOffBits, sizeof(unsigned int));

+- writeme(fd, &bh.biSize, sizeof(unsigned int));

+- writeme(fd, &bh.biWidth, sizeof(int));

+- writeme(fd, &bh.biHeight, sizeof(int));

+- writeme(fd, &bh.biPlanes, sizeof(unsigned short));

+- writeme(fd, &bh.biBitCount, sizeof(unsigned short));

+- writeme(fd, &bh.biCompression, sizeof(unsigned int));

+- writeme(fd, &bh.biSizeImage, sizeof(unsigned int));

+- writeme(fd, &bh.biXPelsPerMeter, sizeof(int));

+- writeme(fd, &bh.biYPelsPerMeter, sizeof(int));

+- writeme(fd, &bh.biClrUsed, sizeof(unsigned int));

+- writeme(fd, &bh.biClrImportant, sizeof(unsigned int));

++ (*dst->finish_output)(&dinfo, dst);

+- if((tempbuf=(unsigned char *)malloc(dstpitch*h))==NULL)

+- _throw("Memory allocation error");

+- pixelconvert(buf, f, srcpitch, tempbuf, BMP_BGR, dstpitch, w, h,

+- !srcbottomup);

+- if((byteswritten=write(fd, tempbuf, dstpitch*h))!=dstpitch*h)

+- _throw(strerror(errno));

+- finally:

+- if(tempbuf) free(tempbuf);

+- if(fd!=-1) close(fd);

+- return retcode;

++ bailout:

++ jpeg_destroy_decompress(&dinfo);

++ if(file) fclose(file);

++ return retval;

+ }

+ const char *bmpgeterr(void)

+ {

+- return __bmperr;

++ return errStr;

+ }

+Index: bmp.h

+===================================================================

+--- bmp.h (revision 829)

++++ bmp.h (working copy)

+@@ -1,48 +1,42 @@